ormlambda 1.5.0__py3-none-any.whl → 2.0.2__py3-none-any.whl

ormlambda/__init__.py

@@ -1,4 +1,11 @@
-from .model_base import BaseModel  # noqa: F401
+# enums
+from .common.enums import (  # noqa: F401
+    JoinType,
+    ConditionType,
+)
+
+from .common.abstract_classes import AbstractSQLStatements  # noqa: F401
+from .common.interfaces import IRepositoryBase  # noqa: F401
 from .utils import Table, Column, ForeignKey  # noqa: F401
 from .utils.lambda_disassembler import Disassembler, nameof  # noqa: F401
-from .common.interfaces import IRepositoryBase  # noqa: F401
+from .model_base import BaseModel  # noqa: F401  # COMMENT: to avoid relative import we need to import BaseModel after import Table,Column, ForeignKey, IRepositoryBase and Disassembler

ormlambda/common/__init__.py

@@ -1,2 +1 @@
 
-

ormlambda/common/abstract_classes/__init__.py

@@ -1,3 +1,3 @@
 from .non_query_base import NonQueryBase  # noqa: F401
 from .abstract_model import AbstractSQLStatements  # noqa: F401
-from .query_base import QueryBase  # noqa: F401
+from .query_base import QueryBase  # noqa: F401

ormlambda/common/abstract_classes/abstract_model.py

@@ -1,31 +1,14 @@
-from typing import Any, Callable, Optional, Type, override, Iterable, Literal
-from enum import Enum
+from __future__ import annotations
+from typing import Any, Type, override, Iterable, Literal, TYPE_CHECKING
 from collections import defaultdict
-from abc import abstractmethod
-import inspect
 
-from ...utils import ForeignKey, Table
 
-from ..interfaces import IQuery, IRepositoryBase, IStatements_two_generic
-from ..interfaces.IStatements import OrderType
+from ormlambda.utils import Table
+from ormlambda.common.interfaces import IQuery, IRepositoryBase, IStatements_two_generic
 
-from ...components.update import UpdateQueryBase
-from ...components.select import ISelect
-from ...components.delete import DeleteQueryBase
-from ...components.upsert import UpsertQueryBase
-from ...components.select import TableColumn
-from ...components.insert import InsertQueryBase
-from ...components.where.abstract_where import AbstractWhere
-
-
-class JoinType(Enum):
-    RIGHT_INCLUSIVE = "RIGHT JOIN"
-    LEFT_INCLUSIVE = "LEFT JOIN"
-    RIGHT_EXCLUSIVE = "RIGHT JOIN"
-    LEFT_EXCLUSIVE = "LEFT JOIN"
-    FULL_OUTER_INCLUSIVE = "RIGHT JOIN"
-    FULL_OUTER_EXCLUSIVE = "RIGHT JOIN"
-    INNER_JOIN = "INNER JOIN"
+if TYPE_CHECKING:
+    from ormlambda.components.select import ISelect
+    from ormlambda.components.select import TableColumn
 
 
 ORDER_QUERIES = Literal["select", "join", "where", "order", "with", "group by", "limit", "offset"]
@@ -36,7 +19,7 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
     __order__: tuple[str, ...] = ("select", "join", "where", "order", "with", "group by", "limit", "offset")
 
     def __init__(self, model: T, repository: IRepositoryBase[TRepo]) -> None:
-        self.valid_repository(repository)
+        self.__valid_repository(repository)
 
         self._model: T = model
         self._repository: IRepositoryBase[TRepo] = repository
@@ -48,149 +31,17 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
             raise Exception(f"'{model}' class does not inherit from Table class")
 
     @staticmethod
-    def valid_repository(repository: Any) -> bool:
+    def __valid_repository(repository: Any) -> bool:
         if not isinstance(repository, IRepositoryBase):
             raise ValueError(f"'repository' attribute does not instance of '{IRepositoryBase.__name__}'")
         return True
 
