tests.model.mets_bench_extreme

Complexity

Total Complexity

34

Size/Duplication

Total Lines	278
Duplicated Lines	7.91 %

Importance

Changes

0

27 Functions

Rating	Name	Duplication	Size	Complexity
A	test_b500()	0	6	1
A	benchmark_find_files_all()	0	2	1
A	test_b2000_c()	0	6	1
A	test_s2000()	0	6	1
A	test_s500()	0	6	1
A	benchmark_find_files_fileid()	0	5	1
A	test_s1000_c()	0	6	1
A	test_b2000()	0	6	1
A	test_s5000()	0	6	1
A	test_b1000_c()	0	6	1
A	test_s50()	0	6	1
B	_build_mets()	22	22	8
A	benchmark_find_files_physical_page()	0	5	1
A	assert_len()	0	3	1
A	test_b50()	0	6	1
A	test_b50_c()	0	6	1
A	test_s500_c()	0	6	1
A	test_s5000_c()	0	6	1
A	test_b5000()	0	6	1
A	test_b1000()	0	6	1
A	test_s2000_c()	0	6	1
A	benchmark_find_files()	0	4	1
A	test_s1000()	0	6	1
A	benchmark_find_files_filegrp()	0	5	1
A	test_b500_c()	0	6	1
A	test_b5000_c()	0	6	1
A	test_s50_c()	0	6	1

# -*- coding: utf-8 -*-

from contextlib import contextmanager
from time import time

from pytest import main, fixture, mark

from ocrd import Resolver
from ocrd_utils import MIME_TO_EXT, getLogger
from ocrd_models import OcrdMets

logger = getLogger('ocrd.benchmark.mets')

GRPS_REG = ['SEG-REG', 'SEG-REPAIR', 'SEG-REG-DESKEW', 'SEG-REG-DESKEW-CLIP', 'SEG-LINE', 'SEG-REPAIR-LINE', 'SEG-LINE-RESEG-DEWARP']
GRPS_IMG = ['FULL', 'PRESENTATION', 'BIN', 'CROP', 'BIN2', 'BIN-DENOISE', 'BIN-DENOISE-DESKEW', 'OCR']

REGIONS_PER_PAGE = 2
LINES_PER_REGION = 2
FILES_PER_PAGE = len(GRPS_IMG) * LINES_PER_REGION + len(GRPS_REG) * REGIONS_PER_PAGE

# Caching is disabled by default
def _build_mets(number_of_pages, force=False, cache_flag=False):

This code seems to be duplicated in your project.

    mets = OcrdMets.empty_mets(cache_flag=cache_flag)
    mets._number_of_pages = number_of_pages

    for n in ['%04d' % (n + 1) for n in range(number_of_pages)]:
        _add_file = lambda n, fileGrp, mimetype, ID=None: mets.add_file(
            fileGrp,
            mimetype=mimetype,
            pageId='PHYS_%s' % n,
            ID=ID if ID else '%s_%s_%s' % (fileGrp, n, MIME_TO_EXT.get(mimetype)[1:].upper()),
            url='%s/%s%s' % (fileGrp, ID if ID else '%s_%s_%s' % (fileGrp, n, MIME_TO_EXT.get(mimetype)[1:].upper()), MIME_TO_EXT.get(mimetype))
        )
        for grp in GRPS_IMG:
            # LINES_PER_REGION = 2
            _add_file(n, grp, 'image/tiff')
            _add_file(n, grp, 'application/vnd.prima.page+xml')
        for grp in GRPS_REG:
            # REGIONS_PER_PAGE = 2
            for region_n in range(REGIONS_PER_PAGE):
                _add_file(n, grp, 'image/png', '%s_%s_region%s' % (grp, n, region_n))

    return mets

def assert_len(expected_len, mets, kwargs):
    test_list = mets.find_all_files(**kwargs)
    assert expected_len == len(test_list)

def benchmark_find_files(number_of_pages, mets):
    benchmark_find_files_filegrp(number_of_pages, mets)
    benchmark_find_files_fileid(number_of_pages, mets)
    benchmark_find_files_physical_page(number_of_pages, mets)
    # This is not really useful to measure. 
    # We iterate all files in both cached and non-cached in the same routine
    # When no specific search parameters are provided
    # benchmark_find_files_all(number_of_pages, mets)

def benchmark_find_files_filegrp(number_of_pages, mets):
	# Best case - first fileGrp
    assert_len((number_of_pages * REGIONS_PER_PAGE), mets, dict(fileGrp='SEG-REG'))
    # Worst case - does not exist
    assert_len(0, mets, dict(fileGrp='SEG-REG-NOTEXIST'))

def benchmark_find_files_fileid(number_of_pages, mets):
	# Best case - first file ID
    assert_len(1, mets, dict(ID='FULL_0001_TIF', fileGrp='FULL'))
    # Worst case - does not exist
    assert_len(0, mets, dict(ID='FULL_0001_TIF-NOTEXISTS', fileGrp='FULL-NOTEXIST'))

def benchmark_find_files_physical_page(number_of_pages, mets):
	# Best case - first physical page
    assert_len(FILES_PER_PAGE, mets, dict(pageId='PHYS_0001'))
    # Worst case - does not exist
    assert_len(0, mets, dict(pageId='PHYS_0001-NOTEXISTS'))

