machineconfig 8.14__py3-none-any.whl → 8.50__py3-none-any.whl

machineconfig/type_hinting/sql/base.py

@@ -0,0 +1,216 @@
+# from uuid import uuid4
+# import enum
+# from datetime import date, datetime, time, timedelta
+
+# import sqlalchemy as sa
+# from sqlalchemy import (
+#     BigInteger,
+#     Boolean,
+#     CHAR,
+#     Date,
+#     DateTime,
+#     Float,
+#     Integer,
+#     Interval,
+#     LargeBinary,
+#     Numeric,
+#     SmallInteger,
+#     String,
+#     Text,
+#     Time,
+#     JSON,
+#     Enum,
+# )
+# from sqlalchemy.dialects.postgresql import (
+#     ARRAY,
+#     JSONB,
+#     UUID,
+# )
+# from sqlalchemy.orm import (
+#     DeclarativeBase,
+#     Mapped,
+#     mapped_column,
+# )
+
+# # Python enum type — stored generally as a VARCHAR or ENUM in the DB
+# class ColorEnum(enum.Enum):
+#     RED = "red"
+#     GREEN = "green"
+#     BLUE = "blue"
+
+# class Base(DeclarativeBase):
+#     pass
+
+# class AllTypesExample(Base):
+#     __tablename__ = "all_types_example"
+
+#     # ----------------------------------
+#     # Integer types
+#     # ----------------------------------
+
+#     id: Mapped[int] = mapped_column(
+#         Integer,
+#         primary_key=True,
+#         comment="Typical SQL INTEGER (~int32 on many databases)"
+#     )
+
+#     small_num: Mapped[int] = mapped_column(
+#         SmallInteger,
+#         comment="SMALLINT (~int16)"
+#     )
+
+#     big_num: Mapped[int] = mapped_column(
+#         BigInteger,
+#         comment="BIGINT (~int64)"
+#     )
+
+#     # ----------------------------------
+#     # Floating-point & precision numbers
+#     # ----------------------------------
+
+#     float_num: Mapped[float] = mapped_column(
+#         Float,
+#         comment="FLOAT → typically float32/float64 depending on precision [Float maps to SQL FLOAT/REAL] (SQLAlchemy docs) :contentReference[oaicite:0]{index=0}"
+#     )
+
+#     decimal_value: Mapped[float] = mapped_column(
+#         Numeric(12, 4),
+#         comment="NUMERIC/DECIMAL fixed precision; client uses python Decimal by default (~exact decimal, not float)"
+#     )
+
+#     # ----------------------------------
+#     # Strings, text, character
+#     # ----------------------------------
+
+#     short_str: Mapped[str] = mapped_column(
+#         String(50),
+#         comment="VARCHAR(n) fixed limit"
+#     )
+
+#     long_text: Mapped[str] = mapped_column(
+#         Text,
+#         comment="TEXT (unbounded string)"
+#     )
+
+#     # ----------------------------------
+#     # Boolean
+#     # ----------------------------------
+
+#     is_active: Mapped[bool] = mapped_column(
+#         Boolean,
+#         comment="BOOLEAN (True/False)"
+#     )
+
+#     # ----------------------------------
+#     # Dates and times
+#     # ----------------------------------
+
+#     date_field: Mapped[date] = mapped_column(
+#         Date,
+#         comment="DATE only (year/month/day)"
+#     )
+
+#     time_field: Mapped[time] = mapped_column(
+#         Time,
+#         comment="TIME only (hh:mm:ss)"
+#     )
+
+#     datetime_field: Mapped[datetime] = mapped_column(
+#         DateTime,
+#         comment="TIMESTAMP without timezone"
+#     )
+
+#     interval_field: Mapped[timedelta] = mapped_column(
+#         Interval,
+#         comment="INTERVAL type (duration)"
+#     )
+
+#     # ----------------------------------
+#     # Binary / blobs
+#     # ----------------------------------
+
+#     binary_data: Mapped[bytes] = mapped_column(
+#         LargeBinary,
+#         comment="Large binary / BLOB"
+#     )
+
+#     # ----------------------------------
+#     # JSON
+#     # ----------------------------------
+
+#     json_data: Mapped[dict] = mapped_column(
+#         JSON,
+#         comment="Generic JSON type (engine specific)"
+#     )
+
+#     jsonb_data: Mapped[dict] = mapped_column(
+#         JSONB,
+#         comment="PostgreSQL JSONB (binary JSON)"
+#     )
+
+#     # ----------------------------------
+#     # Enum
+#     # ----------------------------------
+
+#     color: Mapped[ColorEnum] = mapped_column(
+#         Enum(ColorEnum),
+#         nullable=False,
+#         comment="ENUM type"
+#     )
+
+#     # ----------------------------------
+#     # UUID
+#     # ----------------------------------
+
+#     uuid_field: Mapped[str] = mapped_column(
+#         UUID(as_uuid=True),
+#         default=uuid4,
+#         comment="GUID/UUID (128-bit unique identifier)"
+#     )
+
+#     # ----------------------------------
+#     # Array — PostgreSQL only
+#     # ----------------------------------
+
+#     int_array: Mapped[list[int]] = mapped_column(
+#         ARRAY(Integer),
+#         comment="ARRAY of INTEGER (~list[int32])"
+#     )
+
+#     str_array: Mapped[list[str]] = mapped_column(
+#         ARRAY(String),
+#         comment="ARRAY of VARCHAR strings"
+#     )
+
+#     # ----------------------------------
+#     # Constraints & defaults
+#     # ----------------------------------
+
+#     unique_code: Mapped[str] = mapped_column(
+#         String(20),
+#         unique=True,
+#         nullable=False,
+#         comment="Unique code"
+#     )
+
+#     created_at: Mapped[datetime] = mapped_column(
+#         DateTime,
+#         server_default=sa.func.now(),
+#         comment="timestamp default now"
+#     )
+
+#     # ----------------------------------
+#     # Foreign key
+#     # ----------------------------------
+
+#     related_id: Mapped[int] = mapped_column(
+#         Integer,
+#         sa.ForeignKey("other_table.id"),
+#         comment="Foreign key reference"
+#     )
+
+
+# if __name__ == "__main__":
+#     # Example usage: create the tables in an in-memory SQLite database
+#     q = AllTypesExample()
+#     q.created_at.__qualname__

