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

{alchemy_kit-0.2.0 → alchemy_kit-0.2.1}/.gitignore

@@ -1,4 +1,5 @@
 secret*
+.env*
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

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

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

{alchemy_kit-0.2.0 → alchemy_kit-0.2.1}/alchemy_kit/connect/__init__.py

@@ -1,8 +1,10 @@
+from . import info_builder
 from ._engine_handler import EngineHandler
 from ._engine_manager import EngineManager
 from ._info import ConnectionInfo
 
 __all__ = [
+    "info_builder",
     "EngineHandler",
     "EngineManager",
     "ConnectionInfo",

{alchemy_kit-0.2.0 → alchemy_kit-0.2.1}/alchemy_kit/connect/_conn_builders/mssql.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from pydantic import SecretStr
 import sqlalchemy
 
@@ -5,6 +7,18 @@ from ...types import _driver_types
 from ...types.api_types import SqlServerApi
 
 
+def _tls_query(
+    encrypt: Optional[bool],
+    trust_server_certificate: Optional[bool],
+) -> dict[str, str]:
+    query: dict[str, str] = {}
+    if encrypt is not None:
+        query["Encrypt"] = "yes" if encrypt else "no"
+    if trust_server_certificate is not None:
+        query["TrustServerCertificate"] = "yes" if trust_server_certificate else "no"
+    return query
+
+
 def sql_auth(
     driver: _driver_types.SqlServerDrivers,
     server: str,
@@ -12,6 +26,8 @@ def sql_auth(
     user_name: str,
     user_pwd: SecretStr,
     api: SqlServerApi,
+    encrypt: Optional[bool] = None,
+    trust_server_certificate: Optional[bool] = None,
 ) -> sqlalchemy.URL:
 
     if isinstance(driver, _driver_types.SqlServerODBC):
@@ -25,6 +41,7 @@ def sql_auth(
                 "driver": driver,
                 "ApplicationIntent": "ReadWrite",
                 "MultiSubnetFailover": "yes",
+                **_tls_query(encrypt, trust_server_certificate),
             }
         )
 
@@ -37,6 +54,7 @@ def sql_auth(
             database=database,
             query={
                 "driver": driver,
+                **_tls_query(encrypt, trust_server_certificate),
             }
         )
 
@@ -46,6 +64,8 @@ def microsoft_auth(
     server: str,
     database: str,
     api: SqlServerApi,
+    encrypt: Optional[bool] = None,
+    trust_server_certificate: Optional[bool] = None,
 ) -> sqlalchemy.URL:
     return sqlalchemy.URL.create(
         drivername=f"mssql+{api}",
@@ -56,5 +76,6 @@ def microsoft_auth(
             "Trusted_Connection": "yes",
             "ApplicationIntent": "ReadWrite",
             "MultiSubnetFailover": "yes",
+            **_tls_query(encrypt, trust_server_certificate),
         }
     )

{alchemy_kit-0.2.0 → alchemy_kit-0.2.1}/alchemy_kit/connect/info_builder.py

@@ -84,6 +84,20 @@ def from_env(env_path: GenericPath) -> ConnectionInfo:
 
     return _match_dialect(dialect, env_data.get(Settings.FileExtraction.unique_id_marker), env_data)
 
+_TRUE_VALUES = {"yes", "true", "1", "on"}
+_FALSE_VALUES = {"no", "false", "0", "off"}
+
+def _parse_optional_bool(value: Optional[str]) -> Optional[bool]:
+    """Parse a connection-file flag into a tri-state bool (``None`` when unset)."""
+    if value is None or value == "":
+        return None
+    normalized = value.strip().lower()
+    if normalized in _TRUE_VALUES:
+        return True
+    if normalized in _FALSE_VALUES:
+        return False
+    raise ValueError(f"Expected a boolean-like value, got {value!r}")
+
 def _match_dialect(dialect: DialectTypes, unique_id: Optional[str], conn_data: dict[str, str]) -> ConnectionInfo: # CONTINUE
     """Dispatch a parsed connection definition to the right dialect builder.
 
@@ -109,6 +123,10 @@ def _match_dialect(dialect: DialectTypes, unique_id: Optional[str], conn_data: d
         case DialectTypes.MSSQL:
             driver = _driver_types.parse_sql_server_driver(conn_data[Settings.FileExtraction.driver_marker])
             api = SqlServerApi(conn_data.get(Settings.FileExtraction.api_marker, SqlServerApi.PYODBC))
+            encrypt = _parse_optional_bool(conn_data.get(Settings.FileExtraction.encrypt_marker))
+            trust_server_certificate = _parse_optional_bool(
+                conn_data.get(Settings.FileExtraction.trust_server_certificate_marker)
+            )
 
             if auth == AuthType.SQL_AUTH:
                 return from_values_mssql(
@@ -119,7 +137,9 @@ def _match_dialect(dialect: DialectTypes, unique_id: Optional[str], conn_data: d
                     user_name=conn_data[Settings.FileExtraction.user_name_marker],
                     user_pwd=SecretStr(conn_data[Settings.FileExtraction.user_pwd_marker]),
                     unique_id=unique_id,
-                    api=cast(SqlServerApi, api)
+                    api=cast(SqlServerApi, api),
+                    encrypt=encrypt,
+                    trust_server_certificate=trust_server_certificate,
                 )
             elif auth == AuthType.MICROSOFT_AUTH:
                 return from_values_mssql(
@@ -128,7 +148,9 @@ def _match_dialect(dialect: DialectTypes, unique_id: Optional[str], conn_data: d
                     conn_data[Settings.FileExtraction.server_marker],
                     conn_data[Settings.FileExtraction.database_marker],
                     unique_id=unique_id,
-                    api=api
+                    api=api,
+                    encrypt=encrypt,
+                    trust_server_certificate=trust_server_certificate,
                 )
             else:
                 raise ValueError(f"'{auth}' is not a supported authentication method")
@@ -157,6 +179,8 @@ def from_values_mssql(
     *,
     unique_id: Optional[str] = None,
     api: SqlServerApi = SqlServerApi.PYODBC,
+    encrypt: Optional[bool] = None,
+    trust_server_certificate: Optional[bool] = None,
 ) -> ConnectionInfo: ...
 @overload
 def from_values_mssql(
@@ -169,6 +193,8 @@ def from_values_mssql(
     user_pwd: SecretStr,
     unique_id: Optional[str] = None,
     api: SqlServerApi = SqlServerApi.PYODBC,
+    encrypt: Optional[bool] = None,
+    trust_server_certificate: Optional[bool] = None,
 ) -> ConnectionInfo: ...
 
 def from_values_mssql(
@@ -181,6 +207,8 @@ def from_values_mssql(
     user_pwd: Optional[SecretStr] = None,
     unique_id: Optional[str] = None,
     api: SqlServerApi = SqlServerApi.PYODBC,
+    encrypt: Optional[bool] = None,
+    trust_server_certificate: Optional[bool] = None,
 ) -> ConnectionInfo:
     """Build a SQL Server connection from individual values.
 
@@ -214,10 +242,16 @@ def from_values_mssql(
         case AuthType.SQL_AUTH:
             if user_name is None or user_pwd is None:
                 raise ValueError("SQL Authentication needs user_name and 'user_pwd' to be 'passed'")
-            conn_url = mssql.sql_auth(driver, server, database, user_name, user_pwd, api)
+            conn_url = mssql.sql_auth(
+                driver, server, database, user_name, user_pwd, api,
+                encrypt, trust_server_certificate,
+            )
 
         case AuthType.MICROSOFT_AUTH:
-            conn_url = mssql.microsoft_auth(driver, server, database, api)
+            conn_url = mssql.microsoft_auth(
+                driver, server, database, api,
+                encrypt, trust_server_certificate,
+            )
 
     return ConnectionInfo(conn_url, unique_id)
 

{alchemy_kit-0.2.0 → alchemy_kit-0.2.1}/alchemy_kit/model/_model_def/_extractor.py

@@ -1,11 +1,14 @@
 import re
+from pathlib import Path
 from typing import Any, Mapping, Sequence
 
 import pandas as pd
 from pandera.typing import DataFrame
+from sqlalchemy.engine.interfaces import ReflectedCheckConstraint, ReflectedUniqueConstraint
 from sqlalchemy.exc import NoSuchTableError
 
 from ...connect._engine_handler import EngineHandler
+from ...resources._sql import SQL
 from ...resources.dialect_map import DialectMap, ReflectedTypeFacts, get_map
 from ...types.dialect_types import DialectTypes
 from .._schema_config import SchemaConfig
@@ -35,6 +38,16 @@ _SYSTEM_SCHEMA_PREFIXES: dict[DialectTypes, tuple[str, ...]] = {
     DialectTypes.POSTGRESQL: ("pg_",),
 }
 
+_FALLBACK_SQL_DIR = Path(__file__).parent / "_sql"
+
+_UNIQUE_CONSTRAINTS_FALLBACK_SQL: dict[DialectTypes, str] = {
+    DialectTypes.MSSQL: "mssql_unique_constraints",
+}
+
+_CHECK_CONSTRAINTS_FALLBACK_SQL: dict[DialectTypes, str] = {
+    DialectTypes.MSSQL: "mssql_check_constraints",
+}
+
 
 class MetadataExtractor:
     """Database metadata extraction backed by ``sqlalchemy.Inspector``.
@@ -166,7 +179,7 @@ class MetadataExtractor:
                 index_type="PRIMARY KEY",
             )
 
-        for constraint in self._inspector.get_unique_constraints(object_name, schema=schema_name):
+        for constraint in self._get_unique_constraints(schema_name, object_name):
             add_cluster(
                 constraint.get("name") or f"uq_{object_name}",
                 constraint["column_names"],
@@ -217,11 +230,7 @@ class MetadataExtractor:
         return ListForeignKeys.validate(df)
 
     def list_check_constraints(self, schema_name: str, object_name: str) -> DataFrame[ListCheckConstraints]:
-        try:
-            checks = self._inspector.get_check_constraints(object_name, schema=schema_name)
-        except NotImplementedError:
-            checks = []
-
+        checks = self._get_check_constraints(schema_name, object_name)
         column_names = [column["name"] for column in self._get_columns(schema_name, object_name)]
 
         rows = []
@@ -261,10 +270,71 @@ class MetadataExtractor:
         pk = self._inspector.get_pk_constraint(object_name, schema=schema_name)
         return list(pk.get("constrained_columns") or []) if pk else []
 
+    def _get_unique_constraints(self, schema_name: str, object_name: str) -> list[ReflectedUniqueConstraint]:
+        try:
+            return self._inspector.get_unique_constraints(object_name, schema=schema_name)
+        except NotImplementedError:
+            return self._unique_constraints_fallback(schema_name, object_name)
+
+    def _unique_constraints_fallback(self, schema_name: str, object_name: str) -> list[ReflectedUniqueConstraint]:
+        data = self._run_fallback_sql(_UNIQUE_CONSTRAINTS_FALLBACK_SQL, schema_name, object_name)
+        if data is None:
+            return []
+
+        grouped: dict[str, list[str]] = {}
+        for row in data.itertuples(index=False):
+            grouped.setdefault(str(row.constraint_name), []).append(str(row.column_name))
+
+        return [
+            ReflectedUniqueConstraint(
+                name=name,
+                column_names=columns,
+                comment=None,
+                duplicates_index=None,
+                dialect_options={},
+            )
+            for name, columns in grouped.items()
+        ]
+
+    def _get_check_constraints(self, schema_name: str, object_name: str) -> list[ReflectedCheckConstraint]:
+        try:
+            return self._inspector.get_check_constraints(object_name, schema=schema_name)
+        except NotImplementedError:
+            return self._check_constraints_fallback(schema_name, object_name)
+
+    def _check_constraints_fallback(self, schema_name: str, object_name: str) -> list[ReflectedCheckConstraint]:
+        data = self._run_fallback_sql(_CHECK_CONSTRAINTS_FALLBACK_SQL, schema_name, object_name)
+        if data is None:
+            return []
+
+        return [
+            ReflectedCheckConstraint(
+                name=str(row.constraint_name),
+                sqltext=str(row.sqltext),
+                comment=None,
+                dialect_options={},
+            )
+            for row in data.itertuples(index=False)
+        ]
+
+    def _run_fallback_sql(self, sql_names: Mapping[DialectTypes, str], schema_name: str, object_name: str) -> pd.DataFrame | None:
+        sql_name = sql_names.get(self._dialect)
+        if sql_name is None:
+            return None
+
+        sql = SQL(
+            sql_path=sql_name,
+            query_parameters={"schema_name": schema_name, "object_name": object_name},
+        )
+        sql.set_script_dir(_FALLBACK_SQL_DIR)
+
+        _, data = self._handler.run_sql(sql)
+        return data
+
     def _get_single_column_uniques(self, schema_name: str, object_name: str) -> set[str]:
         unique_columns: set[str] = set()
 
-        for constraint in self._inspector.get_unique_constraints(object_name, schema=schema_name):
+        for constraint in self._get_unique_constraints(schema_name, object_name):
             if len(constraint["column_names"]) == 1:
                 unique_columns.add(constraint["column_names"][0])
 

alchemy_kit-0.2.1/alchemy_kit/model/_model_def/_sql/mssql_check_constraints.sql

@@ -0,0 +1,9 @@
+SELECT
+    cc.name       AS constraint_name,
+    cc.definition AS sqltext
+FROM sys.check_constraints cc
+JOIN sys.tables  t ON t.object_id = cc.parent_object_id
+JOIN sys.schemas s ON s.schema_id = t.schema_id
+WHERE s.name = @schema_name
+  AND t.name = @object_name
+ORDER BY cc.name

alchemy_kit-0.2.1/alchemy_kit/model/_model_def/_sql/mssql_unique_constraints.sql

@@ -0,0 +1,14 @@
+SELECT
+    kc.name AS constraint_name,
+    c.name  AS column_name
+FROM sys.key_constraints kc
+JOIN sys.tables        t ON t.object_id = kc.parent_object_id
+JOIN sys.schemas       s ON s.schema_id = t.schema_id
+JOIN sys.index_columns ic ON ic.object_id = kc.parent_object_id
+                         AND ic.index_id = kc.unique_index_id
+JOIN sys.columns       c ON c.object_id = ic.object_id
+                        AND c.column_id = ic.column_id
+WHERE kc.type = 'UQ'
+  AND s.name = @schema_name
+  AND t.name = @object_name
+ORDER BY kc.name, ic.key_ordinal

{alchemy_kit-0.2.0 → alchemy_kit-0.2.1}/alchemy_kit/resources/_settings.py

@@ -42,4 +42,6 @@ class Settings(NotInstantiable):
         database_marker = "database"
         user_name_marker = "user_name"
         user_pwd_marker = "user_pwd"
+        encrypt_marker = "encrypt"
+        trust_server_certificate_marker = "trust_server_certificate"
 

{alchemy_kit-0.2.0 → alchemy_kit-0.2.1}/alchemy_kit/resources/dialect_map/_base.py

@@ -54,6 +54,7 @@ class DialectMap[_TypeParameters: str](ABC):
     dialect_paramaters: ClassVar[frozenset[str]]
     py_types: ClassVar[dict[str, PyTypeParameters]]
     sa_types: ClassVar[dict[str, SaTypeFactory]]
+    _reflected_synonyms: ClassVar[dict[str, str]] = {}
 
     _quote_open: ClassVar[str] = '"'
     _quote_close: ClassVar[str] = '"'
@@ -108,9 +109,13 @@ class DialectMap[_TypeParameters: str](ABC):
 
         The type name is the lowercased class name, which for dialect-specific
         reflected types matches the dialect's SQL type name (``NVARCHAR`` ->
-        ``nvarchar``). A string type whose ``length`` is ``None`` is unbounded
-        and reported as ``-1``; parameters a type does not carry are ``0``.
-        Dialects with different conventions override this.
+        ``nvarchar``). Dialects sometimes reflect a SQL type as a class whose
+        name differs from the type's own name (MSSQL ``int`` ->
+        ``sqltypes.INTEGER``); ``_reflected_synonyms`` maps those class names
+        back to the dialect's canonical type name. A string type whose
+        ``length`` is ``None`` is unbounded and reported as ``-1``; parameters
+        a type does not carry are ``0``. Dialects with different conventions
+        override this.
         """
         length = getattr(sa_type, "length", None)
         if hasattr(sa_type, "length") and length is None:
@@ -118,8 +123,9 @@ class DialectMap[_TypeParameters: str](ABC):
         else:
             max_length = length or 0
 
+        sql_type = type(sa_type).__name__.lower()
         return ReflectedTypeFacts(
-            sql_type=type(sa_type).__name__.lower(),
+            sql_type=cls._reflected_synonyms.get(sql_type, sql_type),
             max_length=max_length,
             precision=getattr(sa_type, "precision", None) or 0,
             scale=getattr(sa_type, "scale", None) or 0,

{alchemy_kit-0.2.0 → alchemy_kit-0.2.1}/alchemy_kit/resources/dialect_map/mariadb.py

@@ -140,6 +140,13 @@ class MariadbMap(DialectMap[MariadbTypeParameters]):
         "geometrycollection": NullType,
     }
 
+    # Reflected class name -> dialect type name (NCHAR/NVARCHAR are national
+    # charset variants MariaDB stores as char/varchar)
+    _REFLECTED_SYNONYMS: dict[str, MariadbTypeParameters] = {
+        "nchar": "char",
+        "nvarchar": "varchar",
+    }
+
     # SQL type name buckets (MariaDB lengths are in characters)
     _length_types_char: set[MariadbTypeParameters] = {"char", "varchar"}
     _length_types_bin: set[MariadbTypeParameters] = {"binary", "varbinary"}
@@ -150,6 +157,7 @@ class MariadbMap(DialectMap[MariadbTypeParameters]):
     # Parent parameters
     py_types = cast(dict[str, PyTypeParameters], _PY_TYPES)
     sa_types = cast(dict[str, SaTypeFactory], _SA_TYPES)
+    _reflected_synonyms = cast(dict[str, str], _REFLECTED_SYNONYMS)
     dialect = DialectTypes.MARIADB
     dialect_paramaters = frozenset(get_args(MariadbTypeParameters))
     _quote_open = "`"

{alchemy_kit-0.2.0 → alchemy_kit-0.2.1}/alchemy_kit/resources/dialect_map/mssql.py

@@ -95,6 +95,13 @@ class MssqlMap(DialectMap[MssqlTypeParameters]):
         "sql_variant": sa_mssql.SQL_VARIANT,
     }
 
+    # Reflected class name -> dialect type name ("int" reflects as
+    # sqltypes.INTEGER; "double precision" is an alias of float(53))
+    _REFLECTED_SYNONYMS: dict[str, MssqlTypeParameters] = {
+        "integer": "int",
+        "double_precision": "float",
+    }
+
     # SQL type name buckets
     _length_types_char: set[MssqlTypeParameters] = {"char", "varchar"}        # 1 byte/char
     _length_types_nchar: set[MssqlTypeParameters] = {"nchar", "nvarchar"}     # 2 bytes/char (Unicode)
@@ -106,6 +113,7 @@ class MssqlMap(DialectMap[MssqlTypeParameters]):
     # Parent parameters
     py_types = cast(dict[str, PyTypeParameters], _PY_TYPES)
     sa_types = cast(dict[str, SaTypeFactory], _SA_TYPES)
+    _reflected_synonyms = cast(dict[str, str], _REFLECTED_SYNONYMS)
     dialect = DialectTypes.MSSQL
     dialect_paramaters = frozenset(get_args(MssqlTypeParameters))
     _quote_open = "["

{alchemy_kit-0.2.0 → alchemy_kit-0.2.1}/alchemy_kit/resources/dialect_map/mysql.py

@@ -130,6 +130,13 @@ class MysqlMap(DialectMap[MysqlTypeParameters]):
         "geometrycollection": NullType,
     }
 