-    @property
-    @abstractmethod
-    def INSERT_QUERY(self) -> Type[InsertQueryBase[T, TRepo]]: ...
-    @property
-    @abstractmethod
-    def UPSERT_QUERY(self) -> Type[UpsertQueryBase[T, TRepo]]: ...
-    @property
-    @abstractmethod
-    def UPDATE_QUERY(self) -> Type[UpdateQueryBase[T, TRepo]]: ...
-    @property
-    @abstractmethod
-    def DELETE_QUERY(self) -> Type[DeleteQueryBase[T, TRepo]]: ...
-    @property
-    @abstractmethod
-    def LIMIT_QUERY(self) -> Type[IQuery]: ...
-    @property
-    @abstractmethod
-    def OFFSET_QUERY(self) -> Type[IQuery]: ...
-    @property
-    @abstractmethod
-    def JOIN_QUERY(self) -> Type[IQuery]: ...
-    @property
-    @abstractmethod
-    def WHERE_QUERY(self) -> Type[IQuery]: ...
-    @property
-    @abstractmethod
-    def ORDER_QUERY(self) -> Type[IQuery]: ...
-    @property
-    @abstractmethod
-    def SELECT_QUERY(self) -> Type[ISelect]: ...
-
-    @override
-    def create_table(self) -> None:
-        if not self._repository.table_exists(self._model.__table_name__):
-            self._repository.execute(self._model.create_table_query())
-        return None
-
-    @override
-    def table_exists(self) -> bool:
-        return self._repository.table_exists(self._model.__table_name__)
-
-    @override
-    def insert(self, instances: T | list[T]) -> None:
-        insert = self.INSERT_QUERY(self._model, self._repository)
-        insert.insert(instances)
-        insert.execute()
-        self._query_list.clear()
-        return None
-
-    @override
-    def delete(self, instances: Optional[T | list[T]] = None) -> None:
-        if instances is None:
-            response = self.select()
-            if len(response) == 0:
-                return None
-            # [0] because if we do not select anything, we retrieve all columns of the unic model, stored in tuple[tuple[model]] structure.
-            # We always going to have a tuple of one element
-            return self.delete(response)
-
-        delete = self.DELETE_QUERY(self._model, self._repository)
-        delete.delete(instances)
-        delete.execute()
-        # not necessary to call self._query_list.clear() because select() method already call it
-        return None
-
-    @override
-    def upsert(self, instances: T | list[T]) -> None:
-        upsert = self.UPSERT_QUERY(self._model, self._repository)
-        upsert.upsert(instances)
-        upsert.execute()
-        self._query_list.clear()
-        return None
-
-    @override
-    def update(self, dicc: dict[str, Any] | list[dict[str, Any]]) -> None:
-        update = self.UPDATE_QUERY(self._model, self._repository, self._query_list["where"])
-        update.update(dicc)
-        update.execute()
-        self._query_list.clear()
-        return None
-
-    @override
-    def limit(self, number: int) -> "IStatements_two_generic[T,TRepo]":
-        limit = self.LIMIT_QUERY(number)
-        # Only can be one LIMIT SQL parameter. We only use the last LimitQuery
-        limit_list = self._query_list["limit"]
-        if len(limit_list) > 0:
-            self._query_list["limit"] = [limit]
-        else:
-            self._query_list["limit"].append(limit)
-        return self
-
-    @override
-    def offset(self, number: int) -> "IStatements_two_generic[T,TRepo]":
-        offset = self.OFFSET_QUERY(number)
-        self._query_list["offset"].append(offset)
-        return self
-
-    @override
-    def join(self, table_left: Table, table_right: Table, *, by: str) -> "IStatements_two_generic[T,TRepo]":
-        where = ForeignKey.MAPPED[table_left][table_right]
-        join_query = self.JOIN_QUERY[table_left, Table](table_left, table_right, JoinType(by), where=where)
-        self._query_list["join"].append(join_query)
-        return self
-
-    @override
-    def where(self, lambda_: Callable[[T], bool] = lambda: None, **kwargs) -> "IStatements_two_generic[T,TRepo]":
-        # FIXME [x]: I've wrapped self._model into tuple to pass it instance attr. Idk if it's correct
-        where_query = self.WHERE_QUERY[T](function=lambda_, instances=(self._model,), **kwargs)
-        self._query_list["where"].append(where_query)
-        return self
-
-    @override
-    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> "IStatements_two_generic[T,TRepo]":
-        order = self.ORDER_QUERY[T](self._model, _lambda_col, order_type)
-        self._query_list["order"].append(order)
-        return self
+    def __repr__(self):
+        return f"<Model: {self.__class__.__name__}>"
 
+    @property
     @override
