dataclass-extensions 0.2.6__tar.gz → 0.2.8__tar.gz

{dataclass_extensions-0.2.6 → dataclass_extensions-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataclass-extensions
-Version: 0.2.6
+Version: 0.2.8
 Summary: Additional functionality for Python dataclasses
 Author-email: Pete Walsh <epwalsh10@gmail.com>
 License:                                  Apache License
@@ -263,7 +263,6 @@ assert decode(FruitBasket, encode(basket)) == basket
 
 You can also define how to encode/decode non-dataclass types:
 
-
 ```python
 from dataclasses import dataclass
 from dataclass_extensions import decode, encode
@@ -280,11 +279,12 @@ class Bar:
 encode.register_encoder(lambda foo: {"x": foo.x}, Foo)
 decode.register_decoder(lambda d: Foo(d["x"]), Foo)
 
-encode(Bar(foo=Foo(10)))  # {'foo': {'x': 10}}
-decode(Bar, {"foo": {"x": 10}})
+bar = Bar(foo=Foo(10))
+assert encode(bar) == {"foo": {"x": 10}}
+assert decode(Bar, encode(bar)) == bar
 ```
 
-### Registrable subclasses
+### Polymorphism through registrable subclasses
 
 ```python
 from dataclasses import dataclass
@@ -307,6 +307,7 @@ class Banana(Fruit):
 class Apple(Fruit):
     calories: int = 150
     price: float = 1.50
+    variety: str = "Granny Smith"
 
 @dataclass
 class FruitBasket:
@@ -314,7 +315,14 @@ class FruitBasket:
     count: int
 
 basket = FruitBasket(fruit=Apple(), count=2)
-# note the additional "type" field, which corresponds to the registered name of the subclass
-assert encode(basket) == {"fruit": {"calories": 150, "price": 1.5, "type": "apple"}, "count": 2}
+assert encode(basket) == {
+    "fruit": {
+        "type": "apple",  # corresponds to the registered name
+        "calories": 150,
+        "price": 1.5,
+        "variety": "Granny Smith",
+    },
+    "count": 2,
+}
 assert decode(FruitBasket, encode(basket)) == basket
 ```

{dataclass_extensions-0.2.6 → dataclass_extensions-0.2.8}/README.md

@@ -37,7 +37,6 @@ assert decode(FruitBasket, encode(basket)) == basket
 
 You can also define how to encode/decode non-dataclass types:
 
-
 ```python
 from dataclasses import dataclass
 from dataclass_extensions import decode, encode
@@ -54,11 +53,12 @@ class Bar:
 encode.register_encoder(lambda foo: {"x": foo.x}, Foo)
 decode.register_decoder(lambda d: Foo(d["x"]), Foo)
 
-encode(Bar(foo=Foo(10)))  # {'foo': {'x': 10}}
-decode(Bar, {"foo": {"x": 10}})
+bar = Bar(foo=Foo(10))
+assert encode(bar) == {"foo": {"x": 10}}
+assert decode(Bar, encode(bar)) == bar
 ```
 
-### Registrable subclasses
+### Polymorphism through registrable subclasses
 
 ```python
 from dataclasses import dataclass
@@ -81,6 +81,7 @@ class Banana(Fruit):
 class Apple(Fruit):
     calories: int = 150
     price: float = 1.50
+    variety: str = "Granny Smith"
 
 @dataclass
 class FruitBasket:
@@ -88,7 +89,14 @@ class FruitBasket:
     count: int
 
 basket = FruitBasket(fruit=Apple(), count=2)
-# note the additional "type" field, which corresponds to the registered name of the subclass
-assert encode(basket) == {"fruit": {"calories": 150, "price": 1.5, "type": "apple"}, "count": 2}
+assert encode(basket) == {
+    "fruit": {
+        "type": "apple",  # corresponds to the registered name
+        "calories": 150,
+        "price": 1.5,
+        "variety": "Granny Smith",
+    },
+    "count": 2,
+}
 assert decode(FruitBasket, encode(basket)) == basket
 ```

{dataclass_extensions-0.2.6 → dataclass_extensions-0.2.8}/src/dataclass_extensions/decode.py

@@ -115,6 +115,17 @@ def _coerce(
                 except ValueError:
                     pass
 
+        if allowed_type is int:
+            if _safe_isinstance(value, (int, float)) and (value_as_int := int(value)) == value:
+                return value_as_int
+            elif _safe_isinstance(value, str):
+                try:
+                    value_as_float = float(value)
+                    if (value_as_int := int(value_as_float)) == value_as_float:
+                        return value_as_int
+                except ValueError:
+                    pass
+
         origin = getattr(allowed_type, "__origin__", None)
         args = getattr(allowed_type, "__args__", None)
         if (origin is list or origin is collections.abc.MutableSequence) and _safe_isinstance(

{dataclass_extensions-0.2.6 → dataclass_extensions-0.2.8}/src/dataclass_extensions/registrable.py

@@ -17,6 +17,8 @@ if sys.version_info < (3, 11):
 class Registrable:
     _registry: ClassVar[dict[str, Type[Registrable]]]
     _default_type: ClassVar[str | None]
+    registered_name: ClassVar[str | None]
+    registered_base: ClassVar[Type[Registrable] | None]
 
     type: dataclasses.InitVar[str | None] = dataclasses.field(
         default=None, kw_only=True, repr=False
@@ -24,16 +26,14 @@ class Registrable:
 
     def __new__(cls, *args, type: str | None = None, **kwargs):
         del args, kwargs
-        if type is not None and (
-            not hasattr(cls, "registered_name") or type != cls.registered_name  # type: ignore
-        ):
+        if type is not None and type != cls.registered_name:
             if type not in cls._registry:
                 raise KeyError(
                     f"'{type}' is not registered name for {cls.__name__}. "
                     f"Available choices are: {list(cls._registry.keys())}"
                 )
             return super().__new__(cls._registry[type])
-        elif cls._default_type is not None and not hasattr(cls, "registered_name"):
+        elif cls._default_type is not None and cls.registered_name is None:
             return super().__new__(cls._registry[cls._default_type])
         else:
             return super().__new__(cls)
@@ -44,6 +44,10 @@ class Registrable:
             cls._registry = {}
         if not hasattr(cls, "_default_type"):
             cls._default_type = None
+        if not hasattr(cls, "registered_name"):
+            cls.registered_name = None
+        if not hasattr(cls, "registered_base"):
+            cls.registered_base = None
 
     @classmethod
     def register(cls, name: str, default: bool = False) -> Callable[[Type[R]], Type[R]]:
@@ -64,28 +68,18 @@ class Registrable:
                 else:
                     cls._default_type = name
 
-            fields = [
-                (f.name, f.type, f) for f in dataclasses.fields(subclass) if f.name != "type"  # type: ignore
-            ] + [
-                ("registered_name", ClassVar[str], name),  # type: ignore
-                ("registered_base", ClassVar[R], cls),  # type: ignore
-                ("type", dataclasses.InitVar[str | None], dataclasses.field(default=name, kw_only=True, repr=False)),  # type: ignore
-            ]
-            subclass = dataclasses.make_dataclass(
-                subclass.__name__,
-                fields,  # type: ignore
-                bases=(subclass,),
-            )
             cls._registry[name] = subclass
-            return subclass
+            subclass.registered_name = name
+            subclass.registered_base = cls
+            return subclass  # type: ignore
 
         return register_subclass
 
     @classmethod
     def get_registered_name(cls: Type[R], subclass: Type[R] | None = None) -> str:
         if subclass is None:
-            if hasattr(cls, "registered_name"):
-                return cls.registered_name  # type: ignore
+            if cls.registered_name is not None:
+                return cls.registered_name
             else:
                 raise ValueError(
                     f"class {cls.__name__} is not a registered subclass of any base registrable class"

dataclass_extensions-0.2.8/src/dataclass_extensions/version.py

@@ -0,0 +1 @@
+VERSION = "0.2.8"

{dataclass_extensions-0.2.6 → dataclass_extensions-0.2.8}/src/dataclass_extensions.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataclass-extensions
-Version: 0.2.6
+Version: 0.2.8
 Summary: Additional functionality for Python dataclasses
 Author-email: Pete Walsh <epwalsh10@gmail.com>
 License:                                  Apache License
@@ -263,7 +263,6 @@ assert decode(FruitBasket, encode(basket)) == basket
 
 You can also define how to encode/decode non-dataclass types:
 
-
 ```python
 from dataclasses import dataclass
 from dataclass_extensions import decode, encode
@@ -280,11 +279,12 @@ class Bar:
 encode.register_encoder(lambda foo: {"x": foo.x}, Foo)
 decode.register_decoder(lambda d: Foo(d["x"]), Foo)
 
-encode(Bar(foo=Foo(10)))  # {'foo': {'x': 10}}
-decode(Bar, {"foo": {"x": 10}})
+bar = Bar(foo=Foo(10))
+assert encode(bar) == {"foo": {"x": 10}}
+assert decode(Bar, encode(bar)) == bar
 ```
 
-### Registrable subclasses
+### Polymorphism through registrable subclasses
 
 ```python
 from dataclasses import dataclass
@@ -307,6 +307,7 @@ class Banana(Fruit):
 class Apple(Fruit):
     calories: int = 150
     price: float = 1.50
+    variety: str = "Granny Smith"
 
 @dataclass
 class FruitBasket:
@@ -314,7 +315,14 @@ class FruitBasket:
     count: int
 
 basket = FruitBasket(fruit=Apple(), count=2)
-# note the additional "type" field, which corresponds to the registered name of the subclass
-assert encode(basket) == {"fruit": {"calories": 150, "price": 1.5, "type": "apple"}, "count": 2}
+assert encode(basket) == {
+    "fruit": {
+        "type": "apple",  # corresponds to the registered name
+        "calories": 150,
+        "price": 1.5,
+        "variety": "Granny Smith",
+    },
+    "count": 2,
+}
 assert decode(FruitBasket, encode(basket)) == basket
 ```

dataclass_extensions-0.2.6/src/dataclass_extensions/version.py

@@ -1 +0,0 @@
-VERSION = "0.2.6"