alchemy-kit 0.2.1__tar.gz → 0.2.2__tar.gz

alchemy_kit-0.2.2/.import_linter_cache/alchemy_kit.meta.json

@@ -0,0 +1 @@
+{"alchemy_kit.model._builders._column_metadata": 1783788006.4632034, "alchemy_kit.connect.info_builder": 1783988911.0389419, "alchemy_kit.model": 1783123761.4766204, "alchemy_kit.model._model.constraint_model": 1783792900.5904074, "alchemy_kit.connect._conn_builders": 1781477258.7415013, "alchemy_kit.types._sql_utilities": 1783181974.5998778, "alchemy_kit.types.api_types": 1781653146.483559, "alchemy_kit.resources.dialect_map.mariadb": 1783992205.4850442, "alchemy_kit.types.dialect_types": 1782685078.7530954, "alchemy_kit.connect._conn_builders.mssql": 1783988674.3429148, "alchemy_kit.model._builders._check_parser": 1783804394.2903757, "alchemy_kit.resources._sql": 1783134313.4017901, "alchemy_kit.model._builders._model": 1783305892.6582034, "alchemy_kit.model._model.schema_model": 1782863015.7352564, "alchemy_kit.model._model.column_model": 1783137431.929781, "alchemy_kit.resources._compiler": 1784156156.726372, "alchemy_kit.model._table": 1784166124.3054385, "alchemy_kit.model.units": 1784151164.3408992, "alchemy_kit.model._model_def._extractor": 1783983932.895483, "alchemy_kit.resources.dialect_map.oracle": 1783992222.8661819, "alchemy_kit.types._sql_parameters": 1783136113.744246, "alchemy_kit.types.generic_path": 1782619664.2724166, "alchemy_kit.types.py_type_parameters": 1783871618.5644596, "alchemy_kit.resources.dialect_map._base": 1784139216.637915, "alchemy_kit.resources.dialect_map.postgresql": 1783992260.2914782, "alchemy_kit.model._model.db_model": 1783134298.5988443, "alchemy_kit.model._model_def": 1783793306.3740585, "alchemy_kit.connect": 1783979242.2356217, "alchemy_kit.model.base_model": 1784166108.7544315, "alchemy_kit.model._model": 1782768187.8235765, "alchemy_kit.connect._engine_manager": 1783182851.0969985, "alchemy_kit.model._model_def._frames": 1783793240.1109478, "alchemy_kit.types.errors": 1782777339.3075414, "alchemy_kit.resources.dir_helpers": 1782766100.265875, "alchemy_kit.resources": 1782594201.0667772, "alchemy_kit.model._builders._build_stub_file": 1784166269.5865104, "alchemy_kit.resources.dialect_map.mssql": 1783992194.1459546, "alchemy_kit.builder._base": 1784166201.488475, "alchemy_kit.builder._select": 1784166228.843489, "alchemy_kit.connect._drivers": 1783810352.0290878, "alchemy_kit.types.errors._model_validation_error": 1782777264.4723163, "alchemy_kit.builder._temp": 1784166243.8624969, "alchemy_kit.resources._settings": 1783988624.634489, "alchemy_kit.connect._engine_handler": 1784166082.4634204, "alchemy_kit.builder._insert": 1784166236.0814927, "alchemy_kit.model._builder": 1783304246.27759, "alchemy_kit.types": 1783134286.447885, "alchemy_kit.model._builders": 1783030834.3739681, "alchemy_kit.types.sql_type_parameters": 1783823966.2638404, "alchemy_kit.model.units._operand_unit": 1784156176.032399, "alchemy_kit.model._model.object_model": 1783792902.916411, "alchemy_kit.resources._better_logger": 1781466641.7605743, "alchemy_kit.types.auth_types": 1781654455.9127147, "alchemy_kit.model._schema_config": 1782918118.3620167, "alchemy_kit.model.units._object_unit": 1784166140.9344459, "alchemy_kit.model.units._column_unit": 1784166182.7314658, "alchemy_kit.model._builders._svg": 1783283781.2235174, "alchemy_kit.model._builders._build_py_file": 1784166260.1425054, "alchemy_kit.connect._info": 1783993996.204647, "alchemy_kit.types.sql_types": 1784124232.398432, "alchemy_kit.types._driver_types": 1783987776.477921, "alchemy_kit.builder": 1783894730.0536327, "alchemy_kit.model._utils": 1783793791.5428987, "alchemy_kit.resources._identifiers": 1784156301.8850915, "alchemy_kit.resources.dialect_map.mysql": 1783992200.267003, "alchemy_kit": 1782516403.8490307, "alchemy_kit.resources.dialect_map": 1783894579.0565424, "alchemy_kit.resources.dialect_map.sqlite": 1783992228.453226}

alchemy_kit-0.2.2/.import_linter_cache/b436f6e8205b1418cbee6b7347a3c7b0d1be876b.data.json

@@ -0,0 +1 @@
+{"alchemy_kit.resources._sql":[["alchemy_kit.resources._settings",9,"from ._settings import Settings"],["alchemy_kit.types.generic_path",8,"from ..types.generic_path import GenericPath"],["alchemy_kit.types._sql_parameters",10,"from ..types._sql_parameters import SqlParamters, SqlTextReplacement"]],"alchemy_kit.types._driver_types":[],"alchemy_kit.types.errors":[["alchemy_kit.types.errors._model_validation_error",1,"from ._model_validation_error import ModelValidationError"]],"alchemy_kit.resources.dialect_map.sqlite":[["alchemy_kit.resources.dialect_map._base",8,"from ._base import ColumnLike, DialectMap, ReflectedTypeFacts, SaTypeFactory"],["alchemy_kit.types.sql_type_parameters",10,"from ...types.sql_type_parameters import SqliteTypeParameters"],["alchemy_kit.types.dialect_types",3,"from alchemy_kit.types.dialect_types import DialectTypes"],["alchemy_kit.types.py_type_parameters",9,"from ...types.py_type_parameters import PyTypeParameters"]],"alchemy_kit.model._schema_config":[],"alchemy_kit.types.sql_type_parameters":[],"alchemy_kit.types.dialect_types":[],"alchemy_kit.model._builders._build_stub_file":[["alchemy_kit.resources.dialect_map",6,"from ...resources.dialect_map import get_codegen_imports, get_type"],["alchemy_kit.model._model.object_model",9,"from .._model.object_model import ObjectModel"],["alchemy_kit.model._model.column_model",8,"from .._model.column_model import ColumnModel"],["alchemy_kit.types.sql_type_parameters",7,"from ...types import DialectTypes, sql_type_parameters"],["alchemy_kit.connect._engine_handler",5,"from ...connect._engine_handler import EngineHandler"],["alchemy_kit.model.base_model",10,"from ..base_model import BaseModel"],["alchemy_kit.model.units",11,"from .. import units"],["alchemy_kit.types",7,"from ...types import DialectTypes, sql_type_parameters"]],"alchemy_kit.model._table":[["alchemy_kit.resources.dialect_map",5,"from ..resources.dialect_map import DialectMap, get_map"],["alchemy_kit.model.base_model",8,"from .base_model import BaseModel"],["alchemy_kit.model._builders._column_metadata",7,"from ._builders._column_metadata import ColumnMetadata"],["alchemy_kit.types.dialect_types",6,"from ..types.dialect_types import DialectTypes"]],"alchemy_kit.types.generic_path":[],"alchemy_kit.model._model.schema_model":[["alchemy_kit.model._model.object_model",1,"from .object_model import ObjectModel"]],"alchemy_kit.model.units._column_unit":[["alchemy_kit.resources.dialect_map",8,"from ...resources.dialect_map import get_map"],["alchemy_kit.model.base_model",10,"from ..base_model import BaseModel"],["alchemy_kit.types.sql_types",9,"from ...types.sql_types import SqlScalarType"],["alchemy_kit.connect._engine_handler",13,"from ...connect._engine_handler import EngineHandler"]],"alchemy_kit.model._builder":[["alchemy_kit.resources._better_logger",5,"from ..resources._better_logger import BetterLogger"],["alchemy_kit.model._utils",8,"from ._utils import clear_dir, parse_db"],["alchemy_kit.model._builders",6,"from . import _builders"],["alchemy_kit.model._schema_config",7,"from ._schema_config import SchemaConfig"],["alchemy_kit.connect._info",4,"from ..connect._info import ConnectionInfo"]],"alchemy_kit.resources._compiler":[["alchemy_kit.types.dialect_types",7,"from ..types.dialect_types import DialectTypes"]],"alchemy_kit.builder._temp":[["alchemy_kit.builder._base",9,"from ._base import SqlBuilder"],["alchemy_kit.model.units",7,"from ..model.units import ObjectUnit"],["alchemy_kit.model._table",6,"from ..model._table import clone_table"],["alchemy_kit.types.dialect_types",8,"from ..types.dialect_types import DialectTypes"]],"alchemy_kit.builder._insert":[["alchemy_kit.model.units",7,"from ..model.units import ColumnUnit, ObjectUnit"],["alchemy_kit.builder._select",10,"from ._select import SelectBuilder"],["alchemy_kit.types.sql_types",8,"from ..types.sql_types import SqlScalarType"],["alchemy_kit.builder._base",9,"from ._base import SqlBuilder"]],"alchemy_kit.model._model_def":[["alchemy_kit.model._model_def._extractor",1,"from ._extractor import MetadataExtractor"],["alchemy_kit.model._model_def._frames",2,"from ._frames import ("]],"alchemy_kit.resources._better_logger":[],"alchemy_kit.resources.dialect_map._base":[["alchemy_kit.types.dialect_types",6,"from ...types.dialect_types import DialectTypes"],["alchemy_kit.types.py_type_parameters",7,"from ...types.py_type_parameters import PyTypeParameters"]],"alchemy_kit.connect._engine_manager":[["alchemy_kit.connect._engine_handler",9,"from ._engine_handler import EngineHandler"],["alchemy_kit.resources._better_logger",8,"from ..resources._better_logger import BetterLogger"],["alchemy_kit.connect._info",10,"from ._info import ConnectionInfo"]],"alchemy_kit.model.units":[["alchemy_kit.model.units._operand_unit",9,"from ._operand_unit import OperandUnit"],["alchemy_kit.model.units._object_unit",8,"from ._object_unit import ObjectUnit"],["alchemy_kit.model.units._column_unit",1,"from ._column_unit import ("]],"alchemy_kit.connect._engine_handler":[["alchemy_kit.connect._info",9,"from ._info import ConnectionInfo"],["alchemy_kit.types._sql_parameters",7,"from ..types._sql_parameters import SqlParamMap"],["alchemy_kit.resources._sql",6,"from ..resources._sql import SQL"],["alchemy_kit.types.sql_types",8,"from ..types.sql_types import SQL_EXPAND_CLASSES"]],"alchemy_kit.model._builders._build_py_file":[["alchemy_kit.resources._identifiers",5,"from ...resources._identifiers import Identifiers"],["alchemy_kit.model.base_model",11,"from ..base_model import BaseModel"],["alchemy_kit.model._model.column_model",8,"from .._model.column_model import ColumnModel"],["alchemy_kit.types",7,"from ...types import DialectTypes, sql_type_parameters"],["alchemy_kit.model._builders._check_parser",12,"from ._check_parser import ColumnComparisonCheck, IndexFilterCondition, parse_column_check, parse_index_filter, parse_table_check"],["alchemy_kit.types.sql_type_parameters",7,"from ...types import DialectTypes, sql_type_parameters"],["alchemy_kit.model._model.constraint_model",9,"from .._model.constraint_model import CheckConstraintModel, FilteredUniqueIndexModel"],["alchemy_kit.model._builders._column_metadata",13,"from ._column_metadata import ColumnMetadata, ForeignKeyMeta"],["alchemy_kit.resources.dialect_map",6,"from ...resources.dialect_map import get_codegen_imports, get_str_length, get_type, render_reference"],["alchemy_kit.model._model.object_model",10,"from .._model.object_model import ObjectModel"]],"alchemy_kit.types._sql_utilities":[],"alchemy_kit.model.units._operand_unit":[["alchemy_kit.resources._compiler",6,"from ...resources._compiler import new_sql_type"],["alchemy_kit.model.units._column_unit",8,"from ._column_unit import AggregateColumnUnit, ColumnUnit, WindowFunctionUnit"],["alchemy_kit.types.dialect_types",7,"from ...types.dialect_types import DialectTypes"]],"alchemy_kit.connect._drivers":[],"alchemy_kit.builder._base":[["alchemy_kit.model.units._object_unit",11,"from ..model.units._object_unit import ObjectUnit"],["alchemy_kit.connect._engine_handler",16,"from ..connect._engine_handler import EngineHandler"],["alchemy_kit.resources.dialect_map",13,"from ..resources.dialect_map import get_sa_dialect"],["alchemy_kit.model.base_model",9,"from ..model.base_model import BaseModel"],["alchemy_kit.model.units._column_unit",10,"from ..model.units._column_unit import _ExpressionUnit"],["alchemy_kit.resources._sql",12,"from ..resources._sql import SQL"]],"alchemy_kit.model._builders._model":[["alchemy_kit.resources._identifiers",4,"from ...resources._identifiers import Identifiers"],["alchemy_kit.resources._better_logger",3,"from ...resources._better_logger import BetterLogger"],["alchemy_kit.model._builders._build_py_file",6,"from ._build_py_file import PyFileBuilder"],["alchemy_kit.model._builders._build_stub_file",7,"from ._build_stub_file import StubFileBuilder"],["alchemy_kit.model._model.db_model",5,"from .._model.db_model import DBModel"]],"alchemy_kit.types.api_types":[],"alchemy_kit.builder._select":[["alchemy_kit.builder._base",8,"from ._base import SqlBuilder"],["alchemy_kit.types.sql_types",7,"from ..types.sql_types import SqlJoinTypes"],["alchemy_kit.model.units",6,"from ..model.units import BooleanColumnUnit, ColumnUnit, ObjectUnit, OrderingColumnUnit"]],"alchemy_kit.model._model_def._frames":[["alchemy_kit.model.base_model",4,"from ..base_model import BaseModel"]],"alchemy_kit.connect._conn_builders.mssql":[["alchemy_kit.types.api_types",7,"from ...types.api_types import SqlServerApi"],["alchemy_kit.types._driver_types",6,"from ...types import _driver_types"]],"alchemy_kit.model._utils":[["alchemy_kit.connect._engine_manager",8,"from ..connect._engine_manager import EngineManager"],["alchemy_kit.model._model.schema_model",16,"from ._model.schema_model import SchemaModel"],["alchemy_kit.model._model_def",17,"from ._model_def import ("],["alchemy_kit.model._model.constraint_model",13,"from ._model.constraint_model import CheckConstraintModel, FilteredUniqueIndexModel, ForeignKeyConstraintModel"],["alchemy_kit.model._model.column_model",12,"from ._model.column_model import ColumnModel, ForeignKeyModel"],["alchemy_kit.model._model.object_model",15,"from ._model.object_model import ObjectModel"],["alchemy_kit.connect._info",9,"from ..connect._info import ConnectionInfo"],["alchemy_kit.types._sql_utilities",11,"from ..types._sql_utilities import ObjectType"],["alchemy_kit.model._model.db_model",14,"from ._model.db_model import DBModel"],["alchemy_kit.resources._better_logger",10,"from ..resources._better_logger import BetterLogger"],["alchemy_kit.model._schema_config",26,"from ._schema_config import SchemaConfig"]],"alchemy_kit.model._model.column_model":[],"alchemy_kit.resources.dialect_map.oracle":[["alchemy_kit.types.py_type_parameters",9,"from ...types.py_type_parameters import PyTypeParameters"],["alchemy_kit.types.sql_type_parameters",10,"from ...types.sql_type_parameters import OracleTypeParameters"],["alchemy_kit.resources.dialect_map._base",8,"from ._base import ColumnLike, DialectMap, SaTypeFactory"],["alchemy_kit.types.dialect_types",3,"from alchemy_kit.types.dialect_types import DialectTypes"]],"alchemy_kit.resources.dir_helpers":[["alchemy_kit.resources._settings",4,"from ._settings import Settings"]],"alchemy_kit.model._model.db_model":[["alchemy_kit.model._model.schema_model",2,"from .schema_model import SchemaModel"],["alchemy_kit.types.dialect_types",1,"from ...types.dialect_types import DialectTypes"]],"alchemy_kit.types.py_type_parameters":[],"alchemy_kit.model._model":[],"alchemy_kit.model._model.object_model":[["alchemy_kit.model._model.constraint_model",2,"from .constraint_model import CheckConstraintModel, FilteredUniqueIndexModel, ForeignKeyConstraintModel"],["alchemy_kit.model._model.column_model",1,"from .column_model import ColumnModel"],["alchemy_kit.types._sql_utilities",3,"from ...types._sql_utilities import ObjectType"]],"alchemy_kit.model._model.constraint_model":[],"alchemy_kit.model._builders._check_parser":[["alchemy_kit.types.dialect_types",8,"from ...types.dialect_types import DialectTypes"]],"alchemy_kit.model.units._object_unit":[["alchemy_kit.model.units._column_unit",7,"from ._column_unit import ColumnUnit"],["alchemy_kit.model._table",6,"from .._table import table_from_model"],["alchemy_kit.model.base_model",5,"from ..base_model import BaseModel, MetaData"],["alchemy_kit.connect._engine_handler",10,"from ...connect._engine_handler import EngineHandler"]],"alchemy_kit.model":[["alchemy_kit.model._schema_config",2,"from ._schema_config import SchemaConfig"],["alchemy_kit.model._builder",1,"from ._builder import build"]],"alchemy_kit.resources._settings":[],"alchemy_kit.model._builders._svg":[["alchemy_kit.resources._better_logger",3,"from ...resources._better_logger import BetterLogger"],["alchemy_kit.model._model.db_model",4,"from .._model.db_model import DBModel"]],"alchemy_kit":[],"alchemy_kit.resources.dialect_map.mysql":[["alchemy_kit.types.py_type_parameters",9,"from ...types.py_type_parameters import PyTypeParameters"],["alchemy_kit.resources.dialect_map._base",8,"from ._base import ColumnLike, DialectMap, SaTypeFactory"],["alchemy_kit.types.dialect_types",3,"from alchemy_kit.types.dialect_types import DialectTypes"],["alchemy_kit.types.sql_type_parameters",10,"from ...types.sql_type_parameters import MysqlTypeParameters"]],"alchemy_kit.resources.dialect_map":[["alchemy_kit.resources.dialect_map.mssql",15,"from .mssql import MssqlMap"],["alchemy_kit.resources.dialect_map.mysql",16,"from .mysql import MysqlMap"],["alchemy_kit.types.py_type_parameters",12,"from ...types.py_type_parameters import PyTypeParameters"],["alchemy_kit.resources.dialect_map.mariadb",14,"from .mariadb import MariadbMap"],["alchemy_kit.resources.dialect_map.postgresql",18,"from .postgresql import PostgresqlMap"],["alchemy_kit.resources.dialect_map.sqlite",19,"from .sqlite import SqliteMap"],["alchemy_kit.types.dialect_types",11,"from ...types.dialect_types import DialectTypes"],["alchemy_kit.resources.dialect_map.oracle",17,"from .oracle import OracleMap"],["alchemy_kit.resources.dialect_map._base",13,"from ._base import ColumnLike, DialectMap, ReflectedTypeFacts"]],"alchemy_kit.model._model_def._extractor":[["alchemy_kit.resources._sql",11,"from ...resources._sql import SQL"],["alchemy_kit.resources.dialect_map",12,"from ...resources.dialect_map import DialectMap, ReflectedTypeFacts, get_map"],["alchemy_kit.model._model_def._frames",15,"from ._frames import ("],["alchemy_kit.model._schema_config",14,"from .._schema_config import SchemaConfig"],["alchemy_kit.types.dialect_types",13,"from ...types.dialect_types import DialectTypes"],["alchemy_kit.connect._engine_handler",10,"from ...connect._engine_handler import EngineHandler"]],"alchemy_kit.resources.dialect_map.postgresql":[["alchemy_kit.types.dialect_types",3,"from alchemy_kit.types.dialect_types import DialectTypes"],["alchemy_kit.types.sql_type_parameters",10,"from ...types.sql_type_parameters import PostgresqlTypeParameters"],["alchemy_kit.types.py_type_parameters",9,"from ...types.py_type_parameters import PyTypeParameters"],["alchemy_kit.resources.dialect_map._base",8,"from ._base import ColumnLike, DialectMap, ReflectedTypeFacts, SaTypeFactory"]],"alchemy_kit.resources.dialect_map.mssql":[["alchemy_kit.types.sql_type_parameters",9,"from ...types.sql_type_parameters import MssqlTypeParameters"],["alchemy_kit.resources.dialect_map._base",7,"from ._base import ColumnLike, DialectMap, ReflectedTypeFacts, SaTypeFactory"],["alchemy_kit.types.dialect_types",3,"from alchemy_kit.types.dialect_types import DialectTypes"],["alchemy_kit.types.py_type_parameters",8,"from ...types.py_type_parameters import PyTypeParameters"]],"alchemy_kit.connect._conn_builders":[],"alchemy_kit.types.errors._model_validation_error":[],"alchemy_kit.connect._info":[["alchemy_kit.resources.dir_helpers",8,"from ..resources.dir_helpers import find_project_root"],["alchemy_kit.types.dialect_types",7,"from ..types.dialect_types import DialectTypes"]],"alchemy_kit.types._sql_parameters":[["alchemy_kit.types.sql_types",2,"from .sql_types import SqlParamType"]],"alchemy_kit.model.base_model":[["alchemy_kit.model.units._object_unit",176,"from .units._object_unit import ObjectUnit"],["alchemy_kit.model.units._object_unit",16,"from .units._object_unit import ObjectUnit"],["alchemy_kit.model._builders._column_metadata",128,"from ._builders._column_metadata import ColumnMetadata"],["alchemy_kit.connect._engine_handler",14,"from ..connect._engine_handler import EngineHandler"],["alchemy_kit.model._builders._column_metadata",15,"from ._builders._column_metadata import ForeignKeyMeta"],["alchemy_kit.types.errors._model_validation_error",11,"from ..types.errors._model_validation_error import ModelValidationError"],["alchemy_kit.resources._sql",10,"from ..resources._sql import SQL"]],"alchemy_kit.types.sql_types":[],"alchemy_kit.types":[["alchemy_kit.types.generic_path",4,"from .generic_path import GenericPath"],["alchemy_kit.types._driver_types",1,"from ._driver_types import SqlServerNative, SqlServerODBC"],["alchemy_kit.types._sql_parameters",2,"from ._sql_parameters import SqlParamters, SqlTextReplacement, SqlParamMap"],["alchemy_kit.types.dialect_types",3,"from .dialect_types import DialectTypes, DialectTypesInput"]],"alchemy_kit.connect":[["alchemy_kit.connect._info",4,"from ._info import ConnectionInfo"],["alchemy_kit.connect._engine_handler",2,"from ._engine_handler import EngineHandler"],["alchemy_kit.connect._engine_manager",3,"from ._engine_manager import EngineManager"],["alchemy_kit.connect.info_builder",1,"from . import info_builder"]],"alchemy_kit.resources._identifiers":[],"alchemy_kit.connect.info_builder":[["alchemy_kit.types.dialect_types",13,"from ..types.dialect_types import DialectTypes"],["alchemy_kit.types.generic_path",14,"from ..types.generic_path import GenericPath"],["alchemy_kit.connect._conn_builders.mssql",15,"from ._conn_builders import mssql"],["alchemy_kit.types._driver_types",10,"from ..types import _driver_types"],["alchemy_kit.connect._drivers",16,"from ._drivers import require_driver"],["alchemy_kit.types.api_types",11,"from ..types.api_types import SqlServerApi"],["alchemy_kit.types.auth_types",12,"from ..types.auth_types import AuthType"],["alchemy_kit.resources._settings",9,"from ..resources._settings import Settings"],["alchemy_kit.connect._info",17,"from ._info import ConnectionInfo"]],"alchemy_kit.types.auth_types":[],"alchemy_kit.model._builders":[["alchemy_kit.model._builders._svg",2,"from ._svg import build_svg"],["alchemy_kit.model._builders._model",1,"from ._model import build_model"]],"alchemy_kit.resources.dialect_map.mariadb":[["alchemy_kit.resources.dialect_map._base",10,"from ._base import ColumnLike, DialectMap, SaTypeFactory"],["alchemy_kit.types.sql_type_parameters",12,"from ...types.sql_type_parameters import MariadbTypeParameters"],["alchemy_kit.types.dialect_types",3,"from alchemy_kit.types.dialect_types import DialectTypes"],["alchemy_kit.types.py_type_parameters",11,"from ...types.py_type_parameters import PyTypeParameters"]],"alchemy_kit.model._builders._column_metadata":[],"alchemy_kit.builder":[["alchemy_kit.builder._base",1,"from ._base import SqlBuilder"],["alchemy_kit.builder._temp",4,"from ._temp import TempBuilder"],["alchemy_kit.builder._select",3,"from ._select import SelectBuilder"],["alchemy_kit.builder._insert",2,"from ._insert import InsertBuilder"]],"alchemy_kit.resources":[["alchemy_kit.resources._sql",3,"from ._sql import SQL"],["alchemy_kit.resources._settings",2,"from ._settings import Settings"],["alchemy_kit.resources._better_logger",1,"from ._better_logger import BetterLogger"]]}