+    # Reflected class name -> dialect type name (NCHAR/NVARCHAR are national
+    # charset variants MySQL stores as char/varchar)
+    _REFLECTED_SYNONYMS: dict[str, MysqlTypeParameters] = {
+        "nchar": "char",
+        "nvarchar": "varchar",
+    }
+
     # SQL type name buckets (MySQL lengths are in characters)
     _length_types_char: set[MysqlTypeParameters] = {"char", "varchar"}
     _length_types_bin: set[MysqlTypeParameters] = {"binary", "varbinary"}
@@ -140,6 +147,7 @@ class MysqlMap(DialectMap[MysqlTypeParameters]):
     # Parent parameters
     py_types = cast(dict[str, PyTypeParameters], _PY_TYPES)
     sa_types = cast(dict[str, SaTypeFactory], _SA_TYPES)
+    _reflected_synonyms = cast(dict[str, str], _REFLECTED_SYNONYMS)
     dialect = DialectTypes.MYSQL
     dialect_paramaters = frozenset(get_args(MysqlTypeParameters))
     _quote_open = "`"

{alchemy_kit-0.2.0 → alchemy_kit-0.2.1}/alchemy_kit/resources/dialect_map/oracle.py

@@ -96,6 +96,14 @@ class OracleMap(DialectMap[OracleTypeParameters]):
         "xmltype": NullType,
     }
 