machineconfig/type_hinting/sql/core_schema.py

@@ -0,0 +1,64 @@
+import enum
+from uuid import uuid4
+
+import sqlalchemy as sa
+from sqlalchemy import BigInteger, Boolean, Column, Date, DateTime, Float, ForeignKey, Integer, Interval, JSON, LargeBinary, MetaData, Numeric, SmallInteger, String, Table, Text, Time
+from sqlalchemy.dialects.postgresql import ARRAY, JSONB, UUID
+
+
+class ColorEnum(enum.Enum):
+    RED = "red"
+    GREEN = "green"
+    BLUE = "blue"
+
+
+metadata: MetaData = MetaData()
+
+other_table: Table = Table(
+    "other_table",
+    metadata,
+    Column("id", Integer, primary_key=True, comment="Referenced by all_types_example.related_id"),
+)
+
+all_types_example: Table = Table(
+    "all_types_example",
+    metadata,
+    Column("id", Integer, primary_key=True, comment="Typical SQL INTEGER (~int32 on many databases)"),
+    Column("small_num", SmallInteger, comment="SMALLINT (~int16)"),
+    Column("big_num", BigInteger, comment="BIGINT (~int64)"),
+    Column("float_num", Float, comment="FLOAT → typically float32/float64 depending on precision"),
+    Column(
+        "decimal_value",
+        Numeric(12, 4),
+        comment="NUMERIC/DECIMAL fixed precision; client uses python Decimal by default (~exact decimal, not float)",
+    ),
+    Column("short_str", String(50), comment="VARCHAR(n) fixed limit"),
+    Column("long_text", Text, comment="TEXT (unbounded string)"),
+    Column("is_active", Boolean, comment="BOOLEAN (True/False)"),
+    Column("date_field", Date, comment="DATE only (year/month/day)"),
+    Column("time_field", Time, comment="TIME only (hh:mm:ss)"),
+    Column("datetime_field", DateTime, comment="TIMESTAMP without timezone"),
+    Column("interval_field", Interval, comment="INTERVAL type (duration)"),
+    Column("binary_data", LargeBinary, comment="Large binary / BLOB"),
+    Column("json_data", JSON, comment="Generic JSON type (engine specific)"),
+    Column("jsonb_data", JSONB, comment="PostgreSQL JSONB (binary JSON)"),
+    Column("color", sa.Enum(ColorEnum), nullable=False, comment="ENUM type"),
+    Column("uuid_field", UUID(as_uuid=True), default=uuid4, comment="GUID/UUID (128-bit unique identifier)"),
+    Column("int_array", ARRAY(Integer), comment="ARRAY of INTEGER (~list[int32])"),
+    Column("str_array", ARRAY(String), comment="ARRAY of VARCHAR strings"),
+    Column("unique_code", String(20), unique=True, nullable=False, comment="Unique code"),
+    Column("created_at", DateTime, server_default=sa.func.now(), comment="timestamp default now"),
+    Column("related_id", Integer, ForeignKey("other_table.id"), comment="Foreign key reference"),
+)
+
+
+__all__: tuple[str, ...] = (
+    "ColorEnum",
+    "all_types_example",
+    "metadata",
+    "other_table",
+)
+
+if __name__ == "__main__":
+    q = all_types_example
+    # q.colo

