ormlambda 3.7.1__py3-none-any.whl → 3.11.0__py3-none-any.whl

ormlambda/databases/my_sql/statements.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Concatenate, Iterable, override, Type, TYPE_CHECKING, Any, Callable, Optional
+from typing import Concatenate, Iterable, TypedDict, override, Type, TYPE_CHECKING, Any, Callable, Optional
 from mysql.connector import errors, errorcode
 
 from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext
@@ -28,11 +28,12 @@ from .clauses import InsertQuery
 from .clauses import Limit
 from .clauses import Offset
 from .clauses import Order
-from .clauses.select import Select
+from .clauses import Select
 
 from .clauses import UpsertQuery
 from .clauses import UpdateQuery
 from .clauses import Where
+from .clauses import Having
 from .clauses import Count
 from .clauses import GroupBy
 from .clauses import Alias
@@ -60,12 +61,23 @@ def clear_list[T, **P](f: Callable[Concatenate[MySQLStatements, P], T]) -> Calla
     return wrapper
 
 
+class OrderType(TypedDict):
+    Select: Select
+    JoinSelector: JoinSelector
+    Where: Where
+    Order: Order
+    GroupBy: GroupBy
+    Having: Having
+    Limit: Limit
+    Offset: Offset
+
+
 class QueryBuilder(IQuery):
-    __order__: tuple[str, ...] = ("Select", "JoinSelector", "Where", "Order", "GroupBy", "Limit", "Offset")
+    __order__: tuple[str, ...] = ("Select", "JoinSelector", "Where", "GroupBy", "Having", "Order", "Limit", "Offset")
 
     def __init__(self, by: JoinType = JoinType.INNER_JOIN):
         self._context = ClauseInfoContext()
-        self._query_list: dict[str, IQuery] = {}
+        self._query_list: OrderType = {}
         self._by = by
 
         self._joins: Optional[IQuery] = None
@@ -113,6 +125,15 @@ class QueryBuilder(IQuery):
     def GROUP_BY(self) -> IQuery:
         return self._query_list.get("GroupBy", None)
 
+    @property
+    def HAVING(self) -> IQuery:
+        where = self._query_list.get("Having", None)
+        if not isinstance(where, Iterable):
+            if not where:
+                return ()
+            return (where,)
+        return where
+
     @property
     def LIMIT(self) -> IQuery:
         return self._query_list.get("Limit", None)
@@ -133,8 +154,9 @@ class QueryBuilder(IQuery):
             self.SELECT.query,
             JOINS,
             Where.join_condition(self.WHERE, True, self._context) if self.WHERE else None,
-            self.ORDER.query if self.ORDER else None,
             self.GROUP_BY.query if self.GROUP_BY else None,
+            Having.join_condition(self.HAVING, True, self._context) if self.HAVING else None,
+            self.ORDER.query if self.ORDER else None,
             self.LIMIT.query if self.LIMIT else None,
             self.OFFSET.query if self.OFFSET else None,
         )
@@ -154,8 +176,8 @@ class QueryBuilder(IQuery):
         joins = set()
         # Always it's gonna be a set of two
         # FIXME [x]: Resolved when we get Compare object instead ClauseInfo. For instance, when we have multiples condition using '&' or '|'
-        for _ in range(len(ForeignKey.stored_calls)):
-            fk = ForeignKey.stored_calls.pop()
+        for fk in ForeignKey.stored_calls.copy():
+            fk = ForeignKey.stored_calls.pop(fk)
             self._context._add_table_alias(fk.tright, fk.alias)
             join = JoinSelector(fk.resolved_function(self._context), by, context=self._context, alias=fk.alias)
             joins.add(join)
@@ -278,7 +300,7 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
 
         if GlobalChecker.is_lambda_function(selection):
             selection = selection(*self.models)
-        return Count[T](element=selection, alias_clause=alias_clause, context=self._query_builder._context)
+        return Count(element=selection, alias_clause=alias_clause, context=self._query_builder._context)
 
     @override
     def where(self, conditions: WhereTypes) -> IStatements_two_generic[T, MySQLConnection]:
@@ -291,6 +313,15 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         self._query_builder.add_statement(Where(*conditions))
         return self
 
+    @override
+    def having(self, conditions: WhereTypes) -> IStatements_two_generic[T, MySQLConnection]:
+        if GlobalChecker.is_lambda_function(conditions):
+            conditions = GlobalChecker.resolved_callback_object(conditions, self._models)
+        if not isinstance(conditions, Iterable):
+            conditions = (conditions,)
+        self._query_builder.add_statement(Having(*conditions))
+        return self
+
     @override
     def order[TValue](self, columns: Callable[[T], TValue], order_type: OrderTypes) -> IStatements_two_generic[T, MySQLConnection]:
         query = GlobalChecker.resolved_callback_object(columns, self._models) if GlobalChecker.is_lambda_function(columns) else columns