# Get all files, i.e., pass an empty search parameter -> dict()
def benchmark_find_files_all(number_of_pages, mets):
    assert_len((number_of_pages * FILES_PER_PAGE), mets, dict())




# ---- BENCHMARKING for 50-500-1000-2000-5000 pages ---- #

# ----- 50 pages -> build, search, build (cached), search (cached) ----- #
mets_50 = None
@mark.benchmark(group="build", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_b50(benchmark):
    @benchmark
    def result():
        global mets_50
        mets_50 = _build_mets(50, force=True)

@mark.benchmark(group="search", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_s50(benchmark):
    @benchmark
    def ret(): 
        global mets_50
        benchmark_find_files(50, mets_50)
del mets_50

mets_c_50 = None
@mark.benchmark(group="build_cached", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_b50_c(benchmark):
    @benchmark
    def result():
        global mets_c_50
        mets_c_50 = _build_mets(50, force=True, cache_flag=True)

@mark.benchmark(group="search_cached", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_s50_c(benchmark):
    @benchmark
    def ret():
        global mets_c_50
        benchmark_find_files(50, mets_c_50)
del mets_c_50
# ----------------------------------------------------------------------- #



# ----- 500 pages -> build, search, build (cached), search (cached) ----- #
mets_500 = None
@mark.benchmark(group="build", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_b500(benchmark):
    @benchmark
    def result():
        global mets_500
        mets_500 = _build_mets(500, force=True)

@mark.benchmark(group="search", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_s500(benchmark):
    @benchmark
    def ret(): 
        global mets_500
        benchmark_find_files(500, mets_500)
del mets_500


mets_c_500 = None
@mark.benchmark(group="build_cached", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_b500_c(benchmark):
    @benchmark
    def result():
        global mets_c_500
        mets_c_500 = _build_mets(500, force=True, cache_flag=True)

@mark.benchmark(group="search_cached", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_s500_c(benchmark):
    @benchmark
    def ret():
        global mets_c_500
        benchmark_find_files(500, mets_c_500)
del mets_c_500

# ----------------------------------------------------------------------- #



# ----- 1000 pages -> build, search, build (cached), search (cached) ----- #
mets_1000 = None
@mark.benchmark(group="build", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_b1000(benchmark):
    @benchmark
    def result():
        global mets_1000
        mets_1000 = _build_mets(1000, force=True)

@mark.benchmark(group="search", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_s1000(benchmark):
    @benchmark
    def ret(): 
        global mets_1000
        benchmark_find_files(1000, mets_1000)
del mets_1000

mets_c_1000 = None
@mark.benchmark(group="build_cached", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_b1000_c(benchmark):
    @benchmark
    def result():
        global mets_c_1000
        mets_c_1000 = _build_mets(1000, force=True, cache_flag=True)

@mark.benchmark(group="search_cached", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_s1000_c(benchmark):
    @benchmark
    def ret():
        global mets_c_1000
        benchmark_find_files(1000, mets_c_1000)
del mets_c_1000

# ------------------------------------------------------------------------ #



# ----- 2000 pages -> build, search, build (cached), search (cached) ----- #
mets_2000 = None
@mark.benchmark(group="build", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_b2000(benchmark):
    @benchmark
    def result():
        global mets_2000
        mets_2000 = _build_mets(2000, force=True)

@mark.benchmark(group="search", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_s2000(benchmark):
    @benchmark
    def ret(): 
        global mets_2000
        benchmark_find_files(2000, mets_2000)
del mets_2000

mets_c_2000 = None
@mark.benchmark(group="build_cached", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_b2000_c(benchmark):
    @benchmark
    def result():
        global mets_c_2000
        mets_c_2000 = _build_mets(2000, force=True, cache_flag=True)

@mark.benchmark(group="search_cached", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_s2000_c(benchmark):
    @benchmark
    def ret():
        global mets_c_2000
        benchmark_find_files(2000, mets_c_2000)
del mets_c_2000

# ------------------------------------------------------------------------ #



# ----- 5000 pages -> build, search, build (cached), search (cached) ----- #
mets_5000 = None
@mark.benchmark(group="build", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_b5000(benchmark):
    @benchmark
    def result():
        global mets_5000
        mets_5000 = _build_mets(5000, force=True)

@mark.benchmark(group="search", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_s5000(benchmark):
    @benchmark
    def ret(): 
        global mets_5000
        benchmark_find_files(5000, mets_5000)
del mets_5000

mets_c_5000 = None
@mark.benchmark(group="build_cached", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_b5000_c(benchmark):
    @benchmark
    def result():
        global mets_c_5000
        mets_c_5000 = _build_mets(5000, force=True, cache_flag=True)

@mark.benchmark(group="search_cached", max_time=0.1, min_rounds=1, disable_gc=False, warmup=False)
def test_s5000_c(benchmark):
    @benchmark
    def ret():
        global mets_c_5000
        benchmark_find_files(5000, mets_c_5000)
del mets_c_5000

# ------------------------------------------------------------------------ #

if __name__ == '__main__':
    args = ['']
    # args.append('--benchmark-max-time=10')
    # args.append('--benchmark-min-time=0.1')
    # args.append('--benchmark-warmup=False')
    # args.append('--benchmark-disable-gc')
    args.append('--benchmark-verbose')
    args.append('--benchmark-min-rounds=1')
    args.append('--tb=short')
    main(args)