sandwich 0.2.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

sandwich/dialects/base.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from typing import Tuple
 
-from sqlalchemy import Table
+from sqlalchemy import Table, TextClause
 
 class DialectHandler(ABC):
     @abstractmethod
@@ -64,7 +64,16 @@ class DialectHandler(ABC):
         pass
 
     @abstractmethod
-    def make_sat_proc(
+    def make_link_proc(
+        self,
+        link_table: Table,
+        hk_keys: list,
+        header: str
+    ) -> Tuple[str, str, str]:
+        pass
+
+    @abstractmethod
+    def make_scd2_sat_proc(
         self,
         sat_table: Table,
         hk_name: str,
@@ -74,25 +83,14 @@ class DialectHandler(ABC):
         stg_schema: str,
         header: str
     ) -> Tuple[str, str, str]:
-        """Generate satellite population procedure.
-
-        Args:
-            sat_table: SQLAlchemy Table object for satellite
-            hk_name: Hash key column name
-            hashdiff_col: Hash diff column name
-            is_available_col: Is available column name
-            loaddate_col: Load date column name
-            columns_list: Comma-separated list of columns
-            stg_schema: Staging schema name ('stg' or 'proxy')
-            header: Auto-generated header comment
+        pass
 
-        Returns:
-            Tuple of (procedure_code, procedure_name)
-        """
+    @abstractmethod
+    def make_scd0_sat_proc(self, sat_table: Table, header: str) -> Tuple[str, str, str]:
         pass
 
     @abstractmethod
-    def make_dim_scd2_proc(
+    def make_scd2_dim_proc(
         self,
         dim_table: Table,
         bk_keys: list,
@@ -115,10 +113,7 @@ class DialectHandler(ABC):
     def make_job_proc(
         self,
         entity_name: str,
-        hub_proc_name: str,
-        sat_proc_name: str,
-        dim_proc_name: str,
-        stg_proc_name: str | None,
+        proc_names: list[str],
         header: str
     ) -> Tuple[str, str, str]:
         """Generate main job orchestration procedure.
@@ -137,30 +132,5 @@ class DialectHandler(ABC):
         pass
 
     @abstractmethod
-    def make_drop_proc(
-        self,
-        entity_name: str,
-        stg_schema: str,
-        job_proc_name: str,
-        stg_proc_name: str | None,
-        hub_proc_name: str,
-        sat_proc_name: str,
-        dim_proc_name: str,
-        header: str
-    ) -> Tuple[str, str, str]:
-        """Generate cleanup/drop procedure for all entity objects.
-
-        Args:
-            entity_name: Entity name
-            stg_schema: Staging schema name ('stg' or 'proxy')
-            job_proc_name: Name of job orchestration procedure
-            stg_proc_name: Name of staging materialization procedure (optional)
-            hub_proc_name: Name of hub population procedure
-            sat_proc_name: Name of satellite population procedure
-            dim_proc_name: Name of dimension recalculation procedure
-            header: Auto-generated header comment
-
-        Returns:
-            Tuple of (procedure_code, procedure_name)
-        """
-        pass
+    def make_drop_proc(self, entity_name, table_schemas: list[str], procedures: list[str], header: str) \
+        -> Tuple[str, str, str]: ...

sandwich/dialects/ddl_mssql.py

@@ -15,33 +15,6 @@ begin
 end
 """
 
-# language=sql
-create_proc_register_entity = """
-create or alter proc core.register_entity (
-	@entity_name varchar(100),
-	@template varchar(50)
-) as
-begin
-	set nocount on;
-
-	if exists (
-		select *
-		from core.[entities]
-		where [entity_name] = @entity_name
-	)
-	begin
-		update core.[entities]
-		set [updated] = sysdatetime(), [is_deleted] = 0
-		where [entity_name] = @entity_name
-	end
-	else begin
-		insert into core.[entities]
-		([entity_name], [template])
-		values (@entity_name, @template)
-	end
-end
-"""
-
 # language=sql
 create_table_ExecutionLog = """
 if object_id('core.ExecutionLog') is null
@@ -101,6 +74,8 @@ if schema_id('hub') is null
     exec ('create schema hub')
 if schema_id('sat') is null
     exec ('create schema sat')
+if schema_id('link') is null
+    exec ('create schema link')
 if schema_id('dim') is null
     exec ('create schema dim')
 if schema_id('fact') is null

sandwich/dialects/ddl_postgres.py

@@ -17,24 +17,6 @@ CREATE TABLE IF NOT EXISTS core.entities (
 );
 """
 
-# language=sql
-create_proc_register_entity = """
-CREATE OR REPLACE PROCEDURE core.register_entity(
-    p_entity_name VARCHAR(100),
-    p_gen_path VARCHAR(50)
-)
-LANGUAGE plpgsql
-AS $$
-BEGIN
-    INSERT INTO core.entities (entity_name, template)
-    VALUES (p_entity_name, p_gen_path)
-    ON CONFLICT (entity_name) DO UPDATE
-    SET updated = NOW(),
-        is_deleted = FALSE;
-END;
-$$;
-"""
-
 # language=sql
 create_func_StringToHash= """
 create or replace function core.string_to_hash1(str_value text)

sandwich/dialects/mssql.py

@@ -1,7 +1,11 @@
 """MSSQL dialect handler for SQL code generation."""
 from typing import Tuple
 
-from sqlalchemy import dialects, Table
+from sqlalchemy import dialects, Table, text
+
+#from sandwich import SANDWICH_VERSION
+#from sandwich.modeling import modeling_metadata
+#from sandwich.modeling.strategies.base import ValidationResult
 
 from .base import DialectHandler
 from .utils import get_columns_list
@@ -103,7 +107,47 @@ end
         proc_code = self.apply_proc_template(proc_name, proc_body, header)
         return proc_code, proc_name, f"exec {proc_name}"
 
-    def make_sat_proc(
+    def make_link_proc(self, link_table: Table, hk_keys: list, header: str) -> Tuple[str, str, str]:
+        proc_name = self.get_proc_name_format("elt", f"Populate_{link_table.schema}", link_table.name)
+        where_fields_list_str = "\n\t\tand ".join([f"link.[{hk[0]}] = stg.[{hk[0]}]" for hk in hk_keys if hk[0] != f"hk_{link_table.name}"])
+        columns_list = get_columns_list(link_table)
+
+        # language=sql
+        proc_body = f"""
+    insert into [{link_table.schema}].[{link_table.name}]
+    ({columns_list})
+    select distinct {get_columns_list(link_table, alias="stg")}
+    from stg.[{link_table.name}] as stg
+    where not exists (
+        select *
+        from [{link_table.schema}].[{link_table.name}] as link
+        where {where_fields_list_str}
+    );
+"""
+        proc_code = self.apply_proc_template(proc_name, proc_body, header)
+        return proc_code, proc_name, f"exec {proc_name}"
+
+    def make_scd0_sat_proc(self, sat_table: Table, header: str) -> Tuple[str, str, str]:
+        proc_name = self.get_proc_name_format("elt", f"Populate_{sat_table.schema}", sat_table.name)
+        columns_list = get_columns_list(sat_table)
+        hk_name = f"hk_{sat_table.name}"
+
+        # language=sql
+        proc_body = f"""
+    insert into [{sat_table.schema}].[{sat_table.name}]
+    ({columns_list})
+    select {get_columns_list(sat_table, alias="stg")}
+    from stg.[{sat_table.name}] stg
+    where not exists (
+        select *
+        from sat.[{sat_table.name}] sat
+        where stg.[{hk_name}] = sat.[{hk_name}]
+    )
+"""
+        proc_code = self.apply_proc_template(proc_name, proc_body, header)
+        return proc_code, proc_name, f"exec {proc_name}"
+
+    def make_scd2_sat_proc(
         self,
         sat_table: Table,
         hk_name: str,
@@ -175,12 +219,7 @@ end
         proc_code = self.apply_proc_template(proc_name, proc_body, header)
         return proc_code, proc_name, f"exec {proc_name}"
 
-    def make_dim_scd2_proc(
-        self,
-        dim_table: Table,
-        bk_keys: list,
-        header: str
-    ) -> Tuple[str, str, str]:
+    def make_scd2_dim_proc(self, dim_table: Table, bk_keys: list, header: str) -> Tuple[str, str, str]:
         proc_name = self.get_proc_name_format("elt", f"Recalculate_{dim_table.schema}", dim_table.name)
         columns_list = get_columns_list(dim_table)
         pk_keys = lambda: ", ".join([f"sat.[{bk[0]}]" for bk in bk_keys])
@@ -210,62 +249,33 @@ end
         proc_code = self.apply_proc_template(proc_name, proc_body, header)
         return proc_code, proc_name, f"exec {proc_name}"
 
-    def make_job_proc(
-        self,
-        entity_name: str,
-        hub_proc_name: str,
-        sat_proc_name: str,
-        dim_proc_name: str,
-        stg_proc_name: str | None,
-        header: str
-    ) -> Tuple[str, str, str]:
-        """Generate MSSQL job orchestration procedure."""
+    def make_job_proc(self, entity_name: str, proc_names: list[str], header: str) -> Tuple[str, str, str]:
         proc_name = f"[job].[Run_all_related_to_{entity_name}]"
+        proc_body = "\n\t"
+        for proc in proc_names:
+            if proc is None: continue
+            proc_body += f"exec {proc} @executionID;\n\t"
 
-        stg_call = f"    exec {stg_proc_name} @executionID;\n" if stg_proc_name else ""
-
-        # language=sql
-        proc_body = f"""
-{stg_call}    exec {hub_proc_name} @executionID;
-    exec {sat_proc_name} @executionID;
-    exec {dim_proc_name} @executionID;
-"""
         proc_code = self.apply_proc_template(proc_name, proc_body, header)
         return proc_code, proc_name, f"exec {proc_name}"
 
-    def make_drop_proc(
-        self,
-        entity_name: str,
-        stg_schema: str,
-        job_proc_name: str,
-        stg_proc_name: str | None,
-        hub_proc_name: str,
-        sat_proc_name: str,
-        dim_proc_name: str,
-        header: str
-    ) -> Tuple[str, str, str]:
-        """Generate MSSQL cleanup/drop procedure."""
+    def make_drop_proc(self, entity_name, table_schemas: list[str], procedures: list[str], header: str) -> Tuple[str, str, str]:
         proc_name = f"[meta].[Drop_all_related_to_{entity_name}]"
-
-        stg_drops = f"""
-    drop table if exists [stg].[{entity_name}];
-    drop procedure if exists {stg_proc_name};
-""" if stg_schema == "proxy" else ""
-
-        # language=sql
-        proc_body = f"""{stg_drops}
-    drop table if exists [dim].[{entity_name}];
-    drop procedure if exists {dim_proc_name};
-    drop table if exists [sat].[{entity_name}];
-    drop procedure if exists {sat_proc_name};
-    drop table if exists [hub].[{entity_name}];
-    drop procedure if exists {hub_proc_name};
-    drop procedure if exists {job_proc_name};
-
-    update core.[entities]
+        proc_body = "\n\t"
+        for proc in procedures:
+            if proc is None: continue
+            proc_body += f"drop procedure if exists {proc};\n\t"
+        proc_body += "\n\t"
+        for schema in table_schemas:
+            proc_body += f"drop table if exists [{schema}].[{entity_name}];\n\t"
+        proc_body += "\n\t"
+        proc_body += \
+f"""update core.[entities]
     set [deleted] = sysdatetime()
     , [is_deleted] = 1
     where [entity_name] = '{entity_name}'
 """
+
         proc_code = self.apply_proc_template(proc_name, proc_body, header)
         return proc_code, proc_name, f"exec {proc_name}"
+

sandwich/dialects/postgres.py

@@ -1,7 +1,6 @@
-"""Postgres dialect handler for SQL code generation."""
 from typing import Tuple
 
-from sqlalchemy import dialects, Table
+from sqlalchemy import dialects, Table, text
 
 from src.sandwich.dialects.base import DialectHandler
 
@@ -49,7 +48,7 @@ class PostgresDialectHandler(DialectHandler):
         # TODO: Implement using INSERT...ON CONFLICT or NOT EXISTS pattern
         raise NotImplementedError("Postgres hub procedure not yet implemented")
 
-    def make_sat_proc(
+    def make_sdc2_sat_proc(
         self,
         sat_table: Table,
         hk_name: str,
@@ -65,7 +64,7 @@ class PostgresDialectHandler(DialectHandler):
         # Use BOOLEAN type instead of BIT
         raise NotImplementedError("Postgres satellite procedure not yet implemented")
 
-    def make_dim_scd2_proc(
+    def make_scd2_dim_proc(
         self,
         dim_table: Table,
         bk_keys: list,

sandwich/dialects/utils.py

@@ -89,7 +89,6 @@ def initialize_database(conn: Engine | Connection, dialect: str = "mssql",
         if drop_entities_table:
             init_scripts["drop_entities_table"] = "drop table if exists [core].[entities];"
         init_scripts["create_entities_table"] = ddl_mssql.create_entities_table
-        init_scripts["create_proc_register_entity"] = header + ddl_mssql.create_proc_register_entity
         init_scripts["create_func_StringToHash1"] = header + ddl_mssql.create_func_StringToHash
         for i in range(2, str_to_hash_count):
             init_scripts[f"create_func_StringToHash{i}"] = header + get_string_to_hash_ddl_mssql(i)
@@ -102,7 +101,6 @@ def initialize_database(conn: Engine | Connection, dialect: str = "mssql",
         if drop_entities_table:
             init_scripts["drop_entities_table"] = "drop table if exists core.entities"
         init_scripts["create_entities_table"] = ddl_postgres.create_entities_table
-        init_scripts["create_proc_register_entity"] = ddl_postgres.create_proc_register_entity
         init_scripts["create_func_StringToHash1"] = ddl_postgres.create_func_StringToHash
         for i in range(2, str_to_hash_count):
             init_scripts[f"create_func_StringToHash{i}"] = get_string_to_hash_ddl_postgres(i)
@@ -146,4 +144,4 @@ def parse_auto_generated_header(full_proc_text: str) -> dict[str, Any]:
             started = True
             continue
     result["rows_in_header"] = rows_in_header - 1 if rows_in_header > 0 else 0
-    return result
+    return result

sandwich/dwh/__init__.py

@@ -0,0 +1,82 @@
+from datetime import datetime
+
+from sqlalchemy import Connection, Engine, MetaData, select, Table, text, RowMapping, Sequence
+
+from sandwich.dialects import DialectHandlerFactory
+from sandwich.modeling import get_stg_info, infer_template, Dv2SystemInfo, Dv2Entity, StgInfo
+from sandwich.modeling.strategies import SchemaGenerator, StrategyFactory
+
+
+def _register_entity(entity_name: str, template: str, conn: Engine | Connection,
+                         verbose: bool = False) -> datetime:
+    entities = Table("entities", MetaData(), schema="core", autoload_with=conn)
+    created_result = conn.execute(select(entities.c.created).where(entity_name == entities.c.entity_name)).scalar_one_or_none()
+
+    if created_result is None:
+        created_result = datetime.now()
+        conn.execute(entities.insert().values(entity_name=entity_name, template=template, created=created_result))
+        if verbose:
+            print(f"[ok] Registered `{entity_name}` for `{template}`")
+    else:
+        _update_entity(entity_name, conn, entities, verbose=verbose)
+
+    return created_result
+
+def _update_entity(entity_name: str, conn: Engine | Connection, sys_entities: Table, verbose: bool = False) -> None:
+    conn.execute(
+        sys_entities.update().where(entity_name == sys_entities.c.entity_name).values(updated=datetime.now(), is_deleted=False))
+    if verbose:
+        print(f"[ok] Updated `{entity_name}`")
+
+
+def generate_schema(schema_generator: SchemaGenerator, registered_on: datetime, conn: Engine | Connection,
+                    verbose: bool = False) -> None:
+    tables = schema_generator.make_tables()
+    for table_type, table in tables.items():
+        if table is not None:
+            table.create(conn, checkfirst=True)
+            if verbose:
+                print(f"[ok] Created table [{table.schema}].[{table.name}]")
+
+    procedures = schema_generator.make_procedures(tables, registered_on)
+    for proc_type, (proc_code, proc_name, _) in procedures.items():
+        conn.execute(text(proc_code))
+        if verbose:
+            print(f"[ok] Created or altered {proc_name}")
+
+
+def _generate_schema_for_entity(stg_info: StgInfo, conn: Engine | Connection, dialect: str,
+                                registered_on: datetime, template: str | None, verbose: bool = False) -> None:
+    validator = StrategyFactory.create_validator(template)
+    sys_info = get_system_info(conn)
+    validation_result = validator.validate_staging(stg_info, sys_info)
+    dialect_handler = DialectHandlerFactory.create_handler(dialect)
+    schema_generator = StrategyFactory.create_generator(dialect_handler, validation_result)
+    generate_schema(schema_generator, registered_on, conn, verbose=verbose)
+
+
+def register_and_create_entity(entity_name: str, conn: Engine | Connection, dialect: str, template: str | None = None,
+                               schema: str = "stg", verbose: bool = False) -> None:
+    stg_info = get_stg_info(entity_name, schema, conn)
+    if template is None:
+        template = infer_template(stg_info)
+    registered_on = _register_entity(entity_name, template, conn)
+    _generate_schema_for_entity(stg_info, conn, dialect, registered_on, template, verbose=verbose)
+
+
+def update_registered_entities(conn: Engine | Connection, dialect: str, schema: str = "stg",
+                               verbose: bool = False) -> None:
+    sys_info = get_system_info(conn)
+    for en in sys_info.entities_list:
+        stg_info = get_stg_info(en.entity_name, schema, conn)
+        _update_entity(en.entity_name, conn, sys_info.sys_entities, verbose=verbose)
+        _generate_schema_for_entity(stg_info, conn, dialect, en.created_on, en.template, verbose=verbose)
+
+
+def get_system_info(conn: Engine | Connection):
+    sys_entities = Table("entities", MetaData(), schema="core", autoload_with=conn)
+    select_result = conn.execute(sys_entities.select().where(~sys_entities.c.is_deleted))
+    return Dv2SystemInfo(
+        [Dv2Entity(en["entity_name"], en["template"], en["created"]) for en in select_result.mappings().all()],
+        sys_entities
+    )

sandwich/modeling/__init__.py

@@ -1,7 +1,15 @@
 from dataclasses import dataclass
-from typing import Any
+from datetime import datetime
+from typing import Any, Tuple
+
+from sqlalchemy import Table, Engine, Connection, MetaData
+
+@dataclass(frozen=True)
+class Dv2Entity:
+    entity_name: str
+    template: str
+    created_on: datetime
 
-from sqlalchemy import Table
 
 @dataclass(frozen=True)
 class StgInfo:
@@ -11,6 +19,12 @@ class StgInfo:
     bk_keys: dict[str, Any]
     sys_columns: dict[str, Any]
     bus_columns: dict[str, Any]
+    degenerate_field: Tuple[str, Any] | None = None
+
+@dataclass(frozen=True)
+class Dv2SystemInfo:
+    entities_list: list[Dv2Entity]
+    sys_entities: Table
 
 class Dv2ModelingMetadata:
     HEADER_TEMPLATE = """/* 
@@ -58,24 +72,26 @@ class Dv2ModelingMetadata:
         #self.column_types = self._dialects_config[self.dialect]
         self.required_columns: list[str] = [self.loaddate, self.recordsource]
 
-
 modeling_metadata = Dv2ModelingMetadata()
 
-def get_stg_info(stg: Table) -> StgInfo:
+def get_stg_info(entity_name: str, schema: str, conn: Engine | Connection) -> StgInfo:
+    stg = Table(entity_name, MetaData(), schema=schema, autoload_with=conn)
+
     hk_keys: dict[str, Any] = {}
     bk_keys: dict[str, Any] = {}
     sys_columns: dict[str, Any] = {}
     bus_columns: dict[str, Any] = {}
+    degenerate_field: Tuple[str, Any] | None = None
 
     for col in stg.columns.values():
-        if col.name.startswith("hk_"):
+        if col.name.startswith("hk_"): # hash key
             hk_keys[col.name] = col.type
-        elif col.name.startswith("bk_"):
+        elif col.name.startswith("bk_"): # business key
             bk_keys[col.name] = col.type
-        elif col.name.startswith("sg_"):
+        elif col.name.startswith("dg_"): # degenerate field (transactional links only)
+            degenerate_field = (col.name, col.type)
+        elif col.name.startswith("sg_"): # surrogate key
             raise Exception(f"sg column '{col.name}' is not implemented yet")
-        elif col.name.startswith("ts_"):
-            raise Exception(f"ts column '{col.name}' is not implemented yet")
         elif col.name in modeling_metadata.names:
             # type_name = metadata.column_types[col.name]
             # if not str(col.type).startswith(type_name):
@@ -91,6 +107,7 @@ def get_stg_info(stg: Table) -> StgInfo:
         bk_keys=bk_keys,
         sys_columns=sys_columns,
         bus_columns=bus_columns,
+        degenerate_field=degenerate_field,
     )
 
 def infer_template(stg_info: StgInfo):

sandwich/modeling/strategies/base.py

@@ -0,0 +1,94 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Callable, Tuple
+
+from sqlalchemy import Table
+
+from sandwich.modeling import Dv2SystemInfo, modeling_metadata, StgInfo
+
+@dataclass(frozen=True)
+class ValidationResult:
+    stg_schema: str
+    entity_name: str
+    bk_keys: list[Tuple[str, Any]]
+    hk_keys: list[Tuple[str, Any]]
+    business_column_types: dict[str, Any]
+    system_column_types: dict[str, Any]
+    template: str
+    degenerate_field: Tuple[str, Any] | None = None
+
+class Validator(ABC):
+    @abstractmethod
+    def validate_staging(self, stg_info: StgInfo, sys_info: Dv2SystemInfo, verbose: bool = False) -> ValidationResult:
+        pass
+
+class BaseValidator(Validator):
+    def __init__(self, template: str):
+        self._on_validate_staging: Callable[[StgInfo, Dv2SystemInfo], None] | None = None
+        self.template = template
+
+    def validate_staging(self, stg_info: StgInfo, sys_info: Dv2SystemInfo, verbose: bool = False) -> ValidationResult:
+        """Validate staging table or view for `scd2dim` template.
+
+        Raises: Exception"""
+        if verbose:
+            raise Exception("verbose is not implemented yet")
+
+        system_column_names = stg_info.sys_columns.keys()
+
+        # universal check - all dv2 raw objects should be auditable
+        for required_col in modeling_metadata.required_columns:
+            if required_col not in system_column_names:
+                raise Exception(f"{required_col} column is required")
+
+        if self._on_validate_staging is not None:
+            self._on_validate_staging(stg_info, sys_info)
+
+        # todo: ValidationResult is not required whatsoever
+        return ValidationResult(
+            stg_schema=stg_info.stg_schema,
+            entity_name=stg_info.stg_name,
+            bk_keys=[(nm, tp) for nm, tp in stg_info.bk_keys.items()],
+            hk_keys=[(nm, tp) for nm, tp in stg_info.hk_keys.items()],
+            degenerate_field = stg_info.degenerate_field,
+            business_column_types=stg_info.bus_columns,
+            system_column_types=stg_info.sys_columns,
+            template=self.template
+        )
+
+
+
+class SchemaGenerator(ABC):
+    @abstractmethod
+    def make_tables(self) -> dict[str, Table]:
+        pass
+
+    @abstractmethod
+    def make_procedures(
+        self,
+        tables: dict[str, Table],
+        entity_registration_date: datetime = datetime.now()
+    ) -> dict[str, Tuple[str, str, str]]:
+        pass
+
+# class BaseSchemaGenerator(SchemaGenerator):
+#     def __init__(self, dialect_handler: DialectHandler, validation_result: ValidationResult):
+#         self.dialect_handler = dialect_handler
+#         self._validation_result = validation_result
+#         self._on_make_proc: Callable[[Table, datetime], Tuple[str, str, str]] | None = None
+#
+#     def make_proc(self, tbl: Table, entity_registration_date: datetime) -> Tuple[str, str, str]:
+#         header = modeling_metadata.HEADER_TEMPLATE.format(
+#             created_on=entity_registration_date,
+#             updated_on=datetime.now(),
+#             version=SANDWICH_VERSION,
+#             entity_name=self._validation_result.entity_name
+#         )
+#
+#         if self._validation_result.stg_schema == "proxy":
+#             stg_proc_code, stg_proc_name, stg_call_stmt = self.dialect_handler.make_stg_materialization_proc(
+#                 entity_name=self._validation_result.entity_name,
+#                 header=header
+#             )
+#             procedures["stg"] = (stg_proc_code, stg_proc_name, stg_call_stmt)

sandwich/{strategies → modeling/strategies}/factory.py

@@ -22,10 +22,11 @@ class StrategyFactory:
             raise ValueError(f"Unknown template '{template}'. Available templates: {available}")
 
         validator_class, _ = cls._strategies[template]
-        return validator_class()
+        return validator_class(template)
 
     @classmethod
-    def create_generator(cls, template: str, dialect_handler: DialectHandler, validation_result: ValidationResult) -> SchemaGenerator:
+    def create_generator(cls, dialect_handler: DialectHandler, validation_result: ValidationResult) -> SchemaGenerator:
+        template = validation_result.template
         if template not in cls._strategies:
             available = ", ".join(cls._strategies.keys())
             raise ValueError(f"Unknown template '{template}'. Available templates: {available}")