-    def select[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Optional[Type[TFlavour]] = None, by: JoinType = JoinType.INNER_JOIN):
-        if len(inspect.signature(selector).parameters) == 0:
-            # COMMENT: if we do not specify any lambda function we assumed the user want to retreive only elements of the Model itself avoiding other models
-            result = self.select(selector=lambda x: (x,), flavour=flavour, by=by)
-            # COMMENT: Always we want to retrieve tuple[tuple[Any]]. That's the reason to return result[0] when we ensure the user want only objects of the first table.
-            # Otherwise, we wil return the result itself
-            if flavour:
-                return result
-            return () if not result else result[0]
-        select: ISelect = self.SELECT_QUERY(self._model, select_lambda=selector, by=by)
-        self._query_list["select"].append(select)
-
-        query: str = self.build()
-        if flavour:
-            result = self._return_flavour(query, flavour)
-            if issubclass(flavour, tuple) and isinstance(selector(self._model), property):
-                return tuple([x[0] for x in result])
-            return result
-        return self._return_model(select, query)
+    def repository(self) -> IRepositoryBase[TRepo]: ...
 
     def _return_flavour[TValue](self, query, flavour: Type[TValue]) -> tuple[TValue]:
         return self._repository.read_sql(query, flavour=flavour)
@@ -203,72 +54,6 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
 
         return response_sql
 
-    @override
-    def select_one[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Optional[Type[TFlavour]] = None, by: JoinType = JoinType.INNER_JOIN):
-        self.limit(1)
-        if len(inspect.signature(selector).parameters) == 0:
-            response = self.select(selector=lambda x: (x,), flavour=flavour, by=by)
-        else:
-            response = self.select(selector=selector, flavour=flavour, by=by)
-
-        if flavour:
-            return response[0]
-
-        # response var could be return more than one element when we work with models an we
-        # select columns from different tables using a join query
-        if len(response) == 1 and len(response[0]) == 1:
-            return response[0][0]
-        return tuple([res[0] for res in response])
-
-    @override
-    def build(self) -> str:
-        query: str = ""
-
-        self._create_necessary_inner_join()
-        for x in self.__order__:
-            if sub_query := self._query_list.get(x, None):
-                if isinstance(sub_query[0], self.WHERE_QUERY):
-                    query_ = self.__build_where_clause(sub_query)
-
-                # we must check if any join already exists on query string
-                elif isinstance(sub_query[0], self.JOIN_QUERY):
-                    select_query: str = self._query_list["select"][0].query
-                    query_ = ""
-                    for join in sub_query:
-                        if join.query not in select_query:
-                            query_ += f"\n{join.query}"
-                else:
-                    query_ = "\n".join([x.query for x in sub_query])
-
-                query += f"\n{query_}" if query != "" else query_
-        self._query_list.clear()
-        return query
-
-    def __build_where_clause(self, where_condition: list[AbstractWhere]) -> str:
-        query: str = where_condition[0].query
-
-        for where in where_condition[1:]:
-            q = where.query.replace(where.WHERE, "AND")
-            and_, clause = q.split(" ", maxsplit=1)
-            query += f" {and_} ({clause})"
-        return query
-
-    def _create_necessary_inner_join(self) -> None:
-        # When we applied filters in any table that we wont select any column, we need to add manually all neccessary joins to achieve positive result.
-        if "where" not in self._query_list:
-            return None
-
-        where: AbstractWhere = self._query_list["where"][0]
-        involved_tables = where.get_involved_tables()
-
-        select: ISelect = self._query_list["select"][0]
-        if not involved_tables or (set(involved_tables) == set(select.tables_heritage)):
-            return None
-
-        for l_tbl, r_tbl in involved_tables:
-            # FIXME [ ]: Checked what function was called by the self.join method before the change
-            self.join(l_tbl, r_tbl, by="INNER JOIN")
-
 
 class ClusterQuery:
     def __init__(self, select: ISelect, response_sql: tuple[dict[str, Any]]) -> None:

ormlambda/common/abstract_classes/non_query_base.py

@@ -1,13 +1,15 @@
+from __future__ import annotations
 from abc import abstractmethod
-from typing import Any, Optional, override
+from typing import Any, Optional, Type, override, TYPE_CHECKING
 
-from ..interfaces.INonQueryCommand import INonQueryCommand
+from ormlambda.common.interfaces.INonQueryCommand import INonQueryCommand
 
