pydoptic 0.0.2.post1.dev1__tar.gz → 0.0.2.post1.dev2__tar.gz

{pydoptic-0.0.2.post1.dev1/src/pydoptic.egg-info → pydoptic-0.0.2.post1.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydoptic
-Version: 0.0.2.post1.dev1
+Version: 0.0.2.post1.dev2
 Summary: Model data using reified optics
 Author: John Hungerford
 License-Expression: MIT
@@ -35,7 +35,7 @@ The examples below assume this import, unless a different one is shown:
 
 ```python3
 from pydoptic import (
-    BaseModel, PartialModel, select,
+    BaseModel, Partial, select,
     Discrim, Prop, PropArr, PropOpt, PropOptArr, PropSelect,
     Select, SelectArr, SelectOpt, SelectOptArr, SelectVal, SelectValue,
 )
@@ -87,8 +87,8 @@ model_1_kw: Model2 = Model2(prop_one=42, prop_two="hello")
 model_2_pr: Model2 = Model2.construct(Model1.prop_1.param(42), Model1.prop_2.param("hello"))
 
 # Partial model
-model_1_partial_kw: PartialModel[Model2] = Model2.partial(prop_one=42)
-model_1_partial_pr: PartialModel[Model2] = Model2.construct_partial(
+model_1_partial_kw: Partial[Model2] = Model2.partial(prop_one=42)
+model_1_partial_pr: Partial[Model2] = Model2.construct_partial(
     Model.prop_2.param("hello"),
 )
 
@@ -221,7 +221,7 @@ model: MyModel = MyModel(prop_1='value', prop_2=23, ...)
 dict_value: Dict[str, Any] = model.as_dict_full()
 str_value: str = json.dumps(dict_value)
 
-partial_model: PartialModel[MyModel] = MyModel.partial(prop_1='value', prop_2=23, ...)
+partial_model: Partial[MyModel] = MyModel.partial(prop_1='value', prop_2=23, ...)
 partial_dict: Dict[str, Any] = partial_model.as_dict_full()
 partial_str: str = json.dumps(partial_dict)
 ```
@@ -237,7 +237,7 @@ model: MyModel = MyModel(**dict_value)
 
 partial_str: str = ???
 partial_dict: Dict[str, Any] = json.loads(partial_str)
-partial_model: PartialModel[MyModel] = MyModel.partial(**partial_dict)
+partial_model: Partial[MyModel] = MyModel.partial(**partial_dict)
 ```
 
 Note that given how data can be read from and written to objects, there is no necessity that you validate to models or even partial models at all. My own preferred workflow is to use models for ingestion only -- that is, to consume external data and convert them to my domain in the form of Pydoptic models, and then feed these into the data backend. Once valid data is persisted in a backend, it can then retrieved and manipulated in the form of `dict`s, without ever having to generate a full model. This is a matter of preference, however.
@@ -305,9 +305,9 @@ Conversely, if you only wanted to contact one POC (and you don't care whether th
 
 In the above case, if there are many `Person`s selected byte `poc_select`, only the first one will be returned. If none are, `poc` will be `None`.
 
-To retrieve values from an incomplete representation of the data, such as a `PartialModel` or a `dict`, there are two variants of `get` that you can use. `get_unsafe` will try to retrieve the selected value and fail with a `ValueError` if it's inaccessible due to invalid data (if its inaccessible due to a valid optional property being missing, it will generate an empty `SelectValue` as expected). `get_safe`, on the other hand, will always fail silently, generating empty `SelectValue` when data is missing.
+To retrieve values from an incomplete representation of the data, such as a `Partial` or a `dict`, there are two variants of `get` that you can use. `get_unsafe` will try to retrieve the selected value and fail with a `ValueError` if it's inaccessible due to invalid data (if its inaccessible due to a valid optional property being missing, it will generate an empty `SelectValue` as expected). `get_safe`, on the other hand, will always fail silently, generating empty `SelectValue` when data is missing.
 
-Note that the type signature of `get_unsafe` and `get_safe` are a bit misleading. They will provide accurate types for non-model values (e.g., primitive properties like `int` or `str`), but they will treat nested models as though they are fully typed. When you retrieve a nested model from a `dict` or `PartialModel`, however, in all likelihood it is going to be another `dict` or `PartialModel`.
+Note that the type signature of `get_unsafe` and `get_safe` are a bit misleading. They will provide accurate types for non-model values (e.g., primitive properties like `int` or `str`), but they will treat nested models as though they are fully typed. When you retrieve a nested model from a `dict` or `Partial`, however, in all likelihood it is going to be another `dict` or `Partial`.
 
 ```python3
 class Inner(BaseModel):
@@ -328,7 +328,7 @@ inner_result_full: SelectValue[Inner] = Outer.inner.get(full)
 partial_val = Outer.partial(inner=Inner.partial(prop=23))
 # Accurately typed
 prop_result_partial: SelectValue[int] = prop_select.get_unsafe(partial_val)
-# Inaccurate type! Should be SelectValue[PartialModel[Inner]]
+# Inaccurate type! Should be SelectValue[Partial[Inner]]
 inner_result_partial: SelectValue[Inner] = Outer.inner.get_unsafe(partial_val) 
 
 dict_val = {'inner': {'prop': 23}}
@@ -403,7 +403,7 @@ for arr in prop_arr_select.get(value).as_list:
     arr.append(len(arr))
 ```
 
-To update incomplete data, use `update_unsafe` and `update_safe`. `update_unsafe` will fail with an exception if it's unable to access the data to be updated due to invalid data, whereas `update_safe` will simply ignore (and therefore skip) invalid cases. Like `get`, you need to be careful when updating nested models with the partial variants of `update`. The types will appear to be complete models when they are most likely `PartialModel`s or `dict`s.
+To update incomplete data, use `update_unsafe` and `update_safe`. `update_unsafe` will fail with an exception if it's unable to access the data to be updated due to invalid data, whereas `update_safe` will simply ignore (and therefore skip) invalid cases. Like `get`, you need to be careful when updating nested models with the partial variants of `update`. The types will appear to be complete models when they are most likely `Partial`s or `dict`s.
 
 
 #### `set`, `set_unsafe`, `set_safe`
@@ -478,7 +478,7 @@ print(value)
 
 In the above example, while `sel_opt` is able to clear the `opt` property, `sel_req` cannot clear the selected `req` property so instead it clears the next clearable property, setting `c` to an empty array.
 
-Clearing partial data is even more complicated, since partial data (`PartialModel`s and `dict`s) *can* be cleared even when its required in the model. For this reason, the partial variants of `clear` are distinguished into "strict" and "non-strict" variants. `clear_unsafe_strict` works just like `clear`: it will only clear clearable (optional/array) properties, and will try to clear selected property and work its way backward across the property chain until it finds a clearable property. `clear_unsafe`, on the other hand, will clear the selected property whether or not it's a required field. `clear_safe_strict` and `clear_safe` work the same way, but does not raise exceptions when they encounter invalid data, but simply skip it and move on.
+Clearing partial data is even more complicated, since partial data (`Partial`s and `dict`s) *can* be cleared even when its required in the model. For this reason, the partial variants of `clear` are distinguished into "strict" and "non-strict" variants. `clear_unsafe_strict` works just like `clear`: it will only clear clearable (optional/array) properties, and will try to clear selected property and work its way backward across the property chain until it finds a clearable property. `clear_unsafe`, on the other hand, will clear the selected property whether or not it's a required field. `clear_safe_strict` and `clear_safe` work the same way, but does not raise exceptions when they encounter invalid data, but simply skip it and move on.
 
 #### Precise `Select`s
 

{pydoptic-0.0.2.post1.dev1 → pydoptic-0.0.2.post1.dev2}/README.md

@@ -17,7 +17,7 @@ The examples below assume this import, unless a different one is shown:
 
 ```python3
 from pydoptic import (
-    BaseModel, PartialModel, select,
+    BaseModel, Partial, select,
     Discrim, Prop, PropArr, PropOpt, PropOptArr, PropSelect,
     Select, SelectArr, SelectOpt, SelectOptArr, SelectVal, SelectValue,
 )
@@ -69,8 +69,8 @@ model_1_kw: Model2 = Model2(prop_one=42, prop_two="hello")
 model_2_pr: Model2 = Model2.construct(Model1.prop_1.param(42), Model1.prop_2.param("hello"))
 
 # Partial model
-model_1_partial_kw: PartialModel[Model2] = Model2.partial(prop_one=42)
-model_1_partial_pr: PartialModel[Model2] = Model2.construct_partial(
+model_1_partial_kw: Partial[Model2] = Model2.partial(prop_one=42)
+model_1_partial_pr: Partial[Model2] = Model2.construct_partial(
     Model.prop_2.param("hello"),
 )
 
@@ -203,7 +203,7 @@ model: MyModel = MyModel(prop_1='value', prop_2=23, ...)
 dict_value: Dict[str, Any] = model.as_dict_full()
 str_value: str = json.dumps(dict_value)
 
-partial_model: PartialModel[MyModel] = MyModel.partial(prop_1='value', prop_2=23, ...)
+partial_model: Partial[MyModel] = MyModel.partial(prop_1='value', prop_2=23, ...)
 partial_dict: Dict[str, Any] = partial_model.as_dict_full()
 partial_str: str = json.dumps(partial_dict)
 ```
@@ -219,7 +219,7 @@ model: MyModel = MyModel(**dict_value)
 
 partial_str: str = ???
 partial_dict: Dict[str, Any] = json.loads(partial_str)
-partial_model: PartialModel[MyModel] = MyModel.partial(**partial_dict)
+partial_model: Partial[MyModel] = MyModel.partial(**partial_dict)
 ```
 
 Note that given how data can be read from and written to objects, there is no necessity that you validate to models or even partial models at all. My own preferred workflow is to use models for ingestion only -- that is, to consume external data and convert them to my domain in the form of Pydoptic models, and then feed these into the data backend. Once valid data is persisted in a backend, it can then retrieved and manipulated in the form of `dict`s, without ever having to generate a full model. This is a matter of preference, however.
@@ -287,9 +287,9 @@ Conversely, if you only wanted to contact one POC (and you don't care whether th
 
 In the above case, if there are many `Person`s selected byte `poc_select`, only the first one will be returned. If none are, `poc` will be `None`.
 
-To retrieve values from an incomplete representation of the data, such as a `PartialModel` or a `dict`, there are two variants of `get` that you can use. `get_unsafe` will try to retrieve the selected value and fail with a `ValueError` if it's inaccessible due to invalid data (if its inaccessible due to a valid optional property being missing, it will generate an empty `SelectValue` as expected). `get_safe`, on the other hand, will always fail silently, generating empty `SelectValue` when data is missing.
+To retrieve values from an incomplete representation of the data, such as a `Partial` or a `dict`, there are two variants of `get` that you can use. `get_unsafe` will try to retrieve the selected value and fail with a `ValueError` if it's inaccessible due to invalid data (if its inaccessible due to a valid optional property being missing, it will generate an empty `SelectValue` as expected). `get_safe`, on the other hand, will always fail silently, generating empty `SelectValue` when data is missing.
 
-Note that the type signature of `get_unsafe` and `get_safe` are a bit misleading. They will provide accurate types for non-model values (e.g., primitive properties like `int` or `str`), but they will treat nested models as though they are fully typed. When you retrieve a nested model from a `dict` or `PartialModel`, however, in all likelihood it is going to be another `dict` or `PartialModel`.
+Note that the type signature of `get_unsafe` and `get_safe` are a bit misleading. They will provide accurate types for non-model values (e.g., primitive properties like `int` or `str`), but they will treat nested models as though they are fully typed. When you retrieve a nested model from a `dict` or `Partial`, however, in all likelihood it is going to be another `dict` or `Partial`.
 
 ```python3
 class Inner(BaseModel):
@@ -310,7 +310,7 @@ inner_result_full: SelectValue[Inner] = Outer.inner.get(full)
 partial_val = Outer.partial(inner=Inner.partial(prop=23))
 # Accurately typed
 prop_result_partial: SelectValue[int] = prop_select.get_unsafe(partial_val)
-# Inaccurate type! Should be SelectValue[PartialModel[Inner]]
+# Inaccurate type! Should be SelectValue[Partial[Inner]]
 inner_result_partial: SelectValue[Inner] = Outer.inner.get_unsafe(partial_val) 
 
 dict_val = {'inner': {'prop': 23}}
@@ -385,7 +385,7 @@ for arr in prop_arr_select.get(value).as_list:
     arr.append(len(arr))
 ```
 
-To update incomplete data, use `update_unsafe` and `update_safe`. `update_unsafe` will fail with an exception if it's unable to access the data to be updated due to invalid data, whereas `update_safe` will simply ignore (and therefore skip) invalid cases. Like `get`, you need to be careful when updating nested models with the partial variants of `update`. The types will appear to be complete models when they are most likely `PartialModel`s or `dict`s.
+To update incomplete data, use `update_unsafe` and `update_safe`. `update_unsafe` will fail with an exception if it's unable to access the data to be updated due to invalid data, whereas `update_safe` will simply ignore (and therefore skip) invalid cases. Like `get`, you need to be careful when updating nested models with the partial variants of `update`. The types will appear to be complete models when they are most likely `Partial`s or `dict`s.
 
 
 #### `set`, `set_unsafe`, `set_safe`
@@ -460,7 +460,7 @@ print(value)
 
 In the above example, while `sel_opt` is able to clear the `opt` property, `sel_req` cannot clear the selected `req` property so instead it clears the next clearable property, setting `c` to an empty array.
 
-Clearing partial data is even more complicated, since partial data (`PartialModel`s and `dict`s) *can* be cleared even when its required in the model. For this reason, the partial variants of `clear` are distinguished into "strict" and "non-strict" variants. `clear_unsafe_strict` works just like `clear`: it will only clear clearable (optional/array) properties, and will try to clear selected property and work its way backward across the property chain until it finds a clearable property. `clear_unsafe`, on the other hand, will clear the selected property whether or not it's a required field. `clear_safe_strict` and `clear_safe` work the same way, but does not raise exceptions when they encounter invalid data, but simply skip it and move on.
+Clearing partial data is even more complicated, since partial data (`Partial`s and `dict`s) *can* be cleared even when its required in the model. For this reason, the partial variants of `clear` are distinguished into "strict" and "non-strict" variants. `clear_unsafe_strict` works just like `clear`: it will only clear clearable (optional/array) properties, and will try to clear selected property and work its way backward across the property chain until it finds a clearable property. `clear_unsafe`, on the other hand, will clear the selected property whether or not it's a required field. `clear_safe_strict` and `clear_safe` work the same way, but does not raise exceptions when they encounter invalid data, but simply skip it and move on.
 
 #### Precise `Select`s
 

{pydoptic-0.0.2.post1.dev1 → pydoptic-0.0.2.post1.dev2}/src/pydoptic/__init__.py

@@ -1,4 +1,4 @@
-from pydoptic.base_model import BaseModel, PartialModel, select
+from pydoptic.base_model import BaseModel, Partial, select
 from pydoptic.selector import (
     Discrim,
     LinkedSelect,
@@ -25,7 +25,7 @@ from pydoptic.selector import (
 from pydoptic.validate_types import Validator
 
 __all__ = [
-    'BaseModel', 'PartialModel', 'select',
+    'BaseModel', 'Partial', 'select',
     'Discrim', 'LinkedSelect', 'LinkedSelectArr', 'LinkedSelectOpt', 'LinkedSelectOptArr', 'LinkedSelectVal',
     'MatchSelect', 'ModelLike', 'Param', 'Prop', 'PropArr', 'PropOpt', 'PropOptArr', 'PropSelect',
     'Select', 'Selectable', 'SelectArr', 'SelectOpt', 'SelectOptArr', 'SelectVal', 'SelectValue',

{pydoptic-0.0.2.post1.dev1 → pydoptic-0.0.2.post1.dev2}/src/pydoptic/base_model.py

@@ -172,7 +172,7 @@ class BaseModelMeta(type):
 def _fully_validate(target: Type[M], value: Any, validators: Dict[Type[Any], Validator]) -> M:
     if isinstance(value, target):
         return value
-    elif isinstance(value, PartialModel):
+    elif isinstance(value, Partial):
         if not issubclass(value.model, target):
             raise ValueError(f'received partial model of {value.model} instead of expected model {target}')
         return target(**value.as_dict(), _allow_extra_args=True, _validators=validators)
@@ -187,7 +187,7 @@ class BaseModel(ModelLike, metaclass=BaseModelMeta):
 
     A Pydoptic model consists of `PropSelect` class attributes (`Prop`, `PropOpt`, `PropArr`, and `PropOptArr`) which
     (1) determine which instance attributes are supported, and (2) provide a mechanism for accessing and manipulating data
-    both within instances and other, potentially incomplete data sources (e.g., `PartialModel` or `dict`)
+    both within instances and other, potentially incomplete data sources (e.g., `Partial` or `dict`)
 
     Instances are fully validated.
 
@@ -212,34 +212,34 @@ class BaseModel(ModelLike, metaclass=BaseModelMeta):
         return BaseModel._properties[cls]
 
     @classmethod
-    def partial(cls, **kwargs) -> PartialModel[Self]:
+    def partial(cls, **kwargs) -> Partial[Self]:
         """
         Create a partial instance of this model with a subset of properties. Required properties can be 
-        omitted, but must be otherwise valid. See `PartialModel`.
+        omitted, but must be otherwise valid. See `Partial`.
         """
-        return PartialModel(cls, **kwargs)
+        return Partial(cls, **kwargs)
 
     @classmethod
-    def construct_partial(cls, *values: Param[Self, Any], **kwargs) -> PartialModel[Self]:
+    def construct_partial(cls, *values: Param[Self, Any], **kwargs) -> Partial[Self]:
         """
         Create a partial instance of this model using selectors to specify fields. Required properties can be 
-        omitted, but must be otherwise valid. See `PartialModel`.
+        omitted, but must be otherwise valid. See `Partial`.
         """
-        return PartialModel(cls, **{p.label: p.value for p in values}, **kwargs)
+        return Partial(cls, **{p.label: p.value for p in values}, **kwargs)
 
     @classmethod
     def construct(cls, *values: Param[Self, Any], **kwargs) -> Self:
         """
         Create an instance of this model using selectors to specify fields instead of keyword arguments. 
-        Required properties can be omitted, but must be otherwise valid. See `PartialModel`.
+        Required properties can be omitted, but must be otherwise valid. See `Partial`.
         """
         return cls(**{p.label: p.value for p in values}, **kwargs)
 
-    def as_partial(self) -> PartialModel[Self]:
+    def as_partial(self) -> Partial[Self]:
         """
-        Convert to a `PartialModel`
+        Convert to a `Partial`
         """
-        return PartialModel(self.__class__, **self.as_dict())
+        return Partial(self.__class__, **self.as_dict())
 
     def __init__(self, **kwargs):
         """
@@ -336,7 +336,7 @@ class BaseModel(ModelLike, metaclass=BaseModelMeta):
                 ...
         return mapping
 
-    def select_partial(self, *selectors: Select[Self, Any]) -> PartialModel[Self]:
+    def select_partial(self, *selectors: Select[Self, Any]) -> Partial[Self]:
         """
         Generate a partial version of this instance, selecting the data to retain with one or more `Select` instances.
         """
@@ -345,10 +345,10 @@ class BaseModel(ModelLike, metaclass=BaseModelMeta):
             selector.copy_to(self, data)
         return self.__class__.partial(**data)
 
-def _partly_validate(target: Type[M], value: Any, validators: Dict[Type[Any], Validator]) -> M | PartialModel[M]:
+def _partly_validate(target: Type[M], value: Any, validators: Dict[Type[Any], Validator]) -> M | Partial[M]:
     if isinstance(value, target):
         return value
-    elif isinstance(value, PartialModel):
+    elif isinstance(value, Partial):
         if not issubclass(value.model, target):
             raise ValueError(f'received partial model of {value.model} instead of expected model {target}')
         return value
@@ -359,7 +359,7 @@ def _partly_validate(target: Type[M], value: Any, validators: Dict[Type[Any], Va
 
 M = TypeVar('M', bound=BaseModel)
 
-class PartialModel(Generic[M], Selectable[M]):
+class Partial(Generic[M], Selectable[M]):
     """
     An incomplete version of model instances. Validates data without requiring that all required properties are present.
     """
@@ -453,7 +453,7 @@ class PartialModel(Generic[M], Selectable[M]):
     def as_dict(self) -> Mapping[str, Any]:
         return self._dict
 
-    def select_partial(self, *selectors: Select[M, Any]) -> PartialModel[M]:
+    def select_partial(self, *selectors: Select[M, Any]) -> Partial[M]:
         """
         Generate another partial instance, selecting the data to retain with one or more `Select` instances.
         """

{pydoptic-0.0.2.post1.dev1 → pydoptic-0.0.2.post1.dev2/src/pydoptic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydoptic
-Version: 0.0.2.post1.dev1
+Version: 0.0.2.post1.dev2
 Summary: Model data using reified optics
 Author: John Hungerford
 License-Expression: MIT
@@ -35,7 +35,7 @@ The examples below assume this import, unless a different one is shown:
 
 ```python3
 from pydoptic import (
-    BaseModel, PartialModel, select,
+    BaseModel, Partial, select,
     Discrim, Prop, PropArr, PropOpt, PropOptArr, PropSelect,
     Select, SelectArr, SelectOpt, SelectOptArr, SelectVal, SelectValue,
 )
@@ -87,8 +87,8 @@ model_1_kw: Model2 = Model2(prop_one=42, prop_two="hello")
 model_2_pr: Model2 = Model2.construct(Model1.prop_1.param(42), Model1.prop_2.param("hello"))
 
 # Partial model
-model_1_partial_kw: PartialModel[Model2] = Model2.partial(prop_one=42)
-model_1_partial_pr: PartialModel[Model2] = Model2.construct_partial(
+model_1_partial_kw: Partial[Model2] = Model2.partial(prop_one=42)
+model_1_partial_pr: Partial[Model2] = Model2.construct_partial(
     Model.prop_2.param("hello"),
 )
 
@@ -221,7 +221,7 @@ model: MyModel = MyModel(prop_1='value', prop_2=23, ...)
 dict_value: Dict[str, Any] = model.as_dict_full()
 str_value: str = json.dumps(dict_value)
 
-partial_model: PartialModel[MyModel] = MyModel.partial(prop_1='value', prop_2=23, ...)
+partial_model: Partial[MyModel] = MyModel.partial(prop_1='value', prop_2=23, ...)
 partial_dict: Dict[str, Any] = partial_model.as_dict_full()
 partial_str: str = json.dumps(partial_dict)
 ```
@@ -237,7 +237,7 @@ model: MyModel = MyModel(**dict_value)
 
 partial_str: str = ???
 partial_dict: Dict[str, Any] = json.loads(partial_str)
-partial_model: PartialModel[MyModel] = MyModel.partial(**partial_dict)
+partial_model: Partial[MyModel] = MyModel.partial(**partial_dict)
 ```
 
 Note that given how data can be read from and written to objects, there is no necessity that you validate to models or even partial models at all. My own preferred workflow is to use models for ingestion only -- that is, to consume external data and convert them to my domain in the form of Pydoptic models, and then feed these into the data backend. Once valid data is persisted in a backend, it can then retrieved and manipulated in the form of `dict`s, without ever having to generate a full model. This is a matter of preference, however.
@@ -305,9 +305,9 @@ Conversely, if you only wanted to contact one POC (and you don't care whether th
 
 In the above case, if there are many `Person`s selected byte `poc_select`, only the first one will be returned. If none are, `poc` will be `None`.
 
-To retrieve values from an incomplete representation of the data, such as a `PartialModel` or a `dict`, there are two variants of `get` that you can use. `get_unsafe` will try to retrieve the selected value and fail with a `ValueError` if it's inaccessible due to invalid data (if its inaccessible due to a valid optional property being missing, it will generate an empty `SelectValue` as expected). `get_safe`, on the other hand, will always fail silently, generating empty `SelectValue` when data is missing.
+To retrieve values from an incomplete representation of the data, such as a `Partial` or a `dict`, there are two variants of `get` that you can use. `get_unsafe` will try to retrieve the selected value and fail with a `ValueError` if it's inaccessible due to invalid data (if its inaccessible due to a valid optional property being missing, it will generate an empty `SelectValue` as expected). `get_safe`, on the other hand, will always fail silently, generating empty `SelectValue` when data is missing.
 
-Note that the type signature of `get_unsafe` and `get_safe` are a bit misleading. They will provide accurate types for non-model values (e.g., primitive properties like `int` or `str`), but they will treat nested models as though they are fully typed. When you retrieve a nested model from a `dict` or `PartialModel`, however, in all likelihood it is going to be another `dict` or `PartialModel`.
+Note that the type signature of `get_unsafe` and `get_safe` are a bit misleading. They will provide accurate types for non-model values (e.g., primitive properties like `int` or `str`), but they will treat nested models as though they are fully typed. When you retrieve a nested model from a `dict` or `Partial`, however, in all likelihood it is going to be another `dict` or `Partial`.
 
 ```python3
 class Inner(BaseModel):
@@ -328,7 +328,7 @@ inner_result_full: SelectValue[Inner] = Outer.inner.get(full)
 partial_val = Outer.partial(inner=Inner.partial(prop=23))
 # Accurately typed
 prop_result_partial: SelectValue[int] = prop_select.get_unsafe(partial_val)
-# Inaccurate type! Should be SelectValue[PartialModel[Inner]]
+# Inaccurate type! Should be SelectValue[Partial[Inner]]
 inner_result_partial: SelectValue[Inner] = Outer.inner.get_unsafe(partial_val) 
 
 dict_val = {'inner': {'prop': 23}}
@@ -403,7 +403,7 @@ for arr in prop_arr_select.get(value).as_list:
     arr.append(len(arr))
 ```
 
-To update incomplete data, use `update_unsafe` and `update_safe`. `update_unsafe` will fail with an exception if it's unable to access the data to be updated due to invalid data, whereas `update_safe` will simply ignore (and therefore skip) invalid cases. Like `get`, you need to be careful when updating nested models with the partial variants of `update`. The types will appear to be complete models when they are most likely `PartialModel`s or `dict`s.
+To update incomplete data, use `update_unsafe` and `update_safe`. `update_unsafe` will fail with an exception if it's unable to access the data to be updated due to invalid data, whereas `update_safe` will simply ignore (and therefore skip) invalid cases. Like `get`, you need to be careful when updating nested models with the partial variants of `update`. The types will appear to be complete models when they are most likely `Partial`s or `dict`s.
 
 
 #### `set`, `set_unsafe`, `set_safe`
@@ -478,7 +478,7 @@ print(value)
 
 In the above example, while `sel_opt` is able to clear the `opt` property, `sel_req` cannot clear the selected `req` property so instead it clears the next clearable property, setting `c` to an empty array.
 
-Clearing partial data is even more complicated, since partial data (`PartialModel`s and `dict`s) *can* be cleared even when its required in the model. For this reason, the partial variants of `clear` are distinguished into "strict" and "non-strict" variants. `clear_unsafe_strict` works just like `clear`: it will only clear clearable (optional/array) properties, and will try to clear selected property and work its way backward across the property chain until it finds a clearable property. `clear_unsafe`, on the other hand, will clear the selected property whether or not it's a required field. `clear_safe_strict` and `clear_safe` work the same way, but does not raise exceptions when they encounter invalid data, but simply skip it and move on.
+Clearing partial data is even more complicated, since partial data (`Partial`s and `dict`s) *can* be cleared even when its required in the model. For this reason, the partial variants of `clear` are distinguished into "strict" and "non-strict" variants. `clear_unsafe_strict` works just like `clear`: it will only clear clearable (optional/array) properties, and will try to clear selected property and work its way backward across the property chain until it finds a clearable property. `clear_unsafe`, on the other hand, will clear the selected property whether or not it's a required field. `clear_safe_strict` and `clear_safe` work the same way, but does not raise exceptions when they encounter invalid data, but simply skip it and move on.
 
 #### Precise `Select`s
 

{pydoptic-0.0.2.post1.dev1 → pydoptic-0.0.2.post1.dev2}/src/pydoptic.egg-info/SOURCES.txt

@@ -14,5 +14,5 @@ src/pydoptic.egg-info/scm_file_list.json
 src/pydoptic.egg-info/scm_version.json
 src/pydoptic.egg-info/top_level.txt
 test/test_base_model.py
-test/test_partial_model.py
+test/test_partial.py
 test/test_selector.py

{pydoptic-0.0.2.post1.dev1 → pydoptic-0.0.2.post1.dev2}/src/pydoptic.egg-info/scm_file_list.json

@@ -9,7 +9,7 @@
     "src/pydoptic/selector.py",
     "src/pydoptic/validate_types.py",
     "test/test_base_model.py",
-    "test/test_partial_model.py",
+    "test/test_partial.py",
     "test/test_selector.py"
   ]
 }

pydoptic-0.0.2.post1.dev2/src/pydoptic.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.0.2",
+  "distance": 2,
+  "node": "g9a2420ef5de99bf2d4026d1af9ef469fad88bcab",
+  "dirty": false,
+  "branch": "main",
+  "node_date": "2026-09-07"
+}

pydoptic-0.0.2.post1.dev1/test/test_partial_model.py → pydoptic-0.0.2.post1.dev2/test/test_partial.py

@@ -24,7 +24,7 @@ class Other(BaseModel):
 class Another(BaseModel):
     value: Prop['Another', float]
 
-def test_partial_model_constructed_from_full_model():
+def test_partial_constructed_from_full_model():
     model_value = TestModel(
         annotation="str",
         select_val_empty=1,
@@ -55,7 +55,7 @@ def test_partial_model_constructed_from_full_model():
     assert model_value.other.value == True # type: ignore[attr-defined]
     assert model_value.other.another.value == 0.2 # type: ignore[attr-defined]
 
-def test_partial_model_should_accept_all_valid_values():
+def test_partial_should_accept_all_valid_values():
     model_value = TestModel.partial(
         annotation="str",
         select_val_empty=1,
@@ -86,7 +86,7 @@ def test_partial_model_should_accept_all_valid_values():
     assert model_value.other.value == True # type: ignore[attr-defined]
     assert model_value.other.another.value == 0.2 # type: ignore[attr-defined]
 
-def test_complete_partial_model_should_become_full_model():
+def test_complete_partial_should_become_full_model():
     model_value = TestModel.partial(
         annotation="str",
         select_val_empty=1,
@@ -117,7 +117,7 @@ def test_complete_partial_model_should_become_full_model():
     assert model_value.other.value == True # type: ignore[attr-defined]
     assert model_value.other.another.value == 0.2 # type: ignore[attr-defined]
 
-def test_partial_model_should_accept_valid_missing_arguments():
+def test_partial_should_accept_valid_missing_arguments():
     model_value = TestModel.partial(
         annotation="str",
         select_val_empty=1,
@@ -146,7 +146,7 @@ def test_partial_model_should_accept_valid_missing_arguments():
     with pytest.raises(AttributeError):
         model_value.select_opt_arr_renamed # type: ignore[attr-defined]
 
-def test_partial_model_should_accept_partial_model_for_nested_models_if_complete():
+def test_partial_should_accept_partial_for_nested_models_if_complete():
     model_value = TestModel.partial(
         annotation="str",
         select_val_empty=1,
@@ -161,14 +161,14 @@ def test_partial_model_should_accept_partial_model_for_nested_models_if_complete
         ),
     )
 
-    assert isinstance(model_value.other, PartialModel) # type: ignore[attr-defined]
+    assert isinstance(model_value.other, Partial) # type: ignore[attr-defined]
     assert model_value.other.model is Other # type: ignore[attr-defined]
     assert model_value.other.value == True # type: ignore[attr-defined]
-    assert isinstance(model_value.other.another, PartialModel) # type: ignore[attr-defined]
+    assert isinstance(model_value.other.another, Partial) # type: ignore[attr-defined]
     assert model_value.other.another.model is Another # type: ignore[attr-defined]
     assert model_value.other.another.value == 0.2 # type: ignore[attr-defined]
 
-def test_partial_model_should_accept_dict_for_nested_models_if_complete():
+def test_partial_should_accept_dict_for_nested_models_if_complete():
     model_value = TestModel.partial(
         annotation="str",
         select_val_empty=1,
@@ -183,14 +183,14 @@ def test_partial_model_should_accept_dict_for_nested_models_if_complete():
         },
     )
 
-    assert isinstance(model_value.other, PartialModel) # type: ignore[attr-defined]
+    assert isinstance(model_value.other, Partial) # type: ignore[attr-defined]
     assert model_value.other.model is Other # type: ignore[attr-defined]
     assert model_value.other.value == True # type: ignore[attr-defined]
-    assert isinstance(model_value.other.another, PartialModel) # type: ignore[attr-defined]
+    assert isinstance(model_value.other.another, Partial) # type: ignore[attr-defined]
     assert model_value.other.another.model is Another # type: ignore[attr-defined]
     assert model_value.other.another.value == 0.2 # type: ignore[attr-defined]
 
-def test_partial_model_init_should_succeed_if_required_param_is_missing():
+def test_partial_init_should_succeed_if_required_param_is_missing():
     model_value = TestModel.partial(
         select_val_empty=1,
         select_val_renamed=1,
@@ -219,7 +219,7 @@ def test_partial_model_init_should_succeed_if_required_param_is_missing():
     assert model_value.select_opt_arr_empty == [1,2,3] # type: ignore[attr-defined]
     assert model_value.select_opt_arr_renamed == [1,2,3] # type: ignore[attr-defined]
 
-def test_incomplete_partial_model_should_fail_to_become_full_model_if_missing_params_are_not_provided():
+def test_incomplete_partial_should_fail_to_become_full_model_if_missing_params_are_not_provided():
     passed = False
     try:
         TestModel.partial(
@@ -244,7 +244,7 @@ def test_incomplete_partial_model_should_fail_to_become_full_model_if_missing_pa
     assert passed
 
 
-def test_incomplete_partial_model_should_become_full_model_if_missing_params_are_provided():
+def test_incomplete_partial_should_become_full_model_if_missing_params_are_provided():
     model_value = TestModel.partial(
         annotation="str",
         select_val_renamed=1,
@@ -276,7 +276,7 @@ def test_incomplete_partial_model_should_become_full_model_if_missing_params_are
     assert model_value.other.value == True # type: ignore[attr-defined]
     assert model_value.other.another.value == 0.2 # type: ignore[attr-defined]
 
-def test_partial_model_init_should_fail_if_primitive_type_is_wrong():
+def test_partial_init_should_fail_if_primitive_type_is_wrong():
     passed = True
     try:
         TestModel.partial(
@@ -302,7 +302,7 @@ def test_partial_model_init_should_fail_if_primitive_type_is_wrong():
 
     assert passed is False
 
-def test_partial_model_init_should_fail_if_primitive_array_param_receives_non_array():
+def test_partial_init_should_fail_if_primitive_array_param_receives_non_array():
     passed = True
     try:
         TestModel.partial(
@@ -328,7 +328,7 @@ def test_partial_model_init_should_fail_if_primitive_array_param_receives_non_ar
 
     assert passed is False
 
-def test_partial_model_init_should_fail_if_primitive_array_param_contains_invalid_element():
+def test_partial_init_should_fail_if_primitive_array_param_contains_invalid_element():
     passed = True
     try:
         TestModel(
@@ -355,7 +355,7 @@ def test_partial_model_init_should_fail_if_primitive_array_param_contains_invali
 
     assert passed is False
 
-def test_partial_model_init_should_fail_if_wrong_model_is_passed():
+def test_partial_init_should_fail_if_wrong_model_is_passed():
     passed = True
     try:
         TestModel(
@@ -378,7 +378,7 @@ def test_partial_model_init_should_fail_if_wrong_model_is_passed():
 
     assert passed is False
 
-def test_partial_model_init_should_fail_if_nested_model_is_invalid_dict():
+def test_partial_init_should_fail_if_nested_model_is_invalid_dict():
     passed = True
     try:
         TestModel(
@@ -405,7 +405,7 @@ def test_partial_model_init_should_fail_if_nested_model_is_invalid_dict():
 
     assert passed is False
 
-def test_partial_model_init_should_accept_incomplete_nested_partial_model():
+def test_partial_init_should_accept_incomplete_nested_partial():
     TestModel.partial(
         annotation="str",
         select_val_empty=1,
@@ -426,14 +426,14 @@ def test_partial_model_init_should_accept_incomplete_nested_partial_model():
 class NestedModelExample(BaseModel):
     nested_model: PropArr['NestedModelExample', Another] = select()
 
-def test_partial_model_init_should_accept_valid_nested_model_array():
+def test_partial_init_should_accept_valid_nested_model_array():
     nested_vals = [Another(value=2.0), {'value': 0.2}, Another.partial(value=23.042)]
     result = NestedModelExample.partial(
         nested_model=nested_vals,
     )
     assert [v.value for v in result.nested_model] == [2.0, 0.2, 23.042] # type: ignore[attr-defined]
 
-def test_partial_model_init_should_fail_if_nested_model_array_is_not_array():
+def test_partial_init_should_fail_if_nested_model_array_is_not_array():
     passed = True
     try:
         NestedModelExample.partial(
@@ -445,7 +445,7 @@ def test_partial_model_init_should_fail_if_nested_model_array_is_not_array():
 
     assert passed
 
-def test_patial_model_init_should_fail_if_nested_model_array_contains_invald_model():
+def test_partial_init_should_fail_if_nested_model_array_contains_invalid_model():
     passed = True
     try:
         NestedModelExample.partial(
@@ -460,7 +460,7 @@ def test_patial_model_init_should_fail_if_nested_model_array_contains_invald_mod
 
     assert passed
 
-def test_partial_model_as_mapping_full_should_be_reversable():
+def test_partial_as_mapping_full_should_be_reversable():
     model_value = TestModel.partial(
         annotation="str",
         select_val_empty=1,
@@ -480,7 +480,7 @@ def test_partial_model_as_mapping_full_should_be_reversable():
 
     assert model_value == model_value_2
 
-def test_base_model_select_parts_should_generate_partial_model_from_selectors_p():
+def test_base_model_select_parts_should_generate_partial_from_selectors_p():
     model_value = TestModel.partial(
         annotation="str",
         select_val_renamed=1,
@@ -526,21 +526,21 @@ class Sub2(Base):
 class Root(BaseModel):
     next: Prop['Root', Base]
 
-def test_partial_model_should_construct_with_discrim():
+def test_partial_should_construct_with_discrim():
     value_1 = Root.partial(next=Sub1.partial(v='1', s1v=23))
     value_2 = Root.partial(next=Sub2.partial(v='2', s2v=True))
 
     assert value_1.next.d == 'Sub1' # type: ignore
     assert value_2.next.d == 'Sub2' # type: ignore
 
-def test_partial_model_should_forbid_constructing_with_invalid_discrim():
+def test_partial_should_forbid_constructing_with_invalid_discrim():
     value = Root.partial(next=Sub1.partial(d='Sub1', v='1', s1v=23))
     assert value.next.d == 'Sub1' # type: ignore
 
     with pytest.raises(ValueError):
         Root.partial(next=Sub2.partial(d='wrong!', v='2', s2v=True))
 
-def test_partial_model_should_forbid_setting_invalid_discrim():
+def test_partial_should_forbid_setting_invalid_discrim():
     value = Root.partial(next=Sub1.partial(d='Sub1', v='1', s1v=23))
     assert value.next.d == 'Sub1' # type: ignore
 

pydoptic-0.0.2.post1.dev1/src/pydoptic.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.0.2",
-  "distance": 1,
-  "node": "ga0068181cb2d8dfd1b14469d4ad3bdc4cfd63617",
-  "dirty": false,
-  "branch": "main",
-  "node_date": "2026-08-18"
-}