@@ -299,23 +330,42 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         return self
 
     @override
-    def concat[*Ts](self, selector: Callable[[T], tuple[*Ts]], alias: bool = True, alias_name: str = "CONCAT") -> IAggregate:
-        return func.Concat[T](self._model, selector, alias=alias, alias_name=alias_name, context=self._query_builder._context)
+    def concat(self, selector: str | Callable[[T], str], alias: str = "CONCAT") -> IAggregate:
+        return func.Concat[T](
+            values=selector,
+            alias_clause=alias,
+            context=self._query_builder._context,
+        )
 
     @override
-    def max[TProp](self, column: Callable[[T], TProp], alias: str = "max", execute: bool = False) -> TProp:
+    def max[TProp](
+        self,
+        column: Callable[[T], TProp],
+        alias: str = "max",
+        execute: bool = False,
+    ) -> TProp:
         if execute is True:
             return self.select_one(self.max(column, alias, execute=False), flavour=dict)[alias]
         return func.Max(elements=column, alias_clause=alias, context=self._query_builder._context)
 
     @override
-    def min[TProp](self, column: Callable[[T], TProp], alias: str = "min", execute: bool = False) -> TProp:
+    def min[TProp](
+        self,
+        column: Callable[[T], TProp],
+        alias: str = "min",
+        execute: bool = False,
+    ) -> TProp:
         if execute is True:
             return self.select_one(self.min(column, alias, execute=False), flavour=dict)[alias]
         return func.Min(elements=column, alias_clause=alias, context=self._query_builder._context)
 
     @override
-    def sum[TProp](self, column: Callable[[T], TProp], alias: str = "sum", execute: bool = False) -> TProp:
+    def sum[TProp](
+        self,
+        column: Callable[[T], TProp],
+        alias: str = "sum",
+        execute: bool = False,
+    ) -> TProp:
         if execute is True:
             return self.select_one(self.sum(column, alias, execute=False), flavour=dict)[alias]
         return func.Sum(elements=column, alias_clause=alias, context=self._query_builder._context)
@@ -372,7 +422,7 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
     ):
         self.limit(1)
 
-        response = self.select(selector=selector, flavour=flavour, by=by,**kwargs)
+        response = self.select(selector=selector, flavour=flavour, by=by, **kwargs)
 
         if not isinstance(response, Iterable):
             return response
@@ -406,16 +456,17 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         )
 
     @override
-    def group_by(self, column: str | Callable[[T, *Ts], Any]):
-        if isinstance(column, str):
-            groupby = GroupBy[T, tuple[*Ts]](self._models, lambda x: column)
-        else:
-            groupby = GroupBy[T, tuple[*Ts]](self._models, column)
+    def groupby[TProp](self, column: ColumnType[TProp] | Callable[[T, *Ts], Any]):
+        groupby = GroupBy(column=column, context=self._query_builder._context)
         # Only can be one LIMIT SQL parameter. We only use the last LimitQuery
         self._query_builder.add_statement(groupby)
         return self
 
     @override
-    def alias[TProp](self, column: ColumnType[TProp], alias: str) -> Alias[T, TProp]:
-        ci = ClauseInfo(table=column.table, column=column, alias_clause=alias, context=self._query_builder._context)
-        return Alias(ci, alias_clause=alias)
+    def alias[TProp](self, column: ColumnType[TProp], alias: str) -> ClauseInfo[T, TProp]:
+        return Alias(
+            table=column.table,
+            column=column,
+            alias_clause=alias,
+            context=self._query_builder._context,
+        )

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/engine/__init__.py

@@ -0,0 +1,2 @@
+from .create import create_engine  # noqa: F401
+from .url import URL  # noqa: F401

ormlambda/engine/create.py

@@ -0,0 +1,35 @@
+from typing import Any
+
+from ormlambda.engine.url import URL, make_url
+from ormlambda import BaseRepository
+
+
+def create_engine(url: URL | str, **kwargs: Any) -> BaseRepository:
+    from ormlambda.databases import MySQLRepository
+
+    # create url.URL object
+    u = make_url(url)
+    url, kwargs = u._instantiate_plugins(kwargs)
+
+    repo_selector = {
+        "mysql": MySQLRepository,
+    }
+
+    if url.drivername not in repo_selector:
+        raise ValueError(f"drivername '{url.drivername}' not expected to load Repository class")
+
+    default_config = {
+        "user": url.username,
+        "password": url.password,
+        "host": url.host,
+        "database": url.database,
+        **kwargs,
+    }
+
+    if url.port:
+        try:
+            default_config["port"] = int(url.port)
+        except ValueError:
+            raise ValueError(f"The port must be an int. '{url.port}' passed.")
+
+    return repo_selector[url.drivername](**default_config)