-from ..interfaces import IRepositoryBase
-from ...utils import Table
+if TYPE_CHECKING:
+    from ormlambda import IRepositoryBase
+    from ormlambda import Table
 
 
-class NonQueryBase[T: Table, TRepo: IRepositoryBase](INonQueryCommand):
+class NonQueryBase[T: Type[Table], TRepo: IRepositoryBase](INonQueryCommand):
     __slots__: tuple[str, ...] = ("_model", "_repository", "_values", "_query")
 
     def __init__(self, model: T, repository: TRepo) -> None:

ormlambda/common/abstract_classes/query_base.py

@@ -1,7 +1,10 @@
 from abc import abstractmethod
+from typing import TYPE_CHECKING
 
-from ...utils import Table
-from ..interfaces import IQuery
+from ormlambda.common.interfaces import IQuery
+
+if TYPE_CHECKING:
+    from ormlambda import Table
 
 
 class QueryBase[T: Table](IQuery):

ormlambda/common/enums/__init__.py

@@ -1,2 +1,2 @@
 from .join_type import JoinType  # noqa: F401
-from .condition_types import ConditionType  # noqa: F401
+from .condition_types import ConditionType  # noqa: F401

ormlambda/common/enums/join_type.py

@@ -1,5 +1,6 @@
 from enum import Enum
 
+
 class JoinType(Enum):
     RIGHT_INCLUSIVE = "RIGHT JOIN"
     LEFT_INCLUSIVE = "LEFT JOIN"
@@ -7,4 +8,4 @@ class JoinType(Enum):
     LEFT_EXCLUSIVE = "LEFT JOIN"
     FULL_OUTER_INCLUSIVE = "RIGHT JOIN"
     FULL_OUTER_EXCLUSIVE = "RIGHT JOIN"
-    INNER_JOIN = "INNER JOIN"
+    INNER_JOIN = "INNER JOIN"

ormlambda/common/interfaces/IQueryCommand.py

@@ -2,7 +2,8 @@ from abc import abstractmethod, ABC
 
 
 class IQuery(ABC):
-    """ Interface to queries that retrieve any element such as select, limit, offset, where, group by, etc..."""
+    """Interface to queries that retrieve any element such as select, limit, offset, where, group by, etc..."""
+
     @property
     @abstractmethod
     def query(self) -> str: ...

ormlambda/common/interfaces/IRepositoryBase.py

@@ -1,23 +1,10 @@
 from abc import ABC, abstractmethod
-import functools
-from typing import Any, Callable, Literal, Optional, Type
+from typing import Any, Literal, Optional, Type
 
 TypeExists = Literal["fail", "replace", "append"]
 
 
 class IRepositoryBase[T](ABC):
-    def check_connection(func: Callable[..., Any]):
-        @functools.wraps(func)
-        def wrapper(self: "IRepositoryBase[T]", *args, **kwargs):
-            if not self.is_connected():
-                self.connect()
-
-            foo = func(self, *args, **kwargs)
-            self.close_connection()
-            return foo
-
-        return wrapper
-
     def __repr__(self) -> str:
         return f"{IRepositoryBase.__name__}: {self.__class__.__name__}"
 
@@ -25,7 +12,7 @@ class IRepositoryBase[T](ABC):
     def is_connected(self) -> bool: ...
 
     @abstractmethod
-    def connect(self, **kwargs: Any) -> "IRepositoryBase[T]": ...
+    def connect(self, **kwargs: Any) -> None: ...
 
     @abstractmethod
     def close_connection(self) -> None: ...
@@ -61,7 +48,6 @@ class IRepositoryBase[T](ABC):
     @abstractmethod
     def connection(self) -> T: ...
 
+    @property
     @abstractmethod
-    def set_config(self, value: dict[str, Any]) -> dict[str, Any]:
-        """Method to update database config"""
-        ...
+    def database(self) -> Optional[str]: ...

ormlambda/common/interfaces/IStatements.py

@@ -1,17 +1,23 @@
-from typing import Any, Callable, Iterable, Optional, Literal, Type, overload
+from __future__ import annotations
+from typing import Any, Callable, Iterable, Optional, Literal, Type, overload, TYPE_CHECKING
 from enum import Enum
 from abc import abstractmethod, ABC
 
 from .IRepositoryBase import IRepositoryBase