+    # Reflected class name -> dialect type name (NVARCHAR2 reflects as the
+    # generic NVARCHAR class; REAL and DOUBLE PRECISION are FLOAT aliases)
+    _REFLECTED_SYNONYMS: dict[str, OracleTypeParameters] = {
+        "nvarchar": "nvarchar2",
+        "real": "float",
+        "double_precision": "float",
+    }
+
     # SQL type name buckets (Oracle lengths reported in characters/bytes as-is)
     _length_types_char: set[OracleTypeParameters] = {
         "char", "nchar", "varchar", "varchar2", "nvarchar2",
@@ -112,6 +120,7 @@ class OracleMap(DialectMap[OracleTypeParameters]):
     # Parent parameters
     py_types = cast(dict[str, PyTypeParameters], _PY_TYPES)
     sa_types = cast(dict[str, SaTypeFactory], _SA_TYPES)
+    _reflected_synonyms = cast(dict[str, str], _REFLECTED_SYNONYMS)
     dialect = DialectTypes.ORACLE
     dialect_paramaters = frozenset(get_args(OracleTypeParameters))
 

{alchemy_kit-0.2.0 → alchemy_kit-0.2.1}/alchemy_kit/resources/dialect_map/postgresql.py

@@ -190,6 +190,14 @@ class PostgresqlMap(DialectMap[PostgresqlTypeParameters]):
         "array": NullType,
     }
 
