enumetyped 0.3.2__tar.gz

enumetyped-0.3.2/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 to present Pydantic Services Inc. and individual contributors.
+
+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.

enumetyped-0.3.2/PKG-INFO

@@ -0,0 +1,220 @@
+Metadata-Version: 2.1
+Name: enumetyped
+Version: 0.3.2
+Summary: Type-containing enumeration
+Home-page: https://github.com/rjotanm/enumetyped
+License: MIT
+Author: Rinat Balbekov
+Author-email: me@rjotanm.dev
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Pydantic
+Classifier: Framework :: Pydantic :: 2
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+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
+Classifier: Typing :: Typed
+Provides-Extra: pydantic
+Requires-Dist: pydantic (>=2.9.0) ; extra == "pydantic"
+Requires-Dist: typing-extensions (>=4.0.0)
+Project-URL: Repository, https://github.com/rjotanm/enumetyped
+Description-Content-Type: text/markdown
+
+# Enumetyped
+
+This package provide a way to create typed enumerations.
+
+# Install
+
+- `pip install enumetyped`
+- `pip install enumetyped[pydantic]` - install with pydantic `>=2.9`
+
+# Quickstart
+
+#### Without pydantic
+```python
+from enumetyped import TypEnum, TypEnumContent
+
+class SimpleEnum(TypEnum[TypEnumContent]):
+    A: type["SimpleEnum[NoValue]"]
+    Int: type["SimpleEnum[int]"]
+
+# isinstance checking
+assert isinstance(SimpleEnum.A(...), SimpleEnum)
+assert isinstance(SimpleEnum.Int(123), SimpleEnum.Int)
+assert not isinstance(SimpleEnum.Int(123), SimpleEnum.A)
+
+# fully pattern-matching
+match SimpleEnum.Int(1):
+    case SimpleEnum.Int(2):
+        a = False
+    case SimpleEnum.Int(1):
+        a = True
+    case SimpleEnum.Int():
+        a = True
+    case _:
+        a = False
+
+assert a
+```
+
+#### With pydantic
+
+```python
+import typing
+from dataclasses import dataclass
+
+from pydantic import BaseModel
+
+from enumetyped import TypEnum, TypEnumContent, NoValue
+from enumetyped.pydantic import TypEnumPydantic, FieldMetadata, Rename
+from typing_extensions import Annotated, TypedDict
+
+
+class Enum(TypEnum[NoValue]):
+    V1: type["Enum"]
+    V2: type["Enum"]
+
+
+@dataclass
+class TestDataClass:
+    a: int
+
+
+class TestModel(BaseModel):
+    b: str
+
+
+class TestTypedDict(TypedDict):
+    tm: TestModel
+
+
+class SimpleEnum(TypEnumPydantic[NoValue]):
+    V1: type["SimpleEnum"]
+    V2: type["SimpleEnum"]
+
+
+class OtherEnum(TypEnumPydantic[TypEnumContent]):
+    Int: type["OtherEnum[int]"]
+    Int: type["OtherEnum[str]"]
+
+
+# class MyEnum(TypEnumPydantic[TypEnumContent], variant="key", content="value"): <- adjacently
+# class MyEnum(TypEnumPydantic[TypEnumContent], variant="key"): <- internally
+class MyEnum(TypEnumPydantic[TypEnumContent]):  # <- externally, default
+    # MyEnum.Int(123)
+    Int: type["MyEnum[int]"]
+
+    # MyEnum.Str(123)
+    Str: type["MyEnum[str]"]
+
+    # MyEnum.Str(OtherEnum.Int(1))
+    Other: type["MyEnum[OtherEnum[Any]]"]  # any from OtherEnum variants
+
+    # MyEnum.Str(MyEnum.Int(1)) | MyEnum.Str(MyEnum.Str(1))
+    Self: type["MyEnum[MyEnum[Any]]"]  # any from self variants
+
+    # MyEnum.OnlySelf(...) - any parameters skipped, serialized just by name
+    NoValue: type["MyEnum[NoValue]"]
+
+    # MyEnum.OnlySelf2(None)
+    Optional: type["MyEnum[Optional[bool]]"]
+
+    # MyEnum.List(["1", "2", "3"])
+    List: type["MyEnum[list[str]]"]
+
+    # MyEnum.Dict({"key": "value"})
+    Dict: type["MyEnum[dict[str, str]]"]
+    # TypedDict: type["MyEnum[{"b": str}]"]
+    TypedDict: type["MyEnum[TestD]"]  # python doesn`t have inline TypedDict now
+
+    # MyEnum.DC(TestDataClass(a=1))
+    DataClass: type["MyEnum[TestDataClass]"]
+
+    # MyEnum.Model(TestModel(b="2"))
+    Model: type["MyEnum[TestModel]"]
+
+    # MyEnum.StrTuple(("1", "2")))
+    StringTuple: Annotated[type["MyEnum[tuple[str, str]]"], FieldMetadata(rename="just_str_tuple")]
+    # or use enumetyped.pydantic.Rename
+    # StrTuple: Annotated[type["MyEnum[tuple[str, str]]"], Rename("some_other_name")]
+
+
+class FinModel(BaseModel):
+    enum: MyEnum
+
+
+def dump_and_load(e: MyEnum):
+    model = FinModel(enum=e)
+    json_ = model.model_dump_json()
+    print(json_)
+    restored = FinModel.model_validate_json(json_)
+    assert model == restored
+
+
+# externally -> {"enum":{"Int":1}} 
+# adjacently -> {"enum":{"key":"Int","value":1}}
+# internally -> not supported
+dump_and_load(MyEnum.Int(1))
+
+# externally -> {"enum":{"Str":"str"}}
+# adjacently -> {"enum":{"key":"Str","value":"str"}}
+# internally -> not supported
+dump_and_load(MyEnum.Str("str"))
+
+# externally -> {"enum":{"List":["list"]}}
+# adjacently -> {"enum":{"key":"List","value":["list"]}}
+# internally -> not supported
+dump_and_load(MyEnum.List(["list"]))
+
+# externally -> {"enum":{"just_str_tuple":["str","str2"]}} 
+# adjacently -> {"enum":{"key":"just_str_tuple","value":["str","str2"]}}
+# internally -> not supported
+dump_and_load(MyEnum.StringTuple(("str", "str2")))
+
+# externally -> {"enum":{"Self":{"Int":1}}} 
+# adjacently -> {"enum":{"key":"Self","value":{"key":"Int","value":1}}}
+# internally -> not supported
+dump_and_load(MyEnum.Self(MyEnum.Int(1)))
+
+# externally -> {"enum":{"DC":{"a":1}}} 
+# adjacently -> {"enum":{"key":"DC","value":{"a":1}}}
+# internally -> {"enum":{"key":"DC","a":1}}}
+dump_and_load(MyEnum.DataClass(TestDataClass(a=1)))
+
+# externally -> {"enum":{"Model":{"b":"test_model"}}} 
+# adjacently -> {"enum":{"key":"Model","value":{"b":"test_model"}}}
+# internally -> {"enum":{"key":"Model", "b":"test_model"}}
+dump_and_load(MyEnum.Model(TestModel(b="test_model")))
+
+# externally -> {"enum":{"TypedDict":{"tm":{"b":"test_model"}}}} 
+# adjacently -> {"enum":{"key":"TypedDict","value":{"tm":{"b":"test_model"}}}}
+# internally -> {"enum":{"key":"TypedDict","tm":{"b":"test_model"}}}
+dump_and_load(MyEnum.TypedDict(TestTypedDict(tm=TestModel(b="test_model"))))
+
+# externally -> {"enum":{"Dict":{"a":"1","b":"2"}}} 
+# adjacently -> {"enum":{"key":"Dict","value":{"a":"1","b":"2"}}}
+# internally -> not supported
+dump_and_load(MyEnum.Dict({"a": "1", "b": "2"}))
+
+# externally -> {"enum":"NoValue"}
+# adjacently -> {"enum":{"key":"NoValue"}}
+# internally -> {"enum":{"key":"NoValue"}}
+dump_and_load(MyEnum.NoValue(...))
+
+# externally -> {"enum":{"Optional":null}} 
+# adjacently -> {"enum":{"key":"Optional","value":null}}
+# internally -> not supported
+dump_and_load(MyEnum.Optional(None))
+```
+
+#### Other
+
+ - [Compatibility](docs/compatibility.md)
+ - [Limitations](docs/limitations.md)

enumetyped-0.3.2/README.md

@@ -0,0 +1,192 @@
+# Enumetyped
+
+This package provide a way to create typed enumerations.
+
+# Install
+
+- `pip install enumetyped`
+- `pip install enumetyped[pydantic]` - install with pydantic `>=2.9`
+
+# Quickstart
+
+#### Without pydantic
+```python
+from enumetyped import TypEnum, TypEnumContent
+
+class SimpleEnum(TypEnum[TypEnumContent]):
+    A: type["SimpleEnum[NoValue]"]
+    Int: type["SimpleEnum[int]"]
+
+# isinstance checking
+assert isinstance(SimpleEnum.A(...), SimpleEnum)
+assert isinstance(SimpleEnum.Int(123), SimpleEnum.Int)
+assert not isinstance(SimpleEnum.Int(123), SimpleEnum.A)
+
+# fully pattern-matching
+match SimpleEnum.Int(1):
+    case SimpleEnum.Int(2):
+        a = False
+    case SimpleEnum.Int(1):
+        a = True
+    case SimpleEnum.Int():
+        a = True
+    case _:
+        a = False
+
+assert a
+```
+
+#### With pydantic
+
+```python
+import typing
+from dataclasses import dataclass
+
+from pydantic import BaseModel
+
+from enumetyped import TypEnum, TypEnumContent, NoValue
+from enumetyped.pydantic import TypEnumPydantic, FieldMetadata, Rename
+from typing_extensions import Annotated, TypedDict
+
+
+class Enum(TypEnum[NoValue]):
+    V1: type["Enum"]
+    V2: type["Enum"]
+
+
+@dataclass
+class TestDataClass:
+    a: int
+
+
+class TestModel(BaseModel):
+    b: str
+
+
+class TestTypedDict(TypedDict):
+    tm: TestModel
+
+
+class SimpleEnum(TypEnumPydantic[NoValue]):
+    V1: type["SimpleEnum"]
+    V2: type["SimpleEnum"]
+
+
+class OtherEnum(TypEnumPydantic[TypEnumContent]):
+    Int: type["OtherEnum[int]"]
+    Int: type["OtherEnum[str]"]
+
+
+# class MyEnum(TypEnumPydantic[TypEnumContent], variant="key", content="value"): <- adjacently
+# class MyEnum(TypEnumPydantic[TypEnumContent], variant="key"): <- internally
+class MyEnum(TypEnumPydantic[TypEnumContent]):  # <- externally, default
+    # MyEnum.Int(123)
+    Int: type["MyEnum[int]"]
+
+    # MyEnum.Str(123)
+    Str: type["MyEnum[str]"]
+
+    # MyEnum.Str(OtherEnum.Int(1))
+    Other: type["MyEnum[OtherEnum[Any]]"]  # any from OtherEnum variants
+
+    # MyEnum.Str(MyEnum.Int(1)) | MyEnum.Str(MyEnum.Str(1))
+    Self: type["MyEnum[MyEnum[Any]]"]  # any from self variants
+
+    # MyEnum.OnlySelf(...) - any parameters skipped, serialized just by name
+    NoValue: type["MyEnum[NoValue]"]
+
+    # MyEnum.OnlySelf2(None)
+    Optional: type["MyEnum[Optional[bool]]"]
+
+    # MyEnum.List(["1", "2", "3"])
+    List: type["MyEnum[list[str]]"]
+
+    # MyEnum.Dict({"key": "value"})
+    Dict: type["MyEnum[dict[str, str]]"]
+    # TypedDict: type["MyEnum[{"b": str}]"]
+    TypedDict: type["MyEnum[TestD]"]  # python doesn`t have inline TypedDict now
+
+    # MyEnum.DC(TestDataClass(a=1))
+    DataClass: type["MyEnum[TestDataClass]"]
+
+    # MyEnum.Model(TestModel(b="2"))
+    Model: type["MyEnum[TestModel]"]
+
+    # MyEnum.StrTuple(("1", "2")))
+    StringTuple: Annotated[type["MyEnum[tuple[str, str]]"], FieldMetadata(rename="just_str_tuple")]
+    # or use enumetyped.pydantic.Rename
+    # StrTuple: Annotated[type["MyEnum[tuple[str, str]]"], Rename("some_other_name")]
+
+
+class FinModel(BaseModel):
+    enum: MyEnum
+
+
+def dump_and_load(e: MyEnum):
+    model = FinModel(enum=e)
+    json_ = model.model_dump_json()
+    print(json_)
+    restored = FinModel.model_validate_json(json_)
+    assert model == restored
+
+
+# externally -> {"enum":{"Int":1}} 
+# adjacently -> {"enum":{"key":"Int","value":1}}
+# internally -> not supported
+dump_and_load(MyEnum.Int(1))
+
+# externally -> {"enum":{"Str":"str"}}
+# adjacently -> {"enum":{"key":"Str","value":"str"}}
+# internally -> not supported
+dump_and_load(MyEnum.Str("str"))
+
+# externally -> {"enum":{"List":["list"]}}
+# adjacently -> {"enum":{"key":"List","value":["list"]}}
+# internally -> not supported
+dump_and_load(MyEnum.List(["list"]))
+
+# externally -> {"enum":{"just_str_tuple":["str","str2"]}} 
+# adjacently -> {"enum":{"key":"just_str_tuple","value":["str","str2"]}}
+# internally -> not supported
+dump_and_load(MyEnum.StringTuple(("str", "str2")))
+
+# externally -> {"enum":{"Self":{"Int":1}}} 
+# adjacently -> {"enum":{"key":"Self","value":{"key":"Int","value":1}}}
+# internally -> not supported
+dump_and_load(MyEnum.Self(MyEnum.Int(1)))
+
+# externally -> {"enum":{"DC":{"a":1}}} 
+# adjacently -> {"enum":{"key":"DC","value":{"a":1}}}
+# internally -> {"enum":{"key":"DC","a":1}}}
+dump_and_load(MyEnum.DataClass(TestDataClass(a=1)))
+
+# externally -> {"enum":{"Model":{"b":"test_model"}}} 
+# adjacently -> {"enum":{"key":"Model","value":{"b":"test_model"}}}
+# internally -> {"enum":{"key":"Model", "b":"test_model"}}
+dump_and_load(MyEnum.Model(TestModel(b="test_model")))
+
+# externally -> {"enum":{"TypedDict":{"tm":{"b":"test_model"}}}} 
+# adjacently -> {"enum":{"key":"TypedDict","value":{"tm":{"b":"test_model"}}}}
+# internally -> {"enum":{"key":"TypedDict","tm":{"b":"test_model"}}}
+dump_and_load(MyEnum.TypedDict(TestTypedDict(tm=TestModel(b="test_model"))))
+
+# externally -> {"enum":{"Dict":{"a":"1","b":"2"}}} 
+# adjacently -> {"enum":{"key":"Dict","value":{"a":"1","b":"2"}}}
+# internally -> not supported
+dump_and_load(MyEnum.Dict({"a": "1", "b": "2"}))
+
+# externally -> {"enum":"NoValue"}
+# adjacently -> {"enum":{"key":"NoValue"}}
+# internally -> {"enum":{"key":"NoValue"}}
+dump_and_load(MyEnum.NoValue(...))
+
+# externally -> {"enum":{"Optional":null}} 
+# adjacently -> {"enum":{"key":"Optional","value":null}}
+# internally -> not supported
+dump_and_load(MyEnum.Optional(None))
+```
+
+#### Other
+
+ - [Compatibility](docs/compatibility.md)
+ - [Limitations](docs/limitations.md)

enumetyped-0.3.2/enumetyped/__init__.py

@@ -0,0 +1,11 @@
+from enumetyped.core import TypEnum, TypEnumContent, NoValue
+
+__all__ = [
+    "NoValue",
+    "TypEnum",
+    "TypEnumContent",
+]
+
+__package_name__ = "enumetyped"
+__version__ = "0.3.2"
+__description__ = "Type-containing enumeration"

enumetyped-0.3.2/enumetyped/core.py

@@ -0,0 +1,144 @@
+import types
+import typing
+
+__all__ = [
+    "NoValue",
+    "TypEnum",
+    "TypEnumContent",
+    "TypEnumMeta",
+]
+
+import typing_extensions
+
+from annotated_types import BaseMetadata
+from typing_extensions import Annotated
+
+TypEnumContent = typing.TypeVar("TypEnumContent")
+
+
+NoValue = types.EllipsisType
+
+
+class TypEnumMeta(type):
+    __full_variant_name__: str
+    __variant_name__: str
+
+    __content_type__: typing.Union[str, type[typing.Any]]
+
+    __variants__: dict[type['_TypEnum[typing.Any]'], str]
+
+    __is_variant__: bool = False
+
+    def __new__(
+            cls,
+            cls_name: str,
+            bases: tuple[typing.Any],
+            class_dict: dict[str, typing.Any],
+    ) -> typing.Any:
+        enum_class = super().__new__(cls, cls_name, bases, class_dict)
+        if enum_class.__annotations__.get("__abstract__"):
+            return enum_class
+
+        if enum_class.__is_variant__:
+            return enum_class
+        else:
+            enum_class.__variants__ = dict()
+
+        enum_class.__full_variant_name__ = cls_name
+        enum_class.__variant_name__ = cls_name
+
+        annotation: typing.Union[type[Annotated[typing.Any, BaseMetadata]], type]
+        for attr, annotation in enum_class.__annotations__.items():
+            if not hasattr(annotation, "__args__"):
+                continue
+
+            if (__origin__ := getattr(annotation, "__origin__", None)) and annotation.__name__ == "Annotated":
+                origin = typing.get_args(__origin__)[0]
+            else:
+                is_type = isinstance(annotation, types.GenericAlias) and annotation.__name__ == "type"
+                if not is_type:
+                    continue
+
+                origin = typing.get_args(annotation)[0]
+
+            split = origin[:-1].split("[", maxsplit=1)
+
+            content_type: str | type[typing.Any]
+            if len(split) == 1:
+                content_type = NoValue
+            else:
+                left, right = split
+                if left != enum_class.__name__:
+                    continue
+
+                if right.split("[", maxsplit=1)[0] == enum_class.__name__:
+                    content_type = enum_class
+                else:
+                    try:
+                        content_type = eval(right)
+                    except NameError:
+                        content_type = right
+
+            try:
+                variant_base = enum_class[content_type]  # type: ignore
+            except TypeError:
+                # When enum is non-generic, like this
+                #
+                # class SimpleEnum(TypEnum):
+                #     V: type["SimpleEnum"]
+                #
+                variant_base = enum_class
+
+            class _EnumVariant(variant_base):  # type: ignore
+                __is_variant__ = True
+
+            _EnumVariant.__name__ = _EnumVariant.__full_variant_name__ = f"{enum_class.__name__}.{attr}"
+            _EnumVariant.__variant_name__ = attr
+            _EnumVariant.__content_type__ = content_type
+
+            enum_class.__variants__[_EnumVariant] = attr
+
+            setattr(enum_class, attr, _EnumVariant)
+
+        return enum_class
+
+    def __repr__(self) -> str:
+        return getattr(self, "__full_variant_name__", self.__class__.__name__)
+
+
+class _TypEnum(typing.Generic[TypEnumContent], metaclass=TypEnumMeta):
+    __match_args__ = ("value",)
+
+    __full_variant_name__: typing.ClassVar[str]
+    __variant_name__: typing.ClassVar[str]
+
+    __content_type__: typing.ClassVar[typing.Union[str, type[typing.Any]]]
+
+    __variants__: typing.ClassVar[dict[type['_TypEnum[typing.Any]'], str]]
+
+    __is_variant__: typing.ClassVar[bool] = False
+
+    __abstract__: typing_extensions.Never
+
+    value: typing.Optional[TypEnumContent]
+
+    def __init__(self, value: TypEnumContent):
+        if self.__content_type__ is NoValue:
+            self.value = None
+        else:
+            self.value = value
+
+    def __repr__(self) -> str:
+        if self.__content_type__ is NoValue:
+            return f"{self.__full_variant_name__}()"
+        return f"{self.__full_variant_name__}({self.value.__repr__()})"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, _TypEnum):
+            return False
+
+        return self.__class__ == other.__class__ and self.value == other.value
+
+
+class TypEnum(_TypEnum[TypEnumContent]):
+    __abstract__: typing_extensions.Never

enumetyped-0.3.2/enumetyped/pydantic/__init__.py

@@ -0,0 +1,18 @@
+import pydantic
+
+if tuple(map(int, pydantic.version.VERSION.split('.'))) < (2, 9, 0):
+    raise ValueError("Pydantic version must be >=2.9.0")
+
+
+from .core import (
+    Rename,
+    TypEnumPydantic,
+    FieldMetadata,
+)
+
+
+__all__ = [
+    "FieldMetadata",
+    "Rename",
+    "TypEnumPydantic",
+]

enumetyped-0.3.2/enumetyped/pydantic/core.py

@@ -0,0 +1,158 @@
+import importlib
+import inspect
+import typing
+import pydantic as pydantic_
+
+from dataclasses import dataclass
+
+import typing_extensions
+from annotated_types import GroupedMetadata, BaseMetadata
+from pydantic_core import core_schema
+from pydantic_core.core_schema import ValidationInfo, SerializerFunctionWrapHandler
+
+from enumetyped.core import TypEnumMeta, _TypEnum, TypEnumContent
+
+__all__ = [
+    "Rename",
+    "FieldMetadata",
+    "TypEnumPydantic",
+    "TypEnumPydanticMeta",
+    "eval_content_type",
+]
+
+from enumetyped.pydantic.serialization import AdjacentlyTagged, InternallyTagged, ExternallyTagged
+from enumetyped.pydantic.serialization.tagged import TaggedSerialization
+
+
+@dataclass(frozen=True, slots=True)
+class Rename(BaseMetadata):
+    value: str
+
+
+@dataclass
+class FieldMetadata(GroupedMetadata):
+    rename: typing.Optional[str] = None
+
+    def __iter__(self) -> typing.Iterator[BaseMetadata]:
+        if self.rename is not None:
+            yield Rename(self.rename)
+
+
+def eval_content_type(cls: type['TypEnumPydantic[TypEnumContent]']) -> type:
+    # Eval annotation into real object
+    base = cls.__orig_bases__[0]  # type: ignore
+    module = importlib.import_module(base.__module__)
+    return eval(cls.__content_type__, module.__dict__)  # type: ignore
+
+
+class TypEnumPydanticMeta(TypEnumMeta):
+    __serialization__: TaggedSerialization
+
+    def __new__(
+            cls,
+            cls_name: str,
+            bases: tuple[typing.Any],
+            class_dict: dict[str, typing.Any],
+            variant: typing.Optional[str] = None,
+            content: typing.Optional[str] = None,
+    ) -> typing.Any:
+        enum_class = super().__new__(cls, cls_name, bases, class_dict)
+        if enum_class.__annotations__.get("__abstract__"):
+            return enum_class
+
+        enum_class.__full_variant_name__ = cls_name
+        enum_class.__variant_name__ = cls_name
+
+        if enum_class.__is_variant__:
+            return enum_class
+
+        enum_class.__names_serialization__ = dict()
+        enum_class.__names_deserialization__ = dict()
+
+        if variant is not None and content is not None:
+            enum_class.__serialization__ = AdjacentlyTagged(variant, content)
+        elif variant is not None:
+            enum_class.__serialization__ = InternallyTagged(variant)
+        else:
+            enum_class.__serialization__ = ExternallyTagged()
+
+        annotation: typing.Union[type[typing_extensions.Annotated[typing.Any, BaseMetadata]], type]
+        for attr, annotation in enum_class.__annotations__.items():
+            if not hasattr(annotation, "__args__"):
+                continue
+
+            enum_variant = getattr(enum_class, attr)
+            if isinstance(enum_variant.__content_type__, str):
+                try:
+                    enum_variant.__content_type__ = eval_content_type(enum_variant)
+                except NameError:
+                    ...
+
+            if isinstance(annotation, typing._AnnotatedAlias):  # type: ignore
+                metadata: list[typing.Union[BaseMetadata, GroupedMetadata]] = []
+                for v in annotation.__metadata__:
+                    if isinstance(v, FieldMetadata):
+                        metadata.extend(v)
+                    else:
+                        metadata.append(v)
+
+                for __meta__ in metadata:
+                    if isinstance(__meta__, Rename):
+                        if __meta__.value in enum_class.__names_deserialization__:
+                            raise ValueError(f"{cls_name}: Two or many field renamed to `{__meta__.value}`")
+
+                        enum_class.__names_serialization__[attr] = __meta__.value
+                        enum_class.__names_deserialization__[__meta__.value] = attr
+
+        return enum_class
+
+
+class TypEnumPydantic(_TypEnum[TypEnumContent], metaclass=TypEnumPydanticMeta):
+    __abstract__: typing_extensions.Never
+
+    __names_serialization__: typing.ClassVar[dict[str, str]]
+    __names_deserialization__: typing.ClassVar[dict[str, str]]
+
+    __serialization__: typing.ClassVar[TaggedSerialization]
+
+    @classmethod
+    def content_type(cls) -> type:
+        # Resolve types when __content_type__ declare after cls declaration
+        if isinstance(cls.__content_type__, str):
+            cls.__content_type__ = eval_content_type(cls)
+        return cls.__content_type__
+
+    @classmethod
+    def __variant_constructor__(
+            cls: type["TypEnumPydantic[TypEnumContent]"],
+            value: typing.Any,
+            info: ValidationInfo,
+    ) -> "TypEnumPydantic[TypEnumContent]":
+        if inspect.isclass(cls.content_type()) and issubclass(cls.content_type(), TypEnumPydantic):
+            value = cls.__python_value_restore__(value, info)
+
+        return cls(value)
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+            cls: type["TypEnumPydantic[TypEnumContent]"],
+            source_type: typing.Any,
+            handler: pydantic_.GetCoreSchemaHandler,
+    ) -> core_schema.CoreSchema:
+        return cls.__serialization__.__get_pydantic_core_schema__(cls, source_type, handler)
+
+    @classmethod
+    def __python_value_restore__(
+            cls: type["TypEnumPydantic[TypEnumContent]"],
+            input_value: typing.Any,
+            info: ValidationInfo,
+    ) -> typing.Any:
+        return cls.__serialization__.__python_value_restore__(cls, input_value, info)
+
+    @classmethod
+    def __pydantic_serialization__(
+            cls: type["TypEnumPydantic[TypEnumContent]"],
+            model: typing.Any,
+            serializer: SerializerFunctionWrapHandler,
+    ) -> typing.Any:
+        return cls.__serialization__.__pydantic_serialization__(cls, model, serializer)

enumetyped-0.3.2/enumetyped/pydantic/serialization/__init__.py

@@ -0,0 +1,9 @@
+from .externally import ExternallyTagged
+from .adjacently import AdjacentlyTagged
+from .internally import InternallyTagged
+
+__all__ = [
+    "ExternallyTagged",
+    "AdjacentlyTagged",
+    "InternallyTagged",
+]

enumetyped-0.3.2/enumetyped/pydantic/serialization/adjacently.py

@@ -0,0 +1,116 @@
+import inspect
+import typing
+
+import pydantic as pydantic_
+from pydantic_core import CoreSchema, core_schema
+from pydantic_core.core_schema import SerializerFunctionWrapHandler, ValidationInfo
+
+from enumetyped.core import TypEnumContent, NoValue
+from enumetyped.pydantic.serialization.tagged import TaggedSerialization
+
+if typing.TYPE_CHECKING:
+    from ..core import TypEnumPydantic  # type: ignore
+
+
+__all__ = [
+    "AdjacentlyTagged",
+]
+
+
+class AdjacentlyTagged(TaggedSerialization):
+    __variant_tag__: str
+    __content_tag__: str
+
+    def __init__(self, variant: str, content: str):
+        self.__variant_tag__ = variant
+        self.__content_tag__ = content
+
+    def __get_pydantic_core_schema__(
+            self,
+            kls: type["TypEnumPydantic[TypEnumContent]"],
+            _source_type: typing.Any,
+            handler: pydantic_.GetCoreSchemaHandler,
+    ) -> CoreSchema:
+        from enumetyped.pydantic.core import TypEnumPydantic
+
+        json_schemas: list[core_schema.CoreSchema] = []
+        for attr in kls.__variants__.values():
+            enum_variant: type[TypEnumPydantic[TypEnumContent]] = getattr(kls, attr)
+            attr = kls.__names_serialization__.get(attr, attr)
+            variant_schema = core_schema.typed_dict_field(core_schema.str_schema(pattern=attr))
+            is_enumetyped_variant = (
+                    inspect.isclass(enum_variant.__content_type__) and
+                    issubclass(enum_variant.__content_type__, TypEnumPydantic)
+            )
+
+            schema = {
+                self.__variant_tag__: variant_schema,
+            }
+
+            if is_enumetyped_variant or enum_variant.__content_type__ is NoValue:
+                if is_enumetyped_variant:
+                    kls_: type = enum_variant.__content_type__  # type: ignore
+                    schema_definition = core_schema.definition_reference_schema(f"{kls_.__name__}:{id(kls_)}")
+                    value_schema = core_schema.typed_dict_field(core_schema.definitions_schema(
+                        schema=schema_definition,
+                        definitions=[
+                            core_schema.any_schema(ref=f"{kls_.__name__}:{id(kls_)}")
+                        ],
+                    ))
+
+                    schema[self.__content_tag__] = value_schema
+            else:
+                value_schema = core_schema.typed_dict_field(handler.generate_schema(enum_variant.__content_type__))
+                schema[self.__content_tag__] = value_schema
+
+            json_schemas.append(core_schema.typed_dict_schema(schema))
+
+        return core_schema.json_or_python_schema(
+            json_schema=core_schema.with_info_after_validator_function(
+                kls.__python_value_restore__,
+                core_schema.union_schema([*json_schemas]),
+            ),
+            python_schema=core_schema.with_info_after_validator_function(
+                kls.__python_value_restore__,
+                core_schema.union_schema([*json_schemas, core_schema.any_schema()]),
+            ),
+            serialization=core_schema.wrap_serializer_function_ser_schema(
+                kls.__pydantic_serialization__
+            ),
+            ref=f"{kls.__name__}:{id(kls)}"
+        )
+
+    def __python_value_restore__(
+            self,
+            kls: type["TypEnumPydantic[TypEnumContent]"],
+            input_value: typing.Any,
+            info: ValidationInfo,
+    ) -> typing.Any:
+        from enumetyped.pydantic.core import TypEnumPydantic
+
+        if isinstance(input_value, TypEnumPydantic):
+            return input_value
+
+        type_key = input_value[self.__variant_tag__]
+        value = input_value.get(self.__content_tag__, None)
+        attr = kls.__names_deserialization__.get(type_key, type_key)
+        return getattr(kls, attr).__variant_constructor__(value, info)
+
+    def __pydantic_serialization__(
+            self,
+            kls: type["TypEnumPydantic[TypEnumContent]"],
+            model: typing.Any,
+            serializer: SerializerFunctionWrapHandler,
+    ) -> typing.Any:
+        attr = model.__variant_name__
+        attr = kls.__names_serialization__.get(attr, attr)
+
+        result = {self.__variant_tag__: attr}
+        if model.__content_type__ is NoValue:
+            pass
+        elif isinstance(model.value, kls):
+            result[self.__content_tag__] = kls.__pydantic_serialization__(model.value, serializer)
+        else:
+            result[self.__content_tag__] = serializer(model.value)
+
+        return result

enumetyped-0.3.2/enumetyped/pydantic/serialization/externally.py

@@ -0,0 +1,110 @@
+import inspect
+import typing
+
+import pydantic as pydantic_
+from pydantic_core import CoreSchema, core_schema
+from pydantic_core.core_schema import SerializerFunctionWrapHandler, ValidationInfo
+
+from enumetyped.core import TypEnumContent, NoValue
+from enumetyped.pydantic.serialization.tagged import TaggedSerialization
+
+if typing.TYPE_CHECKING:
+    from ..core import TypEnumPydantic  # type: ignore
+
+__all__ = [
+    "ExternallyTagged",
+]
+
+
+class ExternallyTagged(TaggedSerialization):
+    def __get_pydantic_core_schema__(
+            self,
+            kls: type["TypEnumPydantic[TypEnumContent]"],
+            _source_type: typing.Any,
+            handler: pydantic_.GetCoreSchemaHandler,
+    ) -> CoreSchema:
+        from enumetyped.pydantic.core import TypEnumPydantic
+
+        json_schema_attrs = {}
+        other_schemas = []
+        for attr in kls.__variants__.values():
+            enum_variant: type[TypEnumPydantic[TypEnumContent]] = getattr(kls, attr)
+            attr = kls.__names_serialization__.get(attr, attr)
+
+            is_enumetyped_variant = (
+                    inspect.isclass(enum_variant.__content_type__) and
+                    issubclass(enum_variant.__content_type__, TypEnumPydantic)
+            )
+
+            item_schema: core_schema.CoreSchema
+            if is_enumetyped_variant or enum_variant.__content_type__ is NoValue:
+                if enum_variant.__content_type__ is NoValue:
+                    other_schemas.append(core_schema.str_schema(pattern=attr))
+                    continue
+                else:
+                    kls_: type = enum_variant.__content_type__  # type: ignore
+                    schema_definition = core_schema.definition_reference_schema(f"{kls_.__name__}:{id(kls_)}")
+                    item_schema = core_schema.definitions_schema(
+                        schema=schema_definition,
+                        definitions=[
+                            core_schema.any_schema(ref=f"{kls_.__name__}:{id(kls_)}")
+                        ],
+                    )
+
+            else:
+                item_schema = handler.generate_schema(enum_variant.__content_type__)
+
+            json_schema_attrs[attr] = core_schema.typed_dict_field(item_schema, required=False)
+
+        schemas = [core_schema.typed_dict_schema(json_schema_attrs), *other_schemas]
+
+        return core_schema.json_or_python_schema(
+            json_schema=core_schema.with_info_after_validator_function(
+                kls.__python_value_restore__,
+                core_schema.union_schema([*schemas]),
+            ),
+            python_schema=core_schema.with_info_after_validator_function(
+                kls.__python_value_restore__,
+                core_schema.union_schema([*schemas, core_schema.any_schema()]),
+            ),
+            serialization=core_schema.wrap_serializer_function_ser_schema(
+                kls.__pydantic_serialization__
+            ),
+            ref=f"{kls.__name__}:{id(kls)}"
+        )
+
+    def __python_value_restore__(
+            self,
+            kls: type["TypEnumPydantic[TypEnumContent]"],
+            input_value: typing.Any,
+            info: ValidationInfo,
+    ) -> typing.Any:
+        from enumetyped.pydantic.core import TypEnumPydantic
+
+        if isinstance(input_value, TypEnumPydantic):
+            return input_value
+
+        if isinstance(input_value, str):
+            input_value = {input_value: None}
+
+        for attr, value in input_value.items():
+            attr = kls.__names_deserialization__.get(attr, attr)
+            return getattr(kls, attr).__variant_constructor__(value, info)
+
+    def __pydantic_serialization__(
+            self,
+            kls: type["TypEnumPydantic[TypEnumContent]"],
+            model: typing.Any,
+            serializer: SerializerFunctionWrapHandler,
+    ) -> typing.Any:
+        attr = model.__variant_name__
+        attr = kls.__names_serialization__.get(attr, attr)
+
+        if model.__content_type__ is NoValue:
+            return attr
+        elif isinstance(model.value, kls):
+            content = kls.__pydantic_serialization__(model.value, serializer)
+        else:
+            content = serializer(model.value)
+
+        return {attr: content}

enumetyped-0.3.2/enumetyped/pydantic/serialization/internally.py

@@ -0,0 +1,140 @@
+import typing
+
+import pydantic as pydantic_
+from pydantic_core import CoreSchema, core_schema, SchemaValidator
+from pydantic_core.core_schema import SerializerFunctionWrapHandler, ValidationInfo
+
+from enumetyped.core import NoValue, TypEnumContent
+from enumetyped.pydantic.serialization.tagged import TaggedSerialization
+
+if typing.TYPE_CHECKING:
+    from ..core import TypEnumPydantic  # type: ignore
+
+__all__ = [
+    "InternallyTagged",
+]
+
+
+class InternallyTagged(TaggedSerialization):
+    __variant_tag__: str
+    __ext_tagged_schema_validator__: SchemaValidator
+
+    def __init__(self, variant: str):
+        self.__variant_tag__ = variant
+
+    def __get_pydantic_core_schema__(
+            self,
+            kls: type["TypEnumPydantic[TypEnumContent]"],
+            source_type: typing.Any,
+            handler: pydantic_.GetCoreSchemaHandler,
+    ) -> CoreSchema:
+        from enumetyped.pydantic.core import TypEnumPydantic
+
+        json_schemas: dict[str, core_schema.CoreSchema] = {}
+        real_schema_attrs = {}
+        real_schemas: list[core_schema.CoreSchema] = []
+
+        for attr in kls.__variants__.values():
+            enum_variant: type[TypEnumPydantic[TypEnumContent]] = getattr(kls, attr)
+            attr = kls.__names_serialization__.get(attr, attr)
+            variant_schema = core_schema.typed_dict_field(core_schema.str_schema(pattern=attr))
+
+            schema = {
+                self.__variant_tag__: variant_schema,
+            }
+            if enum_variant.__content_type__ is NoValue:
+                real_schemas.append(core_schema.str_schema(pattern=attr))
+            else:
+                item_schema = handler.generate_schema(enum_variant.__content_type__)
+                resolved = handler.resolve_ref_schema(item_schema)
+
+                real_schema_attrs[attr] = core_schema.typed_dict_field(resolved, required=False)
+                real_schemas.append(resolved)
+
+                match resolved:
+                    case {"type": "dataclass", "schema": {"fields": fields}}:
+                        fields = {
+                            field["name"]: {
+                                "type": "typed-dict-field",
+                                "schema": field["schema"]
+                            } for field in fields
+                        }
+                        schema.update(**fields)
+                    case {"type": "model", "schema": {"fields": fields}}:
+                        fields = {
+                            k: {
+                                "type": "typed-dict-field",
+                                "schema": v["schema"]
+                            } for k, v in fields.items()
+                        }
+                        schema.update(**fields)
+                    case {"type": "typed-dict", "fields": fields}:
+                        schema.update(**fields)
+                    case _:
+                        raise TypeError(
+                            "Type of content must be a TypedDict, dataclass or BaseModel subclass"
+                        )
+
+            json_schemas[attr] = core_schema.typed_dict_schema(schema)
+
+        # Store nested schema for deserializing
+        self.__ext_tagged_schema_validator__ = SchemaValidator(core_schema.union_schema([
+            core_schema.typed_dict_schema(real_schema_attrs),
+            *real_schemas,
+        ]))
+
+        json_schema = core_schema.tagged_union_schema(
+            choices=json_schemas,
+            discriminator=self.__variant_tag__,
+        )
+        return core_schema.json_or_python_schema(
+            json_schema=core_schema.with_info_after_validator_function(
+                kls.__python_value_restore__,
+                json_schema,
+            ),
+            python_schema=core_schema.with_info_after_validator_function(
+                kls.__python_value_restore__,
+                core_schema.any_schema(),
+            ),
+            serialization=core_schema.wrap_serializer_function_ser_schema(
+                kls.__pydantic_serialization__
+            ),
+            ref=f"{kls.__name__}:{id(kls)}"
+        )
+
+    def __python_value_restore__(
+            self,
+            kls: type["TypEnumPydantic[TypEnumContent]"],
+            input_value: typing.Any,
+            info: ValidationInfo,
+    ) -> typing.Any:
+        if isinstance(input_value, kls):
+            return input_value
+
+        type_key = input_value.pop(self.__variant_tag__)
+        attr = kls.__names_deserialization__.get(type_key, type_key)
+
+        if input_value:
+            value = self.__ext_tagged_schema_validator__.validate_python({type_key: input_value})
+            return getattr(kls, attr).__variant_constructor__(value[type_key], info)
+        else:
+            return getattr(kls, attr).__variant_constructor__(None, info)
+
+    def __pydantic_serialization__(
+            self,
+            kls: type["TypEnumPydantic[TypEnumContent]"],
+            model: typing.Any,
+            serializer: SerializerFunctionWrapHandler,
+    ) -> typing.Any:
+        attr = model.__variant_name__
+        attr = kls.__names_serialization__.get(attr, attr)
+
+        result = {self.__variant_tag__: attr}
+        if model.__content_type__ is NoValue:
+            pass
+        elif isinstance(model.value, kls):
+            result.update(**kls.__pydantic_serialization__(model.value, serializer))
+        else:
+            result.update(**serializer(model.value))
+
+        return result

enumetyped-0.3.2/enumetyped/pydantic/serialization/tagged.py

@@ -0,0 +1,43 @@
+import typing
+from abc import ABC, abstractmethod
+
+import pydantic as pydantic_
+from pydantic_core import CoreSchema
+from pydantic_core.core_schema import SerializerFunctionWrapHandler, ValidationInfo
+
+if typing.TYPE_CHECKING:
+    from ...core import TypEnumContent  # type: ignore
+    from ..core import TypEnumPydantic  # type: ignore
+
+__all__ = [
+    "TaggedSerialization",
+]
+
+
+class TaggedSerialization(ABC):
+    @abstractmethod
+    def __get_pydantic_core_schema__(
+            self,
+            kls: type["TypEnumPydantic[TypEnumContent]"],
+            _source_type: typing.Any,
+            handler: pydantic_.GetCoreSchemaHandler,
+    ) -> CoreSchema:
+        raise NotImplementedError
+
+    @abstractmethod
+    def __python_value_restore__(
+            self,
+            kls: type["TypEnumPydantic[TypEnumContent]"],
+            input_value: typing.Any,
+            info: ValidationInfo,
+    ) -> typing.Any:
+        raise NotImplementedError
+
+    @abstractmethod
+    def __pydantic_serialization__(
+            self,
+            kls: type["TypEnumPydantic[TypEnumContent]"],
+            model: typing.Any,
+            serializer: SerializerFunctionWrapHandler,
+    ) -> typing.Any:
+        raise NotImplementedError

enumetyped-0.3.2/pyproject.toml

@@ -0,0 +1,50 @@
+[tool.poetry]
+package-mode = true
+name = "enumetyped"
+version = "0.3.2"
+
+authors = [
+    "Rinat Balbekov <me@rjotanm.dev>",
+]
+
+description = "Type-containing enumeration"
+repository = "https://github.com/rjotanm/enumetyped"
+license = "MIT"
+readme = "README.md"
+
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Framework :: Pydantic",
+    "Framework :: Pydantic :: 2",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+
+packages = [
+    { include = "enumetyped" },
+]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+typing-extensions = ">=4.0.0"
+
+pydantic = { version = ">=2.9.0", optional = true }
+
+[tool.poetry.group.dev.dependencies]
+mypy = "^1.13.0"
+
+[tool.poetry.extras]
+pydantic = ["pydantic"]
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"