fix: Further fixes to typing

chore(project): Remove outdated BaseModel variation of SchemanticMixin
chore: Update Justfile wrt recent changes to developer paradigm
documentation: Update README.md to reflect the changes from the overhaul!
chore(version): Bump PATCH

.github/workflows/test.yaml

@@ -12,7 +12,7 @@ jobs:
 
     strategy:
       matrix:
-        python-version: [ "3.10", "3.11" ]
+        python-version: [ "3.10", "3.11", "3.12", "3.12" ]
 
     steps:
       - uses: actions/checkout@v3

Justfile

@@ -8,4 +8,7 @@ format:
 	@echo "Formatting complete 🎉"
 
 tcheck:
-	poetry run pyright schemantic
+	mypy -p schemantic
+
+test:
+    poetry run pytest tests

README.md

@@ -1,30 +1,31 @@
 # Schemantic
 
-Create schemas from models or classes with homologous, grouped, or cultured paradigms.
+Do you have configurations stored in files? You have come to the right place! Create schemas from models or classes with homologous, grouped, or cultured paradigms. Batteries for loading and dumping included!
 
-Best with `pydantic.BaseModel` instances, but works with any Python class and `dataclass`/`pydantic.dataclass`!
+Supports `pydantic.BaseModel` and any Python class and `dataclass`/`pydantic.dataclass`!
 
 ## Classes of schemas
 
-### Homolog
+### Homologue
 ```python
 from pydantic import BaseModel
-from ordered_set import OrderedSet
-from schemantic.schema import HomologSchema
+from schemantic import HomologueSchemer
 
 class Thief(BaseModel):
     stolen_goods: int
     steals_only: str
 
-my_homolog = HomologSchema.from_model(Thief, instance_names=OrderedSet(["copycat", "pink_panther"]))
+my_homolog = HomologueSchemer.from_originating_type(Thief, instance_name_to_pre_definition={"copycat": {}, "pink_panther": {}})
 ```
 
+`HomologueSchemer` also accepts `instance_name_getter` parameter, which is a dictionary of instance names to pre-defined values.
+
 ### Grouped
 You can manage multiple schemas as a group:
 
 ```python
 from pydantic import BaseModel
-from schemantic.schema import GroupSchema
+from schemantic import GroupSchemer
 
 class Baker(BaseModel):
     baked_goods: int
@@ -34,24 +35,24 @@ class Cop(BaseModel):
     years_of_service: int
     citizen_of: str
 
-group_schema = GroupSchema.from_originating_types([Baker, Cop], )
+group_schema = GroupSchemer.from_originating_types([Baker, Cop])
 ```
 
 ### Culture
 You can also manage multiple types of schemas under one culture:
 
 ```python
 from ordered_set import OrderedSet
-from schemantic.schema import CultureSchema
+from schemantic import CultureSchemer
 
-CultureSchema(source_schemas=OrderedSet([homolog_schema, group_schema]))
+CultureSchemer(source_schemas=OrderedSet([homolog_schema, group_schema]))
 ```
 
 ## Methods
-`HomologSchema`, `GroupSchema`, and `CultureSchema` have the following methods.
+`HomologueSchemer`, `GroupSchemer`, and `CultureSchemer` have the following methods.
 
 ### `.schema()`
