serialite 0.3.4__tar.gz → 0.3.6__tar.gz

{serialite-0.3.4 → serialite-0.3.6}/PKG-INFO

@@ -1,30 +1,29 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: serialite
-Version: 0.3.4
+Version: 0.3.6
 Summary: A serialization library for Python
-Home-page: https://github.com/drhagen/serialite
-License: MIT
 Keywords: serialization,deserialization,serde,pydantic,fastapi
 Author: David Hagen
-Author-email: david@drhagen.com
-Requires-Python: >=3.10,<4.0
+Author-email: David Hagen <david@drhagen.com>
+License-Expression: MIT
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: typing-extensions~=4.3
+Requires-Dist: fastapi>=0.100,<0.111 ; extra == 'fastapi'
+Requires-Dist: pydantic~=1.10 ; extra == 'fastapi'
+Requires-Dist: numpy>=1.25,<2 ; extra == 'numpy'
+Requires-Dist: ordered-set~=4.1 ; extra == 'ordered-set'
+Requires-Python: >=3.12
+Project-URL: Repository, https://github.com/drhagen/serialite
 Provides-Extra: fastapi
 Provides-Extra: numpy
 Provides-Extra: ordered-set
-Requires-Dist: fastapi (>=0.100,<0.111) ; extra == "fastapi"
-Requires-Dist: numpy (>=1.25,<2.0) ; (python_version < "3.13") and (extra == "numpy")
-Requires-Dist: ordered-set (>=4.1,<5.0) ; extra == "ordered-set"
-Requires-Dist: pydantic (>=1.10,<2.0) ; extra == "fastapi"
-Requires-Dist: typing_extensions (>=4.3,<5.0)
-Project-URL: Repository, https://github.com/drhagen/serialite
 Description-Content-Type: text/markdown
 
 # Serialite
@@ -67,4 +66,3 @@ Finding the correct serializer for each type can be a pain, so
 `serializer(cls: type) -> Serializer` is provided as a convenience function. This is a single
 dispatch function, which looks up the serializer registered for a particular type. For example,
 `serializer(list[float])` will return `ListSerializer(FloatSerializer)`.
-

{serialite-0.3.4 → serialite-0.3.6}/pyproject.toml

@@ -1,48 +1,69 @@
-[tool.poetry]
+[build-system]
+requires = ["uv_build == 0.8.*"]
+build-backend = "uv_build"
+
+[project]
 name = "serialite"
-version = "0.3.4"
+version = "0.3.6"
 description = "A serialization library for Python"
-authors = ["David Hagen <david@drhagen.com>"]
+authors = [ { name = "David Hagen", email = "david@drhagen.com" } ]
 license = "MIT"
 readme = "README.md"
-repository = "https://github.com/drhagen/serialite"
 keywords = ["serialization", "deserialization", "serde", "pydantic", "fastapi"]
+requires-python = ">=3.12"
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
-    "Topic :: Software Development :: Libraries :: Python Modules",
+    "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
 ]
 
+dependencies = [
+    "typing_extensions ~= 4.3",
+]
 
-[tool.poetry.dependencies]
-python = "^3.10"
-typing_extensions = "^4.3"
-fastapi = { version = ">=0.100,<0.111", optional = true }
-pydantic = { version = "^1.10", optional = true }
-ordered-set = { version = "^4.1", optional = true }
-# Lie about numpy only being needed below 3.13 in order to satisfy its Python ceiling
-numpy = { version = "^1.25", optional = true, python = "<3.13" }
+[project.optional-dependencies]
+fastapi = [
+    "fastapi >=0.100,<0.111",
+    "pydantic ~= 1.10",
+]
 
-[tool.poetry.dev-dependencies]
-nox_poetry = "^1.0.3"
+numpy = [
+    "numpy >=1.25,<2",
+]
 
-# Test
-pytest = "^8"
-pytest-cov = "*"
-httpx = "*" # Needed by starlette testclient
+ordered-set = [
+    "ordered-set ~= 4.1",
+]
 
-# Lint
-ruff = "^0.3"
+[project.urls]
+Repository = "https://github.com/drhagen/serialite"
 
