Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package python-frozendict for openSUSE:Factory checked in at 2023-02-20 17:46:08 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-frozendict (Old) and /work/SRC/openSUSE:Factory/.python-frozendict.new.22824 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-frozendict" Mon Feb 20 17:46:08 2023 rev:7 rq:1066715 version:2.3.5 Changes: -------- --- /work/SRC/openSUSE:Factory/python-frozendict/python-frozendict.changes 2022-08-01 21:34:06.186294084 +0200 +++ /work/SRC/openSUSE:Factory/.python-frozendict.new.22824/python-frozendict.changes 2023-02-20 17:46:37.387692404 +0100 @@ -1,0 +2,14 @@ +Mon Feb 20 05:10:47 UTC 2023 - Marcus Rueckert <[email protected]> + +- disable python 3.11 until it is supported by the C extension + +------------------------------------------------------------------- +Mon Feb 20 05:09:24 UTC 2023 - Marcus Rueckert <[email protected]> + +- Update to 2.3.5 + - C Extension is now optional by default + - Pure py package will be no more pubished on Pypi + - Fixed incompatibility with pyinstaller + - Fixed little bug with mypy + +------------------------------------------------------------------- Old: ---- frozendict-2.3.4.tar.gz New: ---- frozendict-2.3.5.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-frozendict.spec ++++++ --- /var/tmp/diff_new_pack.KFJuY5/_old 2023-02-20 17:46:39.239702865 +0100 +++ /var/tmp/diff_new_pack.KFJuY5/_new 2023-02-20 17:46:39.251702933 +0100 @@ -1,7 +1,7 @@ # # spec file for package python-frozendict # -# Copyright (c) 2022 SUSE LLC +# Copyright (c) 2023 SUSE LLC # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -18,15 +18,17 @@ %{?!python_module:%define python_module() python-%{**} python3-%{**}} %define skip_python2 1 +# as of 2.3.5: if you want to enable 3.11 you would need to disable the C extension test for 3.11 otherwise the build will fails in %check +%define skip_python311 1 # Do not enable multibuild unless seriously necessary, it in # combination with arch is a right mess! Name: python-frozendict -Version: 2.3.4 +Version: 2.3.5 Release: 0 Summary: An immutable dictionary License: MIT Group: Development/Languages/Python -URL: https://github.com/slezica/python-frozendict +URL: https://github.com/Marco-Sulla/python-frozendict Source: https://files.pythonhosted.org/packages/source/f/frozendict/frozendict-%{version}.tar.gz BuildRequires: %{python_module devel} BuildRequires: %{python_module pytest} ++++++ frozendict-2.3.4.tar.gz -> frozendict-2.3.5.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/frozendict-2.3.4/MANIFEST.in new/frozendict-2.3.5/MANIFEST.in --- old/frozendict-2.3.4/MANIFEST.in 2022-07-21 23:26:56.000000000 +0200 +++ new/frozendict-2.3.5/MANIFEST.in 2023-02-17 21:33:49.000000000 +0100 @@ -1,3 +1,4 @@ recursive-include frozendict/src * include test/* include frozendict/py.typed +include frozendict/frozendict.pyi diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/frozendict-2.3.4/PKG-INFO new/frozendict-2.3.5/PKG-INFO --- old/frozendict-2.3.4/PKG-INFO 2022-07-21 23:27:07.304688700 +0200 +++ new/frozendict-2.3.5/PKG-INFO 2023-02-17 21:34:01.142109900 +0100 @@ -1,6 +1,6 @@ Metadata-Version: 2.1 Name: frozendict -Version: 2.3.4 +Version: 2.3.5 Summary: A simple immutable dictionary Home-page: https://github.com/Marco-Sulla/python-frozendict Author: Marco Sulla diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/frozendict-2.3.4/frozendict/VERSION new/frozendict-2.3.5/frozendict/VERSION --- old/frozendict-2.3.4/frozendict/VERSION 2022-07-21 23:26:56.000000000 +0200 +++ new/frozendict-2.3.5/frozendict/VERSION 1970-01-01 01:00:00.000000000 +0100 @@ -1 +0,0 @@ -2.3.4 \ No newline at end of file diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/frozendict-2.3.4/frozendict/__init__.py new/frozendict-2.3.5/frozendict/__init__.py --- old/frozendict-2.3.4/frozendict/__init__.py 2022-07-21 23:26:56.000000000 +0200 +++ new/frozendict-2.3.5/frozendict/__init__.py 2023-02-17 21:33:49.000000000 +0100 @@ -8,6 +8,7 @@ from .core import * c_ext = False +from .version import version as __version__ import collections.abc as _abc if not c_ext: @@ -24,14 +25,8 @@ from pathlib import Path -version_filename = "VERSION" - curr_path = Path(__file__) curr_dir = curr_path.parent -version_path = curr_dir / version_filename - -with open(version_path) as f: - __version__ = f.read() if c_ext: __all__ = ("frozendict", "__version__", ) @@ -43,11 +38,8 @@ __all__ += ("FrozenOrderedDict", ) del Path -del version_filename del curr_path del curr_dir -del version_path -del f del _abc if not c_ext: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/frozendict-2.3.4/frozendict/frozendict.pyi new/frozendict-2.3.5/frozendict/frozendict.pyi --- old/frozendict-2.3.4/frozendict/frozendict.pyi 1970-01-01 01:00:00.000000000 +0100 +++ new/frozendict-2.3.5/frozendict/frozendict.pyi 2023-02-17 21:33:49.000000000 +0100 @@ -0,0 +1,6 @@ +try: + from ._frozendict import * +except ImportError: + from .core import * + +FrozenOrderedDict = frozendict diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/frozendict-2.3.4/frozendict/version.py new/frozendict-2.3.5/frozendict/version.py --- old/frozendict-2.3.4/frozendict/version.py 1970-01-01 01:00:00.000000000 +0100 +++ new/frozendict-2.3.5/frozendict/version.py 2023-02-17 21:33:49.000000000 +0100 @@ -0,0 +1 @@ +version = "2.3.5" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/frozendict-2.3.4/frozendict.egg-info/PKG-INFO new/frozendict-2.3.5/frozendict.egg-info/PKG-INFO --- old/frozendict-2.3.4/frozendict.egg-info/PKG-INFO 2022-07-21 23:27:07.000000000 +0200 +++ new/frozendict-2.3.5/frozendict.egg-info/PKG-INFO 2023-02-17 21:34:01.000000000 +0100 @@ -1,6 +1,6 @@ Metadata-Version: 2.1 Name: frozendict -Version: 2.3.4 +Version: 2.3.5 Summary: A simple immutable dictionary Home-page: https://github.com/Marco-Sulla/python-frozendict Author: Marco Sulla diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/frozendict-2.3.4/frozendict.egg-info/SOURCES.txt new/frozendict-2.3.5/frozendict.egg-info/SOURCES.txt --- old/frozendict-2.3.4/frozendict.egg-info/SOURCES.txt 2022-07-21 23:27:07.000000000 +0200 +++ new/frozendict-2.3.5/frozendict.egg-info/SOURCES.txt 2023-02-17 21:34:01.000000000 +0100 @@ -2,10 +2,11 @@ MANIFEST.in README.md setup.py -frozendict/VERSION frozendict/__init__.py frozendict/core.py +frozendict/frozendict.pyi frozendict/py.typed +frozendict/version.py frozendict.egg-info/PKG-INFO frozendict.egg-info/SOURCES.txt frozendict.egg-info/dependency_links.txt diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/frozendict-2.3.4/setup.py new/frozendict-2.3.5/setup.py --- old/frozendict-2.3.4/setup.py 2022-07-21 23:26:56.000000000 +0200 +++ new/frozendict-2.3.5/setup.py 2023-02-17 21:33:49.000000000 +0100 @@ -4,13 +4,15 @@ from pathlib import Path import sys from platform import python_implementation +from os import environ name = "frozendict" main_package_name = "frozendict" test_dir_name = "test" readme_filename = "README.md" -version_filename = "VERSION" +version_filename = "version.py" py_typed_filename = "py.typed" +mypy_filename = "frozendict.pyi" main_url = "https://github.com/Marco-Sulla/python-frozendict"; bug_url = "https://github.com/Marco-Sulla/python-frozendict/issues"; author = "Marco Sulla" @@ -47,15 +49,15 @@ main_package_path = curr_dir / main_package_name -version = "" version_path = main_package_path / version_filename with open(version_path) as f: - version = f.read() + # create the version var + exec(f.read()) excluded_packages = (test_dir_name, ) packages = setuptools.find_packages(exclude=excluded_packages) -package_data_filenames = (version_filename, py_typed_filename) +package_data_filenames = (version_filename, py_typed_filename, mypy_filename) package_data = {package_name: package_data_filenames for package_name in packages} # C extension - START @@ -108,21 +110,39 @@ undef_macros = [] argv = sys.argv +argv_1_exists = len(argv) > 1 -if argv[1] == "c_debug": +if argv_1_exists and argv[1] == "c_debug": undef_macros = ["NDEBUG"] -ext_modules = [] - -ext_modules.append(setuptools.Extension( - ext1_fullname, - sources = cpython_sources, - include_dirs = cpython_include_dirs, - extra_compile_args = extra_compile_args, - undef_macros = undef_macros, -)) - +def get_ext_module( + fullname, + sources, + include_dirs, + extra_compile_args, + undef_macros, + optional +): + ext_module = setuptools.Extension( + fullname, + sources = sources, + include_dirs = include_dirs, + extra_compile_args = extra_compile_args, + undef_macros = undef_macros, + optional = optional, + ) + + return ext_module +def get_ext_module_1(optional): + return get_ext_module( + fullname = ext1_fullname, + sources = cpython_sources, + include_dirs = cpython_include_dirs, + extra_compile_args = extra_compile_args, + undef_macros = undef_macros, + optional = optional, + ) # C extension - END @@ -154,23 +174,36 @@ custom_arg = None -custom_args = ("py", "c", "c_debug") +custom_args_py = ("py", ) +custom_args_c = ("c", "c_debug") +custom_args = custom_args_py + custom_args_c -if len(argv) > 1 and argv[1] in custom_args: +if argv_1_exists and argv[1] in custom_args: custom_arg = argv[1] - sys.argv = [sys.argv[0]] + sys.argv[2:] + sys.argv = [argv[0]] + argv[2:] impl = python_implementation() +# C Extension is optional by default from version 2.3.5 +optional = True + if custom_arg == None: + # If the module is built by pipeline, C Extension must be mandatory. + optional = environ.get('CIBUILDWHEEL', '0') != '1' + if impl == "PyPy": custom_arg = "py" else: custom_arg = "c" + +elif custom_arg in custom_args_c: + optional = False -if custom_arg == "py": +if custom_arg in custom_args_py: setuptools.setup(**common_setup_args) -elif custom_arg in ("c", "c_debug"): +elif custom_arg in custom_args_c: + ext_module_1 = get_ext_module_1(optional) + ext_modules = [ext_module_1] setuptools.setup(ext_modules = ext_modules, **common_setup_args) else: raise ValueError(f"Unsupported custom_arg {custom_arg}") diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/frozendict-2.3.4/test/debug.py new/frozendict-2.3.5/test/debug.py --- old/frozendict-2.3.4/test/debug.py 2022-07-21 23:26:56.000000000 +0200 +++ new/frozendict-2.3.5/test/debug.py 2023-02-17 21:33:49.000000000 +0100 @@ -7,13 +7,12 @@ from frozendict import frozendict from uuid import uuid4 import pickle -import sys from pathlib import Path from copy import copy, deepcopy from collections.abc import MutableMapping -import functools import tracemalloc import gc +import sys def getUuid(): return str(uuid4()) @@ -65,53 +64,44 @@ flush=True ) -def trace(func): - @functools.wraps(func) - def inner(): - tracemalloc.start() - - snapshot1 = tracemalloc.take_snapshot().filter_traces( - (tracemalloc.Filter(True, __file__), ) - ) - - for i in range(iterations): - func() +def trace(iterations=100): + def decorator(func): + def wrapper(): + print( + f"Loops: {iterations} - Evaluating: {func.__name__}", + flush = True + ) + + tracemalloc.start() + + snapshot1 = tracemalloc.take_snapshot().filter_traces( + (tracemalloc.Filter(True, __file__), ) + ) + + for i in range(iterations): + func() + + gc.collect() + + snapshot2 = tracemalloc.take_snapshot().filter_traces( + (tracemalloc.Filter(True, __file__), ) + ) + + top_stats = snapshot2.compare_to(snapshot1, 'lineno') + tracemalloc.stop() + + for stat in top_stats: + if stat.count_diff * 10 > iterations: + print( + f"Error. stat: {stat}", + flush = True + ) + + sys.exit(1) - gc.collect() - - snapshot2 = tracemalloc.take_snapshot().filter_traces( - (tracemalloc.Filter(True, __file__), ) - ) - - top_stats = snapshot2.compare_to(snapshot1, 'lineno') - tracemalloc.stop() - - for stat in top_stats: - if stat.count_diff > 3: - raise ValueError(f"count_diff: {stat.count_diff}") + return wrapper - return inner - -argv = sys.argv -iterations = None -args_num = 1 -right_len = args_num + 1 -len_argv = len(argv) - -if len_argv == right_len: - try: - iterations = int(argv[1]) - except Exception: - pass - -if len_argv != right_len or iterations == None: - err = ( - f"{Path(__file__).name} should have {args_num} and only " + - f"{args_num} integer parameter" - ) - - print(err, file=sys.stderr) - exit(1) + return decorator key_in = getUuid() dict_1 = {key_in: 0} @@ -131,639 +121,639 @@ functions = [] -@trace +@trace() def func_1(): frozendict_class(dict_1) functions.append(func_1) -@trace +@trace() def func_2(): frozendict_class(dict_unashable) functions.append(func_2) -@trace +@trace() def func_3(): frozendict_class(dict_3) functions.append(func_3) -@trace +@trace() def func_4(): frozendict_class() functions.append(func_4) -@trace +@trace() def func_5(): frozendict_class({}) functions.append(func_5) -@trace +@trace() def func_7(): frozendict_class([]) functions.append(func_7) -@trace +@trace() def func_8(): frozendict_class({}, **{}) functions.append(func_8) -@trace +@trace() def func_9(): frozendict_class(**dict_1) functions.append(func_9) -@trace +@trace() def func_10(): frozendict_class(dict_1, **dict_2) functions.append(func_10) -@trace +@trace() def func_11(): frozendict_class(fd_1) functions.append(func_11) -@trace +@trace() def func_12(): generator_1 = ((key, val) for key, val in dict_1.items()) frozendict_class(generator_1) functions.append(func_12) -@trace +@trace() def func_13(): frozendict_class(dict_hole) functions.append(func_13) -@trace +@trace() def func_14(): fd_1.copy() functions.append(func_14) -@trace +@trace() def func_15(): fd_1 == dict_1 functions.append(func_15) -@trace +@trace() def func_16(): fd_1 == fd_1 functions.append(func_16) -@trace +@trace() def func_17(): fd_1 != dict_hole functions.append(func_17) -@trace +@trace() def func_18(): fd_1 != dict_2 functions.append(func_18) -@trace +@trace() def func_19(): fd_1 == dict_hole functions.append(func_19) -@trace +@trace() def func_20(): fd_1 == dict_2 functions.append(func_20) -# @trace +@trace(iterations=1500) def func_21(): pickle.loads(pickle.dumps(fd_1)) functions.append(func_21) -@trace +@trace() def func_22(): frozendict_class(dict_1_items) functions.append(func_22) -@trace +@trace() def func_23(): tuple(fd_1.keys()) functions.append(func_23) -@trace +@trace() def func_24(): tuple(fd_1.values()) functions.append(func_24) -@trace +@trace() def func_25(): tuple(fd_1.items()) functions.append(func_25) -@trace +@trace() def func_26(): frozendict_class.fromkeys(dict_1) functions.append(func_26) -@trace +@trace() def func_27(): frozendict_class.fromkeys(dict_1, 1) functions.append(func_27) -@trace +@trace() def func_28(): frozendict_class.fromkeys(dict_1_keys) functions.append(func_28) -@trace +@trace() def func_29(): frozendict_class.fromkeys(dict_1_keys, 1) functions.append(func_29) -@trace +@trace() def func_30(): frozendict_class.fromkeys(dict_1_keys_set) functions.append(func_30) -@trace +@trace() def func_31(): frozendict_class.fromkeys(dict_1_keys_set, 1) functions.append(func_31) -@trace +@trace() def func_32(): repr(fd_1) functions.append(func_32) -@trace +@trace() def func_33(): fd_1 | dict_2 functions.append(func_33) -@trace +@trace() def func_34(): hash(fd_1) functions.append(func_34) -@trace +@trace() def func_35(): frozendict_class() == frozendict_class() functions.append(func_35) -@trace +@trace() def func_36(): tuple(reversed(fd_1)) functions.append(func_36) -@trace +@trace() def func_37(): tuple(reversed(fd_1.keys())) functions.append(func_37) -@trace +@trace() def func_38(): tuple(reversed(fd_1.items())) functions.append(func_38) -@trace +@trace() def func_39(): tuple(reversed(fd_1.values())) functions.append(func_39) -@trace +@trace() def func_40(): iter(fd_1).__length_hint__() functions.append(func_40) -@trace +@trace() def func_41(): len(fd_1) functions.append(func_41) -@trace +@trace() def func_42(): len(fd_1.keys()) functions.append(func_42) -@trace +@trace() def func_43(): len(fd_1.items()) functions.append(func_43) -@trace +@trace() def func_44(): len(fd_1.values()) functions.append(func_44) -@trace +@trace() def func_45(): fd_1.keys().mapping == fd_1 functions.append(func_45) -@trace +@trace() def func_46(): fd_1.items().mapping == fd_1 functions.append(func_46) -@trace +@trace() def func_47(): fd_1.values().mapping == fd_1 functions.append(func_47) -@trace +@trace() def func_48(): fd_1[key_in] functions.append(func_48) -@trace +@trace() def func_49(): fd_1.get(key_in) functions.append(func_49) -@trace +@trace() def func_50(): fd_1.get(key_notin) functions.append(func_50) -@trace +@trace() def func_51(): fd_1.get(key_notin, 1) functions.append(func_51) -@trace +@trace() def func_52(): key_in in fd_1 functions.append(func_52) -@trace +@trace() def func_53(): key_notin in fd_1 functions.append(func_53) -@trace +@trace() def func_54(): fd_1.copy() functions.append(func_54) -@trace +@trace() def func_55(): copy(fd_1) functions.append(func_55) -@trace +@trace() def func_56(): deepcopy(fd_1) functions.append(func_56) -@trace +@trace() def func_57(): deepcopy(fd_unashable) functions.append(func_57) -@trace +@trace() def func_58(): fd_1.keys() == dict_1.keys() functions.append(func_58) -@trace +@trace() def func_59(): fd_1.items() == dict_1.items() functions.append(func_59) -@trace +@trace() def func_60(): key_notin in fd_1.keys() functions.append(func_60) -@trace +@trace() def func_61(): (key_notin, 0) in fd_1.items() functions.append(func_61) -@trace +@trace() def func_62(): FMissing(fd_1)[0] functions.append(func_62) -@trace +@trace() def func_63(): mp = Map(dict_1) frozendict_class(mp) == dict_1 functions.append(func_63) -@trace +@trace() def func_64(): fd_1.keys().isdisjoint(dict_3) functions.append(func_64) -@trace +@trace() def func_65(): fd_1.keys().isdisjoint(fd_1) functions.append(func_65) -@trace +@trace() def func_66(): fd_1.items().isdisjoint(dict_3.items()) functions.append(func_66) -@trace +@trace() def func_67(): fd_1.items().isdisjoint(fd_1.items()) functions.append(func_67) -@trace +@trace() def func_68(): fd_unashable.keys() - fd_1.keys() functions.append(func_68) -@trace +@trace() def func_69(): fd_1.items() - frozendict_class(dict_hole).items() functions.append(func_69) -@trace +@trace() def func_70(): fd_1.keys() & frozendict_class(dict_hole).keys() functions.append(func_70) -@trace +@trace() def func_71(): fd_1.items() & frozendict_class(dict_hole).items() functions.append(func_71) -@trace +@trace() def func_72(): fd_1.keys() | frozendict_class(dict_2).keys() functions.append(func_72) -@trace +@trace() def func_73(): fd_1.items() | frozendict_class(dict_2).items() functions.append(func_73) -@trace +@trace() def func_74(): fd_1.keys() ^ frozendict_class(dict_hole).keys() functions.append(func_74) -@trace +@trace() def func_75(): fd_1.items() ^ frozendict_class(dict_hole).items() functions.append(func_75) -# @trace +@trace(iterations=1500) def func_76(): pickle.loads(pickle.dumps(iter(fd_1.keys()))) functions.append(func_76) -# @trace +@trace(iterations=1500) def func_77(): pickle.loads(pickle.dumps(iter(fd_1.items()))) functions.append(func_77) -# @trace +@trace(iterations=1500) def func_78(): pickle.loads(pickle.dumps(iter(fd_1.values()))) functions.append(func_78) -@trace +@trace() def func_79(): frozendict_class(dict_hole).keys() < fd_1.keys() functions.append(func_79) -@trace +@trace() def func_80(): frozendict_class(dict_hole).keys() <= fd_1.keys() functions.append(func_80) -@trace +@trace() def func_81(): frozendict_class(dict_hole).items() < fd_1.items() functions.append(func_81) -@trace +@trace() def func_82(): fd_1.keys() > frozendict_class(dict_hole).keys() functions.append(func_82) -@trace +@trace() def func_83(): fd_1.keys() >= frozendict_class(dict_hole).keys() functions.append(func_83) -@trace +@trace() def func_84(): fd_1.items() > frozendict_class(dict_hole).items() functions.append(func_84) -@trace +@trace() def func_85(): fd_1.items() >= frozendict_class(dict_hole).items() functions.append(func_85) -@trace +@trace() def func_86(): fd_1.set(key_in, 1000) functions.append(func_86) -@trace +@trace() def func_87(): fd_1.set(key_notin, 1000) functions.append(func_87) -@trace +@trace() def func_88(): fd_1.delete(key_in) functions.append(func_88) -@trace +@trace() def func_89(): fd_1.setdefault(key_in) functions.append(func_89) -@trace +@trace() def func_90(): fd_1.setdefault(key_notin) functions.append(func_90) -@trace +@trace() def func_91(): fd_1.setdefault(key_notin, 1000) functions.append(func_91) -@trace +@trace() def func_92(): fd_1.key() functions.append(func_92) -@trace +@trace() def func_93(): fd_1.key(0) functions.append(func_93) -@trace +@trace() def func_94(): fd_1.key(-1) functions.append(func_94) -@trace +@trace() def func_95(): fd_1.value() functions.append(func_95) -@trace +@trace() def func_96(): fd_1.value(0) functions.append(func_96) -@trace +@trace() def func_97(): fd_1.value(-1) functions.append(func_97) -@trace +@trace() def func_98(): fd_1.item() functions.append(func_98) -@trace +@trace() def func_99(): fd_1.item(0) functions.append(func_99) -@trace +@trace() def func_100(): fd_1.item(-1) functions.append(func_100) -@trace +@trace() def func_101(): for x in fd_1: pass functions.append(func_101) -@trace +@trace() def func_102(): for x in iter(fd_1): pass functions.append(func_102) -@trace +@trace() def func_103(): for x in fd_1.keys(): pass functions.append(func_103) -@trace +@trace() def func_104(): for x in fd_1.values(): pass functions.append(func_104) -@trace +@trace() def func_105(): for x in fd_1.items(): pass functions.append(func_105) -@trace +@trace() def func_106(): try: hash(fd_unashable) @@ -772,7 +762,7 @@ functions.append(func_106) -@trace +@trace() def func_107(): try: fd_1[key_notin] @@ -781,7 +771,7 @@ functions.append(func_107) -@trace +@trace() def func_108(): try: fd_1.key(len(fd_1)) @@ -791,7 +781,7 @@ functions.append(func_108) -@trace +@trace() def func_109(): try: fd_1.value(len(fd_1)) @@ -800,7 +790,7 @@ functions.append(func_109) -@trace +@trace() def func_110(): try: fd_1.item(len(fd_1)) @@ -809,12 +799,14 @@ functions.append(func_110) + + print_sep() for frozendict_class in (frozendict, F): print_info( frozendict_class, - iterations, + 1, "frozendict_class(dict_1)" ) @@ -822,7 +814,7 @@ print_sep() print_info( frozendict_class, - iterations, + 1, "frozendict_class(dict_unashable)" ) @@ -830,7 +822,11 @@ print_sep() for function in functions: - print_info(frozendict_class, iterations, function) + print( + f"Class = {frozendict_class.__name__} - ", + flush = True, + end = "" + ) function()
