ormlambda 3.12.2__py3-none-any.whl → 3.34.1__py3-none-any.whl

ormlambda/dialects/sqlite/__init__.py

@@ -0,0 +1,5 @@
+from . import base
+from . import pysqlite
+
+# default dialect
+base.dialect = dialect = pysqlite.dialect

ormlambda/dialects/sqlite/base.py

@@ -0,0 +1,47 @@
+from ormlambda.sql import compiler
+from .. import default
+
+
+class SQLiteCompiler(compiler.SQLCompiler):
+    render_table_with_column_in_update_from = True
+    """Overridden from base SQLCompiler value"""
+
+
+class SQLiteDDLCompiler(compiler.DDLCompiler): ...
+
+
+class SQLiteTypeCompiler(compiler.GenericTypeCompiler):
+    def visit_INTEGER(self, type_, **kw):
+        if self._mysql_type(type_) and type_.display_width is not None:
+            return self._extend_numeric(
+                type_,
+                "INTEGER(%(display_width)s)" % {"display_width": type_.display_width},
+            )
+        else:
+            return self._extend_numeric(type_, "INTEGER")
+
+    def visit_VARCHAR(self, type_, **kw):
+        if type_.length is None:
+            raise ValueError("VARCHAR requires a length on dialect %s" % self.dialect.name)
+        return self._extend_string(type_, {}, "VARCHAR(%d)" % type_.length)
+
+    def visit_CHAR(self, type_, **kw):
+        if type_.length is not None:
+            return self._extend_string(type_, {}, "CHAR(%(length)s)" % {"length": type_.length})
+        else:
+            return self._extend_string(type_, {}, "CHAR")
+
+
+class SQLiteDialect(default.DefaultDialect):
+    """Details of the SQLite dialect.
+    Not used directly in application code.
+    """
+
+    name = "mysql"
+
+    statement_compiler = SQLiteCompiler
+    ddl_compiler = SQLiteDDLCompiler
+    type_compiler_cls = SQLiteTypeCompiler
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

ormlambda/dialects/sqlite/pysqlite.py

@@ -0,0 +1,32 @@
+from types import ModuleType
+from ..default import DefaultDialect
+from ormlambda.sql import compiler
+
+
+class SQLiteCompiler(compiler.SQLCompiler): ...
+
+
+class SQLiteDDLCompiler(compiler.DDLCompiler): ...
+
+
+class SQLiteTypeCompiler(compiler.TypeCompiler): ...
+
+
+class SQLiteDialect_pysqlite(DefaultDialect):
+    name = "sqlite"
+
+    statement_compiler = SQLiteCompiler
+    ddl_compiler = SQLiteDDLCompiler
+    type_compiler_cls = SQLiteTypeCompiler
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    @classmethod
+    def import_dbapi(cls) -> ModuleType:
+        from sqlite3 import dbapi2 as sqlite
+
+        return sqlite
+
+
+dialect = SQLiteDialect_pysqlite

ormlambda/engine/__init__.py

@@ -1,2 +1,3 @@
 from .create import create_engine  # noqa: F401
 from .url import URL, make_url  # noqa: F401
+from .base import Engine  # noqa: F401

ormlambda/engine/base.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Literal
+from ormlambda.engine import url
+from ormlambda.sql.ddl import CreateSchema, DropSchema
+
+
+if TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
+type TypeExists = Literal["fail", "replace", "append"]
+
+
+class Engine:
+    def __init__(self, dialect: Dialect, url: url.URL):
+        self.dialect = dialect
+        self.url = url
+        self.repository = self.dialect.repository_cls(url, dialect=dialect)
+
+    def create_schema(self, schema_name: str, if_exists: TypeExists = "fail") -> None:
+        if if_exists == "replace":
+            self.drop_schema(schema_name, if_exists)
+
+        sql = CreateSchema(schema=schema_name, if_not_exists=if_exists== 'append').compile(self.dialect).string
+        try:
+            self.repository.execute(sql)
+        except Exception:
+            if if_exists == "fail":
+                raise
+
+    def drop_schema(self, schema_name: str, if_exists: bool = False) -> None:
+        """
+        Generate a DROP SCHEMA SQL statement for MySQL.
+
+        Args:
+            schema_name (str): Name of the schema/database to drop
+            if_exists (bool): Whether to include IF EXISTS clause
+
+        Returns:
+            str: The SQL DROP SCHEMA statement
+
+        Raises:
+            ValueError: If schema_name is empty or contains invalid characters
+        """
+        # if not schema_name or not isinstance(schema_name, str):
+        #     raise ValueError("Schema name must be a non-empty string")
+
+        sql = DropSchema(schema=schema_name, if_exists=if_exists).compile(self.dialect).string
+        return self.repository.execute(sql)
+
+    def schema_exists(self, schema: str) -> bool:
+        # sql = SchemaExists(schema).compile(self.dialect).string
+        # return bool(res and len(res) > 0)
+
+        return self.repository.database_exists(schema)
+
+    def set_database(self, name: str) -> None:
+        self.repository.database = name
+        return None

