pyrmute 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

pyrmute/_schema_manager.py

@@ -16,6 +16,7 @@ from .types import (
     JsonValue,
     ModelMetadata,
     ModelName,
+    NestedModelInfo,
 )
 
 
@@ -285,7 +286,7 @@ class SchemaManager:
         self: Self,
         name: ModelName,
         version: str | ModelVersion,
-    ) -> list[ModelMetadata]:
+    ) -> list[NestedModelInfo]:
         """Get all nested models referenced by a model.
 
         Args:
@@ -293,19 +294,28 @@ class SchemaManager:
             version: Semantic version.
 
         Returns:
-            List of (model_name, model_version) tuples for nested models.
+            List of NestedModelInfo.
         """
         ver = ModelVersion.parse(version) if isinstance(version, str) else version
         model = self.registry.get_model(name, ver)
 
-        nested: list[ModelMetadata] = []
+        nested: list[NestedModelInfo] = []
 
         for field_info in model.model_fields.values():
             model_type = self._get_model_type_from_field(field_info)
-            if model_type:
-                model_info = self.registry.get_model_info(model_type)
-                if model_info and model_info not in nested:
-                    nested.append(model_info)
+            if not model_type:
+                continue
+
+            model_info = self.registry.get_model_info(model_type)
+
+            if not model_info:
+                continue
+
+            name_, version_ = model_info
+            nested_model_info = NestedModelInfo(name=name_, version=version_)
+
+            if nested_model_info not in nested:
+                nested.append(nested_model_info)
 
         return nested
 

pyrmute/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.0'
-__version_tuple__ = version_tuple = (0, 2, 0)
+__version__ = version = '0.4.0'
+__version_tuple__ = version_tuple = (0, 4, 0)
 
 __commit_id__ = commit_id = None

pyrmute/migration_testing.py

@@ -2,9 +2,9 @@
 
 from collections.abc import Iterator
 from dataclasses import dataclass
-from typing import Self
+from typing import Self, TypeAlias
 
-from .types import MigrationData
+from .types import ModelData
 
 
 @dataclass
@@ -28,8 +28,8 @@ class MigrationTestCase:
         ... )
     """
 
-    source: MigrationData
-    target: MigrationData | None = None
+    source: ModelData
+    target: ModelData | None = None
     description: str = ""
 
 
@@ -55,7 +55,7 @@ class MigrationTestResult:
     """
 
     test_case: MigrationTestCase
-    actual: MigrationData
+    actual: ModelData
     passed: bool
     error: str | None = None
 
@@ -159,3 +159,6 @@ class MigrationTestResults:
             f"✗ {len(self.failures)} of {total_count} test(s) failed "
             f"({passed_count} passed)"
         )
+
+
+MigrationTestCases: TypeAlias = list[tuple[ModelData, ModelData] | MigrationTestCase]

pyrmute/model_manager.py

@@ -13,6 +13,7 @@ from ._schema_manager import SchemaManager
 from .exceptions import MigrationError, ModelNotFoundError
 from .migration_testing import (
     MigrationTestCase,
+    MigrationTestCases,
     MigrationTestResult,
     MigrationTestResults,
 )
@@ -22,9 +23,9 @@ from .types import (
     DecoratedBaseModel,
     JsonSchema,
     JsonSchemaGenerator,
-    MigrationData,
     MigrationFunc,
-    ModelMetadata,
+    ModelData,
+    NestedModelInfo,
 )
 
 
@@ -55,7 +56,7 @@ class ModelManager:
         >>>
         >>> # Define migration between versions
         >>> @manager.migration("User", "1.0.0", "2.0.0")
-        ... def migrate(data: MigrationData) -> MigrationData:
+        ... def migrate(data: ModelData) -> ModelData:
         ...     return {**data, "email": "unknown@example.com"}
         >>>
         >>> # Migrate legacy data
@@ -91,9 +92,9 @@ class ModelManager:
 
     def __init__(self: Self) -> None:
         """Initialize the versioned model manager."""
-        self.registry = Registry()
-        self.migration_manager = MigrationManager(self.registry)
-        self.schema_manager = SchemaManager(self.registry)
+        self._registry = Registry()
+        self._migration_manager = MigrationManager(self._registry)
+        self._schema_manager = SchemaManager(self._registry)
 
     def model(
         self: Self,
@@ -129,7 +130,7 @@ class ModelManager:
             ... class CityV1(BaseModel):
             ...     city: City
         """
-        return self.registry.register(
+        return self._registry.register(
             name, version, schema_generator, enable_ref, backward_compatible
         )
 
@@ -149,11 +150,11 @@ class ModelManager:
         Returns:
             Decorator function for migration function.
         """
-        return self.migration_manager.register_migration(name, from_version, to_version)
+        return self._migration_manager.register_migration(
+            name, from_version, to_version
+        )
 
-    def get(
-        self: Self, name: str, version: str | ModelVersion | None = None
-    ) -> type[BaseModel]:
+    def get(self: Self, name: str, version: str | ModelVersion) -> type[BaseModel]:
         """Get a model by name and version.
 
         Args:
@@ -163,9 +164,18 @@ class ModelManager:
         Returns:
             Model class.
         """
-        if version is None:
-            return self.registry.get_latest(name)
-        return self.registry.get_model(name, version)
+        return self._registry.get_model(name, version)
+
+    def get_latest(self: Self, name: str) -> type[BaseModel]:
+        """Get the latest version of a model by name.
+
+        Args:
+            name: Name of the model.
+
+        Returns:
+            Model class.
+        """
+        return self._registry.get_latest(name)
 
     def has_migration_path(
         self: Self,
@@ -200,14 +210,14 @@ class ModelManager:
             else to_version
         )
         try:
-            self.migration_manager.validate_migration_path(name, from_ver, to_ver)
+            self._migration_manager.validate_migration_path(name, from_ver, to_ver)
             return True
         except (KeyError, ModelNotFoundError, MigrationError):
             return False
 
     def validate_data(
         self: Self,
-        data: MigrationData,
+        data: ModelData,
         name: str,
         version: str | ModelVersion,
     ) -> bool:
@@ -241,7 +251,7 @@ class ModelManager:
 
     def migrate(
         self: Self,
-        data: MigrationData,
+        data: ModelData,
         name: str,
         from_version: str | ModelVersion,
         to_version: str | ModelVersion,
@@ -263,11 +273,11 @@ class ModelManager:
 
     def migrate_data(
         self: Self,
-        data: MigrationData,
+        data: ModelData,
         name: str,
         from_version: str | ModelVersion,
         to_version: str | ModelVersion,
-    ) -> MigrationData:
+    ) -> ModelData:
         """Migrate data between versions.
 
         Args:
@@ -279,11 +289,11 @@ class ModelManager:
         Returns:
             Raw migrated dictionary.
         """
-        return self.migration_manager.migrate(data, name, from_version, to_version)
+        return self._migration_manager.migrate(data, name, from_version, to_version)
 
     def migrate_batch(  # noqa: PLR0913
         self: Self,
-        data_list: Iterable[MigrationData],
+        data_list: Iterable[ModelData],
         name: str,
         from_version: str | ModelVersion,
         to_version: str | ModelVersion,
@@ -341,14 +351,14 @@ class ModelManager:
 
     def migrate_batch_data(  # noqa: PLR0913
         self: Self,
-        data_list: Iterable[MigrationData],
+        data_list: Iterable[ModelData],
         name: str,
         from_version: str | ModelVersion,
         to_version: str | ModelVersion,
         parallel: bool = False,
         max_workers: int | None = None,
         use_processes: bool = False,
-    ) -> list[MigrationData]:
+    ) -> list[ModelData]:
         """Migrate multiple data items between versions, returning raw dictionaries.
 
         Args:
@@ -393,7 +403,7 @@ class ModelManager:
 
     def migrate_batch_streaming(
         self: Self,
-        data_list: Iterable[MigrationData],
+        data_list: Iterable[ModelData],
         name: str,
         from_version: str | ModelVersion,
         to_version: str | ModelVersion,
@@ -439,12 +449,12 @@ class ModelManager:
 
     def migrate_batch_data_streaming(
         self: Self,
-        data_list: Iterable[MigrationData],
+        data_list: Iterable[ModelData],
         name: str,
         from_version: str | ModelVersion,
         to_version: str | ModelVersion,
         chunk_size: int = 100,
-    ) -> Iterable[MigrationData]:
+    ) -> Iterable[ModelData]:
         """Migrate data in chunks, yielding raw dictionaries as they complete.
 
         Useful for large datasets where you want to start processing results before all
@@ -548,7 +558,7 @@ class ModelManager:
         Returns:
             JSON schema dictionary.
         """
-        return self.schema_manager.get_schema(name, version, **kwargs)
+        return self._schema_manager.get_schema(name, version, **kwargs)
 
     def list_models(self: Self) -> list[str]:
         """Get list of all registered models.
@@ -556,7 +566,7 @@ class ModelManager:
         Returns:
             List of model names.
         """
-        return self.registry.list_models()
+        return self._registry.list_models()
 
     def list_versions(self: Self, name: str) -> list[ModelVersion]:
         """Get all versions for a model.
@@ -567,7 +577,7 @@ class ModelManager:
         Returns:
             Sorted list of versions.
         """
-        return self.registry.get_versions(name)
+        return self._registry.get_versions(name)
 
     def dump_schemas(
         self: Self,
@@ -582,7 +592,8 @@ class ModelManager:
             output_dir: Directory path for output.
             indent: JSON indentation level.
             separate_definitions: If True, create separate schema files for nested
-                models and use $ref to reference them.
+                models and use $ref to reference them. Only applies to models with
+                'enable_ref=True'.
             ref_template: Template for $ref URLs when separate_definitions=True.
                 Defaults to relative file references if not provided.
 
@@ -600,46 +611,15 @@ class ModelManager:
             ...     ref_template="https://example.com/schemas/{model}_v{version}.json"
             ... )
         """
-        self.schema_manager.dump_schemas(
+        self._schema_manager.dump_schemas(
             output_dir, indent, separate_definitions, ref_template
         )
 
-    def dump_schemas_with_refs(
-        self: Self,
-        output_dir: str | Path,
-        ref_template: str | None = None,
-        indent: int = 2,
-    ) -> None:
-        """Export schemas with separate files for nested models.
-
-        This is a convenience method that calls dump_schemas with
-        separate_definitions=True.
-
-        Args:
-            output_dir: Directory path for output.
-            ref_template: Template for $ref URLs. Supports {model} and {version}
-                placeholders. Defaults to relative file refs.
-            indent: JSON indentation level.
-
-        Example:
-            >>> # Relative file references (default)
-            >>> manager.dump_schemas_with_refs("schemas/")
-            >>>
-            >>> # Absolute URL references
-            >>> manager.dump_schemas_with_refs(
-            ...     "schemas/",
-            ...     ref_template="https://example.com/schemas/{model}_v{version}.json"
-            ... )
-        """
-        self.schema_manager.dump_schemas(
-            output_dir, indent, separate_definitions=True, ref_template=ref_template
-        )
-
     def get_nested_models(
         self: Self,
         name: str,
         version: str | ModelVersion,
-    ) -> list[ModelMetadata]:
+    ) -> list[NestedModelInfo]:
         """Get all nested models used by a model.
 
         Args:
@@ -647,16 +627,16 @@ class ModelManager:
             version: Semantic version.
 
         Returns:
-            List of (model_name, version) tuples for nested models.
+            List of NestedModelInfo.
         """
-        return self.schema_manager.get_nested_models(name, version)
+        return self._schema_manager.get_nested_models(name, version)
 
     def test_migration(
         self: Self,
         name: str,
         from_version: str | ModelVersion,
         to_version: str | ModelVersion,
-        test_cases: list[tuple[MigrationData, MigrationData] | MigrationTestCase],
+        test_cases: MigrationTestCases,
     ) -> MigrationTestResults:
         """Test a migration with multiple test cases.
 

pyrmute/types.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import Callable
+from dataclasses import dataclass
 from typing import Any, TypeAlias, TypeVar
 
 from pydantic import BaseModel
@@ -19,13 +20,19 @@ JsonSchemaDefinitions: TypeAlias = dict[str, JsonValue]
 JsonSchemaGenerator: TypeAlias = Callable[[type[BaseModel]], JsonSchema]
 SchemaGenerators: TypeAlias = dict[ModelVersion, JsonSchemaGenerator]
 
-MigrationData: TypeAlias = dict[str, Any]
-MigrationFunc: TypeAlias = Callable[[MigrationData], MigrationData]
-
-
+ModelData: TypeAlias = dict[str, Any]
+MigrationFunc: TypeAlias = Callable[[ModelData], ModelData]
 MigrationKey: TypeAlias = tuple[ModelVersion, ModelVersion]
 MigrationMap: TypeAlias = dict[MigrationKey, MigrationFunc]
 
 ModelName: TypeAlias = str
 ModelMetadata: TypeAlias = tuple[ModelName, ModelVersion]
 VersionedModels: TypeAlias = dict[ModelVersion, type[BaseModel]]
+
+
+@dataclass
+class NestedModelInfo:
+    """Contains information about nested models."""
+
+    name: str
+    version: ModelVersion