{alchemy_kit-0.2.1 → alchemy_kit-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alchemy-kit
-Version: 0.2.1
+Version: 0.2.2
 Summary: Add your description here
 License-File: LICENSE
 Requires-Python: >=3.12

{alchemy_kit-0.2.1 → alchemy_kit-0.2.2}/alchemy_kit/builder/_base.py

@@ -7,6 +7,8 @@ from sqlalchemy.engine import Dialect
 from sqlalchemy.sql.expression import ClauseElement
 
 from ..model.base_model import BaseModel
+from ..model.units._column_unit import _ExpressionUnit
+from ..model.units._object_unit import ObjectUnit
 from ..resources._sql import SQL
 from ..resources.dialect_map import get_sa_dialect
 
@@ -16,18 +18,25 @@ if TYPE_CHECKING:
 
 class SqlBuilder(ABC):
     """Base of every SQL statement builder: assembles a SQLAlchemy Core
-    statement from units and compiles it against the model's dialect.
-    Subclasses implement ``_statement``; builders are immutable."""
+    statement from units and compiles it against the dialect of the engine
+    handler the units came from. Subclasses implement ``_statement``;
+    builders are immutable."""
 
-    def __init__(self, base: type[BaseModel[Any]]) -> None:
+    def __init__(self, base: type[BaseModel[Any]], handler: "EngineHandler") -> None:
         self._base = base
+        self._handler = handler
+
+    def _check_units(self, *units: "_ExpressionUnit[Any] | ObjectUnit[Any]") -> None:
+        for unit in units:
+            if unit._handler is not None and unit._handler is not self._handler:
+                raise ValueError("all units in a query must come from the same engine handler")
 
     @abstractmethod
     def _statement(self) -> ClauseElement:
         """Return the Core statement this builder currently describes."""
 
     def _sa_dialect(self) -> Dialect:
-        return get_sa_dialect(self._base._dialect)
+        return get_sa_dialect(self._handler._con_info.dialect)
 
     def _compile(self) -> Compiled:
         return self._statement().compile(
@@ -50,7 +59,8 @@ class SqlBuilder(ABC):
         ``:name`` placeholders for bound values."""
         return str(self._compile())
 
-    def run(self, handler: "EngineHandler", **parameters: Any) -> tuple[int | None, pd.DataFrame]:
-        """Compile and execute through ``handler.run_sql``, returning its
-        ``(row_count, DataFrame)`` pair."""
-        return handler.run_sql(self.to_sql(**parameters))
+    def run(self, **parameters: Any) -> tuple[int | None, pd.DataFrame]:
+        """Compile and execute on the engine handler the units came from,
+        returning its ``(row_count, DataFrame)`` pair."""
+        sql = self.to_sql(**parameters)
+        return self._handler.run_sql(sql)

alchemy_kit-0.2.2/alchemy_kit/builder/_insert.py

@@ -0,0 +1,152 @@
+from typing import Any, Sequence, cast
+
+import pandas as pd
+import sqlalchemy as sa
+from sqlalchemy.sql.expression import Insert
+
+from ..model.units import ColumnUnit, ObjectUnit
+from ..resources._sql import SQL
+from ..resources.dialect_map import get_map
+from ..types.sql_types import SqlScalarType
+from ._base import SqlBuilder
+from ._select import SelectBuilder
+
+
+class InsertBuilder(SqlBuilder):
+    """Builds an ``INSERT`` into an object unit's table; rows come from
+    :meth:`from_values`, :meth:`from_dataframe` or :meth:`from_select`.
+
+    These methods layer onto the statement rather than reset it: repeated
+    :meth:`from_values` merge columns (last wins per column), repeated
+    :meth:`from_dataframe` append rows, and repeated :meth:`from_select`
+    replaces the prior SELECT. Mixing value sources (single vs multi VALUES,
+    or values vs SELECT) raises ``InvalidRequestError``."""
+
+    def __init__(self, target: ObjectUnit[Any]) -> None:
+        super().__init__(target._base, target._handler)
+
+        selectable = target._selectable
+        if not isinstance(selectable, sa.Table):
+            raise TypeError("insert target must be a plain object unit, not an aliased one")
+
+        self._table = selectable
+        self._stmt: Insert = sa.insert(selectable)
+
+    def _with(self, stmt: Insert) -> "InsertBuilder":
+        clone = InsertBuilder.__new__(InsertBuilder)
+        SqlBuilder.__init__(clone, self._base, self._handler)
+        clone._table = self._table
+        clone._stmt = stmt
+        return clone
+
+    def _statement(self) -> Insert:
+        return self._stmt
+
+    def _sql_name(self, name: str) -> str:
+        sql_name = getattr(self._base, name, name)
+        return sql_name if isinstance(sql_name, str) else name
+    
+    def get_parameters(self) -> dict[str, SqlScalarType] | list[dict[str, SqlScalarType]]:
+        """Return the values to insert, keyed by SQL column name: a dict for
+        :meth:`from_values`, one dict per row for :meth:`from_dataframe`
+        (empty for select inserts)."""
+        if multi_values := self._stmt._multi_values:
+            rows = cast("tuple[Sequence[dict[str, SqlScalarType]], ...]", multi_values)
+            return [dict(row) for group in rows for row in group]
+
+        if not (values := self._stmt._values):
+            return {}
+
+        return {str(column): parameter.value for column, parameter in values.items()}
+
+    def from_values(self, **column_values: SqlScalarType) -> "InsertBuilder":
+        """Set the inserted row's values by model field (or SQL column)
+        name; plain values are bound as parameters."""
+        resolved = {
+            self._sql_name(name): ColumnUnit._value_operand(value)
+            for name, value in column_values.items()
+        }
+        return self._with(self._stmt.values(**resolved))
+
+    def from_dataframe(
+        self,
+        df: pd.DataFrame,
+        columns: Sequence[str] | None = None,
+    ) -> "InsertBuilder":
+        """Insert every row of ``df`` as one multi-row ``INSERT``;
+        ``columns`` selects and orders which columns (all when omitted)."""
+        source = list(df.columns) if columns is None else list(columns)
+        target = {name: self._sql_name(name) for name in source}
+        
+        rows = [
+            {target[name]: ColumnUnit._value_operand(record[name]) for name in source}
+            for record in df.to_dict(orient="records")
+        ]
+        return self._with(self._stmt.values(rows))
+
+    def from_select(
+        self,
+        select: SelectBuilder,
+        columns: Sequence[str] | None = None,
+    ) -> "InsertBuilder":
+        """Insert the rows produced by a :class:`SelectBuilder`
+        (``INSERT INTO ... SELECT``); ``columns`` names the targets in the
+        select's output order (the select's own names when omitted)."""
+        if select._handler is not self._handler:
+            raise ValueError("all units in a query must come from the same engine handler")
+        stmt = select._statement()
+
+        if columns is not None:
+            names = [self._sql_name(name) for name in columns]
+        else:
+            names = list(stmt.selected_columns.keys())
+
+        return self._with(self._stmt.from_select(names, stmt))
+
+    def run(self, *, chunk_size: int | None = None, **parameters: Any) -> tuple[int | None, pd.DataFrame]:
+        """Execute the insert; a multi-row ``from_dataframe`` insert that would
+        exceed the dialect's per-statement row/parameter limits (or
+        ``chunk_size`` when given) is split into chunks run in one
+        all-or-nothing transaction."""
+        rows = [row for group in self._stmt._multi_values for row in group]
+        effective = self._effective_chunk_size(chunk_size, rows)
+
+        if effective is None or len(rows) <= effective:
+            return super().run(**parameters)
+
+        sqls = [
+            self._chunk_sql(rows[start:start + effective])
+            for start in range(0, len(rows), effective)
+        ]
+        counts = [count for count, _ in self._handler.run_sqls(sqls)]
+
+        if any(count is None for count in counts):
+            return None, pd.DataFrame()
+        return sum(cast("list[int]", counts)), pd.DataFrame()
+
+    def _effective_chunk_size(self, chunk_size: int | None, rows: Sequence[Any]) -> int | None:
+        if not rows:
+            return None
+
+        limits = get_map(self._handler._con_info.dialect)
+        caps: list[int] = []
+        if limits.max_insert_rows is not None:
+            caps.append(limits.max_insert_rows)
+        if limits.max_statement_params is not None:
+            caps.append(limits.max_statement_params // len(rows[0]))
+
+        safe_max = min(caps) if caps else None
+
+        if chunk_size is None:
+            return safe_max
+        if safe_max is None:
+            return chunk_size
+        return min(chunk_size, safe_max)
+
+    def _chunk_sql(self, chunk: Sequence[Any]) -> SQL:
+        compiled = sa.insert(self._table).values(list(chunk)).compile(
+            dialect=self._sa_dialect(),
+            compile_kwargs={"render_postcompile": True},
+        )
+        return SQL(raw_query=str(compiled), query_parameters={**(compiled.params or {})})
+

{alchemy_kit-0.2.1 → alchemy_kit-0.2.2}/alchemy_kit/builder/_select.py

@@ -3,7 +3,7 @@ from typing import Any
 import sqlalchemy as sa
 from sqlalchemy.sql.expression import ColumnElement, FromClause, Join, Select
 
-from ..model.units import BooleanColumnUnit, ColumnUnit, ObjectUnit
+from ..model.units import BooleanColumnUnit, ColumnUnit, ObjectUnit, OrderingColumnUnit
 from ..types.sql_types import SqlJoinTypes
 from ._base import SqlBuilder
 
@@ -16,14 +16,20 @@ _JOIN_FLAGS: dict[SqlJoinTypes, dict[str, bool]] = {
 
 class SelectBuilder(SqlBuilder):
     """Builds a ``SELECT`` statement from column and/or object units; the
-    dialect comes from the first unit's model and every fluent method
-    returns a new builder."""
+    dialect comes from the first bound unit's engine handler and every
+    fluent method returns a new builder."""
 
     def __init__(self, *columns: "ColumnUnit[Any] | ObjectUnit[Any]") -> None:
         if not columns:
             raise ValueError("SelectBuilder needs at least one column or object unit")
 
-        super().__init__(columns[0]._base)
+        base = next((c._base for c in columns if c._base is not None), None)
+        handler = next((c._handler for c in columns if c._handler is not None), None)
+        if base is None or handler is None:
+            raise ValueError("SelectBuilder needs at least one unit bound to a model")
+
+        super().__init__(base, handler)
+        self._check_units(*columns)
         self._stmt: Select[Any] = sa.select(*(self._selected(c) for c in columns))
         self._from: FromClause | None = None
 
@@ -41,6 +47,12 @@ class SelectBuilder(SqlBuilder):
     def _column_element(column: ColumnUnit[Any]) -> ColumnElement[Any]:
         return column._element
 
+    @staticmethod
+    def _ordering_element(
+        column: "ColumnUnit[Any] | OrderingColumnUnit[Any]",
+    ) -> ColumnElement[Any]:
+        return column._element
+
     @staticmethod
     def _required_condition(
         how: SqlJoinTypes, on: "BooleanColumnUnit[Any] | None"
@@ -53,7 +65,7 @@ class SelectBuilder(SqlBuilder):
         self, stmt: Select[Any], joined: FromClause | None = None
     ) -> "SelectBuilder":
         clone = SelectBuilder.__new__(SelectBuilder)
-        SqlBuilder.__init__(clone, self._base)
+        SqlBuilder.__init__(clone, self._base, self._handler)
         clone._stmt = stmt
         clone._from = joined if joined is not None else self._from
         return clone
@@ -65,6 +77,7 @@ class SelectBuilder(SqlBuilder):
 
     def where(self, *conditions: BooleanColumnUnit[Any]) -> "SelectBuilder":
         """Add ``WHERE`` conditions (multiple conditions are ``AND``-ed)."""
+        self._check_units(*conditions)
         return self._with(
             self._stmt.where(*(self._condition_element(c) for c in conditions))
         )
@@ -78,6 +91,7 @@ class SelectBuilder(SqlBuilder):
         """Add a join to ``other``; ``CROSS`` takes no ``on`` condition and
         ``RIGHT`` compiles as the equivalent operand-flipped ``LEFT OUTER
         JOIN``."""
+        self._check_units(*(other,) if on is None else (other, on))
         left = self._from if self._from is not None else self._stmt.get_final_froms()[0]
 
         joined: Join
@@ -102,21 +116,26 @@ class SelectBuilder(SqlBuilder):
 
     def group_by(self, *columns: ColumnUnit[Any]) -> "SelectBuilder":
         """Add ``GROUP BY`` expressions."""
+        self._check_units(*columns)
         return self._with(
             self._stmt.group_by(*(self._column_element(c) for c in columns))
         )
 
     def having(self, *conditions: BooleanColumnUnit[Any]) -> "SelectBuilder":
         """Add ``HAVING`` conditions (multiple conditions are ``AND``-ed)."""
+        self._check_units(*conditions)
         return self._with(
             self._stmt.having(*(self._condition_element(c) for c in conditions))
         )
 
-    def order_by(self, *columns: ColumnUnit[Any]) -> "SelectBuilder":
+    def order_by(
+        self, *columns: "ColumnUnit[Any] | OrderingColumnUnit[Any]"
+    ) -> "SelectBuilder":
         """Add ``ORDER BY`` expressions (direction via the column's
         ``asc()``/``desc()``)."""
+        self._check_units(*columns)
         return self._with(
-            self._stmt.order_by(*(self._column_element(c) for c in columns))
+            self._stmt.order_by(*(self._ordering_element(c) for c in columns))
         )
 
     def distinct(self) -> "SelectBuilder":

{alchemy_kit-0.2.1 → alchemy_kit-0.2.2}/alchemy_kit/builder/_temp.py

@@ -3,6 +3,7 @@ from typing import Any
 import sqlalchemy as sa
 from sqlalchemy.schema import CreateTable
 
+from ..model._table import clone_table
 from ..model.units import ObjectUnit
 from ..types.dialect_types import DialectTypes
 from ._base import SqlBuilder
@@ -17,34 +18,27 @@ class TempBuilder(SqlBuilder):
     """
 
     def __init__(self, source: ObjectUnit[Any], global_temp: bool = False) -> None:
-        super().__init__(source._base)
+        super().__init__(source._base, source._handler)
 
         table = source._selectable
         if not isinstance(table, sa.Table):
             raise TypeError("temp source must be a plain object unit, not an aliased one")
 
+        dialect = self._handler._con_info.dialect
         temp_name = f"TEMP_{table.name}"
         prefixes: list[str] = ["TEMPORARY"]
 
-        if self._base._dialect is DialectTypes.MSSQL:
+        if dialect is DialectTypes.MSSQL:
             temp_name = f"{'##' if global_temp else '#'}{temp_name}"
             prefixes = []
-        elif self._base._dialect is DialectTypes.ORACLE:
+        elif dialect is DialectTypes.ORACLE:
             prefixes = ["GLOBAL TEMPORARY"]
         elif global_temp:
             raise ValueError(
-                f"{self._base._dialect} does not support global temporary tables"
+                f"{dialect} does not support global temporary tables"
             )
 
-        self._table = sa.Table(
-            temp_name,
-            sa.MetaData(),
-            *(
-                sa.Column(c.name, c.type, nullable=c.nullable, primary_key=c.primary_key)
-                for c in table.columns
-            ),
-            prefixes=prefixes,
-        )
+        self._table = clone_table(table, temp_name, prefixes)
 
     def _statement(self) -> CreateTable:
         return CreateTable(self._table)
@@ -52,5 +46,5 @@ class TempBuilder(SqlBuilder):
     def unit(self) -> ObjectUnit[Any]:
         """Return an :class:`ObjectUnit` over the temporary table, for
         selecting from / inserting into it after :meth:`run`."""
-        return ObjectUnit(self._base, self._table)
+        return ObjectUnit(self._base, self._handler, self._table)
 

{alchemy_kit-0.2.1 → alchemy_kit-0.2.2}/alchemy_kit/connect/_engine_handler.py

@@ -1,14 +1,18 @@
-from typing import Literal, Sequence, cast
+from typing import Literal, Protocol, Sequence, cast
 
 import pandas as pd
 import sqlalchemy
 
 from ..resources._sql import SQL
 from ..types._sql_parameters import SqlParamMap
-from ..types.sql_types import SqlExpandType
+from ..types.sql_types import SQL_EXPAND_CLASSES
 from ._info import ConnectionInfo
 
 
+class _UnitFactory[_UnitT](Protocol):
+    def _get_unit(self, handler: "EngineHandler") -> _UnitT: ...
+
+
 class EngineHandler:
     """Performs database operations against a single pooled engine.
 
@@ -25,6 +29,11 @@ class EngineHandler:
         self._engine = engine
         self._con_info = con_info
 
+    def get_unit[_UnitT](self, model: _UnitFactory[_UnitT]) -> _UnitT:
+        """Return a unit for ``model``, bound to this handler's connection and
+        compiled with its dialect."""
+        return model._get_unit(self)
+
     def get_inspector(self) -> sqlalchemy.Inspector:
         """Return a SQLAlchemy ``Inspector`` bound to this handler's engine."""
         return sqlalchemy.inspect(self._engine)
@@ -93,7 +102,7 @@ class EngineHandler:
 
     def _execute_with_binded_parameters(self, conn: sqlalchemy.Connection, query: sqlalchemy.TextClause, parameters: SqlParamMap) -> sqlalchemy.CursorResult:
         binds = [
-            sqlalchemy.bindparam(key, value, expanding=isinstance(value, SqlExpandType))
+            sqlalchemy.bindparam(key, value, expanding=isinstance(value, SQL_EXPAND_CLASSES))
             for key, value in parameters.items()
         ]
 

{alchemy_kit-0.2.1 → alchemy_kit-0.2.2}/alchemy_kit/connect/_info.py

@@ -1,7 +1,6 @@
 import random
 import string
 from pathlib import Path
-from typing import Optional
 
 import sqlalchemy
 
@@ -29,7 +28,7 @@ class ConnectionInfo:
             resolved or set.
     """
 
-    def __init__(self, conn_url: sqlalchemy.URL, unique_id: Optional[str]) -> None:
+    def __init__(self, conn_url: sqlalchemy.URL, unique_id: str | None = None) -> None:
         self.script_dir: Path | None = None
         self.con_url = conn_url
         self.dialect = self._resolve_dialect(conn_url)

{alchemy_kit-0.2.1 → alchemy_kit-0.2.2}/alchemy_kit/model/_builders/_build_py_file.py

@@ -33,7 +33,7 @@ class PyFileBuilder:
         }
 
     def build(self) -> str:
-        map_module, parameter_map, type_parameters = get_codegen_imports(self.db_dialect)
+        _, _, type_parameters = get_codegen_imports(self.db_dialect)
         check_methods, unparsed_table_checks = self._build_table_checks()
         index_methods, unparsed_indexes = self._build_index_checks()
         check_methods += index_methods
@@ -41,13 +41,9 @@ class PyFileBuilder:
         template = self.template.read_text("UTF-8")
         template = template.format(
             class_name=self.class_name,
-            dialect=f"DialectTypes.{self.db_dialect.name}",
             base_model_module=BaseModel.__module__,
-            dialect_types_module=DialectTypes.__module__,
             type_parameters_module=sql_type_parameters.__name__,
             type_parameters=type_parameters,
-            parameter_map_module=map_module,
-            parameter_map=parameter_map,
             unique=f"unique={self.object_model.get_unique_constrait()!r}",
             metadata=self._get_object_metadata(unparsed_table_checks, unparsed_indexes),
         )

{alchemy_kit-0.2.1 → alchemy_kit-0.2.2}/alchemy_kit/model/_builders/_build_stub_file.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import ClassVar
 
+from ...connect._engine_handler import EngineHandler
 from ...resources.dialect_map import get_codegen_imports, get_type
 from ...types import DialectTypes, sql_type_parameters
 from .._model.column_model import ColumnModel
@@ -27,6 +28,7 @@ class StubFileBuilder:
         template = self.template.read_text("UTF-8").format(
             class_name=self.class_name,
             base_model_module=BaseModel.__module__,
+            engine_handler_module=EngineHandler.__module__,
             object_unit_module=units.__name__,
             column_unit_module=units.__name__,
             type_parameters_module=sql_type_parameters.__name__,

{alchemy_kit-0.2.1 → alchemy_kit-0.2.2}/alchemy_kit/model/_builders/py_template_file.txt

@@ -9,9 +9,7 @@
 # --------------------------------------------------------------------------------
 
 from {base_model_module} import BaseModel, MetaData
-from {dialect_types_module} import DialectTypes
 from {type_parameters_module} import {type_parameters}
-from {parameter_map_module} import {parameter_map}
 from datetime import datetime, date
 from pandera.typing import Series
 from typing import Optional, Any
@@ -19,9 +17,6 @@ import pandas as pd
 import pandera.pandas as pa
 
 class {class_name}(BaseModel[{type_parameters}]):
-    _dialect = {dialect}
-    _map = {parameter_map}
-
     :columns
 
     :checks

{alchemy_kit-0.2.1 → alchemy_kit-0.2.2}/alchemy_kit/model/_builders/stub_template_file.txt

@@ -9,6 +9,7 @@
 # --------------------------------------------------------------------------------
 
 from {base_model_module} import BaseModel
+from {engine_handler_module} import EngineHandler
 from {object_unit_module} import ObjectUnit
 from {column_unit_module} import ColumnUnit
 from {type_parameters_module} import {type_parameters}
@@ -20,7 +21,7 @@ class {class_name}(BaseModel[{type_parameters}]):
     :columns
 
     @classmethod
-    def get_unit(cls) -> {class_name}_Unit: ...
+    def _get_unit(cls, handler: EngineHandler) -> {class_name}_Unit: ...
 
 class {class_name}_Unit(ObjectUnit[{type_parameters}]):
     :unit_columns

alchemy_kit-0.2.2/alchemy_kit/model/_table.py

@@ -0,0 +1,62 @@
+from typing import Any
+
+import sqlalchemy as sa
+
+from ..resources.dialect_map import DialectMap, get_map
+from ..types.dialect_types import DialectTypes
+from ._builders._column_metadata import ColumnMetadata
+from .base_model import BaseModel
+
+_TABLES: dict[tuple[type[BaseModel[Any]], DialectTypes], sa.Table] = {}
+
+
+def _column_from_model(name: str, column: Any, dialect_map: type[DialectMap[Any]]) -> sa.Column[Any]:
+    metadata = ColumnMetadata.from_dict(column.metadata)
+    sa_type = dialect_map.get_sa_type(
+        metadata.original_type, metadata.precision, metadata.scale
+    )
+
+    return sa.Column(
+        name,
+        sa_type,
+        nullable=bool(column.nullable),
+        primary_key=metadata.primary_key,
+    )
+
+
+def table_from_model(base: type[BaseModel[Any]], dialect: DialectTypes) -> sa.Table:
+    """Return the SQLAlchemy Core ``Table`` for a generated model, built in
+    memory from the model's metadata (no reflection) and cached per
+    ``(model, dialect)``.
+
+    Columns carry the dialect's SQLAlchemy type (parameterised with the
+    recorded precision/scale for numerics), nullability, and primary-key
+    flags, so the table serves both expression compilation and DDL rendering.
+    """
+    if (base, dialect) not in _TABLES:
+        metadata = base.Config.metadata
+        dialect_map = get_map(dialect)
+        _TABLES[base, dialect] = sa.Table(
+            metadata["obj_name"],
+            sa.MetaData(),
+            *(
+                _column_from_model(str(name), column, dialect_map)
+                for name, column in base.to_schema().columns.items()
+            ),
+            schema=metadata["schema_name"],
+        )
+    return _TABLES[base, dialect]
+
+
+def clone_table(source: sa.Table, name: str, prefixes: list[str]) -> sa.Table:
+    """Return a new ``Table`` named ``name`` cloning ``source``'s columns, with
+    the given DDL ``prefixes`` (e.g. ``TEMPORARY``)."""
+    return sa.Table(
+        name,
+        sa.MetaData(),
+        *(
+            sa.Column(c.name, c.type, nullable=c.nullable, primary_key=c.primary_key)
+            for c in source.columns
+        ),
+        prefixes=prefixes,
+    )