ormlambda 3.7.0__tar.gz → 3.7.2__tar.gz

{ormlambda-3.7.0 → ormlambda-3.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 3.7.0
+Version: 3.7.2
 Summary: ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions
 Author: p-hzamora
 Author-email: p.hzamora@icloud.com

{ormlambda-3.7.0 → ormlambda-3.7.2}/pyproject.toml

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "3.7.0"
+version = "3.7.2"
 description = "ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions"
 authors = ["p-hzamora <p.hzamora@icloud.com>"]
 readme = "README.md"
@@ -19,6 +19,7 @@ python-dotenv = "^1.0.1"
 pandas = "^2.2.2"
 ruff = "^0.4.5"
 parameterized = "^0.9.0"
+pydantic = "^2.11.1"
 
 
 [build-system]

{ormlambda-3.7.0 → ormlambda-3.7.2}/src/ormlambda/caster/base_caster.py

@@ -14,7 +14,7 @@ class BaseCaster[TProp, TType](abc.ABC):
     def wildcard_to_select(self, value: str) -> str: ...
     @overload
     def wildcard_to_select(self) -> str: ...
-    
+
     @abc.abstractmethod
     def wildcard_to_select(self) -> str: ...
 
@@ -22,7 +22,7 @@ class BaseCaster[TProp, TType](abc.ABC):
     def wildcard_to_where(self, value: str) -> str: ...
     @overload
     def wildcard_to_where(self) -> str: ...
-    
+
     @abc.abstractmethod
     def wildcard_to_where(self) -> str: ...
 
@@ -30,7 +30,7 @@ class BaseCaster[TProp, TType](abc.ABC):
     def wildcard_to_insert(self, value: str) -> str: ...
     @overload
     def wildcard_to_insert(self) -> str: ...
-    
+
     @abc.abstractmethod
     def wildcard_to_insert(self) -> str: ...
 

{ormlambda-3.7.0 → ormlambda-3.7.2}/src/ormlambda/common/global_checker.py

@@ -23,6 +23,6 @@ class GlobalChecker:
         except TypeError as err:
             cond1 = r"takes \d+ positional argument but \d+ were given"
             cond2 = r"missing \d+ required positional arguments:"
-            if re.search(r"("+f"{cond1}|{cond2}"+r")", err.args[0]):
+            if re.search(r"(" + f"{cond1}|{cond2}" + r")", err.args[0]):
                 raise UnmatchedLambdaParameterError(len(tables), obj)
             raise err

{ormlambda-3.7.0 → ormlambda-3.7.2}/src/ormlambda/components/select/ISelect.py

@@ -6,12 +6,12 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from ormlambda.sql.clause_info import ClauseInfo
 
+
 class ISelect(IQuery):
     @property
     @abc.abstractmethod
-    def FROM(self)->ClauseInfo: ...
-    
+    def FROM(self) -> ClauseInfo: ...
+
     @property
     @abc.abstractmethod
-    def COLUMNS(self)->str: ...
-
+    def COLUMNS(self) -> str: ...

ormlambda-3.7.2/src/ormlambda/components/select/__init__.py

@@ -0,0 +1 @@
+from .ISelect import ISelect  # noqa: F401

{ormlambda-3.7.0 → ormlambda-3.7.2}/src/ormlambda/databases/my_sql/caster/types/bytes.py

@@ -6,13 +6,13 @@ class BytesCaster[TType](BaseCaster[bytes, TType]):
     def __init__(self, value: bytes, type_value: TType):
         super().__init__(value, type_value)
 
-    def wildcard_to_select(self, value:str = PLACEHOLDER) -> str:
+    def wildcard_to_select(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_where(self, value:str = PLACEHOLDER) -> str:
+    def wildcard_to_where(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_insert(self, value:str = PLACEHOLDER) -> str:
+    def wildcard_to_insert(self, value: str = PLACEHOLDER) -> str:
         return value
 
     @property

{ormlambda-3.7.0 → ormlambda-3.7.2}/src/ormlambda/databases/my_sql/caster/types/datetime.py

@@ -8,13 +8,13 @@ class DatetimeCaster[TType](BaseCaster[datetime, TType]):
     def __init__(self, value: datetime, type_value: TType):
         super().__init__(value, type_value)
 
-    def wildcard_to_select(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_select(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_where(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_where(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_insert(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_insert(self, value: str = PLACEHOLDER) -> str:
         return value
 
     @property

{ormlambda-3.7.0 → ormlambda-3.7.2}/src/ormlambda/databases/my_sql/caster/types/float.py

@@ -6,13 +6,13 @@ class FloatCaster[TType](BaseCaster[float, TType]):
     def __init__(self, value: float, type_value: TType):
         super().__init__(value, type_value)
 
-    def wildcard_to_select(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_select(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_where(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_where(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_insert(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_insert(self, value: str = PLACEHOLDER) -> str:
         return value
 
     @property

{ormlambda-3.7.0 → ormlambda-3.7.2}/src/ormlambda/databases/my_sql/caster/types/int.py

@@ -6,13 +6,13 @@ class IntegerCaster[TType](BaseCaster[int, TType]):
     def __init__(self, value: int, type_value: TType):
         super().__init__(value, type_value)
 
-    def wildcard_to_select(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_select(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_where(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_where(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_insert(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_insert(self, value: str = PLACEHOLDER) -> str:
         return value
 
     @property

{ormlambda-3.7.0 → ormlambda-3.7.2}/src/ormlambda/databases/my_sql/caster/types/iterable.py

@@ -6,13 +6,13 @@ class IterableCaster[TType](BaseCaster[bytes, TType]):
     def __init__(self, value: bytes, type_value: TType):
         super().__init__(value, type_value)
 
-    def wildcard_to_select(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_select(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_where(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_where(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_insert(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_insert(self, value: str = PLACEHOLDER) -> str:
         return value
 
     @property

{ormlambda-3.7.0 → ormlambda-3.7.2}/src/ormlambda/databases/my_sql/caster/types/none.py

@@ -6,13 +6,13 @@ class NoneTypeCaster[TType](BaseCaster[NoneType, TType]):
     def __init__(self, value: NoneType, type_value: TType):
         super().__init__(value, type_value)
 
-    def wildcard_to_select(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_select(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_where(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_where(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_insert(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_insert(self, value: str = PLACEHOLDER) -> str:
         return value
 
     # TODOL: cheched if it's right

{ormlambda-3.7.0 → ormlambda-3.7.2}/src/ormlambda/databases/my_sql/caster/types/string.py

@@ -6,13 +6,13 @@ class StringCaster[TType](BaseCaster[str, TType]):
     def __init__(self, value: str, type_value: TType):
         super().__init__(value, type_value)
 
-    def wildcard_to_select(self, value:str = PLACEHOLDER) -> str:
+    def wildcard_to_select(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_where(self, value:str = PLACEHOLDER) -> str:
+    def wildcard_to_where(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_insert(self, value:str = PLACEHOLDER) -> str:
+    def wildcard_to_insert(self, value: str = PLACEHOLDER) -> str:
         return value
 
     @property

{ormlambda-3.7.0 → ormlambda-3.7.2}/src/ormlambda/databases/my_sql/clauses/update.py

@@ -56,7 +56,7 @@ class UpdateQuery[T: Type[Table]](UpdateQueryBase[T, IRepositoryBase]):
 
             if self.__is_valid__(col):
                 clean_data = CASTER.for_value(value)
-                col_names.append((col.column_name,clean_data.wildcard_to_insert()))
+                col_names.append((col.column_name, clean_data.wildcard_to_insert()))
                 self._values.append(clean_data.to_database)
 
         set_query: str = ",".join(["=".join(col_data) for col_data in col_names])

{ormlambda-3.7.0 → ormlambda-3.7.2}/src/ormlambda/databases/my_sql/join_context.py

@@ -72,4 +72,3 @@ class JoinContext[TParent: Table, TRepo]:
         parent_table = conditions.difference(model).pop()
 
         return clause_dicc[parent_table], clause_dicc[parent_table].table.__name__
-

{ormlambda-3.7.0 → ormlambda-3.7.2}/src/ormlambda/databases/my_sql/repository/repository.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import contextlib
 from pathlib import Path
-from typing import Any, Generator, Iterable, Optional, Type, override, TYPE_CHECKING
+from typing import Any, Generator, Iterable, Optional, Type, override, TYPE_CHECKING, Unpack
 import shapely as shp
 
 # from mysql.connector.pooling import MySQLConnectionPool
@@ -22,6 +22,7 @@ if TYPE_CHECKING:
     from ormlambda.common.abstract_classes.decomposition_query import ClauseInfo
     from ormlambda import Table
     from ormlambda.databases.my_sql.clauses.select import Select
+    from ..types import MySQLArgs
 
 type TResponse[TFlavour, *Ts] = TFlavour | tuple[dict[str, tuple[*Ts]]] | tuple[tuple[*Ts]] | tuple[TFlavour]
 
@@ -86,7 +87,16 @@ class Response[TFlavour, *Ts]:
             return [list(x) for x in data]
 
         def _default(**kwargs) -> list[TFlavour]:
-            return self._flavour(data, **kwargs)
+            replacer_dicc: dict[str, str] = {x.alias_clause: x.column for x in self._select.all_clauses}
+
+            cleaned_column_names = [replacer_dicc[col] for col in self._columns]
+
+            result = []
+            for attr in data:
+                dicc_attr = dict(zip(cleaned_column_names, attr))
+                result.append(self._flavour(**dicc_attr, **kwargs))
+
+            return result
 
         selector: dict[Type[object], Any] = {
             dict: _dict,
@@ -146,7 +156,7 @@ class MySQLRepository(BaseRepository[MySQLConnectionPool]):
 
     #
 
-    def __init__(self, **kwargs):
+    def __init__(self, **kwargs: Unpack[MySQLArgs]):
         super().__init__(MySQLConnectionPool, **kwargs)
 
     @contextlib.contextmanager

{ormlambda-3.7.0 → ormlambda-3.7.2}/src/ormlambda/databases/my_sql/statements.py

@@ -354,7 +354,6 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         self._query_builder.by = by
         self._query: str = self._query_builder.query
 
-        self._query_builder.clear()
         if flavour:
             result = self._return_flavour(self.query, flavour, select, **kwargs)
             if issubclass(flavour, tuple) and isinstance(select_clause, Column | ClauseInfo):
@@ -363,10 +362,17 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         return self._return_model(select, self.query)
 
     @override
-    def select_one[TValue, TFlavour, *Ts](self, selector: Optional[tuple[TValue, *Ts]] = None, *, flavour: Optional[Type[TFlavour]] = None, by: JoinType = JoinType.INNER_JOIN):
+    def select_one[TValue, TFlavour, *Ts](
+        self,
+        selector: Optional[tuple[TValue, *Ts]] = None,
+        *,
+        flavour: Optional[Type[TFlavour]] = None,
+        by: JoinType = JoinType.INNER_JOIN,
+        **kwargs,
+    ):
         self.limit(1)
 
-        response = self.select(selector=selector, flavour=flavour, by=by)
+        response = self.select(selector=selector, flavour=flavour, by=by, **kwargs)
 
         if not isinstance(response, Iterable):
             return response
@@ -384,8 +390,20 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         return tuple([res[0] for res in response])
 
     @override
-    def first[TValue, *Ts](self, selector: Optional[tuple[TValue, *Ts]] = None):
-        return self.select_one(selector)
+    def first[TValue, TFlavour, *Ts](
+        self,
+        selector: Optional[tuple[TValue, *Ts]] = None,
+        *,
+        flavour: Optional[Type[TFlavour]] = None,
+        by: JoinType = JoinType.INNER_JOIN,
+        **kwargs,
+    ):
+        return self.select_one(
+            selector=selector,
+            flavour=flavour,
+            by=by,
+            **kwargs,
+        )
 
     @override
     def group_by(self, column: str | Callable[[T, *Ts], Any]):

ormlambda-3.7.2/src/ormlambda/databases/my_sql/types.py

@@ -0,0 +1,73 @@
+from typing import Callable, Optional, Type, TypedDict, Any
+
+from mysql.connector.constants import (
+    CharacterSet,
+    ClientFlag,
+)
+from mysql.connector.types import HandShakeType, BinaryProtocolType
+from mysql.connector.conversion import MySQLConverter
+
+
+class MySQLArgs(TypedDict):
+    client_flags: ClientFlag | int
+    sql_mode: Optional[str]
+    time_zone: Optional[str]
+    autocommit: bool
+    server_version: Optional[tuple[int, ...]]
+    handshake: Optional[HandShakeType]
+    conn_attrs: dict[str, str]
+
+    user: str
+    password: str
+    password1: str
+    password2: str
+    password3: str
+    database: str
+    host: str
+    port: int
+    unix_socket: Optional[str]
+    client_host: str
+    client_port: int
+    ssl: dict[str, Optional[str | bool | list[str]]]
+    ssl_disabled: bool
+    force_ipv6: bool
+    oci_config_file: Optional[str]
+    oci_config_profile: Optional[str]
+    webauthn_callback: Optional[str | Callable[[str], None]]
+    krb_service_principal: Optional[str]
+    openid_token_file: Optional[str]
+
+    use_unicode: bool
+    get_warnings: bool
+    raise_on_warnings: bool
+    connection_timeout: Optional[int]
+    read_timeout: Optional[int]
+    write_timeout: Optional[int]
+    buffered: bool
+    unread_result: bool
+    have_next_result: bool
+    raw: bool
+    in_transaction: bool
+    allow_local_infile: bool
+    allow_local_infile_in_path: Optional[str]
+
+    prepared_statements: Any
+    query_attrs: dict[str, BinaryProtocolType]
+
+    ssl_active: bool
+    auth_plugin: Optional[str]
+    auth_plugin_class: Optional[str]
+    pool_config_version: Any
+    converter_class: Optional[Type[MySQLConverter]]
+    converter_str_fallback: bool
+    compress: bool
+
+    consume_results: bool
+    init_command: Optional[str]
+    character_set: CharacterSet
+
+
+__all__ = [
+    "MySQLArgs",
+    "ClientFlag",
+]

{ormlambda-3.7.0 → ormlambda-3.7.2}/src/ormlambda/repository/base_repository.py

@@ -1,11 +1,11 @@
 import contextlib
-from typing import Generator, Type
+from typing import Generator, Type, Unpack
 from ormlambda.repository import IRepositoryBase
 import abc
 
 
 class BaseRepository[TPool](IRepositoryBase):
-    def __init__(self, pool: Type[TPool], **kwargs: str) -> None:
+    def __init__[TArgs](self, pool: Type[TPool], **kwargs: Unpack[TArgs]) -> None:
         self._data_config: dict[str, str] = kwargs
         self._pool: TPool = pool(**kwargs)
 

{ormlambda-3.7.0 → ormlambda-3.7.2}/src/ormlambda/repository/interfaces/IRepositoryBase.py

@@ -5,6 +5,7 @@ from typing import Optional, Type, Iterable, TYPE_CHECKING
 if TYPE_CHECKING:
     from ormlambda.statements.types import TypeExists
 
+
 class IRepositoryBase(ABC):
     def __repr__(self) -> str:
         return f"{IRepositoryBase.__name__}: {self.__class__.__name__}"

{ormlambda-3.7.0 → ormlambda-3.7.2}/src/ormlambda/sql/table/table_constructor.py

@@ -170,8 +170,8 @@ class Table(metaclass=TableMeta):
         return tuple([x for x in cls.__annotations__.values() if isinstance(x, Column)])
 
     @classmethod
-    def get_column[TProp](cls,name:str) -> Column[TProp]:
-        for key,value in cls.__annotations__.items():
+    def get_column[TProp](cls, name: str) -> Column[TProp]:
+        for key, value in cls.__annotations__.items():
             if name == key:
                 return value
 

{ormlambda-3.7.0 → ormlambda-3.7.2}/src/ormlambda/statements/interfaces/IStatements.py

@@ -253,19 +253,19 @@ class IStatements[T: Table](ABC):
     @overload
     def select_one(self) -> T: ...
     @overload
-    def select_one[TFlavour](self, *, by: Optional[Enum] = ..., flavour: Type[TFlavour]) -> TFlavour: ...
+    def select_one[TFlavour](self, *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
     @overload
     def select_one[T1](self, selector: Callable[[T], T1 | tuple[T1]], *, by: Optional[Enum] = ...) -> T1: ...
     @overload
     def select_one[*TRes](self, selector: Callable[[T], tuple[*TRes]], *, by: Optional[Enum] = ...) -> tuple[*TRes]: ...
     @overload
-    def select_one[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type) -> T1: ...
+    def select_one[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type, **kwargs) -> T1: ...
     @overload
-    def select_one[T1, TFlavour](self, selector: Callable[[T], T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour]) -> T1: ...
+    def select_one[T1, TFlavour](self, selector: Callable[[T], T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
     @overload
-    def select_one[*TRest](self, selector: Callable[[T], tuple[*TRest]], *, by: Optional[Enum] = ..., flavour: Type[tuple]) -> tuple[*TRest]: ...
+    def select_one[*TRest](self, selector: Callable[[T], tuple[*TRest]], *, by: Optional[Enum] = ..., flavour: Type[tuple], **kwargs) -> tuple[*TRest]: ...
     @overload
-    def select_one[TFlavour](self, selector: Callable[[T], tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour]) -> TFlavour: ...
+    def select_one[TFlavour](self, selector: Callable[[T], tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
     @abstractmethod
     def select_one[TValue, TFlavour, *TRest](
         self,
@@ -280,6 +280,28 @@ class IStatements[T: Table](ABC):
     # region first
     @overload
     def first(self) -> T: ...
+    @overload
+    def first[TFlavour](self, *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    @overload
+    def first[T1](self, selector: Callable[[T], T1 | tuple[T1]], *, by: Optional[Enum] = ...) -> T1: ...
+    @overload
+    def first[*TRes](self, selector: Callable[[T], tuple[*TRes]], *, by: Optional[Enum] = ...) -> tuple[*TRes]: ...
+    @overload
+    def first[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type, **kwargs) -> T1: ...
+    @overload
+    def first[T1, TFlavour](self, selector: Callable[[T], T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    @overload
+    def first[*TRest](self, selector: Callable[[T], tuple[*TRest]], *, by: Optional[Enum] = ..., flavour: Type[tuple], **kwargs) -> tuple[*TRest]: ...
+    @overload
+    def first[TFlavour](self, selector: Callable[[T], tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    @abstractmethod
+    def first[TValue, TFlavour, *TRest](
+        self,
+        selector: Optional[Callable[[T], tuple[TValue, *TRest]]] = lambda: None,
+        *,
+        flavour: Type[TFlavour] = ...,
+        by: Optional[Enum] = ...,
+    ): ...
 
     # endregion
 

ormlambda-3.7.0/src/ormlambda/components/select/__init__.py

@@ -1 +0,0 @@
-from .ISelect import ISelect  # noqa: F401