-from ..enums import JoinType
-from ...utils import Table
+from ormlambda.common.enums import JoinType
+
+if TYPE_CHECKING:
+    from ormlambda import Table
 
 OrderType = Literal["ASC", "DESC"]
 
+# TODOH: This var is duplicated from 'src\ormlambda\databases\my_sql\clauses\create_database.py'
+TypeExists = Literal["fail", "replace", "append"]
+
 
 class IStatements[T: Table](ABC):
     @abstractmethod
-    def create_table(self) -> None: ...
+    def create_table(self, if_exists: TypeExists) -> None: ...
 
     @abstractmethod
     def table_exists(self) -> bool: ...
@@ -38,6 +44,8 @@ class IStatements[T: Table](ABC):
     @abstractmethod
     def insert(self, values: T | list[T]) -> None: ...
 
+    # endregion
+
     # region upsert
     @overload
     def upsert(self, values: T) -> None:
@@ -71,13 +79,19 @@ class IStatements[T: Table](ABC):
 
     # region limit
     @abstractmethod
-    def limit(self, number: int) -> "IStatements[T]": ...
+    def limit(self, number: int) -> IStatements[T]: ...
 
     # endregion
 
     # region offset
     @abstractmethod
-    def offset(self, number: int) -> "IStatements[T]": ...
+    def offset(self, number: int) -> IStatements[T]: ...
+
+    # endregion
+
+    # region count
+    @abstractmethod
+    def count(self) -> int: ...
 
     # endregion
 
@@ -97,13 +111,13 @@ class IStatements[T: Table](ABC):
 
     # region join
     @abstractmethod
-    def join(self, table_left: Table, table_right: Table, *, by: str) -> "IStatements[T]": ...
+    def join(self, table_left: Table, table_right: Table, *, by: str) -> IStatements[T]: ...
 
     # endregion
 
     # region where
     @overload
-    def where(self, lambda_: Callable[[T], bool]) -> "IStatements[T]":
+    def where(self, lambda_: Callable[[T], bool]) -> IStatements[T]:
         """
         This method creates where clause by passing the lambda's condition
 
@@ -115,7 +129,7 @@ class IStatements[T: Table](ABC):
         ...
 
     @overload
-    def where(self, lambda_: Callable[[T], Iterable]) -> "IStatements[T]":
+    def where(self, lambda_: Callable[[T], Iterable]) -> IStatements[T]:
         """
         This method creates where clause by passing the Iterable in lambda function
         EXAMPLE
@@ -126,7 +140,7 @@ class IStatements[T: Table](ABC):
         ...
 
     @overload
