serialite 0.3.2__tar.gz → 0.3.3__tar.gz

{serialite-0.3.2 → serialite-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: serialite
-Version: 0.3.2
+Version: 0.3.3
 Summary: A serialization library for Python
 Home-page: https://github.com/drhagen/serialite
 License: MIT
@@ -18,8 +18,10 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Provides-Extra: fastapi
 Provides-Extra: numpy
+Provides-Extra: ordered-set
 Requires-Dist: fastapi (>=0.100,<0.101) ; 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

{serialite-0.3.2 → serialite-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "serialite"
-version = "0.3.2"
+version = "0.3.3"
 description = "A serialization library for Python"
 authors = ["David Hagen <david@drhagen.com>"]
 license = "MIT"
@@ -20,6 +20,7 @@ python = "^3.10"
 typing_extensions = "^4.3"
 fastapi = { version = "^0.100", 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" }
 
@@ -38,6 +39,7 @@ ruff = ">=0.0.275"
 [tool.poetry.extras]
 fastapi = ["fastapi", "pydantic"]
 numpy = ["numpy"]
+ordered-set = ["ordered-set"]
 
 
 [tool.coverage.run]

{serialite-0.3.2 → serialite-0.3.3}/src/serialite/_dispatcher.py

@@ -196,6 +196,13 @@ def list_to_data(cls):
     return ListSerializer(serializer(cls.__args__[0]))
 
 
+@serializer.register(set)
+def set_to_data(cls):
+    from ._implementations import SetSerializer
+
+    return SetSerializer(serializer(cls.__args__[0]))
+
+
 @serializer.register(tuple)
 def tuple_to_data(cls):
     from ._implementations import TupleSerializer
@@ -261,3 +268,16 @@ else:
         from ._implementations import ArraySerializer
 
         return ArraySerializer(dtype=float)
+
+
+try:
+    from ordered_set import OrderedSet
+except ImportError:
+    pass
+else:
+
+    @serializer.register(OrderedSet)
+    def ordered_set_to_data(cls):
+        from ._implementations import OrderedSetSerializer
+
+        return OrderedSetSerializer(serializer(cls.__args__[0]))

{serialite-0.3.2 → serialite-0.3.3}/src/serialite/_implementations/__init__.py

@@ -13,6 +13,7 @@ from ._literal import LiteralSerializer
 from ._none import NoneSerializer
 from ._path import PathSerializer
 from ._reserved import ReservedSerializer
+from ._set import SetSerializer
 from ._string import StringSerializer
 from ._tuple import TupleSerializer
 from ._union import OptionalSerializer, TryUnionSerializer
@@ -22,3 +23,8 @@ try:
     from ._array import ArraySerializer
 except ImportError:
     pass
+
+try:
+    from ._ordered_set import OrderedSetSerializer
+except ImportError:
+    pass

serialite-0.3.3/src/serialite/_implementations/_ordered_set.py

@@ -0,0 +1,56 @@
+__all__ = ["OrderedSetSerializer"]
+
+
+from typing import Generic, TypeVar
+
+from ordered_set import OrderedSet
+
+from .._base import Serializer
+from .._result import DeserializationFailure, DeserializationResult, DeserializationSuccess
+from .._stable_set import StableSet
+
+Element = TypeVar("Element")
+
+
+class OrderedSetSerializer(Generic[Element], Serializer[OrderedSet[Element]]):
+    def __init__(self, element_serializer: Serializer[Element]):
+        self.element_serializer = element_serializer
+
+    def from_data(self, data) -> DeserializationResult[OrderedSet[Element]]:
+        # Return early if the data isn't even a list
+        if not isinstance(data, list):
+            return DeserializationFailure(f"Not a valid list: {data!r}")
+
+        # Validate values
+        errors = {}
+        values = OrderedSet()
+        for i, value in enumerate(data):
+            value_or_error = self.element_serializer.from_data(value)
+            if isinstance(value_or_error, DeserializationFailure):
+                errors[str(i)] = value_or_error.error
+            elif value_or_error.value in values:
+                errors[str(i)] = (
+                    f"Duplicated value found: {value_or_error.value!r}. "
+                    "Expected a list of unique values."
+                )
+            else:
+                values.add(value_or_error.value)
+
+        if len(errors) > 0:
+            return DeserializationFailure(errors)
+        else:
+            return DeserializationSuccess(values)
+
+    def to_data(self, value: OrderedSet[Element]):
+        if not isinstance(value, OrderedSet):
+            raise ValueError(f"Not an OrderedSet: {value!r}")
+
+        return [self.element_serializer.to_data(item) for item in value]
+
+    def collect_openapi_models(
+        self, parent_models: StableSet[Serializer]
+    ) -> StableSet[Serializer]:
+        return self.element_serializer.collect_openapi_models(parent_models)
+
+    def to_openapi_schema(self, refs: dict[Serializer, str], force: bool = False):
+        return {"type": "array", "items": self.element_serializer.to_openapi_schema(refs)}

serialite-0.3.3/src/serialite/_implementations/_set.py

@@ -0,0 +1,54 @@
+__all__ = ["SetSerializer"]
+
+
+from typing import Generic, TypeVar
+
+from .._base import Serializer
+from .._result import DeserializationFailure, DeserializationResult, DeserializationSuccess
+from .._stable_set import StableSet
+
+Element = TypeVar("Element")
+
+
+class SetSerializer(Generic[Element], Serializer[set[Element]]):
+    def __init__(self, element_serializer: Serializer[Element]):
+        self.element_serializer = element_serializer
+
+    def from_data(self, data) -> DeserializationResult[set[Element]]:
+        # Return early if the data isn't even a list
+        if not isinstance(data, list):
+            return DeserializationFailure(f"Not a valid list: {data!r}")
+
+        # Validate values
+        errors = {}
+        values = set()
+        for i, value in enumerate(data):
+            value_or_error = self.element_serializer.from_data(value)
+            if isinstance(value_or_error, DeserializationFailure):
+                errors[str(i)] = value_or_error.error
+            elif value_or_error.value in values:
+                errors[str(i)] = (
+                    f"Duplicated value found: {value_or_error.value!r}. "
+                    "Expected a list of unique values."
+                )
+            else:
+                values.add(value_or_error.value)
+
+        if len(errors) > 0:
+            return DeserializationFailure(errors)
+        else:
+            return DeserializationSuccess(values)
+
+    def to_data(self, value: set[Element]):
+        if not isinstance(value, set):
+            raise ValueError(f"Not a set: {value!r}")
+
+        return [self.element_serializer.to_data(item) for item in value]
+
+    def collect_openapi_models(
+        self, parent_models: StableSet[Serializer]
+    ) -> StableSet[Serializer]:
+        return self.element_serializer.collect_openapi_models(parent_models)
+
+    def to_openapi_schema(self, refs: dict[Serializer, str], force: bool = False):
+        return {"type": "array", "items": self.element_serializer.to_openapi_schema(refs)}