ormlambda/engine/create.py

@@ -1,35 +1,21 @@
+from __future__ import annotations
 from typing import Any
 
 from ormlambda.engine.url import URL, make_url
-from ormlambda import BaseRepository
 
+from . import base
 
-def create_engine(url: URL | str, **kwargs: Any) -> BaseRepository:
-    from ormlambda.databases import MySQLRepository
 
+def create_engine(url: URL | str, **kwargs: Any) -> base.Engine:
     # create url.URL object
     u = make_url(url)
     url, kwargs = u._instantiate_plugins(kwargs)
 
-    repo_selector = {
-        "mysql": MySQLRepository,
-    }
+    entrypoint = u._get_entrypoint()
+    dialect_cls = entrypoint.get_dialect_cls()
 
-    if url.drivername not in repo_selector:
-        raise ValueError(f"drivername '{url.drivername}' not expected to load Repository class")
+    dialect_args = {}
+    dialect_args["dbapi"] = dialect_cls.import_dbapi()
 
-    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)
+    dialect = dialect_cls(**dialect_args)
+    return base.Engine(dialect, u)

ormlambda/engine/url.py

@@ -1,23 +1,16 @@
-"""
-URL class extracted from SQLAlchemy
-"""
+# engine/url.py
+# Copyright (C) 2005-2025 the SQLAlchemy authors and contributors
+# <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: https://www.opensource.org/licenses/mit-license.php
+#
 
 from __future__ import annotations
 
 import re
 import collections.abc as collections_abc
