diff -pruN 2.37-1/CHANGELOG 2.38-1/CHANGELOG --- 2.37-1/CHANGELOG 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/CHANGELOG 2025-09-21 18:58:09.000000000 +0000 @@ -1,3 +1,10 @@ +2.38 +==== +* Fix unintended behaviour where a `str` could be loaded as `list[str]` + This is caused by a [quirk of python's types](https://github.com/python/typing/issues/256). + To restore the previous behaviour set `iterstr=True` +* Drop support to python 3.9 + 2.37 ==== * Do not use new syntax in any place. diff -pruN 2.37-1/Makefile 2.38-1/Makefile --- 2.37-1/Makefile 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/Makefile 2025-09-21 18:58:09.000000000 +0000 @@ -1,4 +1,4 @@ -MINIMUM_PYTHON_VERSION=3.9 +MINIMUM_PYTHON_VERSION=3.10 all: pypi diff -pruN 2.37-1/README.md 2.38-1/README.md --- 2.37-1/README.md 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/README.md 2025-09-21 18:58:09.000000000 +0000 @@ -48,10 +48,10 @@ Can be treated more easily if loaded int class User: username: str shell: str = 'bash' - sessions: List[str] = dataclasses.field(default_factory=list) + sessions: list[str] = dataclasses.field(default_factory=list) class Logins(NamedTuple): - users: List[User] + users: list[User] ``` And the data can be loaded into the structure with this: @@ -77,11 +77,11 @@ The following things are supported: * NamedTuple * Enum * Optional[SomeType] - * List[SomeType] - * Dict[TypeA, TypeB] - * Tuple[TypeA, TypeB, TypeC] and Tuple[SomeType, ...] - * Set[SomeType] - * Union[TypeA, TypeB] + * list[SomeType] + * dict[TypeA, TypeB] + * tuple[TypeA, TypeB, TypeC] and tuple[SomeType, ...] + * set[SomeType] + * TypeA | TypeB * dataclass * attr.s * ForwardRef (Refer to the type in its own definition) @@ -109,14 +109,14 @@ Mypy and similar tools work without requ # This is treated as Any, no checks done. data = json.load(f) -# This is treated as Dict[str, int] +# This is treated as dict[str, int] # but there will be runtime errors if the data does not # match the expected format -data = json.load(f) # type: Dict[str, int] +data = json.load(f) # type: dict[str, int] -# This is treated as Dict[str, int] and an exception is -# raised if the actual data is not Dict[str, int] -data = typedload.load(json.load(f), Dict[str, int]) +# This is treated as dict[str, int] and an exception is +# raised if the actual data is not dict[str, int] +data = typedload.load(json.load(f), dict[str, int]) ``` So when using Mypy, it makes sense to make sure that the type is correct, @@ -150,6 +150,7 @@ Used by As dependency, typedload is used by those entities. Feel free to add to the list. +* The USA armed forces (regrettably) (via [Appgate](https://www.appgate.com/federal-division)) * [Lyft](https://eng.lyft.com/python-upgrade-playbook-1479145d52f4) * Several universities around the world (via [Relational](https://ltworf.codeberg.page/relational/)) * People who love IRC (via [localslackirc](https://github.com/ltworf/localslackirc)) diff -pruN 2.37-1/debian/changelog 2.38-1/debian/changelog --- 2.37-1/debian/changelog 2024-11-26 12:03:09.000000000 +0000 +++ 2.38-1/debian/changelog 2025-09-22 06:29:00.000000000 +0000 @@ -1,3 +1,9 @@ +typedload (2.38-1) unstable; urgency=medium + + * New upstream release + + -- Salvo 'LtWorf' Tomaselli Mon, 22 Sep 2025 08:29:00 +0200 + typedload (2.37-1) unstable; urgency=medium * New upstream release diff -pruN 2.37-1/docs/3.10_dump_objects.svg 2.38-1/docs/3.10_dump_objects.svg --- 2.37-1/docs/3.10_dump_objects.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.10_dump_objects.svg 1970-01-01 00:00:00.000000000 +0000 @@ -1,149 +0,0 @@ - - - -Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 0 - - - - - 1 - - - - - 2 - - - - - 3 - - - - - 4 - - - - - 5 - - - - - pydantic2 - - - - - apischema - - - - - 2.34 - - - - - 2.35 - - - - - 2.36 - - - - - - - - - dump objects - - - dump objects - - - - - - - - - - - - - - - - - - - - - - seconds - - - - - x-units - - - - - - - typedload performance test python 3.10.14 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz - - - - - - - diff -pruN 2.37-1/docs/3.10_fail_load_list_of_floats_and_ints.svg 2.38-1/docs/3.10_fail_load_list_of_floats_and_ints.svg --- 2.37-1/docs/3.10_fail_load_list_of_floats_and_ints.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.10_fail_load_list_of_floats_and_ints.svg 1970-01-01 00:00:00.000000000 +0000 @@ -1,154 +0,0 @@ - - - -Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 0 - - - - - 0.5 - - - - - 1 - - - - - 1.5 - - - - - 2 - - - - - 2.5 - - - - - 3 - - - - - pydantic2 - - - - - apischema - - - - - 2.34 - - - - - 2.35 - - - - - 2.36 - - - - - - - - - fail load list of floats and ints - - - fail load list of floats and ints - - - - - - - - - - - - - - - - - - - - - - seconds - - - - - x-units - - - - - - - typedload performance test python 3.10.14 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz - - - - - - - diff -pruN 2.37-1/docs/3.10_fail_tagged_union_of_objects.svg 2.38-1/docs/3.10_fail_tagged_union_of_objects.svg --- 2.37-1/docs/3.10_fail_tagged_union_of_objects.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.10_fail_tagged_union_of_objects.svg 1970-01-01 00:00:00.000000000 +0000 @@ -1,149 +0,0 @@ - - - -Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 0 - - - - - 1 - - - - - 2 - - - - - 3 - - - - - 4 - - - - - 5 - - - - - pydantic2 - - - - - apischema - - - - - 2.34 - - - - - 2.35 - - - - - 2.36 - - - - - - - - - fail tagged union of objects - - - fail tagged union of objects - - - - - - - - - - - - - - - - - - - - - - seconds - - - - - x-units - - - - - - - typedload performance test python 3.10.14 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz - - - - - - - diff -pruN 2.37-1/docs/3.10_load_big_dictionary.svg 2.38-1/docs/3.10_load_big_dictionary.svg --- 2.37-1/docs/3.10_load_big_dictionary.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.10_load_big_dictionary.svg 1970-01-01 00:00:00.000000000 +0000 @@ -1,164 +0,0 @@ - - - -Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 0 - - - - - 1 - - - - - 2 - - - - - 3 - - - - - 4 - - - - - 5 - - - - - 6 - - - - - 7 - - - - - 8 - - - - - pydantic2 - - - - - apischema - - - - - 2.34 - - - - - 2.35 - - - - - 2.36 - - - - - - - - - load big dictionary - - - load big dictionary - - - - - - - - - - - - - - - - - - - - - - seconds - - - - - x-units - - - - - - - typedload performance test python 3.10.14 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz - - - - - - - diff -pruN 2.37-1/docs/3.10_load_dictionary_of_tuples.svg 2.38-1/docs/3.10_load_dictionary_of_tuples.svg --- 2.37-1/docs/3.10_load_dictionary_of_tuples.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.10_load_dictionary_of_tuples.svg 1970-01-01 00:00:00.000000000 +0000 @@ -1,154 +0,0 @@ - - - -Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 0 - - - - - 1 - - - - - 2 - - - - - 3 - - - - - 4 - - - - - 5 - - - - - 6 - - - - - pydantic2 - - - - - apischema - - - - - 2.34 - - - - - 2.35 - - - - - 2.36 - - - - - - - - - load dictionary of tuples - - - load dictionary of tuples - - - - - - - - - - - - - - - - - - - - - - seconds - - - - - x-units - - - - - - - typedload performance test python 3.10.14 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz - - - - - - - diff -pruN 2.37-1/docs/3.10_load_list_of_NamedTuple_objects.svg 2.38-1/docs/3.10_load_list_of_NamedTuple_objects.svg --- 2.37-1/docs/3.10_load_list_of_NamedTuple_objects.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.10_load_list_of_NamedTuple_objects.svg 1970-01-01 00:00:00.000000000 +0000 @@ -1,154 +0,0 @@ - - - -Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 0 - - - - - 1 - - - - - 2 - - - - - 3 - - - - - 4 - - - - - 5 - - - - - 6 - - - - - pydantic2 - - - - - apischema - - - - - 2.34 - - - - - 2.35 - - - - - 2.36 - - - - - - - - - load list of NamedTuple objects - - - load list of NamedTuple objects - - - - - - - - - - - - - - - - - - - - - - seconds - - - - - x-units - - - - - - - typedload performance test python 3.10.14 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz - - - - - - - diff -pruN 2.37-1/docs/3.10_load_list_of_attrs_objects.svg 2.38-1/docs/3.10_load_list_of_attrs_objects.svg --- 2.37-1/docs/3.10_load_list_of_attrs_objects.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.10_load_list_of_attrs_objects.svg 1970-01-01 00:00:00.000000000 +0000 @@ -1,169 +0,0 @@ - - - -Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -0.1 - - - - - -0.05 - - - - - 0 - - - - - 0.05 - - - - - 0.1 - - - - - 0.15 - - - - - 0.2 - - - - - 0.25 - - - - - 0.3 - - - - - 0.35 - - - - - pydantic2 - - - - - apischema - - - - - 2.34 - - - - - 2.35 - - - - - 2.36 - - - - - - - - - load list of attrs objects - - - load list of attrs objects - - - - - - - - - - - - - - - - - - - - - - seconds - - - - - x-units - - - - - - - typedload performance test python 3.10.14 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz - - - - - - - diff -pruN 2.37-1/docs/3.10_load_list_of_dataclass_objects.svg 2.38-1/docs/3.10_load_list_of_dataclass_objects.svg --- 2.37-1/docs/3.10_load_list_of_dataclass_objects.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.10_load_list_of_dataclass_objects.svg 1970-01-01 00:00:00.000000000 +0000 @@ -1,149 +0,0 @@ - - - -Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 0 - - - - - 1 - - - - - 2 - - - - - 3 - - - - - 4 - - - - - 5 - - - - - pydantic2 - - - - - apischema - - - - - 2.34 - - - - - 2.35 - - - - - 2.36 - - - - - - - - - load list of dataclass objects - - - load list of dataclass objects - - - - - - - - - - - - - - - - - - - - - - seconds - - - - - x-units - - - - - - - typedload performance test python 3.10.14 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz - - - - - - - diff -pruN 2.37-1/docs/3.10_load_list_of_floats_and_ints.svg 2.38-1/docs/3.10_load_list_of_floats_and_ints.svg --- 2.37-1/docs/3.10_load_list_of_floats_and_ints.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.10_load_list_of_floats_and_ints.svg 1970-01-01 00:00:00.000000000 +0000 @@ -1,164 +0,0 @@ - - - -Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 0 - - - - - 0.5 - - - - - 1 - - - - - 1.5 - - - - - 2 - - - - - 2.5 - - - - - 3 - - - - - 3.5 - - - - - 4 - - - - - pydantic2 - - - - - apischema - - - - - 2.34 - - - - - 2.35 - - - - - 2.36 - - - - - - - - - load list of floats and ints - - - load list of floats and ints - - - - - - - - - - - - - - - - - - - - - - seconds - - - - - x-units - - - - - - - typedload performance test python 3.10.14 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz - - - - - - - diff -pruN 2.37-1/docs/3.10_load_list_of_ints.svg 2.38-1/docs/3.10_load_list_of_ints.svg --- 2.37-1/docs/3.10_load_list_of_ints.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.10_load_list_of_ints.svg 1970-01-01 00:00:00.000000000 +0000 @@ -1,149 +0,0 @@ - - - -Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 0 - - - - - 0.5 - - - - - 1 - - - - - 1.5 - - - - - 2 - - - - - 2.5 - - - - - pydantic2 - - - - - apischema - - - - - 2.34 - - - - - 2.35 - - - - - 2.36 - - - - - - - - - load list of ints - - - load list of ints - - - - - - - - - - - - - - - - - - - - - - seconds - - - - - x-units - - - - - - - typedload performance test python 3.10.14 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz - - - - - - - diff -pruN 2.37-1/docs/3.10_load_list_of_large_NamedTuples.svg 2.38-1/docs/3.10_load_list_of_large_NamedTuples.svg --- 2.37-1/docs/3.10_load_list_of_large_NamedTuples.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.10_load_list_of_large_NamedTuples.svg 1970-01-01 00:00:00.000000000 +0000 @@ -1,154 +0,0 @@ - - - -Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -0.1 - - - - - 0 - - - - - 0.1 - - - - - 0.2 - - - - - 0.3 - - - - - 0.4 - - - - - 0.5 - - - - - pydantic2 - - - - - apischema - - - - - 2.34 - - - - - 2.35 - - - - - 2.36 - - - - - - - - - load list of large NamedTuples - - - load list of large NamedTuples - - - - - - - - - - - - - - - - - - - - - - seconds - - - - - x-units - - - - - - - typedload performance test python 3.10.14 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz - - - - - - - diff -pruN 2.37-1/docs/3.10_load_list_of_lists.svg 2.38-1/docs/3.10_load_list_of_lists.svg --- 2.37-1/docs/3.10_load_list_of_lists.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.10_load_list_of_lists.svg 1970-01-01 00:00:00.000000000 +0000 @@ -1,144 +0,0 @@ - - - -Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 0 - - - - - 0.5 - - - - - 1 - - - - - 1.5 - - - - - 2 - - - - - pydantic2 - - - - - apischema - - - - - 2.34 - - - - - 2.35 - - - - - 2.36 - - - - - - - - - load list of lists - - - load list of lists - - - - - - - - - - - - - - - - - - - - - - seconds - - - - - x-units - - - - - - - typedload performance test python 3.10.14 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz - - - - - - - diff -pruN 2.37-1/docs/3.10_load_with_alias.svg 2.38-1/docs/3.10_load_with_alias.svg --- 2.37-1/docs/3.10_load_with_alias.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.10_load_with_alias.svg 1970-01-01 00:00:00.000000000 +0000 @@ -1,149 +0,0 @@ - - - -Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -0.1 - - - - - -0.08 - - - - - -0.06 - - - - - -0.04 - - - - - -0.02 - - - - - 0 - - - - - pydantic2 - - - - - apischema - - - - - 2.34 - - - - - 2.35 - - - - - 2.36 - - - - - - - - - load with alias - - - load with alias - - - - - - - - - - - - - - - - - - - - - - seconds - - - - - x-units - - - - - - - typedload performance test python 3.10.14 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz - - - - - - - diff -pruN 2.37-1/docs/3.10_tagged_union_of_objects.svg 2.38-1/docs/3.10_tagged_union_of_objects.svg --- 2.37-1/docs/3.10_tagged_union_of_objects.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.10_tagged_union_of_objects.svg 1970-01-01 00:00:00.000000000 +0000 @@ -1,169 +0,0 @@ - - - -Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 0 - - - - - 0.5 - - - - - 1 - - - - - 1.5 - - - - - 2 - - - - - 2.5 - - - - - 3 - - - - - 3.5 - - - - - 4 - - - - - 4.5 - - - - - pydantic2 - - - - - apischema - - - - - 2.34 - - - - - 2.35 - - - - - 2.36 - - - - - - - - - tagged union of objects - - - tagged union of objects - - - - - - - - - - - - - - - - - - - - - - seconds - - - - - x-units - - - - - - - typedload performance test python 3.10.14 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz - - - - - - - diff -pruN 2.37-1/docs/3.11_dump_objects.svg 2.38-1/docs/3.11_dump_objects.svg --- 2.37-1/docs/3.11_dump_objects.svg 1970-01-01 00:00:00.000000000 +0000 +++ 2.38-1/docs/3.11_dump_objects.svg 2025-09-21 23:16:59.000000000 +0000 @@ -0,0 +1,164 @@ + + + +Gnuplot +Produced by GNUPLOT 6.0 patchlevel 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + 0.5 + + + + + 1 + + + + + 1.5 + + + + + 2 + + + + + 2.5 + + + + + 3 + + + + + 3.5 + + + + + 4 + + + + + pydantic2 + + + + + apischema + + + + + 2.36 + + + + + 2.37 + + + + + 2.38 + + + + + + + + + dump objects + + + dump objects + + + + + + + + + + + + + + + + + + + + + + seconds + + + + + x-units + + + + + + + typedload performance test python 3.11.13 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + + + + + + + diff -pruN 2.37-1/docs/3.11_fail_load_list_of_floats_and_ints.svg 2.38-1/docs/3.11_fail_load_list_of_floats_and_ints.svg --- 2.37-1/docs/3.11_fail_load_list_of_floats_and_ints.svg 1970-01-01 00:00:00.000000000 +0000 +++ 2.38-1/docs/3.11_fail_load_list_of_floats_and_ints.svg 2025-09-21 23:16:59.000000000 +0000 @@ -0,0 +1,154 @@ + + + +Gnuplot +Produced by GNUPLOT 6.0 patchlevel 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + 0.5 + + + + + 1 + + + + + 1.5 + + + + + 2 + + + + + 2.5 + + + + + 3 + + + + + pydantic2 + + + + + apischema + + + + + 2.36 + + + + + 2.37 + + + + + 2.38 + + + + + + + + + fail load list of floats and ints + + + fail load list of floats and ints + + + + + + + + + + + + + + + + + + + + + + seconds + + + + + x-units + + + + + + + typedload performance test python 3.11.13 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + + + + + + + diff -pruN 2.37-1/docs/3.11_fail_tagged_union_of_objects.svg 2.38-1/docs/3.11_fail_tagged_union_of_objects.svg --- 2.37-1/docs/3.11_fail_tagged_union_of_objects.svg 1970-01-01 00:00:00.000000000 +0000 +++ 2.38-1/docs/3.11_fail_tagged_union_of_objects.svg 2025-09-21 23:16:59.000000000 +0000 @@ -0,0 +1,149 @@ + + + +Gnuplot +Produced by GNUPLOT 6.0 patchlevel 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + 1 + + + + + 2 + + + + + 3 + + + + + 4 + + + + + 5 + + + + + pydantic2 + + + + + apischema + + + + + 2.36 + + + + + 2.37 + + + + + 2.38 + + + + + + + + + fail tagged union of objects + + + fail tagged union of objects + + + + + + + + + + + + + + + + + + + + + + seconds + + + + + x-units + + + + + + + typedload performance test python 3.11.13 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + + + + + + + diff -pruN 2.37-1/docs/3.11_load_big_dictionary.svg 2.38-1/docs/3.11_load_big_dictionary.svg --- 2.37-1/docs/3.11_load_big_dictionary.svg 1970-01-01 00:00:00.000000000 +0000 +++ 2.38-1/docs/3.11_load_big_dictionary.svg 2025-09-21 23:16:59.000000000 +0000 @@ -0,0 +1,164 @@ + + + +Gnuplot +Produced by GNUPLOT 6.0 patchlevel 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + 1 + + + + + 2 + + + + + 3 + + + + + 4 + + + + + 5 + + + + + 6 + + + + + 7 + + + + + 8 + + + + + pydantic2 + + + + + apischema + + + + + 2.36 + + + + + 2.37 + + + + + 2.38 + + + + + + + + + load big dictionary + + + load big dictionary + + + + + + + + + + + + + + + + + + + + + + seconds + + + + + x-units + + + + + + + typedload performance test python 3.11.13 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + + + + + + + diff -pruN 2.37-1/docs/3.11_load_dictionary_of_tuples.svg 2.38-1/docs/3.11_load_dictionary_of_tuples.svg --- 2.37-1/docs/3.11_load_dictionary_of_tuples.svg 1970-01-01 00:00:00.000000000 +0000 +++ 2.38-1/docs/3.11_load_dictionary_of_tuples.svg 2025-09-21 23:16:59.000000000 +0000 @@ -0,0 +1,154 @@ + + + +Gnuplot +Produced by GNUPLOT 6.0 patchlevel 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + 1 + + + + + 2 + + + + + 3 + + + + + 4 + + + + + 5 + + + + + 6 + + + + + pydantic2 + + + + + apischema + + + + + 2.36 + + + + + 2.37 + + + + + 2.38 + + + + + + + + + load dictionary of tuples + + + load dictionary of tuples + + + + + + + + + + + + + + + + + + + + + + seconds + + + + + x-units + + + + + + + typedload performance test python 3.11.13 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + + + + + + + diff -pruN 2.37-1/docs/3.11_load_list_of_NamedTuple_objects.svg 2.38-1/docs/3.11_load_list_of_NamedTuple_objects.svg --- 2.37-1/docs/3.11_load_list_of_NamedTuple_objects.svg 1970-01-01 00:00:00.000000000 +0000 +++ 2.38-1/docs/3.11_load_list_of_NamedTuple_objects.svg 2025-09-21 23:16:59.000000000 +0000 @@ -0,0 +1,154 @@ + + + +Gnuplot +Produced by GNUPLOT 6.0 patchlevel 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + 1 + + + + + 2 + + + + + 3 + + + + + 4 + + + + + 5 + + + + + 6 + + + + + pydantic2 + + + + + apischema + + + + + 2.36 + + + + + 2.37 + + + + + 2.38 + + + + + + + + + load list of NamedTuple objects + + + load list of NamedTuple objects + + + + + + + + + + + + + + + + + + + + + + seconds + + + + + x-units + + + + + + + typedload performance test python 3.11.13 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + + + + + + + diff -pruN 2.37-1/docs/3.11_load_list_of_attrs_objects.svg 2.38-1/docs/3.11_load_list_of_attrs_objects.svg --- 2.37-1/docs/3.11_load_list_of_attrs_objects.svg 1970-01-01 00:00:00.000000000 +0000 +++ 2.38-1/docs/3.11_load_list_of_attrs_objects.svg 2025-09-21 23:16:59.000000000 +0000 @@ -0,0 +1,169 @@ + + + +Gnuplot +Produced by GNUPLOT 6.0 patchlevel 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + -0.1 + + + + + -0.05 + + + + + 0 + + + + + 0.05 + + + + + 0.1 + + + + + 0.15 + + + + + 0.2 + + + + + 0.25 + + + + + 0.3 + + + + + 0.35 + + + + + pydantic2 + + + + + apischema + + + + + 2.36 + + + + + 2.37 + + + + + 2.38 + + + + + + + + + load list of attrs objects + + + load list of attrs objects + + + + + + + + + + + + + + + + + + + + + + seconds + + + + + x-units + + + + + + + typedload performance test python 3.11.13 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + + + + + + + diff -pruN 2.37-1/docs/3.11_load_list_of_dataclass_objects.svg 2.38-1/docs/3.11_load_list_of_dataclass_objects.svg --- 2.37-1/docs/3.11_load_list_of_dataclass_objects.svg 1970-01-01 00:00:00.000000000 +0000 +++ 2.38-1/docs/3.11_load_list_of_dataclass_objects.svg 2025-09-21 23:16:59.000000000 +0000 @@ -0,0 +1,149 @@ + + + +Gnuplot +Produced by GNUPLOT 6.0 patchlevel 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + 1 + + + + + 2 + + + + + 3 + + + + + 4 + + + + + 5 + + + + + pydantic2 + + + + + apischema + + + + + 2.36 + + + + + 2.37 + + + + + 2.38 + + + + + + + + + load list of dataclass objects + + + load list of dataclass objects + + + + + + + + + + + + + + + + + + + + + + seconds + + + + + x-units + + + + + + + typedload performance test python 3.11.13 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + + + + + + + diff -pruN 2.37-1/docs/3.11_load_list_of_floats_and_ints.svg 2.38-1/docs/3.11_load_list_of_floats_and_ints.svg --- 2.37-1/docs/3.11_load_list_of_floats_and_ints.svg 1970-01-01 00:00:00.000000000 +0000 +++ 2.38-1/docs/3.11_load_list_of_floats_and_ints.svg 2025-09-21 23:16:59.000000000 +0000 @@ -0,0 +1,164 @@ + + + +Gnuplot +Produced by GNUPLOT 6.0 patchlevel 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + 0.5 + + + + + 1 + + + + + 1.5 + + + + + 2 + + + + + 2.5 + + + + + 3 + + + + + 3.5 + + + + + 4 + + + + + pydantic2 + + + + + apischema + + + + + 2.36 + + + + + 2.37 + + + + + 2.38 + + + + + + + + + load list of floats and ints + + + load list of floats and ints + + + + + + + + + + + + + + + + + + + + + + seconds + + + + + x-units + + + + + + + typedload performance test python 3.11.13 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + + + + + + + diff -pruN 2.37-1/docs/3.11_load_list_of_ints.svg 2.38-1/docs/3.11_load_list_of_ints.svg --- 2.37-1/docs/3.11_load_list_of_ints.svg 1970-01-01 00:00:00.000000000 +0000 +++ 2.38-1/docs/3.11_load_list_of_ints.svg 2025-09-21 23:16:59.000000000 +0000 @@ -0,0 +1,149 @@ + + + +Gnuplot +Produced by GNUPLOT 6.0 patchlevel 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + 0.5 + + + + + 1 + + + + + 1.5 + + + + + 2 + + + + + 2.5 + + + + + pydantic2 + + + + + apischema + + + + + 2.36 + + + + + 2.37 + + + + + 2.38 + + + + + + + + + load list of ints + + + load list of ints + + + + + + + + + + + + + + + + + + + + + + seconds + + + + + x-units + + + + + + + typedload performance test python 3.11.13 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + + + + + + + diff -pruN 2.37-1/docs/3.11_load_list_of_large_NamedTuples.svg 2.38-1/docs/3.11_load_list_of_large_NamedTuples.svg --- 2.37-1/docs/3.11_load_list_of_large_NamedTuples.svg 1970-01-01 00:00:00.000000000 +0000 +++ 2.38-1/docs/3.11_load_list_of_large_NamedTuples.svg 2025-09-21 23:16:59.000000000 +0000 @@ -0,0 +1,154 @@ + + + +Gnuplot +Produced by GNUPLOT 6.0 patchlevel 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + -0.1 + + + + + 0 + + + + + 0.1 + + + + + 0.2 + + + + + 0.3 + + + + + 0.4 + + + + + 0.5 + + + + + pydantic2 + + + + + apischema + + + + + 2.36 + + + + + 2.37 + + + + + 2.38 + + + + + + + + + load list of large NamedTuples + + + load list of large NamedTuples + + + + + + + + + + + + + + + + + + + + + + seconds + + + + + x-units + + + + + + + typedload performance test python 3.11.13 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + + + + + + + diff -pruN 2.37-1/docs/3.11_load_list_of_lists.svg 2.38-1/docs/3.11_load_list_of_lists.svg --- 2.37-1/docs/3.11_load_list_of_lists.svg 1970-01-01 00:00:00.000000000 +0000 +++ 2.38-1/docs/3.11_load_list_of_lists.svg 2025-09-21 23:16:59.000000000 +0000 @@ -0,0 +1,149 @@ + + + +Gnuplot +Produced by GNUPLOT 6.0 patchlevel 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + 0.5 + + + + + 1 + + + + + 1.5 + + + + + 2 + + + + + 2.5 + + + + + pydantic2 + + + + + apischema + + + + + 2.36 + + + + + 2.37 + + + + + 2.38 + + + + + + + + + load list of lists + + + load list of lists + + + + + + + + + + + + + + + + + + + + + + seconds + + + + + x-units + + + + + + + typedload performance test python 3.11.13 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + + + + + + + diff -pruN 2.37-1/docs/3.11_load_with_alias.svg 2.38-1/docs/3.11_load_with_alias.svg --- 2.37-1/docs/3.11_load_with_alias.svg 1970-01-01 00:00:00.000000000 +0000 +++ 2.38-1/docs/3.11_load_with_alias.svg 2025-09-21 23:16:59.000000000 +0000 @@ -0,0 +1,149 @@ + + + +Gnuplot +Produced by GNUPLOT 6.0 patchlevel 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + -0.1 + + + + + -0.08 + + + + + -0.06 + + + + + -0.04 + + + + + -0.02 + + + + + 0 + + + + + pydantic2 + + + + + apischema + + + + + 2.36 + + + + + 2.37 + + + + + 2.38 + + + + + + + + + load with alias + + + load with alias + + + + + + + + + + + + + + + + + + + + + + seconds + + + + + x-units + + + + + + + typedload performance test python 3.11.13 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + + + + + + + diff -pruN 2.37-1/docs/3.11_tagged_union_of_objects.svg 2.38-1/docs/3.11_tagged_union_of_objects.svg --- 2.37-1/docs/3.11_tagged_union_of_objects.svg 1970-01-01 00:00:00.000000000 +0000 +++ 2.38-1/docs/3.11_tagged_union_of_objects.svg 2025-09-21 23:16:59.000000000 +0000 @@ -0,0 +1,149 @@ + + + +Gnuplot +Produced by GNUPLOT 6.0 patchlevel 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + 1 + + + + + 2 + + + + + 3 + + + + + 4 + + + + + 5 + + + + + pydantic2 + + + + + apischema + + + + + 2.36 + + + + + 2.37 + + + + + 2.38 + + + + + + + + + tagged union of objects + + + tagged union of objects + + + + + + + + + + + + + + + + + + + + + + seconds + + + + + x-units + + + + + + + typedload performance test python 3.11.13 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + + + + + + + diff -pruN 2.37-1/docs/3.13_dump_objects.svg 2.38-1/docs/3.13_dump_objects.svg --- 2.37-1/docs/3.13_dump_objects.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.13_dump_objects.svg 2025-09-21 23:16:59.000000000 +0000 @@ -7,7 +7,7 @@ > Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 +Produced by GNUPLOT 6.0 patchlevel 3 @@ -42,46 +42,36 @@ - + 0 - + 0.2 - + 0.4 - + 0.6 - + 0.8 - + 1 - - 1.2 - - - - - 1.4 - - - pydantic2 @@ -93,17 +83,17 @@ - 2.34 + 2.36 - 2.35 + 2.37 - 2.36 + 2.38 @@ -121,11 +111,11 @@ - - - - - + + + + + @@ -149,7 +139,7 @@ - typedload performance test python 3.13.0 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + typedload performance test python 3.13.7 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz diff -pruN 2.37-1/docs/3.13_fail_load_list_of_floats_and_ints.svg 2.38-1/docs/3.13_fail_load_list_of_floats_and_ints.svg --- 2.37-1/docs/3.13_fail_load_list_of_floats_and_ints.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.13_fail_load_list_of_floats_and_ints.svg 2025-09-21 23:16:59.000000000 +0000 @@ -7,7 +7,7 @@ > Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 +Produced by GNUPLOT 6.0 patchlevel 3 @@ -42,36 +42,31 @@ - + 0 - + 0.2 - + 0.4 - + 0.6 - + 0.8 - - 1 - - - pydantic2 @@ -83,17 +78,17 @@ - 2.34 + 2.36 - 2.35 + 2.37 - 2.36 + 2.38 @@ -111,11 +106,11 @@ - - - - - + + + + + @@ -139,7 +134,7 @@ - typedload performance test python 3.13.0 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + typedload performance test python 3.13.7 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz diff -pruN 2.37-1/docs/3.13_fail_tagged_union_of_objects.svg 2.38-1/docs/3.13_fail_tagged_union_of_objects.svg --- 2.37-1/docs/3.13_fail_tagged_union_of_objects.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.13_fail_tagged_union_of_objects.svg 2025-09-21 23:16:59.000000000 +0000 @@ -7,7 +7,7 @@ > Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 +Produced by GNUPLOT 6.0 patchlevel 3 @@ -42,59 +42,79 @@ - + 0 - + + 0.5 + + + + 1 - + + 1.5 + + + + 2 - + + 2.5 + + + + 3 - + + 3.5 + + + + 4 - + pydantic2 - + apischema - - 2.34 + + 2.36 - - 2.35 + + 2.37 - - 2.36 + + 2.38 - + fail tagged union of objects @@ -106,11 +126,11 @@ - - - - - + + + + + @@ -121,20 +141,20 @@ - + seconds - + x-units - - typedload performance test python 3.13.0 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + + typedload performance test python 3.13.7 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz diff -pruN 2.37-1/docs/3.13_load_big_dictionary.svg 2.38-1/docs/3.13_load_big_dictionary.svg --- 2.37-1/docs/3.13_load_big_dictionary.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.13_load_big_dictionary.svg 2025-09-21 23:16:59.000000000 +0000 @@ -7,7 +7,7 @@ > Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 +Produced by GNUPLOT 6.0 patchlevel 3 @@ -42,64 +42,84 @@ - + 0 - + + 0.5 + + + + 1 - + + 1.5 + + + + 2 - + + 2.5 + + + + 3 - + + 3.5 + + + + 4 - - 5 + + 4.5 - + pydantic2 - + apischema - - 2.34 + + 2.36 - - 2.35 + + 2.37 - - 2.36 + + 2.38 - + load big dictionary @@ -111,11 +131,11 @@ - - - - - + + + + + @@ -126,20 +146,20 @@ - + seconds - + x-units - - typedload performance test python 3.13.0 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + + typedload performance test python 3.13.7 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz diff -pruN 2.37-1/docs/3.13_load_dictionary_of_tuples.svg 2.38-1/docs/3.13_load_dictionary_of_tuples.svg --- 2.37-1/docs/3.13_load_dictionary_of_tuples.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.13_load_dictionary_of_tuples.svg 2025-09-21 23:16:59.000000000 +0000 @@ -7,7 +7,7 @@ > Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 +Produced by GNUPLOT 6.0 patchlevel 3 @@ -42,42 +42,42 @@ - + 0 - + 0.5 - + 1 - + 1.5 - + 2 - + 2.5 - + 3 - + 3.5 @@ -93,17 +93,17 @@ - 2.34 + 2.36 - 2.35 + 2.37 - 2.36 + 2.38 @@ -121,11 +121,11 @@ - - - - - + + + + + @@ -149,7 +149,7 @@ - typedload performance test python 3.13.0 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + typedload performance test python 3.13.7 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz diff -pruN 2.37-1/docs/3.13_load_list_of_NamedTuple_objects.svg 2.38-1/docs/3.13_load_list_of_NamedTuple_objects.svg --- 2.37-1/docs/3.13_load_list_of_NamedTuple_objects.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.13_load_list_of_NamedTuple_objects.svg 2025-09-21 23:16:59.000000000 +0000 @@ -7,7 +7,7 @@ > Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 +Produced by GNUPLOT 6.0 patchlevel 3 @@ -42,23 +42,48 @@ - + 0 - - 0.5 + + 0.2 - + + 0.4 + + + + + 0.6 + + + + + 0.8 + + + + 1 - - 1.5 + + 1.2 + + + + + 1.4 + + + + + 1.6 @@ -73,17 +98,17 @@ - 2.34 + 2.36 - 2.35 + 2.37 - 2.36 + 2.38 @@ -101,11 +126,11 @@ - - - - - + + + + + @@ -129,7 +154,7 @@ - typedload performance test python 3.13.0 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + typedload performance test python 3.13.7 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz diff -pruN 2.37-1/docs/3.13_load_list_of_attrs_objects.svg 2.38-1/docs/3.13_load_list_of_attrs_objects.svg --- 2.37-1/docs/3.13_load_list_of_attrs_objects.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.13_load_list_of_attrs_objects.svg 2025-09-21 23:16:59.000000000 +0000 @@ -7,7 +7,7 @@ > Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 +Produced by GNUPLOT 6.0 patchlevel 3 @@ -47,27 +47,27 @@ - + 0 - + 0.1 - + 0.2 - + 0.3 - + 0.4 @@ -83,17 +83,17 @@ - 2.34 + 2.36 - 2.35 + 2.37 - 2.36 + 2.38 @@ -111,11 +111,11 @@ - - - - - + + + + + @@ -139,7 +139,7 @@ - typedload performance test python 3.13.0 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + typedload performance test python 3.13.7 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz diff -pruN 2.37-1/docs/3.13_load_list_of_dataclass_objects.svg 2.38-1/docs/3.13_load_list_of_dataclass_objects.svg --- 2.37-1/docs/3.13_load_list_of_dataclass_objects.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.13_load_list_of_dataclass_objects.svg 2025-09-21 23:16:59.000000000 +0000 @@ -7,7 +7,7 @@ > Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 +Produced by GNUPLOT 6.0 patchlevel 3 @@ -42,46 +42,41 @@ - + 0 - + 0.2 - + 0.4 - + 0.6 - + 0.8 - + 1 - + 1.2 - - 1.4 - - - pydantic2 @@ -93,17 +88,17 @@ - 2.34 + 2.36 - 2.35 + 2.37 - 2.36 + 2.38 @@ -121,11 +116,11 @@ - - - - - + + + + + @@ -149,7 +144,7 @@ - typedload performance test python 3.13.0 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + typedload performance test python 3.13.7 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz diff -pruN 2.37-1/docs/3.13_load_list_of_floats_and_ints.svg 2.38-1/docs/3.13_load_list_of_floats_and_ints.svg --- 2.37-1/docs/3.13_load_list_of_floats_and_ints.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.13_load_list_of_floats_and_ints.svg 2025-09-21 23:16:59.000000000 +0000 @@ -7,7 +7,7 @@ > Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 +Produced by GNUPLOT 6.0 patchlevel 3 @@ -42,36 +42,31 @@ - + 0 - + 0.2 - + 0.4 - + 0.6 - + 0.8 - - 1 - - - pydantic2 @@ -83,17 +78,17 @@ - 2.34 + 2.36 - 2.35 + 2.37 - 2.36 + 2.38 @@ -111,11 +106,11 @@ - - - - - + + + + + @@ -139,7 +134,7 @@ - typedload performance test python 3.13.0 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + typedload performance test python 3.13.7 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz diff -pruN 2.37-1/docs/3.13_load_list_of_ints.svg 2.38-1/docs/3.13_load_list_of_ints.svg --- 2.37-1/docs/3.13_load_list_of_ints.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.13_load_list_of_ints.svg 2025-09-21 23:16:59.000000000 +0000 @@ -7,7 +7,7 @@ > Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 +Produced by GNUPLOT 6.0 patchlevel 3 @@ -47,41 +47,36 @@ - + 0 - + 0.1 - + 0.2 - + 0.3 - + 0.4 - + 0.5 - - 0.6 - - - pydantic2 @@ -93,17 +88,17 @@ - 2.34 + 2.36 - 2.35 + 2.37 - 2.36 + 2.38 @@ -121,11 +116,11 @@ - - - - - + + + + + @@ -149,7 +144,7 @@ - typedload performance test python 3.13.0 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + typedload performance test python 3.13.7 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz diff -pruN 2.37-1/docs/3.13_load_list_of_large_NamedTuples.svg 2.38-1/docs/3.13_load_list_of_large_NamedTuples.svg --- 2.37-1/docs/3.13_load_list_of_large_NamedTuples.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.13_load_list_of_large_NamedTuples.svg 2025-09-21 23:16:59.000000000 +0000 @@ -7,7 +7,7 @@ > Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 +Produced by GNUPLOT 6.0 patchlevel 3 @@ -42,41 +42,36 @@ - + 0 - + 0.2 - + 0.4 - + 0.6 - + 0.8 - + 1 - - 1.2 - - - pydantic2 @@ -88,17 +83,17 @@ - 2.34 + 2.36 - 2.35 + 2.37 - 2.36 + 2.38 @@ -116,11 +111,11 @@ - - - - - + + + + + @@ -144,7 +139,7 @@ - typedload performance test python 3.13.0 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + typedload performance test python 3.13.7 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz diff -pruN 2.37-1/docs/3.13_load_list_of_lists.svg 2.38-1/docs/3.13_load_list_of_lists.svg --- 2.37-1/docs/3.13_load_list_of_lists.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.13_load_list_of_lists.svg 2025-09-21 23:16:59.000000000 +0000 @@ -7,7 +7,7 @@ > Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 +Produced by GNUPLOT 6.0 patchlevel 3 @@ -42,27 +42,27 @@ - + 0 - + 0.5 - + 1 - + 1.5 - + 2 @@ -78,17 +78,17 @@ - 2.34 + 2.36 - 2.35 + 2.37 - 2.36 + 2.38 @@ -106,11 +106,11 @@ - - - - - + + + + + @@ -134,7 +134,7 @@ - typedload performance test python 3.13.0 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + typedload performance test python 3.13.7 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz diff -pruN 2.37-1/docs/3.13_load_with_alias.svg 2.38-1/docs/3.13_load_with_alias.svg --- 2.37-1/docs/3.13_load_with_alias.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.13_load_with_alias.svg 2025-09-21 23:16:59.000000000 +0000 @@ -7,7 +7,7 @@ > Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 +Produced by GNUPLOT 6.0 patchlevel 3 @@ -47,32 +47,32 @@ - + 0 - + 0.1 - + 0.2 - + 0.3 - + 0.4 - + 0.5 @@ -88,17 +88,17 @@ - 2.34 + 2.36 - 2.35 + 2.37 - 2.36 + 2.38 @@ -116,11 +116,11 @@ - - - - - + + + + + @@ -144,7 +144,7 @@ - typedload performance test python 3.13.0 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + typedload performance test python 3.13.7 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz diff -pruN 2.37-1/docs/3.13_tagged_union_of_objects.svg 2.38-1/docs/3.13_tagged_union_of_objects.svg --- 2.37-1/docs/3.13_tagged_union_of_objects.svg 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/3.13_tagged_union_of_objects.svg 2025-09-21 23:16:59.000000000 +0000 @@ -7,7 +7,7 @@ > Gnuplot -Produced by GNUPLOT 6.0 patchlevel 0 +Produced by GNUPLOT 6.0 patchlevel 3 @@ -42,51 +42,46 @@ - + 0 - + 0.5 - + 1 - + 1.5 - + 2 - + 2.5 - + 3 - + 3.5 - - 4 - - - pydantic2 @@ -98,17 +93,17 @@ - 2.34 + 2.36 - 2.35 + 2.37 - 2.36 + 2.38 @@ -126,11 +121,11 @@ - - - - - + + + + + @@ -154,7 +149,7 @@ - typedload performance test python 3.13.0 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz + typedload performance test python 3.13.7 Intel(R) Xeon(R) CPU E3-1246 v3 3.50GHz diff -pruN 2.37-1/docs/CHANGELOG.md 2.38-1/docs/CHANGELOG.md --- 2.37-1/docs/CHANGELOG.md 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/CHANGELOG.md 2025-09-21 18:58:09.000000000 +0000 @@ -1,3 +1,10 @@ +2.38 +==== +* Fix unintended behaviour where a `str` could be loaded as `list[str]` + This is caused by a [quirk of python's types](https://github.com/python/typing/issues/256). + To restore the previous behaviour set `iterstr=True` +* Drop support to python 3.9 + 2.37 ==== * Do not use new syntax in any place. diff -pruN 2.37-1/docs/README.md 2.38-1/docs/README.md --- 2.37-1/docs/README.md 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/README.md 2025-09-21 18:58:09.000000000 +0000 @@ -48,10 +48,10 @@ Can be treated more easily if loaded int class User: username: str shell: str = 'bash' - sessions: List[str] = dataclasses.field(default_factory=list) + sessions: list[str] = dataclasses.field(default_factory=list) class Logins(NamedTuple): - users: List[User] + users: list[User] ``` And the data can be loaded into the structure with this: @@ -77,11 +77,11 @@ The following things are supported: * NamedTuple * Enum * Optional[SomeType] - * List[SomeType] - * Dict[TypeA, TypeB] - * Tuple[TypeA, TypeB, TypeC] and Tuple[SomeType, ...] - * Set[SomeType] - * Union[TypeA, TypeB] + * list[SomeType] + * dict[TypeA, TypeB] + * tuple[TypeA, TypeB, TypeC] and tuple[SomeType, ...] + * set[SomeType] + * TypeA | TypeB * dataclass * attr.s * ForwardRef (Refer to the type in its own definition) @@ -109,14 +109,14 @@ Mypy and similar tools work without requ # This is treated as Any, no checks done. data = json.load(f) -# This is treated as Dict[str, int] +# This is treated as dict[str, int] # but there will be runtime errors if the data does not # match the expected format -data = json.load(f) # type: Dict[str, int] +data = json.load(f) # type: dict[str, int] -# This is treated as Dict[str, int] and an exception is -# raised if the actual data is not Dict[str, int] -data = typedload.load(json.load(f), Dict[str, int]) +# This is treated as dict[str, int] and an exception is +# raised if the actual data is not dict[str, int] +data = typedload.load(json.load(f), dict[str, int]) ``` So when using Mypy, it makes sense to make sure that the type is correct, @@ -150,6 +150,7 @@ Used by As dependency, typedload is used by those entities. Feel free to add to the list. +* The USA armed forces (regrettably) (via [Appgate](https://www.appgate.com/federal-division)) * [Lyft](https://eng.lyft.com/python-upgrade-playbook-1479145d52f4) * Several universities around the world (via [Relational](https://ltworf.codeberg.page/relational/)) * People who love IRC (via [localslackirc](https://github.com/ltworf/localslackirc)) diff -pruN 2.37-1/docs/errors.md 2.38-1/docs/errors.md --- 2.37-1/docs/errors.md 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/errors.md 2025-09-21 18:58:09.000000000 +0000 @@ -20,8 +20,8 @@ class Thing(NamedTuple): value: int class Data(NamedTuple): - field1: List[Thing] - field2: Tuple[Thing, ...] + field1: list[Thing] + field2: tuple[Thing, ...] typedload.load({'field1': [{'value': 12}, {'value': 'a'}], 'field2': []}, Data) @@ -45,7 +45,7 @@ For example: ```python try: - typedload.load([1, 2, 'a'], List[int]) + typedload.load([1, 2, 'a'], list[int]) except Exception as e: print(e.trace[-1]) ``` @@ -61,7 +61,7 @@ Another example, with an object: ```python class O(NamedTuple): - data: List[int] + data: list[int] try: typedload.load({'data': [1, 2, 'a']}, O) diff -pruN 2.37-1/docs/examples.md 2.38-1/docs/examples.md --- 2.37-1/docs/examples.md 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/examples.md 2025-09-21 23:16:59.000000000 +0000 @@ -46,21 +46,18 @@ typedload.dump(d) Loading with optional and default values ---------------------------------------- -Python typing is confusing for many concerning the meaning of `Optional`. An `Optional[T]` means that the field can assume `None` as value, but the value must still be specified, and can't be omitted. If, on the other hand, a variable has a default value, then when it's not explicitly specified, the default value is assumed. +Python typing is confusing for many concerning the meaning of `Optional`. A `T | None` means that the field can assume `None` as value, but the value must still be specified, and can't be omitted. If, on the other hand, a variable has a default value, then when it's not explicitly specified, the default value is assumed. Typedload follows exactly the normal behaviour of python and mypy. -With the new syntax, writing `Optional[int]` is equivalent to `int | None`. - - ```python import typedload -from typing import Optional, NamedTuple +from typing import NamedTuple class User(NamedTuple): username: str # Must be assigned - nickname: Optional[str] # Must be assigned and can be None - last_login: Optional[int] = None # Not required. + nickname: str | None # Must be assigned and can be None + last_login: int | None = None # Not required. # This fails, as nickname is not present typedload.load({'username': 'ltworf'}, User) @@ -86,7 +83,7 @@ There is of course no relationship betwe ```python class A(NamedTuple): # The field can be None, but if not specified it defaults to 3 - i: Optional[int] = 3 + i: int | None = 3 ``` Dumping with optional and default values @@ -129,16 +126,16 @@ For example, Slack sends events in this ```python import typedload -from typing import List, Literal, Union, NamedTuple +from typing import Literal, NamedTuple events = [ { - "type": "message", - "text": "hello" + "type": "message", + "text": "hello" }, { - "type": "user-joined", - "username": "giufà" + "type": "user-joined", + "username": "giufà" } ] @@ -153,7 +150,7 @@ class UserJoined(NamedTuple): username: str # Now to load our event list -typedload.load(events, List[Union[Message, UserJoined]]) +typedload.load(events, list[Message | UserJoined]) # Out: [Message(type='message', text='hello'), UserJoined(type='user-joined', username='giufà')] ``` @@ -171,16 +168,16 @@ For example, using objects where all the ```python import typedload -from typing import NamedTuple, Union, Optional +from typing import NamedTuple class Person(NamedTuple): name: str = '' class Data(NamedTuple): - data: Optional[str] = None + data: str | None = None # WARNING: This might return either a Person or a Data. It's random -typedload.load({}, Union[Person, Data]) +typedload.load({}, Person | Data) # Out: Data(data=None) # Out: Person(name='') ``` @@ -188,7 +185,7 @@ typedload.load({}, Union[Person, Data]) To detect the situation, we can use `uniondebugconflict=True` ```python -typedload.load({}, Union[Person, Data], uniondebugconflict=True) +typedload.load({}, Person | Data, uniondebugconflict=True) # Out: TypedloadTypeError: Value of dict could be loaded into Union 2 times ``` @@ -201,7 +198,7 @@ You might want to use `failonextra` for ```python import typedload -from typing import NamedTuple, Union +from typing import NamedTuple class Person(NamedTuple): @@ -215,7 +212,7 @@ class Car(NamedTuple): data = {'name': 'macchina', 'model': 'TP21'} # WARNING: This can return either a Person or a Car -typedload.load(data, Union[Person, Car]) +typedload.load(data, Person | Car) # Out: Person(name='macchina') # Out: Car(name='macchina', model='TP21') @@ -241,7 +238,7 @@ typedload.load(data, Car, failonextra=Tr # Out: Car(name='macchina', model='TP21') # At this point the union will reliably pick the class that we want -typedload.load(data, Union[Person, Car], failonextra=True) +typedload.load(data, Person | Car, failonextra=True) # Out: Car(name='macchina', model='TP21') ``` @@ -254,17 +251,17 @@ For example, if a value can be an object ```python import typedload -from typing import NamedTuple, Union +from typing import NamedTuple class Data(NamedTuple): data: int # This loads "{'date': 33}", since the object is not a valid Data object. -typedload.load({'date': 33}, Union[str, Data]) +typedload.load({'date': 33}, str | Data) # Out: "{'date': 33}" # This fails, because the dictionary is not cast to str -typedload.load({'date': 33}, Union[str, Data], basiccast=False) +typedload.load({'date': 33}, str | Data, basiccast=False) # TypedloadValueError: Value of dict could not be loaded into typing.Union[str, __main__.Data] ``` @@ -281,7 +278,7 @@ Let's see how typedload can help us surv ```python import typedload -from typing import NamedTuple, Union, List +from typing import NamedTuple import dataclasses # Multiple data points, a list is used @@ -306,11 +303,11 @@ class Point(NamedTuple): class Data: # We make an hidden field to load the data_points field from the json # If the value is absent it will default to an empty list - # The hidden field can either be a List[Point] or directly a Point object + # The hidden field can either be a list[Point] or directly a Point object _data_points: Point | list[Point] = dataclasses.field(default_factory=list, metadata={'name': 'data_points'}) @property - def data_points(self) -> List[Point]: + def data_points(self) -> list[Point]: # We make a property called data_points, that always returns a list if not isinstance(self._data_points, list): return [self._data_points] @@ -510,3 +507,18 @@ class B(TypedDict, total=False): c: int d: int ``` + +String iteration +---------------- + +Because of a [problem in python's type system](https://github.com/python/typing/issues/256) a `str` object is also a valid `Iterable[str]`. This means that until version 2.37 this would work + +``` +load("123", list[str]) +``` + +And wold return `["1", "2", "3"]`. + +From 2.38 this raises a `TypedloadTypeError`. + +To use the previous behaviour it is possible to set `iterstr=True` when creating the `Loader` object, or when calling `load()` from the top module. diff -pruN 2.37-1/docs/origin_story.md 2.38-1/docs/origin_story.md --- 2.37-1/docs/origin_story.md 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/origin_story.md 2025-09-21 18:58:09.000000000 +0000 @@ -17,4 +17,4 @@ So, I just wrote a stand alone library o The result of writing the same library twice was that the second time around it came out better, and so the original version got completely discarded and at $DAYJOB typedload is now in use. -At the time pydantic existed but it was not available on any distribution and was not production quality. +At the time pydantic existed but it was not available on any distribution and was not production quality. I am a lazy person so if it had been usable I would have used it instead. But in the end I think typedload is better. But that's just my own opinion. diff -pruN 2.37-1/docs/performance.md 2.38-1/docs/performance.md --- 2.37-1/docs/performance.md 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/performance.md 2025-09-21 23:16:59.000000000 +0000 @@ -6,7 +6,7 @@ Negative values mean that the library fa The tests are done on my PC. The following libraries are tested: * `typedload`, the 3 most recent versions. It shines with tagged unions, which is what I mostly use. -* `pydantic2` years of work to rewrite it in Rust, [implemented detection of tagged unions years after I did it](https://github.com/pydantic/pydantic/issues/5163#issuecomment-1619203179), still managing to lose some benchmarks 😅 +* `pydantic2` years of work to rewrite it in Rust, [implemented detection of tagged unions years after I did it](https://github.com/pydantic/pydantic/issues/5163#issuecomment-1619203179), still managing to lose some benchmarks 😅 (sorry I find it hilarious that a company hiring a team of developers to do a Rust implementation cannot beat *all* the benchmarks when typedload is pure python and I work on it every once in a while). * `apischema` is slower where there are unions, faster otherwise Using Python 3.13 @@ -21,16 +21,16 @@ Using Python 3.13 ![performance chart](3.13_load_list_of_ints.svg "Load list of ints") -Using Pypy 7.3.17 +Using Pypy 7.3.20 ----------------- -![performance chart](3.10_tagged_union_of_objects.svg "Load tagged union of objects") -![performance chart](3.10_dump_objects.svg "Dump objects") -![performance chart](3.10_load_list_of_floats_and_ints.svg "Load list of floats and ints") -![performance chart](3.10_load_list_of_lists.svg "Load list of lists") -![performance chart](3.10_load_list_of_NamedTuple_objects.svg "Load list of NamedTuple") -![performance chart](3.10_load_big_dictionary.svg "Load big dictionary") -![performance chart](3.10_load_list_of_ints.svg "Load list of ints") +![performance chart](3.11_tagged_union_of_objects.svg "Load tagged union of objects") +![performance chart](3.11_dump_objects.svg "Dump objects") +![performance chart](3.11_load_list_of_floats_and_ints.svg "Load list of floats and ints") +![performance chart](3.11_load_list_of_lists.svg "Load list of lists") +![performance chart](3.11_load_list_of_NamedTuple_objects.svg "Load list of NamedTuple") +![performance chart](3.11_load_big_dictionary.svg "Load big dictionary") +![performance chart](3.11_load_list_of_ints.svg "Load list of ints") Run the tests diff -pruN 2.37-1/docs/supported_types.md 2.38-1/docs/supported_types.md --- 2.37-1/docs/supported_types.md 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/supported_types.md 2025-09-21 18:58:09.000000000 +0000 @@ -10,7 +10,7 @@ typedload.load(obj, None) It will either return a None or fail. -This is normally used to handle unions such as `Optional[int]` rather than by itself. +This is normally used to handle unions such as `int | None` rather than by itself. Basic types ----------- @@ -308,10 +308,10 @@ typedload.load(data, A | B) A typical case is when using Optional values ```python -In : typedload.load(3, Optional[int]) +In : typedload.load(3, int | None) Out: 3 -In : typedload.load(None, Optional[int]) +In : typedload.load(None, int | None) Out: None ``` @@ -324,11 +324,11 @@ Point2d = tuple[float, float] Point3d = tuple[float, float, float] # This is not what we wanted, the 3rd coordinate is lost -In : typedload.load((1,1,1), Union[Point2d, Point3d]) +In : typedload.load((1,1,1), Point2d | Point3d) Out: (1.0, 1.0) # Make the loading more strict! -In : typedload.load((1,1,1), Union[Point2d, Point3d], failonextra=True) +In : typedload.load((1,1,1), Point2d | Point3d, failonextra=True) Out: (1.0, 1.0, 1.0) ``` @@ -336,7 +336,7 @@ But in some cases it cannot be simply so ```python # A casting must be done, str was chosen, but could have been int -In : typedload.load(1.1, Union[str, int]) +In : typedload.load(1.1, str | int) Out: '1.1' @@ -347,7 +347,7 @@ class B(NamedTuple): y: str='a' # Both A and B accept an empty constructor -In : typedload.load({}, Union[A, B]) +In : typedload.load({}, A | B) Out: A(x=1) ``` @@ -356,7 +356,7 @@ Out: A(x=1) Typedload can't solve certain ambiguities, but setting `uniondebugconflict=True` will help detect them. ```python -In : typedload.load({}, Union[A, B], uniondebugconflict=True) +In : typedload.load({}, A | B, uniondebugconflict=True) TypedloadTypeError: Value of dict could be loaded into typing.Union[__main__.A, __main__.B] multiple times ``` diff -pruN 2.37-1/docs/version_numbers.md 2.38-1/docs/version_numbers.md --- 2.37-1/docs/version_numbers.md 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/docs/version_numbers.md 2025-09-21 18:58:09.000000000 +0000 @@ -7,4 +7,4 @@ The second number being bumped means bug Dropping support for EOL python versions is not considered breaking API. -Changes that trigger failures in buggy code are acceptable [See here](https://lwn.net/Articles/416821/). I am not Linus Torvalds and I don't have to follow his rules. +Changes that trigger failures in buggy code are acceptable [See here](https://lwn.net/Articles/416821/). I am not Linus Torvalds and I don't have to follow his rules (and neither does he). diff -pruN 2.37-1/pyproject.toml 2.38-1/pyproject.toml --- 2.37-1/pyproject.toml 2024-11-26 12:09:03.000000000 +0000 +++ 2.38-1/pyproject.toml 2025-09-22 06:29:42.000000000 +0000 @@ -1,13 +1,13 @@ [project] name = "typedload" -version = "2.37" +version = "2.38" authors = [ { name="Salvo 'LtWorf' Tomaselli", email="tiposchi@tiscali.it" }, ] description = "Load and dump data from json-like format into typed data structures" readme = "README.md" -requires-python = ">=3.9" -classifiers = ['Development Status :: 5 - Production/Stable', 'Intended Audience :: Developers', 'License :: OSI Approved :: GNU General Public License v3 (GPLv3)', 'Typing :: Typed', 'Programming Language :: Python :: 3.9', 'Programming Language :: Python :: 3.10', 'Programming Language :: Python :: 3.11', 'Programming Language :: Python :: 3.12', 'Programming Language :: Python :: 3.13'] +requires-python = ">=3.10" +classifiers = ['Development Status :: 5 - Production/Stable', 'Intended Audience :: Developers', 'License :: OSI Approved :: GNU General Public License v3 (GPLv3)', 'Typing :: Typed', 'Programming Language :: Python :: 3.10', 'Programming Language :: Python :: 3.11', 'Programming Language :: Python :: 3.12', 'Programming Language :: Python :: 3.13', 'Programming Language :: Python :: 3.14'] keywords = ['typing', 'types', 'mypy', 'json', 'schema', 'json-schema', 'python3', 'namedtuple', 'enums', 'dataclass', 'pydantic'] license = {file = "LICENSE"} diff -pruN 2.37-1/setup.py 2.38-1/setup.py --- 2.37-1/setup.py 2024-11-26 12:09:02.000000000 +0000 +++ 2.38-1/setup.py 2025-09-22 06:29:41.000000000 +0000 @@ -3,14 +3,14 @@ from setuptools import setup setup( name='typedload', - version='2.37', + version='2.38', description='Load and dump data from json-like format into typed data structures', readme='README.md', url='https://ltworf.codeberg.page/typedload/', author="Salvo 'LtWorf' Tomaselli", author_email='tiposchi@tiscali.it', license='GPL-3.0-only', - classifiers=['Development Status :: 5 - Production/Stable', 'Intended Audience :: Developers', 'License :: OSI Approved :: GNU General Public License v3 (GPLv3)', 'Typing :: Typed', 'Programming Language :: Python :: 3.9', 'Programming Language :: Python :: 3.10', 'Programming Language :: Python :: 3.11', 'Programming Language :: Python :: 3.12', 'Programming Language :: Python :: 3.13'], + classifiers=['Development Status :: 5 - Production/Stable', 'Intended Audience :: Developers', 'License :: OSI Approved :: GNU General Public License v3 (GPLv3)', 'Typing :: Typed', 'Programming Language :: Python :: 3.10', 'Programming Language :: Python :: 3.11', 'Programming Language :: Python :: 3.12', 'Programming Language :: Python :: 3.13', 'Programming Language :: Python :: 3.14'], keywords='typing types mypy json schema json-schema python3 namedtuple enums dataclass pydantic', packages=['typedload'], package_data={"typedload": ["py.typed", "__init__.pyi"]}, diff -pruN 2.37-1/tests/__main__.py 2.38-1/tests/__main__.py --- 2.37-1/tests/__main__.py 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/tests/__main__.py 2025-09-21 23:16:59.000000000 +0000 @@ -1,5 +1,5 @@ # typedload -# Copyright (C) 2018-2024 Salvo "LtWorf" Tomaselli +# Copyright (C) 2018-2025 Salvo "LtWorf" Tomaselli # # typedload is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -21,8 +21,8 @@ import unittest import sys print('Running tests using %s' % sys.version) -if sys.version_info.major != 3 or sys.version_info.minor < 9: - raise Exception('Only version 3.9 and above supported') +if sys.version_info.major != 3 or sys.version_info.minor < 10: + raise Exception('Only version 3.10 and above supported') from .test_dataloader import * from .test_datadumper import * @@ -35,12 +35,12 @@ from .test_typechecks import * from .test_datetime import * from .test_literal import * from .test_typeddict import * - -if sys.version_info.minor >= 10: - from .test_orunion import * +from .test_orunion import * if sys.version_info.minor >= 12: from .test_typealias import * +else: + print("============\n\nWARNING: SKIPPING TYPEALIAS TESTS") # Run tests for attr only if it is installed try: @@ -51,6 +51,8 @@ except ImportError: if attr_module: from .test_attrload import * +else: + print("============\n\nWARNING: SKIPPING ATTR TESTS") if __name__ == '__main__': unittest.main() diff -pruN 2.37-1/tests/test_dataloader.py 2.38-1/tests/test_dataloader.py --- 2.37-1/tests/test_dataloader.py 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/tests/test_dataloader.py 2025-06-02 21:47:54.000000000 +0000 @@ -1,5 +1,5 @@ # typedload -# Copyright (C) 2018-2024 Salvo "LtWorf" Tomaselli +# Copyright (C) 2018-2025 Salvo "LtWorf" Tomaselli # # typedload is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -243,7 +243,7 @@ class TestFastIterableLoad(unittest.Test class TestTupleLoad(unittest.TestCase): def test_ellipsis(self): - loader = dataloader.Loader() + loader = dataloader.Loader(iterstr=True) l = list(range(33)) t = tuple(l) @@ -580,3 +580,14 @@ class TestNewType(unittest.TestCase): bar = loader.load("bar", Foo) assert bar == "bar" assert type(bar) is str + +class TestStringNotIterable(unittest.TestCase): + + def test_notiterable(self): + loader = dataloader.Loader() + with self.assertRaises(TypeError): + loader.load("abc", list[str]) + + def test_iterable(self): + loader = dataloader.Loader(iterstr=True) + assert loader.load("abc", list[str]) == ["a", "b", "c"] diff -pruN 2.37-1/typedload/datadumper.py 2.38-1/typedload/datadumper.py --- 2.37-1/typedload/datadumper.py 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/typedload/datadumper.py 2025-09-21 23:16:59.000000000 +0000 @@ -26,8 +26,9 @@ from inspect import signature from enum import Enum import pathlib import re -from typing import * import uuid +from typing import Any, Callable, get_type_hints, Type + from .exceptions import TypedloadValueError from .typechecks import is_attrs, NONETYPE, is_literal @@ -71,8 +72,8 @@ class Dumper: handlers: This is the list that the dumper uses to perform its task. The type is: - List[ - Tuple[ + list[ + tuple[ Callable[[Any], bool], Callable[['Dumper', Any, Any], Any] ] @@ -99,7 +100,7 @@ class Dumper: There is support for: * Basic python types (int, str, bool, float, NoneType) * NamedTuple, dataclasses, attrs, TypedDict - * Dict[TypeA, TypeB] + * dict[TypeA, TypeB] * Enum * List * Tuple @@ -145,16 +146,16 @@ class Dumper: (lambda value: '__dataclass_fields__' in dir(value), _dataclassdump), (lambda value: isinstance(value, (list, tuple, set, frozenset)), _iteratordump), (lambda value: isinstance(value, Enum), lambda l, value, t: l.dump(value.value)), - (lambda value: isinstance(value, Dict), lambda l, value, t: {l.dump(k): l.dump(v) for k, v in value.items()}), + (lambda value: isinstance(value, dict), lambda l, value, t: {l.dump(k): l.dump(v) for k, v in value.items()}), (is_attrs, _attrdump), (lambda value: isinstance(value, (datetime.date, datetime.time)), _datetimedump), (lambda value: isinstance(value, datetime.timedelta), _timedeltadump), (lambda value: isinstance(value, re.Pattern), _patterndump), (lambda value: type(value) in self.strconstructed, lambda l, value, t: str(value)), - ] # type: List[Tuple[Callable[[Any], bool], Callable[['Dumper', Any, Any], Any]|Callable[['Dumper', Any], Any]]] + ] # type: list[tuple[Callable[[Any], bool], Callable[['Dumper', Any, Any], Any]|Callable[['Dumper', Any], Any]]] - self._handlerscache = {} # type: Dict[Type[Any], Callable[['Dumper', Any, Any], Any]] - self._dataclasscache = {} # type: Dict[Type[Any], Tuple[Set[str], Dict[str, Any], Dict[str, Any], Dict[str, str], Set[str], bool]] + self._handlerscache = {} # type: dict[Type[Any], Callable[['Dumper', Any, Any], Any]] + self._dataclasscache = {} # type: dict[Type[Any], tuple[set[str], dict[str, Any], dict[str, Any], dict[str, str], set[str], bool]] for k, v in kwargs.items(): setattr(self, k, v) @@ -202,11 +203,11 @@ class Dumper: func = lambda d, v, _: f(d, v) # type: ignore else: func = f # type: ignore - self._handlerscache[t] = func # type: ignore - return func(self, value, annotated_type) # type: ignore + self._handlerscache[t] = func + return func(self, value, annotated_type) -def _attrdump(d, value, t) -> Dict[str, Any]: +def _attrdump(d, value, t) -> dict[str, Any]: r = {} for attr in value.__attrs_attrs__: attrval = getattr(value, attr.name) @@ -222,7 +223,7 @@ def _attrdump(d, value, t) -> Dict[str, return r -def _datetimedump(d: Dumper, value: Union[datetime.time, datetime.date, datetime.datetime], t): +def _datetimedump(d: Dumper, value: datetime.time | datetime.date | datetime.datetime, t): if d.isodates: return value.isoformat() import warnings @@ -251,7 +252,7 @@ def _patterndump(d: Dumper, value: re.Pa return value.pattern -def _namedtupledump(d: Dumper, value, t) -> Dict[str, Any]: +def _namedtupledump(d: Dumper, value, t) -> dict[str, Any]: field_defaults = getattr(value, '_field_defaults', {}) # Named tuple, skip default values return { @@ -260,7 +261,7 @@ def _namedtupledump(d: Dumper, value, t) } -def _dataclassdump(d: Dumper, value, t) -> Dict[str, Any]: +def _dataclassdump(d: Dumper, value, t) -> dict[str, Any]: t = type(value) try: fields, defaults, type_hints, renames, needs_dump, hasdict = d._dataclasscache[t] @@ -304,7 +305,7 @@ def _dataclassdump(d: Dumper, value, t) return r -def _iteratordump(d: Dumper, value: Any, t: Any) -> List[Any]: +def _iteratordump(d: Dumper, value: Any, t: Any) -> list[Any]: if t != Any: try: itertypes = t.__args__ @@ -313,7 +314,7 @@ def _iteratordump(d: Dumper, value: Any, else: itertypes = (Any,) # list[T] or tuple[T, ...] - if (len(itertypes) == 1) or (len(itertypes) == 2 and itertypes[1] == ...): # type: ignore + if (len(itertypes) == 1) or (len(itertypes) == 2 and itertypes[1] == ...): # This is true for lists/sets but not tuples itertype = itertypes[0] else: diff -pruN 2.37-1/typedload/dataloader.py 2.38-1/typedload/dataloader.py --- 2.37-1/typedload/dataloader.py 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/typedload/dataloader.py 2025-09-21 23:16:59.000000000 +0000 @@ -3,7 +3,7 @@ typedload Module to load data into typed data structures """ -# Copyright (C) 2018-2024 Salvo "LtWorf" Tomaselli +# Copyright (C) 2018-2025 Salvo "LtWorf" Tomaselli # # typedload is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -27,7 +27,7 @@ import ipaddress from itertools import compress, count, repeat from pathlib import Path import re -from typing import * +from typing import Any, Callable, Type, TypeVar, get_type_hints import uuid from .exceptions import * @@ -42,7 +42,7 @@ try: # older python versions, so we only import it # from 3.12 onwards (which is also where it can be used) from typing import TypeAliasType # type: ignore - from .alias import unalias # type: ignore + from .alias import unalias except ImportError: unalias = None # type: ignore @@ -108,14 +108,14 @@ class Loader: handlers: This is the list that the loader uses to perform its task. The type is: - List[ - Tuple[ + list[ + tuple[ Callable[[Type[T]], bool], Callable[['Loader', Any, Type[T]], T] ] ] - The elements are: Tuple[Condition,Loader] + The elements are: tuple[Condition, Loader] Condition(type) -> Bool Loader(loader, value, type) -> type @@ -127,10 +127,18 @@ class Loader: strconstructed: Set of types to construct from a string. + iterstr: Defaults to False + If set, str objects are considered iterable and can be used to + be loaded into list[str] or similar. + This was the default behaviour previously. + From 2.38 loading a string into list[str] will fail. + You can restore the previous unintended behaviour by setting this to + True. + frefs: Dictionary to resolve ForwardRef. Something like class Node(NamedTuple): - next: Optional['Node'] + next: 'Node' | None requires a ForwardRef (also in python3.7), which means that the type is stored as string and must be resolved at runtime. @@ -190,7 +198,7 @@ class Loader: self.raiseconditionerrors = True # Forward refs dictionary - self.frefs = {} # type: Optional[Dict[str, Type]] + self.frefs = {} # type: dict[str, Type] | None # Enable conversion of dict-like things to dicts, before loading self.dictequivalence = True @@ -201,6 +209,9 @@ class Loader: # Fail if multiple types work within the union self.uniondebugconflict = False + # str objects can't be loaded as list[str] or similar + self.iterstr = False + # Objects loaded from a string self.strconstructed = { Path, @@ -241,18 +252,18 @@ class Loader: (is_attrs, _attrload), (is_any, _anyload), (is_newtype, _newtypeload), - ] # type: List[Tuple[Callable[[Any], bool], Callable[[Loader, Any, Any], Any]]] + ] # type: list[tuple[Callable[[Any], bool], Callable[[Loader, Any, Any], Any]]] for k, v in kwargs.items(): setattr(self, k, v) - self._indexcache = {} # type: Dict[Any, Callable[[Loader, Any, Any], Any]] + self._indexcache = {} # type: dict[Any, Callable[[Loader, Any, Any], Any]] - self._objfieldscache = {} # type: Dict[Type, Any] + self._objfieldscache = {} # type: dict[Type, Any] - self._unionload_discriminatorcache = {} # type: Dict[int, Tuple[Optional[str], Optional[Dict[Any, Type]]]] + self._unionload_discriminatorcache = {} # type: dict[int, tuple[str | None, None | dict[Any, Type]]] - self._union_sorted_args_cache = {} # type: Dict[int, List[Type]] + self._union_sorted_args_cache = {} # type: dict[int, list[Type]] def index(self, type_: Type[T]) -> int: """ @@ -281,7 +292,7 @@ class Loader: return r - def load(self, value: Any, type_: Type[T], *, annotation: Optional[Annotation] = None) -> T: + def load(self, value: Any, type_: Type[T], *, annotation: Annotation | None = None) -> T: """ Loads value into the typed data structure. @@ -336,7 +347,7 @@ def _forwardrefload(l: Loader, value: An """ if l.frefs is None: raise TypedloadException('ForwardRef resolving is disabled for the loader', value=value, type_=type_) - tname = type_.__forward_arg__ # type: ignore + tname = type_.__forward_arg__ t = l.frefs.get(tname) if t is None: raise TypedloadValueError( @@ -386,9 +397,9 @@ def _basicload(l: Loader, value: Any, ty return value -def _dictload(l: Loader, value: Any, type_) -> Dict: +def _dictload(l: Loader, value: Any, type_) -> dict: """ - This loads into something like Dict[str,str] + This loads into something like dict[str, str] Recursively loads both keys and values. """ @@ -444,18 +455,18 @@ def _dictload(l: Loader, value: Any, typ raise TypedloadAttributeError(str(e), type_=type_, value=value) -def _tupleload(l: Loader, value: Any, type_) -> Tuple: +def _tupleload(l: Loader, value: Any, type_) -> tuple: """ - This loads into something like Tuple[int,str] + This loads into something like tuple[int,str] """ args = type_.__args__ len_args = len(args) - if len_args == 2 and args[1] == ...: # Tuple[something, ...] + if len_args == 2 and args[1] == ...: # tuple[something, ...] return _iterload(l, value, type_, tuple) - # Tuple[something, something, somethingelse] + # tuple[something, something, somethingelse] if isinstance(value, dict): raise TypedloadTypeError('Unable to load dictionary as a tuple', value=value, type_=type_) @@ -485,7 +496,7 @@ def _tupleload(l: Loader, value: Any, ty raise TypedloadTypeError('Exception is not a subclass of TypedloadException. Make sure all handlers only raise TypedloadException') -def _mangle_names(namesmap: Dict[str, str], value: Dict[str, Any], failonextra: bool) -> Dict[str, Any]: +def _mangle_names(namesmap: dict[str, str], value: dict[str, Any], failonextra: bool) -> dict[str, Any]: """ Mangling names of a dictionary. @@ -512,9 +523,9 @@ def _mangle_names(namesmap: Dict[str, st return r -def _dataclassload(l: Loader, value: Dict[str, Any], type_) -> Any: +def _dataclassload(l: Loader, value: dict[str, Any], type_) -> Any: """ - This loads a Dict[str, Any] into a NamedTuple. + This loads a dict[str, Any] into a NamedTuple. """ try: fields, necessary_fields, type_hints, transforms = l._objfieldscache[type_] @@ -570,7 +581,7 @@ def _dictequivalence(l: Loader, value: A return value -def _objloader(l: Loader, fields: Set[str], necessary_fields: Set[str], type_hints, value: Any, type_, early_needed_fields_check: bool) -> Any: +def _objloader(l: Loader, fields: set[str], necessary_fields: set[str], type_hints, value: Any, type_, early_needed_fields_check: bool) -> Any: ''' Helper function to load dict-like data into an object. ''' @@ -651,7 +662,7 @@ def _objloader(l: Loader, fields: Set[st def _namedtupleload(l: Loader, value: Any, type_) -> Any: """ - This loads a Dict[str, Any] into a NamedTuple. + This loads a dict[str, Any] into a NamedTuple. """ try: @@ -675,7 +686,7 @@ def _namedtupleload(l: Loader, value: An def _typeddictload(l: Loader, value: Any, type_) -> Any: """ - This loads a Dict[str, Any] into a NamedTuple. + This loads a dict[str, Any] into a NamedTuple. """ try: fields, necessary_fields, type_hints = l._objfieldscache[type_] @@ -687,7 +698,6 @@ def _typeddictload(l: Loader, value: Any fields = set(type_hints.keys()) if hasattr(type_, '__required_keys__') and hasattr(type_, '__optional_keys__'): - # TypedDict, since 3.9 necessary_fields = set(type_.__required_keys__) elif not type_.__total__: necessary_fields = set() @@ -737,7 +747,7 @@ def _unionload(l: Loader, value: Any, ty # Give a score to the types try: - sorted_args = l._union_sorted_args_cache[type_id] # type: List[Type] + sorted_args = l._union_sorted_args_cache[type_id] # type: list[Type] except KeyError: sorted_args = list(args) sorted_args.sort(key=lambda i: i in l.basictypes) @@ -749,7 +759,7 @@ def _unionload(l: Loader, value: Any, ty # Bump up if the Literal field matches try: - discriminatorscache = l._unionload_discriminatorcache[type_id] # type: Tuple[Optional[str], Optional[Dict[Any, Type]]] + discriminatorscache = l._unionload_discriminatorcache[type_id] # type: tuple[str | None, None | dict[Any, Type]] # First time generate the deep inspection for literal except KeyError: @@ -875,7 +885,7 @@ def _noneload(l: Loader, value: Any, typ raise TypedloadValueError('Not None', value=value, type_=type_) -def _datetimeload(l: Loader, value: Any, type_) -> Union[datetime.date, datetime.time, datetime.datetime]: +def _datetimeload(l: Loader, value: Any, type_) -> datetime.date | datetime.time | datetime.datetime: try: if isinstance(value, str): return type_.fromisoformat(value) @@ -985,6 +995,8 @@ def _iterload(l: Loader, value: Any, typ """ if isinstance(value, dict): raise TypedloadTypeError('Unable to load dictionary as an iterable', value=value, type_=type_) + elif not l.iterstr and isinstance(value, str): + raise TypedloadTypeError('str object is not loadable as an iterable', value=value, type_=type_) t = type_.__args__[0] # Get function pointer for the handler diff -pruN 2.37-1/typedload/exceptions.py 2.38-1/typedload/exceptions.py --- 2.37-1/typedload/exceptions.py 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/typedload/exceptions.py 2025-09-21 18:58:09.000000000 +0000 @@ -22,7 +22,7 @@ Exceptions from enum import Enum -from typing import Any, List, NamedTuple, Optional, Type, Union +from typing import Any, NamedTuple, Type __all__ = [ @@ -50,17 +50,15 @@ class AnnotationType(Enum): UNION = 'union' -Annotation = NamedTuple('Annotation', [ - ('annotation_type', AnnotationType), - ('value', Union[str, int, Type]), -]) +class Annotation(NamedTuple): + annotation_type: AnnotationType + value: str | int | Type -TraceItem = NamedTuple('TraceItem', [ - ('value', Any), - ('type_', Type), - ('annotation', Optional[Annotation]), -]) +class TraceItem(NamedTuple): + value: Any + type_: Type + annotation: Annotation | None class TypedloadException(Exception): @@ -91,10 +89,10 @@ class TypedloadException(Exception): def __init__( self, description: str, - trace: Optional[List[TraceItem]] = None, + trace: list[TraceItem] | None = None, value: Any=None, - type_: Optional[Type] = None, - exceptions: Optional[List['TypedloadException']] = None) -> None: + type_: Type | None = None, + exceptions: list['TypedloadException'] | None = None) -> None: super().__init__(description) self.trace = trace if trace else [] self.value = value @@ -102,7 +100,7 @@ class TypedloadException(Exception): self.exceptions = exceptions if exceptions else [] @staticmethod - def _path(trace: List[TraceItem]) -> str: + def _path(trace: list[TraceItem]) -> str: ''' Compact representation of where in the data the exception happened ''' @@ -118,7 +116,7 @@ class TypedloadException(Exception): path[0] = '' return '.'.join(path) - def _subexceptions(self, indent: int, trace: List) -> str: + def _subexceptions(self, indent: int, trace: list) -> str: ''' Recursive list of all exceptions that happened in the unions ''' diff -pruN 2.37-1/typedload/typechecks.py 2.38-1/typedload/typechecks.py --- 2.37-1/typedload/typechecks.py 2024-11-26 12:08:24.000000000 +0000 +++ 2.38-1/typedload/typechecks.py 2025-09-21 18:58:09.000000000 +0000 @@ -72,14 +72,7 @@ __all__ = [ from typing import ForwardRef, Literal from typing import _TypedDictMeta # type: ignore - -UnionType = None # type: Any -try: - # Since 3.10 - from types import UnionType # type: ignore -except ImportError: - pass - +from types import UnionType try: # Since 3.11 @@ -107,26 +100,15 @@ def is_tuple(type_: Any) -> bool: ''' return _generic_type_check(type_, tuple, Tuple) -if UnionType: - # Uniontype is 3.10 defined on 3.10 and None otherwise - def is_union(type_: Any) -> bool: - ''' - Union[A, B] - Union - Optional[A] - A | B - ''' - return getattr(type_, '__origin__', None) == Union or getattr(type_, '__class__', None) == UnionType -else: - def is_union(type_: Any) -> bool: - ''' - Union[A, B] - Union - Optional[A] - ''' - # Uniontype is 3.10 defined on 3.10 and None otherwise - return getattr(type_, '__origin__', None) == Union +def is_union(type_: Any) -> bool: + ''' + Union[A, B] + Union + Optional[A] + A | B + ''' + return getattr(type_, '__origin__', None) == Union or getattr(type_, '__class__', None) == UnionType def is_optional(type_: Any) -> bool: