tol-sdk 1.6.37__py3-none-any.whl → 1.7.0__py3-none-any.whl

tol/sql/filter.py

@@ -6,10 +6,10 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from collections import defaultdict
-from collections.abc import MutableMapping
+from collections.abc import Iterable, Iterator, MutableMapping
 from functools import reduce
 from itertools import chain
-from typing import Any, Dict, Iterable, Iterator, Optional, Tuple, Type
+from typing import Any, Dict, Optional, Tuple, Type
 
 from sqlalchemy import BinaryExpression, cast, inspect, not_
 from sqlalchemy.dialects.postgresql import JSONB
@@ -30,8 +30,8 @@ class AliasTrie(MutableMapping[str, 'AliasTrie']):
     def alias(self) -> AliasedClass[Model]:
         return self.__alias
 
-    def __getitem__(self, k: str) -> AliasTrie:
-        return self.__dict[k]
+    def __getitem__(self, key: str) -> AliasTrie:
+        return self.__dict[key]
 
     def __setitem__(self, key: str, value: AliasTrie) -> None:
         self.__dict[key] = value
@@ -67,7 +67,9 @@ class DatabaseFilter(ABC):
         """Adds a relation field to the filter, for joining later"""
 
     @abstractmethod
-    def get_query(self, session: Session, base_model: type[Model]) -> Query[Model]:
+    def get_query(
+        self, session: Session, base_model: type[Model]
+    ) -> tuple[Query[Model], AliasedClass[Model]]:
         """Gets an aliased query"""
 
 
@@ -103,7 +105,7 @@ class DefaultDatabaseFilter(DatabaseFilter):
         query = self.__apply_joins(
             query,
             self.__alias_trie,
-            self.__base_alias,
+            self.__base_model,
         )
 
         if self.__filter is None:
@@ -117,13 +119,10 @@ class DefaultDatabaseFilter(DatabaseFilter):
 
         return query
 
-    def get_query(self, session: Session, base_model: Model) -> Query[Model]:
-        # TODO this is not thread safe
-        self.__base_alias: AliasedClass[Model] = aliased(
-            base_model,
-        )
+    def get_query(self, session: Session, base_model: Model) -> [Query[Model]]:
+        self.__base_model = base_model
 