machineconfig/type_hinting/sql/core_schema_typeddict.py

@@ -0,0 +1,41 @@
+
+from typing import Any, Literal, TypedDict, TypeAlias
+
+import datetime
+import decimal
+import uuid
+
+AllTypesExampleColor: TypeAlias = Literal["red", "green", "blue"]
+
+class OtherTableRow(TypedDict):
+    id: int
+
+class AllTypesExampleRow(TypedDict):
+    id: int
+    small_num: int | None
+    big_num: int | None
+    float_num: float | None
+    decimal_value: decimal.Decimal | None
+    short_str: str | None
+    long_text: str | None
+    is_active: bool | None
+    date_field: datetime.date | None
+    time_field: datetime.time | None
+    datetime_field: datetime.datetime | None
+    interval_field: datetime.timedelta | None
+    binary_data: bytes | None
+    json_data: Any | None
+    jsonb_data: Any | None
+    color: AllTypesExampleColor
+    uuid_field: uuid.UUID | None
+    int_array: list[int] | None
+    str_array: list[str] | None
+    unique_code: str
+    created_at: datetime.datetime | None
+    related_id: int | None
+
+__all__: tuple[str, ...] = (
+    "OtherTableRow",
+    "AllTypesExampleRow",
+    "AllTypesExampleColor",
+)

machineconfig/type_hinting/sql/typeddict_codegen.py