-Creates a dictionary, which represents the schema of the origin class/model.
+Creates a BaseModel derived class instance, which represents the schema of the origin class/model.
 
 ```python
 my_homolog.schema()
@@ -153,9 +154,7 @@ class TestModel(SchemanticProjectModelMixin, BaseModel):
     exclude_me: Optional[int] = None
     _exclude_me_too: Optional[float] = None
 
-    @classmethod  # type: ignore[misc]
-    @computed_field(return_type=set[str])
-    @property
+    @classmethod
     def fields_to_exclude_from_single_schema(cls) -> set[str]:
         upstream = super().fields_to_exclude_from_single_schema
         upstream.update(("exclude_me",))

pyproject.toml

@@ -1,10 +1,18 @@
 [tool.poetry]
 name = "schemantic"
-version = "2.0.2"
+version = "2.0.3"
 description = "Manipulate model schemas utilizing homologous, grouped, or cultured paradigms"
 authors = ["caniko <[email protected]>"]
 license = "BSD-4"
 readme = "README.md"
+classifiers = [
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+    "Operating System :: OS Independent",
+]
 
 [tool.poetry.dependencies]
 python = ">=3.10,<4.0"

schemantic/project.py

@@ -1,7 +1,5 @@
 from typing import Any, ClassVar
 
-from pydantic import BaseModel
-
 
 class SchemanticProjectMixin:
     include_private: ClassVar[bool] = False
@@ -14,13 +12,14 @@ def fields_to_exclude_from_single_schema(cls) -> set[str]:
 
         Usage:
             @classmethod
-            @property
             def fields_to_exclude_from_single_schema(cls) -> set[str]:
                 upstream = super().fields_to_exclude_from_single_schema()
                 upstream.update(("SOME", "FIELD"))
                 return upstream
 
-        :return:
+            Notice `upstream = super().fields_to_exclude_from_single_schema()`, it ensures
+            that we can inherit the exclusion fields from the parent class. You don't need
+            to do this on your root class; moreover, downstream classes could benefit from it.
         """
         return set()
 
@@ -30,16 +29,3 @@ def single_schema_kwargs(cls) -> dict[str, Any]:
             include_private=cls.include_private,
             fields_to_exclude=cls.fields_to_exclude_from_single_schema(),
         )
-
-
-SchemanticProjectType = type[SchemanticProjectMixin]
-
-
-class SchemanticProjectModelMixin(BaseModel, SchemanticProjectMixin):
-    @classmethod
-    def fields_to_exclude_from_single_schema(cls) -> set[str]:
-        return super().fields_to_exclude_from_single_schema()
-
-    @classmethod
-    def single_schema_kwargs(cls) -> dict[str, Any]:
-        return super().single_schema_kwargs()

schemantic/schema/functional.py

@@ -63,7 +63,7 @@ def class_arg_alias_to_type_string(
 ) -> SignatureModel:
     constructor_signature = inspect.signature(source_cls.__init__)
 
-    result = dict(required={}, optional={})
+    result = SignatureModel()
 
     type_hints = get_type_hints(source_cls.__init__)
     for param_name, param in constructor_signature.parameters.items():
@@ -87,15 +87,15 @@ def class_arg_alias_to_type_string(
             arg_type = native_fallback_get(type_hint.__name__)
 
         if param.default == inspect.Parameter.empty:
-            result[REQUIRED_MAPPING_KEY][param_name] = InitArgTypeInfo(
+            result.required[param_name] = InitArgTypeInfo(
                 type_hint=arg_type, owner_to_default={source_cls: None}
             )
         else:
-            result[OPTIONAL_MAPPING_KEY][param_name] = InitArgTypeInfo(
+            result.optional[param_name] = InitArgTypeInfo(
                 type_hint=arg_type, owner_to_default={source_cls: param.default}
             )
 
-    return SignatureModel(**result)
+    return result
 
 
 def _fallback_get(source: dict, key: str) -> str:

schemantic/schema/model.py

@@ -20,7 +20,7 @@
 
 
 class ClassNameMixin(BaseModel):
-    class_name: str = ...
+    class_name: str
 
 
 class DefiningMixin(BaseModel):
@@ -95,13 +95,13 @@ class SingleSchema(DefiningSignatureModel, ClassNameMixin):
 
 class HomologueSchema(ClassNameMixin):
     common: dict = Field(default_factory=dict)
-    instances: Annotated[dict[str, SchemaDefinition], Doc("The definition of each class instance")] = ...
-    init_signature: SignatureModel = ...
+    instances: Annotated[dict[str, SchemaDefinition], Doc("The definition of each class instance")]
+    init_signature: SignatureModel
 
 
 class GroupSchema(BaseModel):
     common: CommonSignatureModel = Field(default_factory=CommonSignatureModel)
-    members: Annotated[dict[str, GroupMemberSchema], Doc("The definition of each group member")] = ...
+    members: Annotated[dict[str, GroupMemberSchema], Doc("The definition of each group member")]
     argument_to_typing: ArgNameToTypeInfo
 
 

schemantic/utils/mapping.py

@@ -5,8 +5,6 @@ def update_assert_disjoint(dict_a: dict, dict_b: dict, error_msg_add: Optional[s
     """
     Detects key collisions between two dictionaries.
 
-    :param dict_a: The first dictionary.
-    :param dict_b: The second dictionary.
     :raises ValueError: If a key collision is detected.
     """
     if any(k in dict_a and dict_a[k] != dict_a[k] for k in dict_b):

tests/test_schema_model.py

@@ -3,12 +3,12 @@
 
 from pydantic import BaseModel
 
-from schemantic.project import SchemanticProjectModelMixin
+from schemantic.project import SchemanticProjectMixin
 from tests.model import infer_expected_schemas
 from tests.test_case.main import AbstractTestCulture, AbstractTestGroup, AbstractTestHomologue, AbstractTestSingle
 
 
-class TestModel(SchemanticProjectModelMixin, BaseModel):
+class TestModel(SchemanticProjectMixin, BaseModel):
     must_be: int
     we: str = "n"