plugantic 0.2.3__tar.gz → 0.2.4__tar.gz

{plugantic-0.2.3/src/plugantic.egg-info → plugantic-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugantic
-Version: 0.2.3
+Version: 0.2.4
 Summary: Simplified extendable composition with pydantic
 Author-email: Martin Kunze <martin@martinkunze.com>
 Project-URL: Homepage, https://github.com/martinkunze/plugantic

{plugantic-0.2.3 → plugantic-0.2.4}/src/plugantic/_consts.py

@@ -1,2 +1,2 @@
 # Single source of truth for information needed at runtime and build-time (i.e. version)
-version = "0.2.3"
+version = "0.2.4"

{plugantic-0.2.3 → plugantic-0.2.4}/src/plugantic/plugin.py

@@ -1,4 +1,4 @@
-from typing_extensions import ClassVar, Type, Self, Literal, Any, TypeVar, Set, Self, get_type_hints, get_origin, get_args, TYPE_CHECKING
+from typing_extensions import ClassVar, Type, Self, Literal, Any, TypeVar, Set, Collection, Sequence, get_type_hints, get_origin, get_args, TYPE_CHECKING
 from pydantic import BaseModel, GetCoreSchemaHandler, Field, ConfigDict, model_validator
 from pydantic.fields import FieldInfo
 from pydantic_core.core_schema import tagged_union_schema, union_schema
@@ -6,7 +6,7 @@ from pydantic_core.core_schema import tagged_union_schema, union_schema
 
 class PluganticConfigDict(ConfigDict, total=False):
     varname_type: str
-    value: str
+    value: str|Collection[str]
     auto_downcast: bool
     downcast_order: int
 
@@ -15,28 +15,24 @@ _T2 = TypeVar("_T2")
 
 class PluganticModelMeta(type(BaseModel)):
     def __and__(cls: Type[_T1], other: Type[_T2]) -> Type[_T1|_T2]:
-        if issubclass(other, PluginModel) or isinstance(other, PluganticCombinedModel):
-            return PluganticCombinedAnd(cls, other)
-
-        return super().__and__(other)
+        if issubclass(cls, PluginModel) and (issubclass(other, PluginModel) or isinstance(other, PluganticCombinedModel)):
+            return PluganticCombinedAnd(cls, other) # pyright: ignore[reportReturnType]
+        return NotImplemented
 
     def __rand__(cls: Type[_T1], other: Type[_T2]) -> Type[_T1|_T2]:
-        if issubclass(other, PluginModel) or isinstance(other, PluganticCombinedModel):
-            return PluganticCombinedAnd(other, cls)
-
-        return super().__rand__(other)
+        if issubclass(cls, PluginModel) and (issubclass(other, PluginModel) or isinstance(other, PluganticCombinedModel)):
+            return PluganticCombinedAnd(other, cls) # pyright: ignore[reportReturnType]
+        return NotImplemented
 
     def __or__(cls: Type[_T1], other: Type[_T2]) -> Type[_T1|_T2]:
-        if issubclass(other, PluginModel) or isinstance(other, PluganticCombinedModel):
-            return PluganticCombinedOr(cls, other)
-
-        return super().__or__(other)
+        if issubclass(cls, PluginModel) and (issubclass(other, PluginModel) or isinstance(other, PluganticCombinedModel)):
+            return PluganticCombinedOr(cls, other) # pyright: ignore[reportReturnType]
+        return NotImplemented
 
     def __ror__(cls: Type[_T1], other: Type[_T2]) -> Type[_T1|_T2]:
-        if issubclass(other, PluginModel) or isinstance(other, PluganticCombinedModel):
-            return PluganticCombinedOr(other, cls)
-
-        return super().__ror__(other)
+        if issubclass(cls, PluginModel) and (issubclass(other, PluginModel) or isinstance(other, PluganticCombinedModel)):
+            return PluganticCombinedOr(other, cls) # pyright: ignore[reportReturnType]
+        return NotImplemented
     
 if TYPE_CHECKING:
     _PluginModelMeta = type(BaseModel)
@@ -50,11 +46,11 @@ class PluginModel(BaseModel, metaclass=_PluginModelMeta):
     __plugantic_was_schema_created__: ClassVar[bool] = False
     __plugantic_check_schema_usage__: ClassVar[bool] = True
     
-    model_config: ClassVar[PluganticConfigDict] = PluganticConfigDict()
+    model_config: ClassVar[ConfigDict|PluganticConfigDict] = PluganticConfigDict(defer_build=True)
 
     if not TYPE_CHECKING:
         def __init__(self, *args, **kwargs):
-            declared_type = self._get_declared_type() # inject the default discriminator value if not provided
+            declared_type = self._get_declared_types()[0] # inject the default discriminator value if not provided
             if declared_type:
                 kwargs = {
                     self.__plugantic_varname_type__: declared_type,
@@ -64,7 +60,7 @@ class PluginModel(BaseModel, metaclass=_PluginModelMeta):
 
     def __init_subclass__(cls, *,
         varname_type: str|None=None,
-        value: str|None=None,
+        value: str|Collection[str]|None=None,
         auto_downcast: bool|None=None,
         downcast_order: int|None=None,
     **kwargs):
@@ -89,7 +85,9 @@ class PluginModel(BaseModel, metaclass=_PluginModelMeta):
             cls.__plugantic_varname_type__ = varname_type
 
         if value is not None:
-            cls._create_annotation(cls.__plugantic_varname_type__, Literal[value])
+            if isinstance(value, str):
+                value = [value]
+            cls._create_annotation(cls.__plugantic_varname_type__, Literal[*value])
         
         cls._ensure_varname_default()
 
@@ -134,10 +132,10 @@ class PluginModel(BaseModel, metaclass=_PluginModelMeta):
         SomeConfig(type="something") # works
         SomeConfig(type="else") # fails
         """
-        declared_type = cls._get_declared_type()
-        if not declared_type:
+        declared_types = cls._get_declared_types()
+        if not declared_types:
             return
-        cls._create_field_default(cls.__plugantic_varname_type__, declared_type)
+        cls._create_field_default(cls.__plugantic_varname_type__, declared_types[0])
 
     @classmethod
     def _get_declared_annotation(cls, name: str):
@@ -153,18 +151,18 @@ class PluginModel(BaseModel, metaclass=_PluginModelMeta):
         return annotation
 
     @classmethod
-    def _get_declared_type(cls) -> str|None:
+    def _get_declared_types(cls) -> Sequence[str]:
         """Get the value declared for the discriminator name (e.g. `type: Literal["something"]` -> "something")"""
         field = cls._get_declared_annotation(cls.__plugantic_varname_type__)
 
         if get_origin(field) is Literal:
-            return get_args(field)[0]
+            return get_args(field)
 
-        return None
+        return []
 
     @classmethod
     def _is_valid_subclass(cls) -> bool:
-        if cls._get_declared_type():
+        if cls._get_declared_types():
             return True
         return False
 
@@ -185,20 +183,21 @@ class PluginModel(BaseModel, metaclass=_PluginModelMeta):
         subclasses = set(cls._get_valid_subclasses())
         if len(subclasses) == 1:
             subcls = subclasses.pop()
-            subcls._mark_schame_created()
+            subcls._mark_schema_created()
             return handler(subcls)
 
         for subcls in subclasses:
-            subcls._mark_schame_created()
+            subcls._mark_schema_created()
 
         choices = dict[str, Type[Self]]()
 
         for subcls in subclasses:
-            type_ = subcls._get_declared_type()
-            existing = choices.get(type_, None)
-            if existing:
-                subcls = existing.__plugantic_order__(subcls)
-            choices[type_] = subcls
+            types = subcls._get_declared_types()
+            for type_ in types:
+                existing = choices.get(type_, None)
+                if existing:
+                    subcls = existing.__plugantic_order__(subcls)
+                choices[type_] = subcls
 
         choices = {
             type_: handler(subcls)
@@ -209,7 +208,7 @@ class PluginModel(BaseModel, metaclass=_PluginModelMeta):
 
     @classmethod
     def __get_pydantic_core_schema__(cls, source, handler: GetCoreSchemaHandler):
-        cls._mark_schame_created()
+        cls._mark_schema_created()
         return cls._as_tagged_union(handler)
 
     @classmethod
@@ -227,7 +226,7 @@ class PluginModel(BaseModel, metaclass=_PluginModelMeta):
         return cls
 
     @classmethod
-    def _mark_schame_created(cls) -> None:
+    def _mark_schema_created(cls) -> None:
         cls.__plugantic_was_schema_created__ = True
         
     @classmethod
@@ -246,6 +245,7 @@ class PluginModel(BaseModel, metaclass=_PluginModelMeta):
         return False
 
     @model_validator(mode="wrap")
+    @classmethod
     def _try_downcast(cls, data, handler):
         if isinstance(data, cls):
             pass
@@ -255,58 +255,59 @@ class PluginModel(BaseModel, metaclass=_PluginModelMeta):
             except Exception as e:
                 raise ValueError(f"Failed to downcast given {repr(data)} to required {cls.__name__}; please provide the required config directly") from e
         return handler(data)
-    
-    model_config = {"defer_build": True}
 
 class PluganticCombinedModel:
-    def __init__(self, *args: "PluganticCombinedModel|type[PluginModel]"):
+    def __init__(self, *args: "PluganticCombinedModel|Type[PluginModel]"):
         self.items = args
     
-    def _get_valid_subclasses(self) -> Set[type[PluginModel]]: ...
+    def _get_valid_subclasses(self) -> Set[Type[PluginModel]]: ...
 
     def __and__(self, other: Type):
         if isinstance(other, PluganticCombinedModel) or issubclass(other, PluginModel):
             return PluganticCombinedAnd(self, other)
-        return super().__and__(other)
+        return NotImplemented
 
     def __rand__(self, other):
         if isinstance(other, PluganticCombinedModel) or issubclass(other, PluginModel):
             return PluganticCombinedAnd(other, self)
-        return super().__rand__(other)
+        return NotImplemented
 
     def __or__(self, other):
         if isinstance(other, PluganticCombinedModel) or issubclass(other, PluginModel):
             return PluganticCombinedOr(self, other)
-        return super().__or__(other)
+        return NotImplemented
 
     def __ror__(self, other):
         if isinstance(other, PluganticCombinedModel) or issubclass(other, PluginModel):
             return PluganticCombinedOr(other, self)
-        return super().__ror__(other)
+        return NotImplemented
 
     def __get_pydantic_core_schema__(self, source, handler: GetCoreSchemaHandler):
         subclasses = set(self._get_valid_subclasses())
         if len(subclasses) == 1:
             subcls = subclasses.pop()
-            subcls._mark_schame_created()
+            subcls._mark_schema_created()
             return handler(subcls)
         
         choices = dict[str, dict[str, Type[PluginModel]]]()
         for subcls in subclasses:
-            subcls._mark_schame_created()
+            subcls._mark_schema_created()
             varname = subcls.__plugantic_varname_type__
-            type_ = subcls._get_declared_type()
-            existing = choices.setdefault(varname, {}).get(type_, None)
-            if existing:
-                subcls = existing.__plugantic_order__(subcls)
-            choices[varname][type_] = subcls
+            if varname is None:
+                continue
+            types = subcls._get_declared_types()
+            for type_ in types:
+                existing = choices.setdefault(varname, {}).get(type_, None)
+                if existing:
+                    subcls = existing.__plugantic_order__(subcls)
+                choices[varname][type_] = subcls
 
         choices = {
             varname: {type_: handler(subcls) for type_, subcls in types.items()}
             for varname, types in choices.items()
         }
 
-        unions = [
+        unions: list = [
             tagged_union_schema(c, discriminator=d) for d, c in choices.items()
         ]
 

{plugantic-0.2.3 → plugantic-0.2.4/src/plugantic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugantic
-Version: 0.2.3
+Version: 0.2.4
 Summary: Simplified extendable composition with pydantic
 Author-email: Martin Kunze <martin@martinkunze.com>
 Project-URL: Homepage, https://github.com/martinkunze/plugantic

{plugantic-0.2.3 → plugantic-0.2.4}/src/plugantic.egg-info/SOURCES.txt

@@ -3,7 +3,6 @@ README.md
 pyproject.toml
 src/plugantic/__init__.py
 src/plugantic/_consts.py
-src/plugantic/_helpers.py
 src/plugantic/_types.py
 src/plugantic/plugin.py
 src/plugantic.egg-info/PKG-INFO

{plugantic-0.2.3 → plugantic-0.2.4}/test/test_auto_downcast.py

@@ -1,5 +1,5 @@
 from typing import Literal
-from plugantic import PluginModel
+from plugantic import PluginModel, Field
 from pydantic import BaseModel
 
 def test_auto_downcast():
@@ -10,11 +10,11 @@ def test_auto_downcast():
         pass
 
     class Impl1(Base):
-        type: Literal["impl1"]
+        type: Literal["impl1"] = Field(default=...)
         value: str|None
 
     class Impl2(Impl1, Feature1):
-        value: str
+        value: str # pyright: ignore[reportIncompatibleVariableOverride]
 
     class Impl3(Impl1):
         pass

{plugantic-0.2.3 → plugantic-0.2.4}/test/test_basic_usage.py

@@ -1,5 +1,5 @@
 from typing_extensions import Literal
-from plugantic import PluginModel
+from plugantic import PluginModel, Field
 from pydantic import BaseModel
 
 def test_basic_usage_subclass_args():
@@ -13,7 +13,7 @@ def test_basic_usage_subclass_args():
         number: int|None = None
 
     class TestImplNumberStrict(TestImplNumber, value="number-strict"):
-        number: int = 0
+        number: int = 0 # pyright: ignore[reportIncompatibleVariableOverride]
 
     class OtherConfig(BaseModel):
         config: TestBase
@@ -50,7 +50,7 @@ def test_basic_usage_subclass_annotated():
         value: str
         
     class TestImplText(TestBase):
-        type: Literal["text"]
+        type: Literal["text"] = Field(default=...)
         text: str
         
     class TestImplNumber(TestBase):
@@ -58,15 +58,15 @@ def test_basic_usage_subclass_annotated():
         number: int|None = None
         
     class TestImplNumberStrict(TestImplNumber):
-        type: Literal["number-strict"]
-        number: int = 0
+        type: Literal["number-strict"] # pyright: ignore[reportIncompatibleVariableOverride]
+        number: int = 0 # pyright: ignore[reportIncompatibleVariableOverride]
         
     class OtherConfig(BaseModel):
         config: TestBase
         
     OtherConfig(config=TestImplText(value="some text", text="other text"))
-    OtherConfig(config=TestImplNumber(value="some number"))
-    OtherConfig(config=TestImplNumberStrict(value="strict number", number=3))
+    OtherConfig(config=TestImplNumber(value="some number")) # pyright: ignore[reportCallIssue]
+    OtherConfig(config=TestImplNumberStrict(value="strict number", number=3)) # pyright: ignore[reportCallIssue]
     
     c1 = OtherConfig.model_validate({"config": {
         "type": "text",
@@ -104,7 +104,7 @@ def test_basic_usage_subclass_config():
         model_config = {"value": "number"}
         
     class TestImplNumberStrict(TestImplNumber):
-        number: int = 0
+        number: int = 0 # pyright: ignore[reportIncompatibleVariableOverride]
         model_config = {"value": "number-strict"}
         
     class OtherConfig(BaseModel):
@@ -137,3 +137,58 @@ def test_basic_usage_subclass_config():
     assert not isinstance(c2.config, TestImplNumberStrict)
     assert isinstance(c3.config, TestImplNumberStrict)
 
+def test_basic_usage_multiple_values():
+    class TestBase(PluginModel, varname_type="type"):
+        pass
+
+    class TestImplText(TestBase, value=["text", "str"]):
+        text: str
+
+    class TestImplNumber(TestBase):
+        number: int
+        model_config = {"value": ["number", "num"]}
+
+    class TestImplEmpty(TestBase):
+        type: Literal["empty", "none"] = Field(default=...)
+
+    class OtherConfig(BaseModel):
+        config: TestBase
+
+    OtherConfig(config=TestImplText(text="other text"))
+    OtherConfig(config=TestImplNumber(number=3))
+    OtherConfig(config=TestImplEmpty())
+
+    c1 = OtherConfig.model_validate({"config": {
+        "type": "text",
+        "text": "some text",
+    }})
+
+    c2 = OtherConfig.model_validate({"config": {
+        "type": "str",
+        "text": "other text",
+    }})
+
+    c3 = OtherConfig.model_validate({"config": {
+        "type": "number",
+        "number": 3,
+    }})
+
+    c4 = OtherConfig.model_validate({"config": {
+        "type": "num",
+        "number": 3,
+    }})
+
+    c5 = OtherConfig.model_validate({"config": {
+        "type": "empty",
+    }})
+
+    c6 = OtherConfig.model_validate({"config": {
+        "type": "none",
+    }})
+
+    assert isinstance(c1.config, TestImplText)
+    assert isinstance(c2.config, TestImplText)
+    assert isinstance(c3.config, TestImplNumber)
+    assert isinstance(c4.config, TestImplNumber)
+    assert isinstance(c5.config, TestImplEmpty)
+    assert isinstance(c6.config, TestImplEmpty)

plugantic-0.2.3/src/plugantic/_helpers.py

@@ -1,42 +0,0 @@
-from __future__ import annotations
-
-from typing_extensions import TypeVar, Iterable, TypeGuard, TypeAliasType, Callable
-from itertools import combinations, product
-
-T = TypeVar("T")
-RecursiveList = TypeAliasType("RecursiveList", Iterable["RecursiveListItem[T]"], type_params=(T,))
-RecursiveListItem = TypeAliasType("RecursiveListItem", T | RecursiveList[T], type_params=(T,))
-
-def recursive_linear(items: RecursiveList[T], typeguard: Callable[[RecursiveListItem[T]], TypeGuard[T]], join: Callable[[Iterable[T]], T]) -> Iterable[T]:
-    result = []
-    for item in items:
-        if typeguard(item):
-            result.append(item)
-        else:
-            result.extend(recursive_powerset(item, typeguard, join))
-    return result
-
-def recursive_powerset(items: RecursiveList[T], typeguard: Callable[[RecursiveListItem[T]], TypeGuard[T]], join: Callable[[Iterable[T]], T]) -> Iterable[T]:
-    arbitrary_subset = []
-    subsets = []
-    for downcast in items:
-        if typeguard(downcast):
-            arbitrary_subset.append(downcast)
-        else:
-            linear_subset = recursive_linear(downcast, typeguard, join)
-            linear_subset = ((), *((d,) for d in linear_subset))
-            subsets.append(linear_subset)
-
-    arbitrary_powerset = [()]
-    for l in range(1, len(arbitrary_subset) + 1):
-        arbitrary_powerset.extend(combinations(arbitrary_subset, l))
-    subsets.append(arbitrary_powerset)
-
-    powerset = []
-    for subset in product(*subsets):
-        callbacks = [c for s in subset for c in s]
-        if not callbacks:
-            continue
-        powerset.append(join(callbacks))
-
-    return powerset