+    # Reflected class name -> dialect type name (catalog types '"char"' and
+    # 'name' reflect as the generic sqltypes.String; FLOAT is stored as
+    # double precision)
+    _REFLECTED_SYNONYMS: dict[str, PostgresqlTypeParameters] = {
+        "string": "text",
+        "float": "double precision",
+    }
+
     # SQL type name buckets (PostgreSQL lengths are in characters)
     _length_types_char: set[PostgresqlTypeParameters] = {
         "character", "char", "character varying", "varchar", "bpchar",
@@ -204,6 +212,7 @@ class PostgresqlMap(DialectMap[PostgresqlTypeParameters]):
     # Parent parameters
     py_types = cast(dict[str, PyTypeParameters], _PY_TYPES)
     sa_types = cast(dict[str, SaTypeFactory], _SA_TYPES)
+    _reflected_synonyms = cast(dict[str, str], _REFLECTED_SYNONYMS)
     dialect = DialectTypes.POSTGRESQL
     dialect_paramaters = frozenset(get_args(PostgresqlTypeParameters))
 

{alchemy_kit-0.2.0 → alchemy_kit-0.2.1}/alchemy_kit/resources/dialect_map/sqlite.py

@@ -82,6 +82,13 @@ class SqliteMap(DialectMap[SqliteTypeParameters]):
         "blob": sa_sqlite.BLOB,
     }
 