-        return session.query(self.__base_alias)
+        return session.query(base_model)
 
     def __apply_joins(
         self,
@@ -135,6 +134,7 @@ class DefaultDatabaseFilter(DatabaseFilter):
         for part, trie in parent_trie.items():
             alias = trie.alias
 
+            # Probably want an outerjoin() here
             query = query.join(alias, getattr(parent_alias, part))
 
             query = self.__apply_joins(
@@ -160,11 +160,11 @@ class DefaultDatabaseFilter(DatabaseFilter):
         self.__rel_keys.add(field)
 
     def __build_alias_trie(self, paths: Iterable[str]) -> AliasTrie:
-        trie = AliasTrie(self.__base_alias)
+        trie = AliasTrie(self.__base_model)
 
         for path in paths:
             parts = path.split('.')
-            current_alias = self.__base_alias
+            current_alias = self.__base_model
             current = trie
             for part in parts[:-1]:
                 if part not in current:
@@ -176,6 +176,8 @@ class DefaultDatabaseFilter(DatabaseFilter):
                     )
                     current[part] = step
                     current = step
+                else:
+                    current = current[part]
                 current_alias = current.alias
 
         return trie
@@ -520,16 +522,16 @@ class DefaultDatabaseFilter(DatabaseFilter):
             return self.__get_column_attr(model, key)
 
     def __get_id_column(self, model: type[Model]) -> MappedColumn:
-        og_model: type[Model] = model._aliased_insp.mapper.class_
+        og_model: type[Model] = inspect(model).mapper.class_
         id_key = og_model.get_id_column_name()
         return self.__get_column_attr(model, id_key)
 
     def __get_column_attr(self, model: AliasedClass[Model], key: str) -> MappedColumn:
-        columns = {
-            col.key: col
-            for col in model._aliased_insp.selectable.c
-        }
-        return columns[key]
+        for col in inspect(model).selectable.c:
+            if col.key == key:
+                return col
+        msg = f"Failed to find column '{key}' in '{model}'"
+        raise ValueError(msg)
 
     def __get_relation_column(
         self,

tol/sql/model.py

@@ -6,6 +6,8 @@ from __future__ import annotations
 
 from abc import ABCMeta
 from datetime import datetime
+from functools import cache
+from types import MappingProxyType  # A read-only dict
 from typing import Any, Iterable, Optional, Type
 
 from sqlalchemy import JSON, inspect
@@ -198,30 +200,32 @@ def model_base() -> Type[DefaultModel]:
             return getattr(cls, name)
 
         @classmethod
-        def get_to_many_relationship_config(cls) -> dict[str, str]:
+        @cache
+        def get_to_many_relationship_config(cls) -> MappingProxyType[str, str]:
             relationships = inspect(cls).relationships
             all_ = {
-                cls.__get_relationshship_name(r): cls.__get_relationship_target(r)
+                r.key: cls.__get_relationship_target(r)
                 for r in relationships
                 if cls.__is_to_many_relationship(r)
             }
-            return {
+            return MappingProxyType({
                 k: v for k, v in all_.items()
                 if not k.startswith('_')
-            }
+            })
 
         @classmethod
-        def get_to_one_relationship_config(cls) -> dict[str, str]:
+        @cache
+        def get_to_one_relationship_config(cls) -> MappingProxyType[str, str]:
             relationships = inspect(cls).relationships
             all_ = {
-                cls.__get_relationshship_name(r): cls.__get_relationship_target(r)
+                r.key: cls.__get_relationship_target(r)
                 for r in relationships
                 if cls.__is_to_one_relationship(r)
             }
-            return {
+            return MappingProxyType({
                 k: v for k, v in all_.items()
                 if not k.startswith('_')
-            }
+            })
 
         @classmethod
         def get_foreign_key_name(cls, relationship_name: str) -> str:
@@ -230,12 +234,13 @@ def model_base() -> Type[DefaultModel]:
             return foreign_key.name
 
         @classmethod
-        def get_attribute_types(cls) -> dict[str, type]:
+        @cache
+        def get_attribute_types(cls) -> MappingProxyType[str, type]:
             names = cls.__get_attribute_names()
             columns = inspect(cls).columns
-            return {
+            return MappingProxyType({
                 k: columns[k].type.python_type for k in names
-            }
+            })
 
         @classmethod
         def get_id_attribute_type(cls) -> dict[str, type]:
@@ -268,13 +273,15 @@ def model_base() -> Type[DefaultModel]:
             cls,
             relationship_name: str
         ) -> MappedColumn:
+            """
+            Returns the local foreign key column given a relationship name
+            """
 
-            relationships = inspect(cls).relationships
-            all_keys = relationships[relationship_name]._calculated_foreign_keys
-            if len(all_keys) != 1:
+            rel = inspect(cls).relationships[relationship_name]
+            all_cols = tuple(rel.local_columns)
+            if len(all_cols) != 1:
                 raise NotImplementedError('Composite keys are not supported.')
-            (foreign_key, ) = all_keys
-            return foreign_key
+            return all_cols[0]
 
         def __get_attributes_map(
             self,
@@ -285,13 +292,9 @@ def model_base() -> Type[DefaultModel]:
                 name: getattr(self, name) for name in names
             }
 
-        @classmethod
-        def __get_relationshship_name(cls, relationship) -> str:
-            return str(relationship).split('.')[-1]
-
         @classmethod
         def __get_relationship_target(cls, relationship) -> str:
-            return list(relationship.remote_side)[0].table.name
+            return relationship.entity.tables[0].name
 
         @classmethod
         def __get_all_relationship_names(cls) -> list[str]:
@@ -310,47 +313,49 @@ def model_base() -> Type[DefaultModel]:
             )
 
         @classmethod
-        def get_all_foreign_key_names(cls) -> set[str]:
+        @cache
+        def get_all_foreign_key_names(cls) -> frozenset[str]:
             """
             Returns only the names of columns which are foreign keys used in
-            relationsips.
+            relationsips. i.e. To-one relationships.
             """
 
+            col_to_attr = cls.__get_column_name_to_attribute_map()
+
             foreign_keys = set()
             for rel in inspect(cls).relationships:
                 for col in rel.local_columns:
-                    # Test if it really is a foreign key
-                    if len(col.foreign_keys) > 0:
-                        if attr_name := cls.__get_foreign_key_attribute_name(col.name):
-                            foreign_keys.add(attr_name)
-            return foreign_keys
+                    # If it is really a foreign key, get the name of the
+                    # attribute in the model
+                    if len(col.foreign_keys) > 0 and (attr_name := col_to_attr.get(col.name)):
+                        foreign_keys.add(attr_name)
+            return frozenset(foreign_keys)
 
         @classmethod