-from typing import (
-    Any,
-    Literal,
-    cast,
-    Iterable,
-    Mapping,
-    NamedTuple,
-    Optional,
-    overload,
-    Sequence,
-    Union,
-)
+from typing import Any, Literal, Type, cast, Iterable, Mapping, NamedTuple, Optional, overload, Sequence, Union, TYPE_CHECKING
 
 from urllib.parse import (
     parse_qsl,
@@ -28,7 +21,12 @@ from urllib.parse import (
 
 from . import utils
 
-type DrivernameType = Literal["mysql"] | str
+from ..dialects import registry
+
+if TYPE_CHECKING:
+    from ..dialects import Dialect
+
+type DrivernameType = Literal["mysql", "sqlite"] | str
 
 
 class URL(NamedTuple):
@@ -665,6 +663,20 @@ class URL(NamedTuple):
 
         return u, kwargs
 
+    def _get_entrypoint(self) -> Type[Dialect]:
+        """Return the dialect class for this URL.
+
+        This is the dialect class that corresponds to the database backend
+        in use, and is the portion of the :attr:`_engine.URL.drivername`
+        that is to the left of the plus sign.
+
+        """
+        if "+" not in self.drivername:
+            name = self.drivername
+        else:
+            name = self.drivername.replace("+", ".")
+        return registry.load(name)
+
 
 def make_url(name_or_url: str | URL) -> URL:
     """Given a string, produce a new URL instance.
@@ -684,10 +696,10 @@ def make_url(name_or_url: str | URL) -> URL:
 
     if isinstance(name_or_url, str):
         return _parse_url(name_or_url)
-    elif not isinstance(name_or_url, URL) and not hasattr(name_or_url, "_sqla_is_testing_if_this_is_a_mock_object"):
+    if not isinstance(name_or_url, URL) and not hasattr(name_or_url, "_sqla_is_testing_if_this_is_a_mock_object"):
         raise ValueError(f"Expected string or URL object, got {name_or_url!r}")
-    else:
-        return name_or_url
+
+    return name_or_url
 
 
 def _parse_url(name: str) -> URL:

ormlambda/env.py

@@ -0,0 +1,30 @@
+import os
+from pathlib import Path
+import logging
+import sys
+
+ORMLAMBDA_DIR = Path(__file__).parent
+SRC_DIR = ORMLAMBDA_DIR.parent
+BASE_DIR = SRC_DIR.parent
+
+
+try:
+    from dotenv import find_dotenv, load_dotenv
+
+    load_dotenv(find_dotenv(str(BASE_DIR / ".env")))
+
+except ImportError:
+    print("dotenv not installed, skipping...")
+
+
+GLOBAL_LOG_LEVEL = os.getenv("GLOBAL_LOG_LEVEL", "ERROR").upper()
+logging.basicConfig(
+    level=logging.getLevelNamesMapping().get(GLOBAL_LOG_LEVEL, logging.ERROR),
+    handlers=[
+        logging.StreamHandler(sys.stdout),
+        logging.FileHandler(str(BASE_DIR / "errors.log"), "w", encoding="utf-8"),
+    ],
+)
+
+log = logging.getLogger(__name__)
+log.info(f"GLOBAL_LOG_LEVEL: {GLOBAL_LOG_LEVEL}")

ormlambda/errors.py

@@ -0,0 +1,17 @@
+class CompileError(Exception):
+    """Exception raised for errors in the compilation process."""
+
+    def __init__(self, message):
+        super().__init__(message)
+        self.message = message
+
+    def __str__(self):
+        return f"CompileError: {self.message}"
+
+
+class NoSuchModuleError(Exception):
+    """Raised when a dynamically-loaded module (usually a database dialect)
+    of a particular name cannot be located."""
+
+    def __str__(self):
+        return f"NoSuchModuleError: {self.args[0]}"

ormlambda/model/base_model.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Type
 
-from ormlambda.engine.template import RepositoryTemplateDict
+from ormlambda.statements import Statements
+from ormlambda.engine import Engine
 
 if TYPE_CHECKING:
     from ormlambda.statements.interfaces import IStatements_two_generic
-    from ormlambda.repository import BaseRepository
 
 
 # endregion
@@ -22,16 +22,14 @@ class BaseModel[T]:
 
     # region Constructor
 
-    def __new__[TPool](cls, model: Type[T], repository: BaseRepository[TPool]) -> IStatements_two_generic[T, TPool]:
-        if repository is None:
+    def __new__[TPool](cls, model: Type[T], engine: Engine) -> IStatements_two_generic[T, TPool]:
+        if engine is None:
             raise ValueError("`None` cannot be passed to the `repository` attribute when calling the `BaseModel` class")
 
-        new_cls = RepositoryTemplateDict().get(repository).statement
+        if not isinstance(engine, Engine):
+            raise ValueError(f"`{engine}` is not a valid `Engine` instance")
 
-        if not new_cls:
-            raise Exception(f"The selected repository '{repository}' does not exist.")
-
-        return new_cls(model, repository)
+        return Statements(model, engine)
 
 
 ORM = BaseModel

ormlambda/repository/base_repository.py

@@ -1,13 +1,44 @@
-import contextlib
-from typing import Generator, Type, Unpack
+from __future__ import annotations
+from typing import Generator, Optional, Type, Unpack, TYPE_CHECKING
 from ormlambda.repository import IRepositoryBase
 import abc
 
+if TYPE_CHECKING:
+    from ormlambda import URL as _URL
+    from ormlambda.dialects.interface.dialect import Dialect
+
 
 class BaseRepository[TPool](IRepositoryBase):
-    def __init__[TArgs](self, pool: Type[TPool], **kwargs: Unpack[TArgs]) -> None:
-        self._pool: TPool = pool(**kwargs)
+    def __init__[TArgs](
+        self,
+        /,
+        url: Optional[_URL] = None,
+        *,
+        dialect: Optional[Dialect] = None,
+        user: Optional[str] = None,
+        password: Optional[str] = None,
+        host: Optional[str] = None,
+        database: Optional[str] = None,
+        pool: Optional[Type[TPool]] = None,
+        **kwargs: Unpack[TArgs],
+    ) -> None:
+        self._dialect = dialect
+        self._url = url
+
+        self._user = user
+        self._password = password
+        self._host = host
+        self._database = database
+
+        if pool:
+            attr = {
+                "user": self._user,
+                "password": self._password,
+                "host": self._host,
+                "database": self._database,
+                **kwargs,
+            }
+            self._pool: TPool = pool(**attr)
 
-    @contextlib.contextmanager
     @abc.abstractmethod
     def get_connection[TCnx](self) -> Generator[TCnx, None, None]: ...

ormlambda/repository/interfaces/IRepositoryBase.py

@@ -1,11 +1,131 @@
 from __future__ import annotations
 from abc import ABC, abstractmethod
-from typing import Optional, Type, Iterable, TYPE_CHECKING
+from typing import (
+    Annotated,
+    Any,
+    Mapping,
+    Optional,
+    Protocol,
+    Sequence,
+    Type,
+    Iterable,
+    TYPE_CHECKING,
+)
 
 if TYPE_CHECKING:
     from ormlambda.statements.types import TypeExists
 
 
+type _DBAPICursorDescription = Sequence[
+    tuple[
+        Annotated[str, "name"],
+        Annotated[str, "type_code"],
+        Annotated[Optional[str], "display_size"],
+        Annotated[Optional[str], "internal_size"],
+        Annotated[Optional[str], "precision"],
+        Annotated[Optional[str], "scale"],
+        Annotated[Optional[str], "null_ok"],
+    ]
+]
+
+
+type _GenericSequence = Sequence[Any]
+
+type _CoreSingleExecuteParams = Mapping[str, Any]
+type _CoreMultiExecuteParams = Sequence[_CoreSingleExecuteParams]
+
+type _DBAPISingleExecuteParams = _GenericSequence | _CoreSingleExecuteParams
+type _DBAPIMultiExecuteParams = Sequence[_GenericSequence] | _CoreMultiExecuteParams
+
+
+class DBAPICursor(Protocol):
+    """protocol representing a :pep:`249` database cursor.
+
+    .. versionadded:: 2.0
+
+    .. seealso::
+
+        `Cursor Objects <https://www.python.org/dev/peps/pep-0249/#cursor-objects>`_
+        - in :pep:`249`
+
+    """  # noqa: E501
+
+    @property
+    def description(
+        self,
+    ) -> _DBAPICursorDescription:
+        """The description attribute of the Cursor.
+
+        .. seealso::
+
+            `cursor.description <https://www.python.org/dev/peps/pep-0249/#description>`_
+            - in :pep:`249`
+
+
+        """  # noqa: E501
+        ...
+
+    @property
+    def rowcount(self) -> int: ...
+
+    arraysize: int
+
+    lastrowid: int
+
+    def close(self) -> None: ...
+
+    def execute(
+        self,
+        operation: Any,
+        parameters: Optional[_DBAPISingleExecuteParams] = None,
+    ) -> Any: ...
+
+    def executemany(
+        self,
+        operation: Any,
+        parameters: _DBAPIMultiExecuteParams,
+    ) -> Any: ...
+
+    def fetchone(self) -> Optional[Any]: ...
+
+    def fetchmany(self, size: int = ...) -> Sequence[Any]: ...
+
+    def fetchall(self) -> Sequence[Any]: ...
+
+    def setinputsizes(self, sizes: Sequence[Any]) -> None: ...
+
+    def setoutputsize(self, size: Any, column: Any) -> None: ...
+
+    def callproc(self, procname: str, parameters: Sequence[Any] = ...) -> Any: ...
+
+    def nextset(self) -> Optional[bool]: ...
+
+    def __getattr__(self, key: str) -> Any: ...
+
+
+class DBAPIConnection(Protocol):
+    """protocol representing a :pep:`249` database connection.
+
+    .. versionadded:: 2.0
+
+    .. seealso::
+
+        `Connection Objects <https://www.python.org/dev/peps/pep-0249/#connection-objects>`_
+        - in :pep:`249`
+
+    """  # noqa: E501
+
+    def close(self) -> None: ...
+
+    def commit(self) -> None: ...
+
+    def cursor(self) -> DBAPICursor: ...
+
+    def rollback(self) -> None: ...
+
+    autocommit: bool
+
+
 class IRepositoryBase(ABC):
     def __repr__(self) -> str:
         return f"{IRepositoryBase.__name__}: {self.__class__.__name__}"
@@ -22,12 +142,6 @@ class IRepositoryBase(ABC):
     @abstractmethod
     def execute(self, query: str) -> None: ...
 
-    @abstractmethod
-    def drop_database(self, name: str) -> None: ...
-
-    @abstractmethod
-    def create_database(self, name: str, if_exists: TypeExists = "fail") -> None: ...
-
     @abstractmethod
     def drop_table(self, name: str) -> None: ...
 

ormlambda/repository/response.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+from typing import Type, Any, TYPE_CHECKING, Optional
+from ormlambda.dialects.interface.dialect import Dialect
+import shapely as shp
+
+# Custom libraries
+from ormlambda.sql.clauses import Alias
+
+if TYPE_CHECKING:
+    from ormlambda.common.abstract_classes.decomposition_query import ClauseInfo
+    from ormlambda import Table
+    from ormlambda.sql.clauses import Select
+
+
+type TResponse[TFlavour, *Ts] = TFlavour | tuple[dict[str, tuple[*Ts]]] | tuple[tuple[*Ts]] | tuple[TFlavour]
+
+
+class Response[TFlavour, *Ts]:
+    def __init__(
+        self,
+        dialect: Dialect,
+        response_values: list[tuple[*Ts]],
+        columns: tuple[str],
+        flavour: Type[TFlavour],
+        select: Optional[Select] = None,
+    ) -> None:
+        self._dialect: Dialect = dialect
+        self._response_values: list[tuple[*Ts]] = response_values
+        self._columns: tuple[str] = columns
+        self._flavour: Type[TFlavour] = flavour
+        self._select: Select = select
+
+        self._response_values_index: int = len(self._response_values)
+
+        self._caster = dialect.caster()
+
+    @property
+    def is_one(self) -> bool:
+        return self._response_values_index == 1
+
+    @property
+    def is_there_response(self) -> bool:
+        return self._response_values_index != 0
+
+    @property
+    def is_many(self) -> bool:
+        return self._response_values_index > 1
+
+    def response(self, **kwargs) -> TResponse[TFlavour, *Ts]:
+        if not self.is_there_response:
+            return tuple([])
+
+        # Cast data using caster
+        cleaned_response = self._response_values
+
+        if self._select is not None:
+            cleaned_response = self._clean_response()
+
+        cast_flavour = self._cast_to_flavour(cleaned_response, **kwargs)
+
+        return tuple(cast_flavour)
+
+    def _cast_to_flavour(self, data: list[tuple[*Ts]], **kwargs) -> list[dict[str, tuple[*Ts]]] | list[tuple[*Ts]] | list[TFlavour]:
+        def _dict(**kwargs) -> list[dict[str, tuple[*Ts]]]:
+            nonlocal data
+            return [dict(zip(self._columns, x)) for x in data]
+
+        def _tuple(**kwargs) -> list[tuple[*Ts]]:
+            nonlocal data
+            return data
+
+        def _set(**kwargs) -> list[set]:
+            nonlocal data
+            for d in data:
+                n = len(d)
+                for i in range(n):
+                    try:
+                        hash(d[i])
+                    except TypeError:
+                        raise TypeError(f"unhashable type '{type(d[i])}' found in '{type(d)}' when attempting to cast the result into a '{set.__name__}' object")
+            return [set(x) for x in data]
+
+        def _list(**kwargs) -> list[list]:
+            nonlocal data
+            return [list(x) for x in data]
+
+        def _default(**kwargs) -> list[TFlavour]:
+            nonlocal data
+            replacer_dicc: dict[str, str] = {}
+
+            for col in self._select.all_clauses:
+                if hasattr(col, "_alias_aggregate") or col.alias_clause is None or isinstance(col, Alias):
+                    continue
+                replacer_dicc[col.alias_clause] = col.column
+
+            cleaned_column_names = [replacer_dicc.get(col, 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,
+            tuple: _tuple,
+            set: _set,
+            list: _list,
+        }
+        return selector.get(self._flavour, _default)(**kwargs)
+
+    def _clean_response(self) -> TFlavour:
+        new_response: list[tuple] = []
+        for row in self._response_values:
+            new_row: list = []
+            for i, data in enumerate(row):
+                alias = self._columns[i]
+                clause_info = self._select[alias]
+                parse_data = self._caster.for_value(data, value_type=clause_info.dtype).from_database
+                new_row.append(parse_data)
+            new_row = tuple(new_row)
+            if not isinstance(new_row, tuple):
+                new_row = tuple(new_row)
+
+            new_response.append(new_row)
+        return new_response
+
+    @staticmethod
+    def _is_parser_required[T: Table](clause_info: ClauseInfo[T]) -> bool:
+        if clause_info is None:
+            return False
+
+        return clause_info.dtype is shp.Point