Loglan-Core 0.3.0__tar.gz → 0.4.2__tar.gz

{loglan_core-0.3.0 → loglan_core-0.4.2/Loglan_Core.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: Loglan-Core
-Version: 0.3.0
+Version: 0.4.2
 Summary: Loglan Dictionary Database Model for SQLAlchemy
 Home-page: https://github.com/torrua/loglan_core
-Download-URL: https://github.com/torrua/loglan_core/archive/0.3.0.tar.gz
+Download-URL: https://github.com/torrua/loglan_core/archive/0.4.2.tar.gz
 Author: torrua
 Author-email: torrua@gmail.com
 License: MIT

{loglan_core-0.3.0/Loglan_Core.egg-info → loglan_core-0.4.2}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: Loglan-Core
-Version: 0.3.0
+Version: 0.4.2
 Summary: Loglan Dictionary Database Model for SQLAlchemy
 Home-page: https://github.com/torrua/loglan_core
-Download-URL: https://github.com/torrua/loglan_core/archive/0.3.0.tar.gz
+Download-URL: https://github.com/torrua/loglan_core/archive/0.4.2.tar.gz
 Author: torrua
 Author-email: torrua@gmail.com
 License: MIT

loglan_core-0.4.2/loglan_core/addons/base_selector.py

@@ -0,0 +1,268 @@
+"""
+This module provides a base selector for SQLAlchemy
+"""
+
+from __future__ import annotations
+
+from typing import Type, Iterable, Any
+
+from sqlalchemy import select, Select
+from sqlalchemy.orm import Session, selectinload, InstrumentedAttribute
+from typing_extensions import Self
+
+from loglan_core.base import BaseModel
+
+
+class BaseSelector:  # pylint: disable=too-many-ancestors
+    """
+    A custom base selector that inherits from SQLAlchemy's Select class.
+    This class provides methods to execute a session and fetch results
+    in different ways. It also provides a way to fetch many results.
+
+    Methods:
+    --------
+    execute(session: Session) -> ResultProxy:
+        Executes the session and returns the result.
+
+    all(session: Session) -> List[ResultRow]:
+        Executes the session and returns all the results.
+
+    scalar(session: Session) -> Any:
+        Executes the session and returns a scalar result.
+
+    fetchmany(session: Session, size: int | None = None) -> List[ResultRow]:
+        Executes the session and fetches a specified number of results.
+
+    """
+
+    def __init__(
+        self,
+        model: Type[BaseModel],
+        is_sqlite: bool = False,
+        case_sensitive: bool = False,
+        disable_model_check: bool = False,
+    ):
+        """Initializes the Selector.
+
+        Args:
+            model (Type): The SQLAlchemy model class to query.
+            is_sqlite (bool): Flag indicating if the database is SQLite.
+            case_sensitive (bool): Flag indicating if the queries should be case-sensitive.
+            disable_model_check (bool): Flag indicating if the model check should be disabled.
+        """
+        self.disable_model_check = disable_model_check
+        if not self.disable_model_check:
+            self._is_model_accepted(model, BaseModel)
+
+        self.model = model
+        self._statement = select(self.model)
+        self._selected_columns = [self.model]
+
+        self.is_sqlite = is_sqlite
+        self.case_sensitive = case_sensitive
+
+    def execute(self, session: Session):
+        """
+        Executes the given session and returns the result.
+
+        Args:
+            session (Session): SQLAlchemy Session object.
+
+        Returns:
+            ResultProxy: The result of the executed session.
+        """
+        return session.execute(self._statement)
+
+    def all(self, session: Session):
+        """
+        Executes the given session and returns all the results as a list.
+
+        Args:
+            session (Session): SQLAlchemy Session object.
+
+        Returns:
+            List[ResultRow]: All the results of the executed session.
+        """
+        return session.execute(self._statement).scalars().all()
+
+    def scalar(self, session: Session):
+        """
+        Executes the given session and returns a scalar result.
+
+        Args:
+            session (Session): SQLAlchemy Session object.
+
+        Returns:
+            Any: The scalar result of the executed session.
+        """
+        return session.execute(self._statement).scalar()
+
+    def fetchmany(self, session: Session, size: int | None = None):
+        """
+        Executes the given session and fetches a specified number of results.
+
+        Args:
+            session (Session): SQLAlchemy Session object.
+            size (int, optional): Number of results to fetch. If None, fetches all results.
+
+        Returns:
+            List[ResultRow]: The fetched results.
+        """
+        return session.execute(self._statement).scalars().fetchmany(size)
+
+    def select_columns(self, *columns: type[BaseModel]) -> Self:
+        """Specify which columns to select without resetting the filters.
+
+        Args:
+            *columns: The columns to select.
+
+        Returns:
+            Self: The current instance for method chaining.
+        """
+        self._selected_columns = list(columns)
+        existing_conditions = self._statement.whereclause
+
+        if existing_conditions is None:
+            self._statement = select(*self._selected_columns)
+        else:
+            self._statement = select(*self._selected_columns).where(existing_conditions)
+        return self
+
+    def limit(self, limit: int) -> Self:
+        """Limit the number of results returned.
+
+        Args:
+            limit (int): The maximum number of results to return.
+
+        Returns:
+            Self: The current instance for method chaining.
+        """
+        self._statement = self._statement.limit(limit)
+        return self
+
+    def offset(self, offset: int) -> Self:
+        """Set the offset for the results returned.
+
+        Args:
+            offset (int): The number of results to skip before starting to return results.
+
+        Returns:
+            Self: The current instance for method chaining.
+        """
+        self._statement = self._statement.offset(offset)
+        return self
+
+    def order_by(self, *columns) -> Self:
+        """Specify the order in which results should be returned.
+
+        Args:
+            *columns: The columns to order by.
+
+        Returns:
+            Self: The current instance for method chaining.
+        """
+        self._statement = self._statement.order_by(*columns)
+        return self
+
+    def filter(self, *args) -> Self:
+        """Filter results based on arbitrary keyword arguments.
+
+        Args:
+            *args: Column-value pairs to filter by.
+
+        Returns:
+            Self: The current instance for method chaining.
+        """
+
+        self._statement = self._statement.filter(*args)
+
+        return self
+
+    def filter_by(self, **kwargs) -> Self:
+        """Filter results based on arbitrary keyword arguments.
+
+        Args:
+            *kwargs: Column-value pairs to filter by.
+
+        Returns:
+            Self: The current instance for method chaining.
+        """
+
+        self._statement = self._statement.filter_by(**kwargs)
+
+        return self
+
+    def where(self, *args) -> Self:
+        """Filter results based on arbitrary keyword arguments.
+
+        Args:
+            *args: Column-value pairs to filter by.
+
+        Returns:
+            Self: The current instance for method chaining.
+        """
+        self._statement = self._statement.where(*args)
+        return self
+
+    def _generate_column_condition(self, key: str | InstrumentedAttribute, value: Any):
+        column = getattr(self.model, key, None) if isinstance(key, str) else key
+        if column is None:
+            raise AttributeError(f"Model {self.model} has no attribute {key}")
+
+        value = str(value).replace("*", "%")
+        if self.case_sensitive:
+            return column.op("GLOB")(value) if self.is_sqlite else column.like(value)
+        return column.ilike(value)
+
+    def get_statement(self) -> Select:
+        """Get the current SQLAlchemy _statement.
+
+        Returns:
+            Select: The current SQLAlchemy _statement.
+        """
+        return self._statement
+
+    def __call__(self, session: Session):
+        """Execute the current _statement and return the results.
+
+        Args:
+            session (Session): The SQLAlchemy session to use for executing the query.
+
+        Returns:
+            list: The results of the query.
+        """
+        return self.all(session)
+
+    @staticmethod
+    def _is_model_accepted(model, parent: type[BaseModel] = BaseModel):
+        """
+        Checks if the model is an instance of BaseModel or its child.
+        Raises:
+            ValueError: If the model is not an instance of BaseModel or its child.
+        """
+        if not issubclass(model, parent):
+            raise ValueError(
+                f"Provided class_={model} is not a inherited from {parent}"
+            )
+
+    def with_relationships(self, selected: Iterable[str] | None = None) -> Self:
+        """
+        Adds relationships to the query.
+
+        Args:
+            selected (set[str]): A set of relationship names to include.
+            Defaults to None if all relationships should be included.
+
+        Returns:
+            Self: A query with the relationships added.
+        """
+        available_relationships = {
+            attr: getattr(self.model, attr) for attr in self.model.relationships()
+        }
+        relationships = {
+            selectinload(v)
+            for k, v in available_relationships.items()
+            if not selected or k in selected
+        }
+        self._statement = self._statement.options(*relationships)
+        return self

{loglan_core-0.3.0 → loglan_core-0.4.2}/loglan_core/addons/definition_selector.py

@@ -11,9 +11,10 @@ Classes:
 
 from __future__ import annotations
 
-from typing import cast
+from typing import Type
 
 from sqlalchemy import select, true
+from typing_extensions import Self
 
 from loglan_core.addons.base_selector import BaseSelector
 from loglan_core.addons.utils import (
@@ -44,39 +45,36 @@ class DefinitionSelector(BaseSelector):  # pylint: disable=too-many-ancestors
         ValueError: If the provided class_ is not a subclass of BaseDefinition.
 
     Attributes:
-        class_: The class to be used as the returned object.
+        model: The class to be used as the returned object.
         is_sqlite: Boolean specifying if the object is being used with SQLite or not.
     """
 
-    def __init__(self, class_=BaseDefinition, is_sqlite: bool = False):
+    def __init__(
+        self,
+        model: Type[BaseDefinition] = BaseDefinition,
+        is_sqlite: bool = False,
+        case_sensitive: bool = False,
+        disable_model_check: bool = False,
+    ):
         """
-        Initializes the object with the given parameters.
+        Initializes the DefinitionSelector object with the provided parameters.
 
         Args:
-            class_ (Type[BaseDefinition]): The class to be used as the returned object.
-            Must be a subclass of BaseDefinition.
-            is_sqlite (bool): Whether the object is being used with SQLite or not.
+            model (Type[BaseDefinition]): The class to be used as the base key.
+                Must be a subclass of BaseDefinition.
+            is_sqlite (bool): If SQLite is being used. Defaults to False.
+            case_sensitive (bool): If the queries should be case-sensitive.
+            disable_model_check (bool): If the model check is disabled during initialization.
 
         Raises:
-            ValueError: If the provided class_ is not a subclass of BaseDefinition.
-
-        Returns:
-            None
+            ValueError: If the provided model is not a subclass of BaseDefinition.
         """
-        if not issubclass(class_, BaseDefinition):
-            raise ValueError(
-                f"Provided attribute class_={class_} is not a {BaseDefinition} or its child"
-            )
-        super().__init__(class_)
-        self.class_ = class_
-        self.is_sqlite = is_sqlite
 
-    @property
-    def inherit_cache(self):  # pylint: disable=C0116
-        """
-        :return: bool
-        """
-        return True
+        super().__init__(model, is_sqlite, case_sensitive, disable_model_check)
+        if not disable_model_check:
+            self._is_model_accepted(model, BaseDefinition)
+
+        self.model = model
 
     def by_event(self, event_id: int | None = None) -> DefinitionSelector:
         """
@@ -90,20 +88,20 @@ class DefinitionSelector(BaseSelector):  # pylint: disable=too-many-ancestors
             DefinitionSelector: The filtered DefinitionSelector instance.
         """
         subquery = (
-            select(self.class_.id)
+            select(self.model.id)
             .join(t_connect_keys)
             .join(BaseWord)
             .where(filter_word_by_event_id(event_id))
             .scalar_subquery()
         )
-        return cast(DefinitionSelector, self.where(self.class_.id.in_(subquery)))
+        self._statement = self._statement.where(self.model.id.in_(subquery))
+        return self
 
     def by_key(
         self,
         key: BaseKey | str,
         language: str | None = None,
-        case_sensitive: bool = False,
-    ) -> DefinitionSelector:
+    ) -> Self:
         """
         This method filters the definitions by the provided key, language and case sensitivity.
 
@@ -111,22 +109,33 @@ class DefinitionSelector(BaseSelector):  # pylint: disable=too-many-ancestors
             key (BaseKey | str): The key to filter by. Can be an instance of BaseKey or a string.
             language (str | None): The language to filter by.
             If None, no language filtering is applied.
-            case_sensitive (bool): Flag indicating whether filtering should be case sensitive.
 
         Returns:
-            DefinitionSelector: The filtered DefinitionSelector instance with distinct keys.
+            Self: The filtered DefinitionSelector instance with distinct keys.
         """
 
         search_key = key.word if isinstance(key, BaseKey) else str(key)
-        filter_key = filter_key_by_word_cs(search_key, case_sensitive, self.is_sqlite)
+        filter_key = filter_key_by_word_cs(
+            search_key, self.case_sensitive, self.is_sqlite
+        )
         filter_language = filter_key_by_language(
             key.language if isinstance(key, BaseKey) else language
         )
 
-        statement = self.join(self.class_.keys).filter(filter_key, filter_language)
-        return cast(DefinitionSelector, statement.distinct())
+        if hasattr(self.model, "keys"):
+            self._statement = (
+                self._statement.join(self.model.keys)
+                .where(filter_key, filter_language)
+                .distinct()
+            )
+        else:
+            raise AttributeError(
+                f"{self.model.__name__} does not have a 'keys' attribute"
+            )
+
+        return self
 
-    def by_language(self, language: str | None = None) -> DefinitionSelector:
+    def by_language(self, language: str | None = None) -> Self:
         """
         This method filters the definitions by the given language.
 
@@ -135,7 +144,14 @@ class DefinitionSelector(BaseSelector):  # pylint: disable=too-many-ancestors
                                    no language filtering is applied.
 
         Returns:
-            DefinitionSelector: The filtered DefinitionSelector instance.
+            Self: The filtered DefinitionSelector instance.
         """
-        filter_language = self.class_.language == language if language else true()
-        return cast(DefinitionSelector, self.filter(filter_language))
+        if hasattr(self.model, "language"):
+            filter_language = self.model.language == language if language else true()
+        else:
+            raise AttributeError(
+                f"{self.model.__name__} does not have a 'language' attribute"
+            )
+        self._statement = self._statement.where(filter_language)
+
+        return self

{loglan_core-0.3.0 → loglan_core-0.4.2}/loglan_core/addons/key_selector.py

@@ -23,7 +23,7 @@ This allows for flexible and powerful querying of keys in a codebase.
 
 from __future__ import annotations
 
-from typing import cast
+from typing import Type
 
 from sqlalchemy import select
 
@@ -44,38 +44,40 @@ class KeySelector(BaseSelector):  # pylint: disable=too-many-ancestors
     A class used to select keys meeting certain criteria.
 
     Attributes:
-        class_ (Type[BaseKey]): The class to be used as the base key.
+        model (Type[BaseKey]): The class to be used as the base key.
             Must be a subclass of BaseKey.
-        is_sqlite (bool): Indicator if the object is being used with SQLite or not.
+        is_sqlite (bool): If SQLite is being used. Defaults to False.
+        case_sensitive (bool): If the queries should be case-sensitive.
+        disable_model_check (bool): If the model check is disabled during initialization.
     """
 
-    def __init__(self, class_=BaseKey, is_sqlite: bool = False) -> None:
+    def __init__(
+        self,
+        model: Type[BaseKey] = BaseKey,
+        is_sqlite: bool = False,
+        case_sensitive: bool = False,
+        disable_model_check: bool = False,
+    ) -> None:
         """
         Initializes the KeySelector object with the provided parameters.
 
         Args:
-            class_ (Type[BaseKey]): The class to be used as the base key.
+            model (Type[BaseKey]): The class to be used as the base key.
                 Must be a subclass of BaseKey.
-            is_sqlite (bool): Indicator if the object is being used with SQLite or not.
+            is_sqlite (bool): If SQLite is being used. Defaults to False.
+            case_sensitive (bool): If the queries should be case-sensitive.
+            disable_model_check (bool): If the model check is disabled during initialization.
 
         Raises:
-            ValueError: If the provided class_ is not a subclass of BaseKey.
+            ValueError: If the provided model is not a subclass of BaseKey.
         """
-        if not issubclass(class_, BaseKey):
-            raise ValueError(
-                f"Provided attribute class_={class_} is not a {BaseKey} or its child"
-            )
-        super().__init__(class_)
-        self.class_ = class_
-        self.is_sqlite = is_sqlite
-
-    @property
-    def inherit_cache(self):  # pylint: disable=C0116
-        """
-        Returns:
-             bool
-        """
-        return True
+
+        super().__init__(model, is_sqlite, case_sensitive, disable_model_check)
+
+        if not self.disable_model_check:
+            self._is_model_accepted(model, BaseKey)
+
+        self.model = model
 
     def by_event(self, event_id: int | None = None) -> KeySelector:
         """
@@ -90,31 +92,30 @@ class KeySelector(BaseSelector):  # pylint: disable=too-many-ancestors
         """
 
         subquery = (
-            select(self.class_.id)
+            select(self.model.id)
             .join(t_connect_keys)
             .join(BaseDefinition)
             .join(BaseWord)
             .where(filter_word_by_event_id(event_id))
             .scalar_subquery()
         )
-        return cast(KeySelector, self.where(self.class_.id.in_(subquery)))
+        self._statement = self._statement.where(self.model.id.in_(subquery))
+        return self
 
-    def by_key(self, key: str, case_sensitive: bool = False) -> KeySelector:
+    def by_key(self, key: str) -> KeySelector:
         """
         Filters the keys by the given key.
 
         Args:
             key (str): The key to filter by.
-            case_sensitive (bool): Determines whether the key search should be
-                case-sensitive. Defaults to False.
 
         Returns:
             KeySelector: The filtered KeySelector instance.
         """
-        return cast(
-            KeySelector,
-            self.where(filter_key_by_word_cs(key, case_sensitive, self.is_sqlite)),
+        self._statement = self._statement.where(
+            filter_key_by_word_cs(key, self.case_sensitive, self.is_sqlite)
         )
+        return self
 
     def by_language(self, language: str | None = None) -> KeySelector:
         """
@@ -127,7 +128,8 @@ class KeySelector(BaseSelector):  # pylint: disable=too-many-ancestors
         Returns:
             KeySelector: The filtered KeySelector instance.
         """
-        return cast(KeySelector, self.where(filter_key_by_language(language)))
+        self._statement = self._statement.where(filter_key_by_language(language))
+        return self
 
     def by_word_id(self, word_id: int) -> KeySelector:
         """
@@ -143,12 +145,12 @@ class KeySelector(BaseSelector):  # pylint: disable=too-many-ancestors
         will be counted with ```.count()``` but excluded from ```.all()``` request
 
         """
-        return cast(
-            KeySelector,
-            self.distinct()
+        self._statement = (
+            self._statement.distinct()
             .join(t_connect_keys)
             .join(BaseDefinition, BaseDefinition.id == t_connect_keys.c.DID)
             .join(BaseWord, BaseWord.id == BaseDefinition.word_id)
             .filter(BaseWord.id == word_id)
-            .order_by(BaseKey.word.asc()),
+            .order_by(BaseKey.word.asc())
         )
+        return self

{loglan_core-0.3.0 → loglan_core-0.4.2}/loglan_core/addons/word_selector.py

@@ -6,53 +6,20 @@ event, key, type, and name through the WordSelector class.
 
 from __future__ import annotations
 
-from functools import wraps
-from typing import Type, Iterable
+from typing import Type
 
-from sqlalchemy import and_, select, join
-from sqlalchemy.orm import selectinload
+from sqlalchemy import and_, select
 from typing_extensions import Self
 
-from loglan_core.connect_tables import t_connect_words
 from loglan_core.addons.base_selector import BaseSelector
 from loglan_core.addons.definition_selector import DefinitionSelector
 from loglan_core.addons.utils import filter_word_by_event_id
+from loglan_core.connect_tables import t_connect_words
 from loglan_core.key import BaseKey
 from loglan_core.type import BaseType
 from loglan_core.word import BaseWord
 
 
-def order_by_name(function):
-    """
-    A decorator that sorts the output of a function by the `name` attribute of
-    the resulting class instances.
-
-    Args:
-        function (callable): The function whose result is to be sorted.
-
-    Returns:
-        callable: A function that will execute the input function and sort its result.
-    """
-
-    @wraps(function)
-    def wrapper(*args, **kwargs):
-        """
-        Wrapper function that applies the sorting logic to the result of the decorated function.
-
-        Args:
-            *args: Positional arguments to be passed to the decorated function.
-            **kwargs: Keyword arguments to be passed to the decorated function.
-
-        Returns:
-            The sorted result of the decorated function.
-
-        """
-        result = function(*args, **kwargs)
-        return result.order_by(result.class_.name)
-
-    return wrapper
-
-
 class WordSelector(BaseSelector):  # pylint: disable=too-many-ancestors
     """
     Class to extract words from a database based on various criteria.
@@ -60,44 +27,39 @@ class WordSelector(BaseSelector):  # pylint: disable=too-many-ancestors
     Extends the SQLAlchemy Select class to provide additional functionality.
     """
 
-    def __init__(self, class_: Type[BaseWord] = BaseWord, is_sqlite: bool = False):
+    def __init__(
+        self,
+        model: Type[BaseWord] = BaseWord,
+        is_sqlite: bool = False,
+        case_sensitive: bool = False,
+        disable_model_check: bool = False,
+    ):
         """
-        Initialize a WordSelector instance.
+        Initializes the WordSelector object with the provided parameters.
 
         Args:
-            class_ (BaseWord): The class to select from. Defaults to BaseWord.
+            model (Type[BaseWord]): The class to be used as the base key.
+                Must be a subclass of BaseWord.
             is_sqlite (bool): If SQLite is being used. Defaults to False.
-        """
-        if not issubclass(class_, BaseWord):
-            raise ValueError(
-                f"Provided attribute class_={class_} is not a {BaseWord} or its child"
-            )
-        super().__init__(class_)
-        self.class_ = class_
-        self.is_sqlite = is_sqlite
+            case_sensitive (bool): If the queries should be case-sensitive.
+            disable_model_check (bool): If the model check is disabled during initialization.
 
-    def with_relationships(self, selected: Iterable[str] | None = None) -> Self:
+        Raises:
+            ValueError: If the provided model is not a subclass of BaseWord.
         """
-        Adds relationships to the query.
 
-        Args:
-            selected (set[str]): A set of relationship names to include.
-            Defaults to None if all relationships should be included.
+        super().__init__(
+            model=model,
+            is_sqlite=is_sqlite,
+            case_sensitive=case_sensitive,
+            disable_model_check=disable_model_check,
+        )
+
+        if not self.disable_model_check:
+            self._is_model_accepted(model, BaseWord)
+
+        self.model = model
 
-        Returns:
-            Self: A query with the relationships added.
-        """
-        available_relationships = {
-            attr: getattr(self.class_, attr) for attr in self.class_.relationships()
-        }
-        relationships = {
-            selectinload(v)
-            for k, v in available_relationships.items()
-            if not selected or k in selected
-        }
-        return self.options(*relationships)
-
-    @order_by_name
     def by_event(self, event_id: int | None = None) -> Self:
         """
         Applies a filter to select words associated with a specific event.
@@ -108,65 +70,36 @@ class WordSelector(BaseSelector):  # pylint: disable=too-many-ancestors
         Returns:
             Self: A query with the filter applied.
         """
-        return self.where(filter_word_by_event_id(event_id))
-
-    @order_by_name
-    def by_attributes(
-        self,
-        case_sensitive: bool = False,
-        **kwargs,
-    ) -> Self:
-        """
-        Selects all words by a set of attributes.
-
-        Args:
-            case_sensitive (bool): Whether the search should be case-sensitive.
-                Defaults to False.
-            **kwargs: A set of attributes to filter by.
+        self._statement = self._statement.where(filter_word_by_event_id(event_id))
+        return self
 
-        Returns:
-            Self: A query with the filter applied.
-        """
-        # pylint: disable=no-member
-        return (
-            super()  # type:ignore
-            .__get__(self, type(self))
-            .by_attrs(
-                class_=self.class_,
-                is_sqlite=self.is_sqlite,
-                case_sensitive=case_sensitive,
-                **kwargs,
-            )
-        )
-
-    @order_by_name
     def by_name(
         self,
         name: str,
-        case_sensitive: bool = False,
     ) -> Self:
         """
         Applies a filter to select words by a specific name.
 
         Args:
             name (str): The name to filter by.
-            case_sensitive (bool): Whether the search should be case-sensitive.
             Defaults to False.
         Returns:
             Self: A query with the filter applied.
         """
+        if hasattr(self.model, "name"):
+            condition = self._generate_column_condition(self.model.name, name)
+        else:
+            raise AttributeError(
+                f"{self.model.__name__} does not have a 'name' attribute"
+            )
 
-        return self.by_attributes(
-            case_sensitive=case_sensitive,
-            name=name,
-        )
+        self._statement = self._statement.where(condition)
+        return self
 
-    @order_by_name
     def by_key(
         self,
         key: BaseKey | str,
         language: str | None = None,
-        case_sensitive: bool = False,
     ) -> Self:
         """
         Applies a filter to select words by a specific key.
@@ -175,22 +108,23 @@ class WordSelector(BaseSelector):  # pylint: disable=too-many-ancestors
             key (BaseKey | str): The key to filter by.
             It can either be an instance of BaseKey or a string.
             language (str | None): The language of the key. Defaults to None.
-            case_sensitive (bool): Whether the search should be case-sensitive.
                 Defaults to False.
 
         Returns:
             Self: A query with the filter applied.
         """
 
-        definition_query = DefinitionSelector(is_sqlite=self.is_sqlite).by_key(
+        definition_query = DefinitionSelector(
+            is_sqlite=self.is_sqlite,
+            case_sensitive=self.case_sensitive,
+        ).by_key(
             key=key,
             language=language,
-            case_sensitive=case_sensitive,
         )
-        subquery = select(definition_query.subquery().c.word_id)
-        return self.where(self.class_.id.in_(subquery))
+        subquery = select(definition_query.get_statement().subquery().c.word_id)
+        self._statement = self._statement.where(self.model.id.in_(subquery))
+        return self
 
-    @order_by_name
     def by_type(
         self,
         type_: BaseType | str | None = None,
@@ -215,7 +149,10 @@ class WordSelector(BaseSelector):  # pylint: disable=too-many-ancestors
             Self: A query with the filter applied.
         """
         if isinstance(type_, BaseType):
-            return self.join(BaseType).where(BaseType.id == type_.id)
+            self._statement = self._statement.join(BaseType).where(
+                BaseType.id == type_.id
+            )
+            return self
 
         type_values = (
             (BaseType.type_, type_),
@@ -227,11 +164,13 @@ class WordSelector(BaseSelector):  # pylint: disable=too-many-ancestors
             i[0].ilike(str(i[1]).replace("*", "%")) for i in type_values if i[1]
         ]
 
-        return (
-            self if not type_filters else self.join(BaseType).where(and_(*type_filters))
-        )
+        if not type_filters:
+            self._statement = self._statement
+            return self
+
+        self._statement = self._statement.join(BaseType).where(and_(*type_filters))
+        return self
 
-    @order_by_name
     def get_derivatives_of(self, word_id: int) -> Self:
         """
         Selects all words that are derived from the given word.
@@ -243,21 +182,15 @@ class WordSelector(BaseSelector):  # pylint: disable=too-many-ancestors
             Self: A query with the filter applied.
         """
 
-        derivative_ids_subquery = (
-            select(self.class_.id)
-            .select_from(
-                join(
-                    t_connect_words,
-                    self.class_,
-                    t_connect_words.c.child_id == self.class_.id,
-                )
-            )
-            .where(t_connect_words.c.parent_id == word_id)
+        derivative_ids_subquery = select(t_connect_words.c.child_id).where(
+            t_connect_words.c.parent_id == word_id
         )
 
-        return self.where(self.class_.id.in_(derivative_ids_subquery))
+        self._statement = self._statement.where(
+            self.model.id.in_(derivative_ids_subquery)
+        )
+        return self
 
-    @order_by_name
     def get_affixes_of(self, word_id: int) -> Self:
         """
         Selects all affixes that are derived from the given word.
@@ -270,7 +203,6 @@ class WordSelector(BaseSelector):  # pylint: disable=too-many-ancestors
         """
         return self.get_derivatives_of(word_id).by_type(type_x="Affix")
 
-    @order_by_name
     def get_complexes_of(self, word_id: int) -> Self:
         """
         Selects all complexes that are derived from the given word.
@@ -282,7 +214,3 @@ class WordSelector(BaseSelector):  # pylint: disable=too-many-ancestors
             Self: A query with the filter applied.
         """
         return self.get_derivatives_of(word_id).by_type(group="Cpx")
-
-    @property
-    def inherit_cache(self):  # pylint: disable=missing-function-docstring
-        return True

{loglan_core-0.3.0 → loglan_core-0.4.2}/loglan_core/base.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 from datetime import datetime
 
 from sqlalchemy import String, inspect, func, select
+from sqlalchemy.ext.hybrid import hybrid_property
 from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
 from sqlalchemy.orm import Session, registry as rg
 from typing_extensions import Annotated
@@ -137,15 +138,19 @@ class BaseModel(DeclarativeBase):
         )
         return f"{self.__class__.__name__}({obj_str})"
 
-    @staticmethod
-    def _filter_add_to_repr(k, v):
+    @classmethod
+    def _filter_add_to_repr(cls, k, v):
         """
         Static method that filters out keys that start with "_" and keys
         that are "created" or "updated" and keys without values from the
         object's attributes. The method is used to generate a string
         representation of the object. It is used internally by the __repr__.
         """
-        return not k.startswith("_") and k not in ["created", "updated"] and v
+        return (
+            not k.startswith("_")
+            and k not in ["created", "updated", *cls.relationships()]
+            and v
+        )
 
     @classmethod
     def get_by_id(cls, session: Session, cid: int):
@@ -205,7 +210,7 @@ class BaseModel(DeclarativeBase):
         Returns:
             set[str]: A set of strings with names of all attribute keys.
         """
-        return set(cls.__mapper__.attrs.keys())
+        return set(cls.__mapper__.attrs.keys()) | cls.hybrid_properties()
 
     @classmethod
     def attributes_basic(cls) -> set[str]:
@@ -218,7 +223,7 @@ class BaseModel(DeclarativeBase):
         Returns:
             set[str]: A set of strings with names of basic attributes.
         """
-        return set(cls.attributes_all() - cls.relationships())
+        return set(cls.attributes_all() - cls.relationships() - cls.hybrid_properties())
 
     @classmethod
     def attributes_extended(cls) -> set[str]:
@@ -258,7 +263,12 @@ class BaseModel(DeclarativeBase):
         Returns:
             set[str]: A set of strings with names of the foreign keys.
         """
-        return set(cls.attributes_all() - cls.relationships() - cls.non_foreign_keys())
+        return set(
+            cls.attributes_all()
+            - cls.relationships()
+            - cls.non_foreign_keys()
+            - cls.hybrid_properties()
+        )
 
     @classmethod
     def non_foreign_keys(cls) -> set[str]:
@@ -278,3 +288,16 @@ class BaseModel(DeclarativeBase):
             column.name for column in columns if not column.foreign_keys
         }
         return non_foreign_keys
+
+    @classmethod
+    def hybrid_properties(cls) -> set[str]:
+        """
+        Class method that computes the hybrid properties of the class.
+
+        It doesn’t require any parameters as it operates on the class itself.
+
+        Returns:
+            set[str]: A set of strings with names of the hybrid properties.
+        """
+        inspector = inspect(cls).all_orm_descriptors
+        return {i.__name__ for i in inspector if isinstance(i, hybrid_property)}

{loglan_core-0.3.0 → loglan_core-0.4.2}/loglan_core/word.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 import datetime
 
 from sqlalchemy import ForeignKey, JSON
+from sqlalchemy.ext.hybrid import hybrid_property
 from sqlalchemy.orm import mapped_column, Mapped
 from sqlalchemy.orm import relationship
 
@@ -104,6 +105,7 @@ class BaseWord(BaseModel):
     type: Mapped[BaseType] = relationship(
         foreign_keys=[type_id],
         back_populates="words",
+        lazy="joined",  # required for proper loading affixes and complexes
     )
 
     event_start_id: Mapped[int] = mapped_column(
@@ -153,3 +155,28 @@ class BaseWord(BaseModel):
         secondaryjoin=(t_connect_words.c.parent_id == id),
         back_populates="derivatives",
     )
+
+    @hybrid_property
+    def affixes(self) -> list[BaseWord]:
+        """
+        Hybrid property that returns a list of affixes that are derived from the word.
+
+        This property is a hybrid of a Python property and a SQLAlchemy expression.
+        It can be used as a property in Python code or as a column in a SQLAlchemy query.
+
+        Returns:
+            list[BaseWord]: A list of affixes that are derived from the word.
+        """
+        return [child for child in self.derivatives if child.type.type_x == "Affix"]
+
+    @hybrid_property
+    def complexes(self) -> list[BaseWord]:
+        """Hybrid property that returns a list of complexes derived from the word.
+
+        This property is a hybrid of a Python property and a SQLAlchemy expression.
+        It can be used as a property in Python code or as a column in a SQLAlchemy query.
+
+        Returns:
+            list[BaseWord]: A list of complexes derived from the word.
+        """
+        return [child for child in self.derivatives if child.type.group == "Cpx"]

{loglan_core-0.3.0 → loglan_core-0.4.2}/setup.py

@@ -4,7 +4,7 @@ from io import open
 
 from setuptools import setup
 
-CURRENT_VERSION = "0.3.0"
+CURRENT_VERSION = "0.4.2"
 
 
 def read(filename):  # pylint: disable=C0116

loglan_core-0.3.0/loglan_core/addons/base_selector.py

@@ -1,202 +0,0 @@
-"""
-This module provides a base selector for SQLAlchemy
-"""
-
-from __future__ import annotations
-
-from typing import Any, Type
-from typing_extensions import Self
-
-from sqlalchemy import Select, BinaryExpression
-from sqlalchemy.orm import Session, InstrumentedAttribute
-
-from loglan_core.base import BaseModel
-
-
-class BaseSelector(Select):  # pylint: disable=too-many-ancestors
-    """
-    A custom base selector that inherits from SQLAlchemy's Select class.
-    This class provides methods to execute a session and fetch results
-    in different ways. It also provides a way to fetch many results.
-
-    Methods:
-    --------
-    execute(session: Session) -> ResultProxy:
-        Executes the session and returns the result.
-
-    all(session: Session) -> List[ResultRow]:
-        Executes the session and returns all the results.
-
-    scalar(session: Session) -> Any:
-        Executes the session and returns a scalar result.
-
-    fetchmany(session: Session, size: int | None = None) -> List[ResultRow]:
-        Executes the session and fetches a specified number of results.
-
-    condition_by_attribute(
-        class_: Type[BaseModel],
-        attr: InstrumentedAttribute | str,
-        value: Any,
-        is_sqlite: bool = False,
-        case_sensitive: bool = False,
-    ) -> BinaryExpression:
-        Creates a filter to select items by a specific attribute value.
-        Support wildcard and case-sensitive search.
-    """
-
-    def execute(self, session: Session):
-        """
-        Executes the given session and returns the result.
-
-        Args:
-        session (Session): SQLAlchemy Session object.
-
-        Returns:
-        ResultProxy: The result of the executed session.
-        """
-        return session.execute(self)
-
-    def all(self, session: Session):
-        """
-        Executes the given session and returns all the results as a list.
-
-        Args:
-        session (Session): SQLAlchemy Session object.
-
-        Returns:
-        List[ResultRow]: All the results of the executed session.
-        """
-        return self.execute(session).scalars().all()
-
-    def scalar(self, session: Session):
-        """
-        Executes the given session and returns a scalar result.
-
-        Args:
-        session (Session): SQLAlchemy Session object.
-
-        Returns:
-        Any: The scalar result of the executed session.
-        """
-        return self.execute(session).scalar()
-
-    def fetchmany(self, session: Session, size: int | None = None):
-        """
-        Executes the given session and fetches a specified number of results.
-
-        Args:
-        session (Session): SQLAlchemy Session object.
-        size (int, optional): Number of results to fetch. If None, fetches all results.
-
-        Returns:
-        List[ResultRow]: The fetched results.
-        """
-        return self.execute(session).scalars().fetchmany(size)
-
-    @classmethod
-    def condition_by_attribute(
-        cls,
-        class_: Type[BaseModel],
-        attr: InstrumentedAttribute | str,
-        value: Any,
-        is_sqlite: bool = False,
-        case_sensitive: bool = False,
-    ) -> BinaryExpression:
-        """
-        Applies a filter to select words by a specific attribute value.
-
-        Args:
-            class_ (BaseModel): The class to select from.
-            attr (str): The attribute to filter by.
-            value (Any): The value of the attribute to filter by.
-            is_sqlite (bool): If SQLite is being used. Defaults to False.
-            case_sensitive (bool): Whether the search should be case-sensitive.
-                Defaults to False.
-        Returns:
-            BaseSelector: A query with the filter applied.
-        """
-
-        cls._is_class_acceptable(class_)
-        attr = cls._get_attr(class_, attr)
-
-        value = str(value).replace("*", "%")
-
-        if case_sensitive:
-            return attr.op("GLOB")(value) if is_sqlite else attr.like(value)
-        return attr.ilike(value)
-
-    @staticmethod
-    def _get_attr(
-        class_: Type[BaseModel],
-        attr: InstrumentedAttribute | str,
-    ) -> InstrumentedAttribute:
-        """
-        Gets the attribute from the class.
-
-        Args:
-            class_ (BaseModel): The class to get the attribute from.
-            attr (str | InstrumentedAttribute): The attribute to get.
-
-        Raises:
-            AttributeError: If the attribute is not found in the class.
-
-        Returns:
-            InstrumentedAttribute: The attribute from the class.
-        """
-        if isinstance(attr, str):
-            try:
-                return getattr(class_, attr)
-            except AttributeError as exc:
-                raise AttributeError(
-                    f"Provided attribute={attr} is not an attribute of {class_}"
-                ) from exc
-        return attr
-
-    @staticmethod
-    def _is_class_acceptable(class_: Type[BaseModel]):
-        """
-        Checks if the class is an instance of BaseModel or its child.
-
-        Args:
-            class_ (Type[BaseModel]): The class to check.
-
-        Raises:
-            ValueError: If the class is not an instance of BaseModel or its child.
-        """
-        if not issubclass(class_, BaseModel):
-            raise ValueError(
-                f"Provided class_={class_} is not a {BaseModel} or its child"
-            )
-
-    def by_attrs(
-        self,
-        class_: Type[BaseModel],
-        is_sqlite: bool = False,
-        case_sensitive: bool = False,
-        **kwargs,
-    ) -> Self:
-        """
-        Selects all words by a set of attributes.
-
-        Args:
-            class_ (Type[BaseModel]): The class to select from.
-            is_sqlite (bool): If SQLite is being used. Defaults to False.
-            case_sensitive (bool): Whether the search should be case-sensitive.
-                Defaults to False.
-            **kwargs: A set of attributes to filter by.
-
-        Returns:
-            BaseSelector: A query with the filter applied.
-        """
-        return self.where(
-            *{
-                self.condition_by_attribute(
-                    class_,
-                    k,
-                    v,
-                    is_sqlite=is_sqlite,
-                    case_sensitive=case_sensitive,
-                )
-                for k, v in kwargs.items()
-            }
-        )