@@ -0,0 +1,222 @@
+
+import enum
+import re
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import sqlalchemy as sa
+from sqlalchemy.dialects.postgresql import ARRAY as PG_ARRAY
+from sqlalchemy.dialects.postgresql import JSONB, UUID as PG_UUID
+from sqlalchemy.sql.type_api import TypeEngine
+from sqlalchemy.sql.sqltypes import (
+    BigInteger,
+    Boolean,
+    Date,
+    DateTime,
+    Float,
+    Integer,
+    Interval,
+    JSON,
+    LargeBinary,
+    Numeric,
+    SmallInteger,
+    String,
+    Text,
+    Time,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class GeneratedModule:
+    code: str
+    exports: tuple[str, ...]
+
+
+def _pascal_case(value: str) -> str:
+    parts = [p for p in re.split(r"[^0-9A-Za-z]+", value) if p]
+    if not parts:
+        return "X"
+    return "".join(p[:1].upper() + p[1:] for p in parts)
+
+
+def _identifier(value: str) -> str:
+    candidate = re.sub(r"[^0-9A-Za-z_]", "_", value)
+    if not candidate:
+        return "x"
+    if candidate[0].isdigit():
+        return f"x_{candidate}"
+    return candidate
+
+
+def _enum_literal_alias_name(table_name: str, column_name: str) -> str:
+    return f"{_pascal_case(table_name)}{_pascal_case(column_name)}"
+
+
+def _literal_union(values: Sequence[str]) -> str:
+    escaped = [v.replace("\\", "\\\\").replace('"', '\\"') for v in values]
+    return "Literal[" + ", ".join(f'"{v}"' for v in escaped) + "]"
+
+
+@dataclass(frozen=True, slots=True)
+class _TypeExpr:
+    expr: str
+    needs_datetime: bool
+    needs_decimal: bool
+    needs_uuid: bool
+    needs_any: bool
+    needs_literal: bool
+
+
+def _union_with_none(type_expr: str, is_nullable: bool) -> str:
+    return f"{type_expr} | None" if is_nullable else type_expr
+
+
+def _type_expr_for_sqla_type(*, column_type: TypeEngine[Any], table_name: str, column_name: str) -> tuple[_TypeExpr, dict[str, str]]:
+    enum_aliases: dict[str, str] = {}
+
+    if isinstance(column_type, (Integer, SmallInteger, BigInteger)):
+        return _TypeExpr("int", False, False, False, False, False), enum_aliases
+    if isinstance(column_type, Float):
+        return _TypeExpr("float", False, False, False, False, False), enum_aliases
+    if isinstance(column_type, Numeric):
+        return _TypeExpr("decimal.Decimal", False, True, False, False, False), enum_aliases
+
+    if hasattr(column_type, "enum_class"):
+        enum_class = getattr(column_type, "enum_class")
+        if isinstance(enum_class, type) and issubclass(enum_class, enum.Enum):
+            values = [str(member.value) for member in enum_class]
+            alias_name = _enum_literal_alias_name(table_name=table_name, column_name=column_name)
+            enum_aliases[alias_name] = _literal_union(values)
+            return _TypeExpr(alias_name, False, False, False, False, True), enum_aliases
+
+    if isinstance(column_type, (String, Text)):
+        return _TypeExpr("str", False, False, False, False, False), enum_aliases
+    if isinstance(column_type, Boolean):
+        return _TypeExpr("bool", False, False, False, False, False), enum_aliases
+    if isinstance(column_type, Date):
+        return _TypeExpr("datetime.date", True, False, False, False, False), enum_aliases
+    if isinstance(column_type, Time):
+        return _TypeExpr("datetime.time", True, False, False, False, False), enum_aliases
+    if isinstance(column_type, DateTime):
+        return _TypeExpr("datetime.datetime", True, False, False, False, False), enum_aliases
+    if isinstance(column_type, Interval):
+        return _TypeExpr("datetime.timedelta", True, False, False, False, False), enum_aliases
+    if isinstance(column_type, LargeBinary):
+        return _TypeExpr("bytes", False, False, False, False, False), enum_aliases
+
+    if isinstance(column_type, (JSON, JSONB)):
+        return _TypeExpr("Any", False, False, False, True, False), enum_aliases
+
+    if isinstance(column_type, PG_UUID):
+        return _TypeExpr("uuid.UUID", False, False, True, False, False), enum_aliases
+
+    if isinstance(column_type, PG_ARRAY):
+        item_type = column_type.item_type
+        item_expr, item_aliases = _type_expr_for_sqla_type(column_type=item_type, table_name=table_name, column_name=column_name)
+        enum_aliases |= item_aliases
+        return (
+            _TypeExpr(f"list[{item_expr.expr}]", item_expr.needs_datetime, item_expr.needs_decimal, item_expr.needs_uuid, item_expr.needs_any, item_expr.needs_literal),
+            enum_aliases,
+        )
+
+    return _TypeExpr("Any", False, False, False, True, False), enum_aliases
+
+
+def generate_typeddict_module_code_for_tables(*, tables: Sequence[sa.Table], module_name: str) -> GeneratedModule:
+    alias_defs: dict[str, str] = {}
+    typed_dict_defs: list[str] = []
+
+    needs_datetime = False
+    needs_decimal = False
+    needs_uuid = False
+    needs_any = False
+    needs_literal = False
+
+    exports: list[str] = []
+
+    for table in tables:
+        table_name = table.name
+        td_name = f"{_pascal_case(table_name)}Row"
+        exports.append(td_name)
+
+        lines: list[str] = [f"class {td_name}(TypedDict):"]
+        for column in table.columns:
+            col_name = column.name
+            type_expr, new_aliases = _type_expr_for_sqla_type(column_type=column.type, table_name=table_name, column_name=col_name)
+            alias_defs |= new_aliases
+
+            needs_datetime = needs_datetime or type_expr.needs_datetime
+            needs_decimal = needs_decimal or type_expr.needs_decimal
+            needs_uuid = needs_uuid or type_expr.needs_uuid
+            needs_any = needs_any or type_expr.needs_any
+            needs_literal = needs_literal or type_expr.needs_literal
+
+            field_name = _identifier(col_name)
+            field_type = _union_with_none(type_expr.expr, column.nullable)
+            lines.append(f"    {field_name}: {field_type}")
+
+        typed_dict_defs.append("\n".join(lines))
+
+    for alias_name in sorted(alias_defs.keys()):
+        exports.append(alias_name)
+
+    _ = module_name
+
+    typing_import_names: list[str] = ["TypedDict"]
+    if alias_defs:
+        typing_import_names.append("TypeAlias")
+    if needs_any:
+        typing_import_names.insert(0, "Any")
+    if needs_literal:
+        typing_import_names.insert(0 if not needs_any else 1, "Literal")
+
+    import_lines: list[str] = [
+        "",
+        f"from typing import {', '.join(typing_import_names)}",
+    ]
+
+    stdlib_imports: list[str] = []
+    if needs_datetime:
+        stdlib_imports.append("import datetime")
+    if needs_decimal:
+        stdlib_imports.append("import decimal")
+    if needs_uuid:
+        stdlib_imports.append("import uuid")
+    if stdlib_imports:
+        import_lines.extend(["", *stdlib_imports])
+
+    code_parts: list[str] = []
+    code_parts.extend(import_lines)
+
+    if alias_defs:
+        code_parts.append("")
+        for alias_name in sorted(alias_defs.keys()):
+            literal_expr = alias_defs[alias_name]
+            code_parts.append(f"{alias_name}: TypeAlias = {literal_expr}")
+
+    code_parts.append("")
+    code_parts.append("\n\n".join(typed_dict_defs))
+
+    exports_tuple = tuple(exports)
+    exports_rendered = ",\n    ".join(f"\"{name}\"" for name in exports_tuple)
+    code_parts.append("")
+    code_parts.append("__all__: tuple[str, ...] = (\n    " + exports_rendered + ",\n)\n")
+
+    return GeneratedModule(code="\n".join(code_parts), exports=exports_tuple)
+
+
+def generate_typeddict_module_code_for_table(*, table: sa.Table, module_name: str) -> GeneratedModule:
+    return generate_typeddict_module_code_for_tables(tables=(table,), module_name=module_name)
+
+
+def write_generated_module(*, generated: GeneratedModule, output_path: Path) -> None:
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(generated.code, encoding="utf-8")
+
+
+def write_typeddict_module_next_to_source(*, generated: GeneratedModule, source_file_path: Path) -> Path:
+    output_path = source_file_path.with_name(f"{source_file_path.stem}_typeddict.py")
+    write_generated_module(generated=generated, output_path=output_path)
+    return output_path

machineconfig/type_hinting/typedict/__init__.py

@@ -0,0 +1 @@
+

machineconfig/type_hinting/typedict/ast_utils.py

@@ -0,0 +1,130 @@
+import ast
+from pathlib import Path
+from dataclasses import dataclass, field
+
+
+type FieldInfo = tuple[str, ast.expr | None, dict[str, tuple[str, str]]]
+type ClassFields = tuple[str, list[FieldInfo]]
+
+_file_cache: dict[Path, ast.Module] = {}
+
+
+def _get_ast(path: Path) -> ast.Module:
+    if path not in _file_cache:
+        _file_cache[path] = ast.parse(path.read_text(encoding="utf-8"))
+    return _file_cache[path]
+
+
+@dataclass
+class FileContext:
+    path: Path
+    tree: ast.Module
+    classes: dict[str, ast.ClassDef] = field(default_factory=dict)
+    imports: dict[str, tuple[str, str]] = field(default_factory=dict)
+
+    def __post_init__(self):
+        self.classes = {node.name: node for node in ast.walk(self.tree) if isinstance(node, ast.ClassDef)}
+        for node in ast.walk(self.tree):
+            if isinstance(node, ast.ImportFrom) and node.module:
+                for alias in node.names:
+                    self.imports[alias.asname or alias.name] = (node.module, alias.name)
+
+
+def _get_context(path: Path) -> FileContext:
+    tree = _get_ast(path)
+    return FileContext(path, tree)
+
+
+def _resolve_imported_class(module_name: str, class_name: str, search_paths: list[Path]) -> tuple[ast.ClassDef, FileContext] | None:
+    parts = module_name.split(".")
+    for root in search_paths:
+        file_path = root.joinpath(*parts).with_suffix(".py")
+        if file_path.exists():
+            try:
+                context = _get_context(file_path)
+                if class_name in context.classes:
+                    return context.classes[class_name], context
+            except Exception:
+                pass
+        init_path = root.joinpath(*parts, "__init__.py")
+        if init_path.exists():
+            try:
+                context = _get_context(init_path)
+                if class_name in context.classes:
+                    return context.classes[class_name], context
+            except Exception:
+                pass
+    return None
+
+
+def load_target_class_fields(source_file_path: Path, search_paths: list[Path] | None = None) -> list[ClassFields]:
+    source_path = Path(source_file_path).resolve()
+    if search_paths is None:
+        search_paths = []
+
+    if not source_path.exists():
+        raise FileNotFoundError(f"Source file not found: {source_path}")
+
+    initial_context = _get_context(source_path)
+
+    def get_parent_node(base: ast.expr, context: FileContext) -> tuple[ast.ClassDef, FileContext] | None:
+        if isinstance(base, ast.Name):
+            if base.id in context.classes:
+                return context.classes[base.id], context
+            if base.id in context.imports:
+                module_name, original_name = context.imports[base.id]
+                return _resolve_imported_class(module_name, original_name, search_paths)  # type: ignore
+        return None
+
+    def collect_fields(class_node: ast.ClassDef, context: FileContext, visited: set[str]) -> list[FieldInfo]:
+        key = f"{context.path}:{class_node.name}"
+        if key in visited:
+            return []
+        visited.add(key)
+        field_info: list[FieldInfo] = []
+        for base in class_node.bases:
+            parent_info = get_parent_node(base, context)
+            if parent_info:
+                parent_node, parent_context = parent_info
+                field_info.extend(collect_fields(parent_node, parent_context, visited))
+        for statement in class_node.body:
+            if isinstance(statement, ast.AnnAssign) and isinstance(statement.target, ast.Name):
+                field_info.append((statement.target.id, statement.annotation, context.imports))
+        return field_info
+
+    def deduplicate_fields(fields: list[FieldInfo]) -> list[FieldInfo]:
+        deduped: dict[str, FieldInfo] = {}
+        for item in fields:
+            field_name = item[0]
+            deduped[field_name] = item
+        return list(deduped.values())
+
+    def is_typeddict(node: ast.ClassDef, context: FileContext, visited: set[str]) -> bool:
+        key = f"{context.path}:{node.name}"
+        if key in visited:
+            return False
+        visited.add(key)
+        for base in node.bases:
+            if (isinstance(base, ast.Name) and base.id == "TypedDict") or (isinstance(base, ast.Attribute) and base.attr == "TypedDict"):
+                return True
+            parent_info = get_parent_node(base, context)
+            if parent_info:
+                parent_node, parent_context = parent_info
+                if is_typeddict(parent_node, parent_context, visited):
+                    return True
+        return False
+
+    target_classes: list[ClassFields] = []
+    for node in ast.walk(initial_context.tree):
+        if not isinstance(node, ast.ClassDef):
+            continue
+        is_dataclass = any(
+            (isinstance(decorator, ast.Name) and decorator.id == "dataclass")
+            or (isinstance(decorator, ast.Attribute) and decorator.attr == "dataclass")
+            or (isinstance(decorator, ast.Call) and ((isinstance(decorator.func, ast.Name) and decorator.func.id == "dataclass") or (isinstance(decorator.func, ast.Attribute) and decorator.func.attr == "dataclass")))
+            for decorator in node.decorator_list
+        )
+        if is_dataclass or is_typeddict(node, initial_context, set()):
+            fields = collect_fields(node, initial_context, set())
+            target_classes.append((node.name, deduplicate_fields(fields)))
+    return target_classes