-    def where(self, lambda_: Callable[[T], bool], **kwargs) -> "IStatements[T]":
+    def where(self, lambda_: Callable[[T], bool], **kwargs) -> IStatements[T]:
         """
         PARAM
         -
@@ -143,17 +157,17 @@ class IStatements[T: Table](ABC):
         ...
 
     @abstractmethod
-    def where(self, lambda_: Callable[[T], bool] = lambda: None, **kwargs) -> "IStatements[T]": ...
+    def where(self, lambda_: Callable[[T], bool] = lambda: None, **kwargs) -> IStatements[T]: ...
 
     # endregion
 
     # region order
     @overload
-    def order[TValue](self, _lambda_col: Callable[[T], TValue]) -> "IStatements[T]": ...
+    def order[TValue](self, _lambda_col: Callable[[T], TValue]) -> IStatements[T]: ...
     @overload
-    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> "IStatements[T]": ...
+    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> IStatements[T]: ...
     @abstractmethod
-    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> "IStatements[T]": ...
+    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> IStatements[T]: ...
 
     # endregion
 
@@ -203,12 +217,16 @@ class IStatements[T: Table](ABC):
     @overload
     def select_one(self) -> T: ...
     @overload
-    def select_one(self, *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[tuple]) -> tuple: ...
+    def select_one[TFlavour](self, *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[TFlavour]) -> TFlavour: ...
     @overload
     def select_one[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> T1: ...
     @overload
     def select_one[*Ts](self, selector: Callable[[T], tuple[*Ts]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[*Ts]: ...
     @overload
+    def select_one[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type) -> T1: ...
+    @overload
+    def select_one[T1, TFlavour](self, selector: Callable[[T], T1], *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[TFlavour]) -> T1: ...
+    @overload
     def select_one[*Ts](self, selector: Callable[[T], tuple[*Ts]], *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[tuple]) -> tuple[*Ts]: ...
     @overload
     def select_one[TFlavour](self, selector: Callable[[T], tuple], *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[TFlavour]) -> TFlavour: ...

ormlambda/common/interfaces/__init__.py

@@ -1,4 +1,4 @@
 from .IQueryCommand import IQuery  # noqa: F401
 from .INonQueryCommand import INonQueryCommand  # noqa: F401
 from .IRepositoryBase import IRepositoryBase  # noqa: F401
-from .IStatements import IStatements,IStatements_two_generic  # noqa: F401
+from .IStatements import IStatements, IStatements_two_generic  # noqa: F401

ormlambda/components/delete/abstract_delete.py

@@ -1,9 +1,12 @@
+from __future__ import annotations
 from abc import abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ormlambda import Table, IRepositoryBase
+from ormlambda.common.abstract_classes import NonQueryBase
 
 from .IDelete import IDelete
-from ...utils import Table
-from ...common.interfaces import IRepositoryBase
-from ...common.abstract_classes import NonQueryBase
 
 
 class DeleteQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, TRepo], IDelete[T]):

ormlambda/components/insert/IInsert.py

@@ -3,4 +3,4 @@ from abc import ABC, abstractmethod
 
 class IInsert[T](ABC):
     @abstractmethod
-    def insert(self, instances: T | list[T])->None: ...
+    def insert(self, instances: T | list[T]) -> None: ...

ormlambda/components/insert/abstract_insert.py

@@ -1,12 +1,16 @@
+from __future__ import annotations
 from abc import abstractmethod
-from ...utils import Table
+from typing import TYPE_CHECKING
 
+if TYPE_CHECKING:
+    from ormlambda import Table
+    from ormlambda import IRepositoryBase
+
+from ormlambda.common.abstract_classes import NonQueryBase
 from .IInsert import IInsert
-from ...common.interfaces import IRepositoryBase
-from ...common.abstract_classes import NonQueryBase
 
 
-class InsertQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, IRepositoryBase], IInsert[T]):
+class InsertQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, TRepo], IInsert[T]):
     def __init__(self, model: T, repository: TRepo) -> None:
         super().__init__(model, repository)
 

ormlambda/components/select/ISelect.py

@@ -1,6 +1,6 @@
 from abc import abstractmethod
 
-from ...common.interfaces import IQuery
+from ormlambda.common.interfaces import IQuery
 from .table_column import TableColumn
 
 

ormlambda/components/select/table_column.py

@@ -1,5 +1,9 @@
+from __future__ import annotations
 from typing import Any, Iterator
-from ...utils import Table
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ormlambda import Table
 
 
 class TableColumn:

ormlambda/components/update/IUpdate.py

@@ -4,4 +4,4 @@ from typing import Any
 
 class IUpdate(ABC):
     @abstractmethod
-    def update(self, dicc: dict[str|property, Any]) -> None: ...
+    def update(self, dicc: dict[str | property, Any]) -> None: ...

ormlambda/components/update/__init__.py

@@ -1,2 +1,2 @@
 from .abstract_update import UpdateQueryBase  # noqa: F401
-from .IUpdate import IUpdate  # noqa: F401
+from .IUpdate import IUpdate  # noqa: F401

ormlambda/components/update/abstract_update.py

@@ -1,11 +1,15 @@
+from __future__ import annotations
 from abc import abstractmethod
-from typing import Any, Optional
+from typing import Any, Optional, TYPE_CHECKING
+
+from ormlambda.components.where import AbstractWhere
+from ormlambda.common.abstract_classes import NonQueryBase
+
+if TYPE_CHECKING:
+    from ormlambda import IRepositoryBase
+    from ormlambda import Table
 
 from .IUpdate import IUpdate
-from ..where import AbstractWhere
-from ...common.interfaces import IRepositoryBase
-from ...common.abstract_classes import NonQueryBase
-from ...utils import Table
 
 
 class UpdateQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, TRepo], IUpdate):

ormlambda/components/upsert/__init__.py

@@ -1,2 +1,2 @@
 from .abstract_upsert import UpsertQueryBase  # noqa: F401
-from .IUpsert import IUpsert  # noqa: F401
+from .IUpsert import IUpsert  # noqa: F401