-        def __get_foreign_key_attribute_name(cls, foreign_key_name: str) -> str | None:
+        def __get_column_name_to_attribute_map(cls) -> dict[str, str]:
             """
-            Gets the model's attribute name in the class definition from the schema's
-            `foreign_key_name`.
+            Returns a dict mapping database column names to this model's
+            attribute names.
             """
 
-            col_to_attr = {
+            return {
                 col_prop.columns[0].name: col_prop.key
                 for col_prop in inspect(cls).column_attrs
             }
 
-            return col_to_attr.get(foreign_key_name)
-
         @classmethod
-        def __get_attribute_names(cls) -> list[str]:
+        @cache
+        def __get_attribute_names(cls) -> tuple[str]:
             excluded = cls.get_excluded_column_names()
             mapper = inspect(cls)
             relationships = cls.__get_all_relationship_names()
             foreign_keys = cls.get_all_foreign_key_names()
-            return [
-                k for k in mapper.attrs.keys()
+            return tuple(
+                k for k in mapper.attrs.keys()  # noqa: SIM118
                 if k not in excluded
                 and k not in relationships
                 and k not in foreign_keys
-            ]
+            )
 
     class LogBase(ModelBase):
         """

tol/sql/relationship.py

@@ -69,7 +69,7 @@ class DefaultSqlRelationshipConfig(ABC):
         else:
             return object_type, RelationshipConfig(
                 to_one=self.__map_config(to_one),
-                to_many=self.__map_config(to_many)
+                to_many=self.__map_config(to_many),
             )
 
     def __map_config(self, config: Dict[str, str]) -> Dict[str, str]:

tol/sql/sql_converter.py

@@ -3,10 +3,10 @@
 # SPDX-License-Identifier: MIT
 
 from abc import ABC
-from typing import Any, Callable, Optional, TypeVar
+from typing import Any, Callable
 
 from .model import Model
-from ..core import DataObject
+from ..core import DataObject, ReqFieldsTree
 from ..core.core_converter import Converter
 from ..core.factory import DataObjectFactory
 
@@ -15,14 +15,6 @@ TypeFunction = Callable[[Model], str]
 """Takes a Model instance, and returns the corresponding DataObject type."""
 
 
-In = TypeVar('In')
-"""The input representation type"""
-
-
-Out = TypeVar('Out')
-"""The output representation type"""
-
-
 class ModelConverter(Converter[Model, DataObject], ABC):
     """
     Converts Sqlalchemy model instances to DataObject instances.
@@ -30,13 +22,11 @@ class ModelConverter(Converter[Model, DataObject], ABC):
 
 
 class DefaultModelConverter(ModelConverter):
-
     def __init__(
         self,
         type_function: TypeFunction,
         data_object_factory: DataObjectFactory,
-        max_depth: int = 1,
-        requested_fields: list[str] | None = None,
+        requested_tree: ReqFieldsTree,
     ) -> None:
         """
         Takes a type_function Callable, which determines the type of the
@@ -45,116 +35,55 @@ class DefaultModelConverter(ModelConverter):
 
         self.__type_function = type_function
         self.__data_object_factory = data_object_factory
-
-        self.__requested_fields = requested_fields
-        self.__max_depth = (
-            None
-            if self.__requested_fields
-            else max_depth
-        )
+        self.__requested_tree = requested_tree
 
     def convert(self, model: Model) -> DataObject:
-        return self.__convert_to_max_depth(
-            model,
-            self.__initial_marker
-        )
-
-    def __convert_to_max_depth(
-        self,
-        model: Model | None,
-        marker: int
-    ) -> DataObject:
-
         if model is None:
             return None
-
-        type_ = self.__type_function(model)
-
-        return self.__data_object_factory(
-            type_,
-            id_=model.instance_id,
-            attributes=model.instance_attributes,
-            to_one=self.__convert_to_ones(
-                model,
-                marker
-            )
-        )
-
-    @property
-    def __initial_marker(self) -> int | str:
-        return (
-            ''
-            if self.__requested_fields
-            else 0
-        )
-
-    def __convert_to_ones(
-        self,
-        model: Model,
-        marker: int | str
-    ) -> dict[str, Optional[DataObject]]:
-
-        if self.__max_depth and marker >= self.__max_depth:
-            return {}
-
-        return {
-            k: self.__convert_to_max_depth(
-                model.instance_to_one_relations[k],
-                self.__get_next_marker(
-                    k,
-                    marker,
-                )
-            )
-            for k in self.__get_requested_to_ones(
-                model,
-                marker,
+        if tree := self.__requested_tree:
+            return self.__convert_requested(model, tree)
+        else:
+            return self.__data_object_factory(
+                self.__type_function(model),
+                id_=model.instance_id,
+                attributes=model.instance_attributes,
             )
-        }
-
-    def __get_next_marker(
-        self,
-        k: str,
-        marker: int | str
-    ) -> int | str:
 
-        if self.__requested_fields:
-            return f'{marker}.{k}' if marker else k
+    def __convert_requested(self, model, tree):
+        if attr_names := tree.attribute_names:
+            attributes = {x: getattr(model, x) for x in attr_names if x != 'id'}
         else:
-            return marker + 1
-
-    def __get_requested_to_ones(
-        self,
-        model_instance: Model,
-        marker: int | str
-    ) -> list[str]:
-
-        all_keys = list(
-            model_instance.get_to_one_relationship_config().keys()
-        )
+            attributes = model.instance_attributes
 
-        if not self.__requested_fields:
-            return all_keys
+        req_to_ones = self.__convert_to_ones_requested(model, tree)
+        req_to_many = self.__convert_to_many_requested(model, tree)
 
-        return [
-            k for k in all_keys
-            if self.__requested_to_one(k, marker)
-        ]
-
-    def __requested_to_one(
-        self,
-        k: str,
-        marker: int | str
-    ) -> bool:
-
-        next_marker = self.__get_next_marker(
-            k,
-            marker,
-        )
-
-        return any(
-            r.startswith(next_marker)
-            for r in self.__requested_fields
+        obj = self.__data_object_factory(
+            self.__type_function(model),
+            id_=model.instance_id,
+            attributes=attributes,
+            to_one=req_to_ones,
+            to_many=req_to_many,
         )
+        return obj
+
+    def __convert_to_ones_requested(self, model, tree):
+        to_ones = {}
+        for rel_name, remote in model.get_to_one_relationship_config().items():
+            one = None
+            if sub_tree := tree.get_sub_tree(rel_name):
+                if sub_model := getattr(model, rel_name):
+                    one = self.__convert_requested(sub_model, sub_tree)
+            else:
+                # Create a stub DataObject
+                rel_col = model.get_foreign_key_name(rel_name)
+                if rel_id := getattr(model, rel_col):
+                    one = self.__data_object_factory(remote, id_=rel_id)
+            to_ones[rel_name] = one
+        return to_ones if to_ones else None
+
+    def __convert_to_many_requested(self, model, tree):
+        return None
 
 
 class DataObjectConverter(Converter[DataObject, Model], ABC):
@@ -164,11 +93,7 @@ class DataObjectConverter(Converter[DataObject, Model], ABC):
 
 
 class DefaultDataObjectConverter(DataObjectConverter):
-
-    def __init__(
-        self,
-        type_models_dict: dict[str, type[Model]]
-    ) -> None:
+    def __init__(self, type_models_dict: dict[str, type[Model]]) -> None:
         """
         `type_models_dict` maps object type to the
         corresponding `type[Model]` class.
@@ -182,40 +107,22 @@ class DefaultDataObjectConverter(DataObjectConverter):
         return model_class(
             **self.__get_id_dict(input_.id, model_class),
             **input_.attributes,
-            **self.__get_relation_dict(
-                model_class,
-                input_._to_one_objects
-            )
+            **self.__get_relation_dict(model_class, input_._to_one_objects),
         )
 
-    def __get_id_dict(
-        self,
-        id_: str,
-        model_class: type[Model]
-    ) -> dict[str, str]:
-
+    def __get_id_dict(self, id_: str, model_class: type[Model]) -> dict[str, str]:
         id_column_name = model_class.get_id_column_name()
         return {id_column_name: id_}
 
     def __get_relation_dict(
-        self,
-        model_class: type[Model],
-        ones: dict[str, DataObject]
+        self, model_class: type[Model], ones: dict[str, DataObject]
     ) -> dict[str, str]:
         # TODO validation - relationship names and their types
 
         return {
-            model_class.get_foreign_key_name(
-                rel_name
-            ): self.__map_to_foreign_key(rel_obj)
+            model_class.get_foreign_key_name(rel_name): self.__map_to_foreign_key(rel_obj)
             for rel_name, rel_obj in ones.items()
         }
 
-    def __map_to_foreign_key(
-        self,
-        rel_obj: DataObject | None
-    ) -> Any | None:
-
-        return (
-            None if rel_obj is None else rel_obj.id
-        )
+    def __map_to_foreign_key(self, rel_obj: DataObject | None) -> Any | None:
+        return None if rel_obj is None else rel_obj.id