+    # Reflected class name -> dialect type name (a declared CHAR reflects as
+    # the generic CHAR class; TIMESTAMP behaves as datetime)
+    _REFLECTED_SYNONYMS: dict[str, SqliteTypeParameters] = {
+        "char": "character",
+        "timestamp": "datetime",
+    }
+
     # SQL type name buckets (SQLite ignores length constraints, but declared
     # lengths are preserved for rendering and validation)
     _length_types_char: set[SqliteTypeParameters] = {
@@ -93,6 +100,7 @@ class SqliteMap(DialectMap[SqliteTypeParameters]):
     # Parent parameters
     py_types = cast(dict[str, PyTypeParameters], _PY_TYPES)
     sa_types = cast(dict[str, SaTypeFactory], _SA_TYPES)
+    _reflected_synonyms = cast(dict[str, str], _REFLECTED_SYNONYMS)
     dialect = DialectTypes.SQLITE
     dialect_paramaters = frozenset(get_args(SqliteTypeParameters))
 

{alchemy_kit-0.2.0 → alchemy_kit-0.2.1}/alchemy_kit/types/_driver_types.py

@@ -2,9 +2,12 @@ from typing import TypeAlias, get_args
 from enum import StrEnum
 
 class SqlServerODBC(StrEnum):
-    DRIVER_17 = "ODBC Driver 17 for SQL Server"
-    DRIVER_11 = "ODBC Driver 11 for SQL Server"
-    SQL_SERVER = "SQL Server"
+    DRIVER_18   = "ODBC Driver 18 for SQL Server"
+    DRIVER_17   = "ODBC Driver 17 for SQL Server"
+    DRIVER_13_1 = "ODBC Driver 13.1 for SQL Server"
+    DRIVER_13   = "ODBC Driver 13 for SQL Server"
+    DRIVER_11   = "ODBC Driver 11 for SQL Server"
+    SQL_SERVER  = "SQL Server"
 
 
 class SqlServerNative(StrEnum):

{alchemy_kit-0.2.0 → alchemy_kit-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "alchemy-kit"
-version = "0.2.0"
+version = "0.2.1"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"

{alchemy_kit-0.2.0 → alchemy_kit-0.2.1}/tests/model/test_builder.py

@@ -5,17 +5,20 @@ from typing import cast
 import pytest
 
 from alchemy_kit.connect._info import ConnectionInfo
+from alchemy_kit.connect import info_builder
 from alchemy_kit.model import build
 from alchemy_kit.model import _builder
 from alchemy_kit.model._model.column_model import ColumnModel, ForeignKeyModel
 from alchemy_kit.model._model.constraint_model import CheckConstraintModel, FilteredUniqueIndexModel
+from alchemy_kit.model import SchemaConfig
 from alchemy_kit.model._model.db_model import DBModel
 from alchemy_kit.model._model.object_model import ObjectModel
 from alchemy_kit.model._model.schema_model import SchemaModel
 from alchemy_kit.types.dialect_types import DialectTypes
 
 
-PREVIEW_DIR = Path(__file__).resolve().parent.parent / "secret_model_preview"
+ROOT = Path(__file__).resolve().parent.parent
+PREVIEW_DIR = ROOT / "secret_model_preview"
 
 def _column(name: str, column_type: str, *, nullable: bool = False, fk_ref: ForeignKeyModel | None = None) -> ColumnModel:
     return ColumnModel(
@@ -117,3 +120,9 @@ def test_build_generates_package(monkeypatch: pytest.MonkeyPatch):
     for path in result_dir.rglob("*.py*"):
         compile(path.read_text(), str(path), "exec")
 
+def test_mssql_local_build():
+    conn = info_builder.from_env(ROOT/".env-mssql")
+    config = SchemaConfig()
+    config.include_schema("uploader")
+    build(conn, ROOT/"secret_local_mssql", schema_config=config, clear_result_dir=True)
+