-[tool.poetry.extras]
-fastapi = ["fastapi", "pydantic"]
-numpy = ["numpy"]
-ordered-set = ["ordered-set"]
+[dependency-groups]
+nox = [
+    "nox-uv == 0.6.*",
+]
+test = [
+    "pytest == 8.*",
+    "coverage == 7.*",
+    "httpx", # Needed by starlette testclient
+]
+lint = [
+    "ruff == 0.3.*"
+]
 
+[tool.uv]
+default-groups = "all"
+python-preference = "only-managed"
 
 [tool.coverage.run]
 branch = true
+source_pkgs = ["serialite"]
+relative_files = true
 
 [tool.coverage.report]
 exclude_lines = [
@@ -54,11 +75,9 @@ exclude_lines = [
 [tool.coverage.paths]
 source = [
     "src/",
-    ".nox/test*/lib/python*/site-packages/",
-    ".nox/test*/Lib/site-packages/",
+    "**/site-packages/",
 ]
 
-
 [tool.ruff]
 src = ["src"]
 line-length = 99
@@ -92,8 +111,3 @@ classmethod-decorators = ["serialite._descriptors.classproperty"]
 
 [tool.ruff.lint.flake8-bugbear]
 extend-immutable-calls = ["serialite.field", "fastapi.Body"]
-
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"

{serialite-0.3.4 → serialite-0.3.6}/src/serialite/_dispatcher.py

@@ -4,7 +4,7 @@ from abc import get_cache_token
 from datetime import datetime
 from pathlib import Path
 from types import GenericAlias, UnionType
-from typing import Any, Literal, TypeVar, Union, get_origin
+from typing import Any, Literal, TypeAliasType, TypeVar, Union, get_origin
 from uuid import UUID
 
 from ._base import Serializer
@@ -67,6 +67,10 @@ def subclassdispatch(func):
                 dispatch_cache.clear()
                 cache_token = current_token
 
+        if isinstance(cls, TypeAliasType):
+            # Hash is not defined on TypeAliasType, so it cannot be used in WeakKeyDictionary
+            return type_alias_type_serializer
+
         origin = get_origin(cls)
         if origin in {Union, UnionType}:
             # issubclass does not work on Union and Optional
@@ -74,10 +78,10 @@ def subclassdispatch(func):
             # must bypass the dispatcher
             if len(cls.__args__) == 2 and cls.__args__[1] is type(None):
                 # Optional is just a Union with NoneType in the second argument
-                return optional_to_data
+                return optional_serializer
             else:
                 # This is the standard Union
-                return union_to_data
+                return union_serializer
 
         try:
             impl = dispatch_cache[cls]
@@ -90,13 +94,13 @@ def subclassdispatch(func):
                     # must extract the base class and dispatch on that
                     if origin is Literal:
                         # issubclass does not work on Literal either
-                        impl = literal_to_data
+                        impl = literal_serializer
                     else:
                         # This is the standard Generic class
                         impl = _find_impl(origin, registry)
                 elif cls is Any:
                     # issubclass does not work on Any; must directly inject this
-                    impl = any_to_data
+                    impl = any_serializer
                 else:
                     impl = _find_impl(cls, registry)
             dispatch_cache[cls] = impl
@@ -141,77 +145,77 @@ def serializer(cls: type[Output]) -> Serializer[Output]:
 
 
 @serializer.register(type(None))
-def none_to_data(cls):
+def none_serializer(cls):
     from ._implementations import NoneSerializer
 
     return NoneSerializer()
 
 
 @serializer.register(bool)
-def boolean_to_data(cls):
+def boolean_serializer(cls):
     from ._implementations import BooleanSerializer
 
     return BooleanSerializer()
 
 
 @serializer.register(int)
-def integer_to_data(cls):
+def integer_serializer(cls):
     from ._implementations import IntegerSerializer
 
     return IntegerSerializer()
 
 
 @serializer.register(float)
-def float_to_data(cls):
+def float_serializer(cls):
     from ._implementations import FloatSerializer
 
     return FloatSerializer()
 
 
 @serializer.register(str)
-def string_to_data(cls):
+def string_serializer(cls):
     from ._implementations import StringSerializer
 
     return StringSerializer()
 
 
 @serializer.register(datetime)
-def datetime_to_data(cls):
+def datetime_serializer(cls):
     from ._implementations import DateTimeSerializer
 
     return DateTimeSerializer()
 
 
 @serializer.register(UUID)
-def uuid_to_data(cls):
+def uuid_serializer(cls):
     from ._implementations import UuidSerializer
 
     return UuidSerializer()
 
 
 @serializer.register(list)
-def list_to_data(cls):
+def list_serializer(cls):
     from ._implementations import ListSerializer
 
     return ListSerializer(serializer(cls.__args__[0]))
 
 
 @serializer.register(set)
-def set_to_data(cls):
+def set_serializer(cls):
     from ._implementations import SetSerializer
 
     return SetSerializer(serializer(cls.__args__[0]))
 
 
 @serializer.register(tuple)
-def tuple_to_data(cls):
+def tuple_serializer(cls):
     from ._implementations import TupleSerializer
 
     return TupleSerializer(*(serializer(arg) for arg in cls.__args__))
 
 
 @serializer.register(dict)
-def dict_to_data(cls):
+def dict_serializer(cls):
     from ._implementations import OrderedDictSerializer, RawDictSerializer
 
     if cls.__args__[0] is str:
@@ -221,7 +225,7 @@ def dict_to_data(cls):
 
 
 @serializer.register(Path)
-def path_to_data(cls):
+def path_serializer(cls):
     from ._implementations import PathSerializer
 
     return PathSerializer()
@@ -229,7 +233,7 @@ def path_to_data(cls):
 
 # Union disables subclassing so Optional cannot be used to dispatch
 # @serializer.register(Optional)
-def optional_to_data(cls):
+def optional_serializer(cls):
     from ._implementations import OptionalSerializer
 
     return OptionalSerializer(serializer(cls.__args__[0]))
@@ -237,26 +241,32 @@ def optional_to_data(cls):
 
 # Union disables subclassing so it cannot be used to dispatch
 # @serializer.register(Union)
-def union_to_data(cls):
+def union_serializer(cls):
     from ._implementations import TryUnionSerializer
 
     return TryUnionSerializer(*[serializer(type_arg) for type_arg in cls.__args__])
 
 
 # @serializer.register(Literal)
-def literal_to_data(cls):
+def literal_serializer(cls):
     from ._implementations import LiteralSerializer
 
     return LiteralSerializer(*cls.__args__)
 
 
 # @serializer.register(Any)
-def any_to_data(cls):
+def any_serializer(cls):
     from ._implementations import JsonSerializer
 
     return JsonSerializer()
 
 
+# TypeAliasType does not implement hashing so it cannot be used to dispatch
+# @serializer.register(TypeAliasType)
+def type_alias_type_serializer(cls):
+    return serializer(cls.__value__)
+
+
 try:
     import numpy as np
 except ImportError:
@@ -264,7 +274,7 @@ except ImportError:
 else:
 
     @serializer.register(np.ndarray)
-    def array_to_data(cls):
+    def array_serializer(cls):
         from ._implementations import ArraySerializer
 
         return ArraySerializer(dtype=float)
@@ -277,7 +287,7 @@ except ImportError:
 else:
 
     @serializer.register(OrderedSet)
-    def ordered_set_to_data(cls):
+    def ordered_set_serializer(cls):
         from ._implementations import OrderedSetSerializer
 
         return OrderedSetSerializer(serializer(cls.__args__[0]))

{serialite-0.3.4 → serialite-0.3.6}/src/serialite/_implementations/_tuple.py

@@ -35,7 +35,7 @@ class TupleSerializer(Generic[Unpack[TupleArguments]], Serializer[tuple[Unpack[T
         # Validate values
         errors = {}
         values = []
-        for i, (item, serializer) in enumerate(zip(data, self.element_serializers)):
+        for i, (item, serializer) in enumerate(zip(data, self.element_serializers, strict=True)):
             value_or_error = serializer.from_data(item)
             if isinstance(value_or_error, DeserializationFailure):
                 errors[str(i)] = value_or_error.error
@@ -57,7 +57,8 @@ class TupleSerializer(Generic[Unpack[TupleArguments]], Serializer[tuple[Unpack[T
             )
 
         return [
-            serializer.to_data(item) for item, serializer in zip(value, self.element_serializers)
+            serializer.to_data(item)
+            for item, serializer in zip(value, self.element_serializers, strict=True)
         ]
 
     def collect_openapi_models(

serialite-0.3.4/LICENSE

@@ -1,19 +0,0 @@
-Copyright (c) 2022 David R Hagen
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.