Cleaned up TypeVars

Author: sveinugu

src/omnipy/api/protocols/public/data.py

@@ -4,10 +4,10 @@
 
 from omnipy.api.protocols.private.log import CanLog
 
-ModelT = TypeVar('ModelT')
+_ModelT = TypeVar('_ModelT')
 
 
-class IsDataset(Protocol[ModelT]):
+class IsDataset(Protocol[_ModelT]):
     """
     Dict-based container of data files that follow a specific Model
     """
@@ -21,7 +21,7 @@ def __init__(
         ...
 
     @classmethod
-    def get_model_class(cls) -> Type[ModelT]:
+    def get_model_class(cls) -> Type[_ModelT]:
         """
         Returns the concrete Model class used for all data files in the dataset, e.g.:
         `Model[list[int]]`
@@ -49,18 +49,18 @@ def from_json(self,
     def to_json_schema(cls, pretty=True) -> str | dict[str, str]:
         ...
 
-    def as_multi_model_dataset(self) -> 'MultiModelDataset[ModelT]':
+    def as_multi_model_dataset(self) -> 'MultiModelDataset[_ModelT]':
         ...
 
 
-class MultiModelDataset(Protocol[ModelT]):
+class MultiModelDataset(Protocol[_ModelT]):
     """
         Variant of Dataset that allows custom models to be set on individual data files
     """
-    def set_model(self, data_file: str, model: ModelT) -> None:
+    def set_model(self, data_file: str, model: _ModelT) -> None:
         ...
 
-    def get_model(self, data_file: str) -> ModelT:
+    def get_model(self, data_file: str) -> _ModelT:
         ...
 
 

src/omnipy/data/dataset.py

@@ -604,20 +604,20 @@ def _to_data_if_model(data_obj: Any):
         return data_obj
 
 
-KwargValT = TypeVar('KwargValT', bound=object)
-ParamModelT = TypeVar('ParamModelT', bound=ParamModel)
-ListOfParamModelT = TypeVar('ListOfParamModelT', bound=ListOfParamModel)
+_KwargValT = TypeVar('_KwargValT', bound=object)
+_ParamModelT = TypeVar('_ParamModelT', bound=ParamModel)
+_ListOfParamModelT = TypeVar('_ListOfParamModelT', bound=ListOfParamModel)
 
 ParamModelSuperKwargsType: TypeAlias = \
-    dict[str, dict[str, ParamModelT | DataWithParams[ParamModelT, KwargValT]]]
+    dict[str, dict[str, _ParamModelT | DataWithParams[_ParamModelT, _KwargValT]]]
 
 ListOfParamModelSuperKwargsType: TypeAlias = \
-    dict[str, dict[str, list[ListOfParamModelT | DataWithParams[ListOfParamModelT, KwargValT]]]]
+    dict[str, dict[str, list[_ListOfParamModelT | DataWithParams[_ListOfParamModelT, _KwargValT]]]]
 
 
-class ParamDataset(Dataset[ParamModelT | DataWithParams[ParamModelT, KwargValT]],
-                   Generic[ParamModelT, KwargValT]):
-    def _init(self, super_kwargs: ParamModelSuperKwargsType, **kwargs: KwargValT) -> None:
+class ParamDataset(Dataset[_ParamModelT | DataWithParams[_ParamModelT, _KwargValT]],
+                   Generic[_ParamModelT, _KwargValT]):
+    def _init(self, super_kwargs: ParamModelSuperKwargsType, **kwargs: _KwargValT) -> None:
         if kwargs and DATA_KEY in super_kwargs:
             super_kwargs[DATA_KEY] = {
                 key: DataWithParams(data=val, params=kwargs)
@@ -627,7 +627,7 @@ def _init(self, super_kwargs: ParamModelSuperKwargsType, **kwargs: KwargValT) ->
     def from_data(self,
                   data: dict[str, Any] | Iterator[tuple[str, Any]],
                   update: bool = True,
-                  **kwargs: KwargValT) -> None:
+                  **kwargs: _KwargValT) -> None:
         if kwargs:
 
             def callback_func(model: ModelT, contents: Any):
@@ -640,7 +640,7 @@ def callback_func(model: ModelT, contents: Any):
     def from_json(self,
                   data: Mapping[str, str] | Iterable[tuple[str, str]],
                   update: bool = True,
-                  **kwargs: KwargValT) -> None:
+                  **kwargs: _KwargValT) -> None:
         if kwargs:
 
             def callback_func(model: ModelT, contents: Any):
@@ -651,9 +651,9 @@ def callback_func(model: ModelT, contents: Any):
             super().from_json(data, update=update)
 
 
-class ListOfParamModelDataset(ParamDataset[ListOfParamModelT, KwargValT],
-                              Generic[ListOfParamModelT, KwargValT]):
-    def _init(self, super_kwargs: ListOfParamModelSuperKwargsType, **kwargs: KwargValT) -> None:
+class ListOfParamModelDataset(ParamDataset[_ListOfParamModelT, _KwargValT],
+                              Generic[_ListOfParamModelT, _KwargValT]):
+    def _init(self, super_kwargs: ListOfParamModelSuperKwargsType, **kwargs: _KwargValT) -> None:
         if kwargs and DATA_KEY in super_kwargs:
             super_kwargs[DATA_KEY] = {
                 key: [DataWithParams(data=_, params=kwargs) for _ in val]

src/omnipy/data/model.py

@@ -12,6 +12,7 @@
                     Generic,
                     get_args,
                     get_origin,
+                    Hashable,
                     Optional,
                     SupportsIndex,
                     Type,
@@ -46,10 +47,10 @@
                                  RestorableContents)
 from omnipy.util.tabulate import tabulate
 
-_KeyT = TypeVar('_KeyT')
+_KeyT = TypeVar('_KeyT', bound=Hashable)
 _ValT = TypeVar('_ValT')
 _IdxT = TypeVar('_IdxT', bound=SupportsIndex)
-RootT = TypeVar('RootT', covariant=True, bound=object)
+_RootT = TypeVar('_RootT', covariant=True, bound=object)
 
 ROOT_KEY = '__root__'
 
@@ -132,7 +133,7 @@ def __instancecheck__(self, instance: Any) -> bool:
         return super().__instancecheck__(instance)
 
 
-class Model(GenericModel, Generic[RootT], metaclass=MyModelMetaclass):
+class Model(GenericModel, Generic[_RootT], metaclass=MyModelMetaclass):
     """
     A data model containing a value parsed according to the model.
 
@@ -168,7 +169,7 @@ class MyNumberList(Model[list[int]]):
     See also docs of the Dataset class for more usage examples.
     """
 
-    __root__: RootT | None
+    __root__: _RootT | None
 
     class Config:
         arbitrary_types_allowed = True
@@ -179,7 +180,7 @@ class Config:
         # json_dumps = orjson_dumps
 
     @classmethod
-    def _get_bound_if_typevar(cls, model: Type[RootT]) -> RootT:
+    def _get_bound_if_typevar(cls, model: Type[_RootT]) -> _RootT:
         if isinstance(model, TypeVar):
             if model.__bound__ is None:  # noqa
                 raise TypeError('The TypeVar "{}" needs to be bound to a '.format(model.__name__)
@@ -189,7 +190,7 @@ def _get_bound_if_typevar(cls, model: Type[RootT]) -> RootT:
         return model
 
     @classmethod
-    def _get_default_value_from_model(cls, model: Type[RootT]) -> RootT:  # noqa: C901
+    def _get_default_value_from_model(cls, model: Type[_RootT]) -> _RootT:  # noqa: C901
         model = cls._get_bound_if_typevar(model)
         origin_type = get_origin(model)
         args = get_args(model)
@@ -219,10 +220,10 @@ def _get_default_value_from_model(cls, model: Type[RootT]) -> RootT:  # noqa: C9
         return origin_type()
 
     @classmethod
-    def _populate_root_field(cls, model: Type[RootT]) -> None:
+    def _populate_root_field(cls, model: Type[_RootT]) -> None:
         default_val = cls._get_default_value_from_model(model)
 
-        def get_default_val() -> RootT:
+        def get_default_val() -> _RootT:
             return default_val
 
         if ROOT_KEY in cls.__config__.fields:
@@ -251,7 +252,7 @@ def _depopulate_root_field(cls):
         del cls.__fields__[ROOT_KEY]
         del cls.__annotations__[ROOT_KEY]
 
-    def __class_getitem__(cls, model: Type[RootT] | TypeVar) -> 'Model[Type[RootT] | TypeVar]':
+    def __class_getitem__(cls, model: Type[_RootT] | TypeVar) -> 'Model[Type[_RootT] | TypeVar]':
         # TODO: change model type to params: Type[Any], tuple[Type[Any], ...]]
         #       as in GenericModel
 
@@ -311,20 +312,20 @@ def __init__(
         __root__: Any | UndefinedType = Undefined,
         **kwargs: Any,
     ) -> None:
-        super_kwargs: dict[str, RootT] = {}
+        super_kwargs: dict[str, _RootT] = {}
         num_root_vals = 0
 
         if value is not Undefined:
-            super_kwargs[ROOT_KEY] = cast(RootT, value)
+            super_kwargs[ROOT_KEY] = cast(_RootT, value)
             num_root_vals += 1
 
         if __root__ is not Undefined:
-            super_kwargs[ROOT_KEY] = cast(RootT, __root__)
+            super_kwargs[ROOT_KEY] = cast(_RootT, __root__)
             num_root_vals += 1
 
         if kwargs:
             if num_root_vals == 0 or not self.is_param_model():
-                super_kwargs[ROOT_KEY] = cast(RootT, kwargs)
+                super_kwargs[ROOT_KEY] = cast(_RootT, kwargs)
                 kwargs = {}
                 num_root_vals += 1
 
@@ -399,11 +400,11 @@ def update_forward_refs(cls, **localns: Any) -> None:
     def validate_contents(self) -> None:
         self._validate_and_set_contents(self.contents)
 
-    def _validate_and_set_contents(self, new_contents: RootT) -> None:
+    def _validate_and_set_contents(self, new_contents: _RootT) -> None:
         self.contents = self._validate_contents_from_value(new_contents)
         self._take_snapshot_of_validated_contents()
 
-    def _validate_contents_from_value(self, value: RootT) -> RootT:
+    def _validate_contents_from_value(self, value: _RootT) -> _RootT:
         if is_model_instance(value):
             value = value.to_data()
         elif is_pure_pydantic_model(value):
@@ -428,7 +429,7 @@ def _parse_data(cls, data: Any) -> Any:
         return data
 
     @root_validator
-    def _parse_root_object(cls, root_obj: dict[str, RootT]) -> Any:  # noqa
+    def _parse_root_object(cls, root_obj: dict[str, _RootT]) -> Any:  # noqa
         assert ROOT_KEY in root_obj
         value = root_obj[ROOT_KEY]
         value = cls._parse_none_value_with_root_type_if_model(value)
@@ -484,11 +485,11 @@ def _parse_with_root_type_if_model(cls, value: Any, root_field: ModelField,
         return value
 
     @property
-    def contents(self) -> RootT:
+    def contents(self) -> _RootT:
         return self.__dict__.get(ROOT_KEY)
 
     @contents.setter
-    def contents(self, value: RootT) -> None:
+    def contents(self, value: _RootT) -> None:
         super().__setattr__(ROOT_KEY, value)
 
     def dict(self, *args, **kwargs) -> dict[str, dict[Any, Any]]:
@@ -805,34 +806,34 @@ def _is_table():
 ParamModelT = TypeVar('ParamModelT', bound='ParamModel')
 
 
-class DataWithParams(GenericModel, Generic[RootT, KwargValT]):
-    data: RootT
+class DataWithParams(GenericModel, Generic[_RootT, KwargValT]):
+    data: _RootT
     params: dict[str, KwargValT]
 
 
-class ParamModel(Model[RootT | DataWithParams[RootT, KwargValT]], Generic[RootT, KwargValT]):
+class ParamModel(Model[_RootT | DataWithParams[_RootT, KwargValT]], Generic[_RootT, KwargValT]):
     def __class_getitem__(
-            cls, model: tuple[Type[RootT], Type[KwargValT]]) -> 'ParamModel[RootT, KwargValT]':
+            cls, model: tuple[Type[_RootT], Type[KwargValT]]) -> 'ParamModel[_RootT, KwargValT]':
         created_model = super().__class_getitem__(model)
         outer_type = created_model._get_root_type(outer=True, with_args=True)
         default_val = cls._get_default_value_from_model(outer_type)
 
-        def get_default_val() -> RootT | DataWithParams[RootT, KwargValT]:
+        def get_default_val() -> _RootT | DataWithParams[_RootT, KwargValT]:
             return default_val
 
         root_field = created_model._get_root_field()
         root_field.default_factory = get_default_val
 
         return created_model
 
-    def _init(self, super_kwargs: dict[str, RootT], **kwargs: KwargValT) -> None:
+    def _init(self, super_kwargs: dict[str, _RootT], **kwargs: KwargValT) -> None:
         if kwargs and ROOT_KEY in super_kwargs:
             super_kwargs[ROOT_KEY] = cast(
-                RootT, DataWithParams(data=super_kwargs[ROOT_KEY], params=kwargs))
+                _RootT, DataWithParams(data=super_kwargs[ROOT_KEY], params=kwargs))
 
     @root_validator
     def _parse_root_object(cls, root_obj: dict[str,
-                                               RootT | DataWithParams[RootT, KwargValT]]) -> Any:
+                                               _RootT | DataWithParams[_RootT, KwargValT]]) -> Any:
         assert ROOT_KEY in root_obj
         root_val = root_obj[ROOT_KEY]
 
@@ -848,7 +849,7 @@ def _parse_root_object(cls, root_obj: dict[str,
         return {ROOT_KEY: cls._parse_data(data, **params)}
 
     @classmethod
-    def _parse_data(cls, data: RootT, **params: KwargValT) -> RootT:
+    def _parse_data(cls, data: _RootT, **params: KwargValT) -> _RootT:
         return data
 
     def from_data(self, value: object, **kwargs: KwargValT) -> None:
@@ -861,7 +862,7 @@ def from_json(self, json_contents: str, **kwargs: KwargValT) -> None:
         if kwargs:
             self._validate_and_set_contents_with_params(self.contents, **kwargs)
 
-    def _validate_and_set_contents_with_params(self, contents: RootT, **kwargs: KwargValT):
+    def _validate_and_set_contents_with_params(self, contents: _RootT, **kwargs: KwargValT):
         self._validate_and_set_contents(DataWithParams(data=contents, params=kwargs))
 
 

src/omnipy/modules/general/datasets.py

@@ -1,9 +1,10 @@
-from typing import Generic, TypeVar
+from typing import Generic, Hashable, TypeVar
 
 from omnipy.data.dataset import Dataset
 
-_KeyT = TypeVar('_KeyT')
 from .models import NestedFrozenDictsModel, NestedFrozenDictsOrTuplesModel, NestedFrozenTuplesModel
+
+_KeyT = TypeVar('_KeyT', bound=Hashable)
 _ScT = TypeVar('_ScT')
 
 

src/omnipy/modules/general/tasks.py

@@ -53,9 +53,9 @@ def import_directory(directory: str,
     return dataset
 
 
-DatasetT = TypeVar('DatasetT', bound=Dataset)
+_DatasetT = TypeVar('_DatasetT', bound=Dataset)
 
 
 @TaskTemplate
-def convert_dataset(dataset: Dataset, dataset_cls: type[DatasetT]) -> DatasetT:
+def convert_dataset(dataset: Dataset, dataset_cls: type[_DatasetT]) -> _DatasetT:
     return dataset_cls(dataset)

src/omnipy/modules/general/typedefs.py

@@ -1,8 +1,8 @@
 from collections import UserDict
 from types import MappingProxyType
-from typing import Generic, Sequence, TypeVar
+from typing import Generic, Hashable, Sequence, TypeVar
 
-_KeyT = TypeVar('_KeyT')
+_KeyT = TypeVar('_KeyT', bound=Hashable)
 _ValT = TypeVar('_ValT')
 
 

src/omnipy/modules/json/datasets.py

@@ -29,10 +29,10 @@
 # TODO: call omnipy modules something else than modules, to distinguish from Python modules.
 #       Perhaps plugins?
 #
-JsonModelT = TypeVar('JsonModelT', bound=Model)
+_JsonModelT = TypeVar('_JsonModelT', bound=Model)
 
 
-class JsonBaseDataset(Dataset[JsonModelT], Generic[JsonModelT]):
+class JsonBaseDataset(Dataset[_JsonModelT], Generic[_JsonModelT]):
     """"""
     ...
 

src/omnipy/util/decorators.py

@@ -1,16 +1,16 @@
 from contextlib import AbstractContextManager
 from typing import Any, Callable, ParamSpec, TypeVar
 
-DecoratedP = ParamSpec('DecoratedP')
-DecoratedR = TypeVar('DecoratedR')
-CallbackP = ParamSpec('CallbackP')
+_DecoratedP = ParamSpec('_DecoratedP')
+_DecoratedR = TypeVar('_DecoratedR')
+_CallbackP = ParamSpec('_CallbackP')
 
 
-def add_callback_after_call(func: Callable[DecoratedP, DecoratedR],
-                            callback_func: Callable[CallbackP, None],
-                            *cb_args: CallbackP.args,
+def add_callback_after_call(func: Callable[_DecoratedP, _DecoratedR],
+                            callback_func: Callable[_CallbackP, None],
+                            *cb_args: _CallbackP.args,
                             with_context: AbstractContextManager | None = None,
-                            **cb_kwargs: CallbackP.kwargs) -> Callable[DecoratedP, DecoratedR]:
+                            **cb_kwargs: _CallbackP.kwargs) -> Callable[_DecoratedP, _DecoratedR]:
     class ValidateAfterCall(AbstractContextManager):
         def __enter__(self):
             ...
@@ -22,7 +22,7 @@ def __exit__(self, exc_type, exc_val, exc_tb):
                 callback_func(*cb_args, **cb_kwargs)
             return ret
 
-    def _inner(*args: DecoratedP.args, **kwargs: DecoratedP.kwargs) -> DecoratedR:
+    def _inner(*args: _DecoratedP.args, **kwargs: _DecoratedP.kwargs) -> _DecoratedR:
         if with_context:
             with with_context:
                 with ValidateAfterCall():