sqlmesh-dag-generator 0.7.2__tar.gz → 0.7.3__tar.gz

{sqlmesh_dag_generator-0.7.2/sqlmesh_dag_generator.egg-info → sqlmesh_dag_generator-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh-dag-generator
-Version: 0.7.2
+Version: 0.7.3
 Summary: Open-source Airflow DAG generator for SQLMesh projects
 Home-page: https://github.com/kubolko/sqlmesh-dag-generator
 Author: Jakub Sumionka
@@ -63,6 +63,14 @@ Transform your SQLMesh models into production-ready Airflow DAGs with **full dat
 - 🛠️ **Dual Mode**: Dynamic (auto-discovery, default) or Static (full control)
 - 🚫 **No Vendor Lock-in**: Open source, no cloud dependencies
 
+### 🏢 Enterprise Features (NEW in v0.8.0)
+
+- 🔔 **Callbacks**: `on_failure_callback`, `on_success_callback`, `sla_miss_callback` for alerting
+- 🏷️ **Tag-Based Filtering**: `include_tags`, `exclude_tags` for Data Mesh team-specific DAGs
+- 🎱 **Pool Configuration**: `pool`, `pool_slots` for resource management
+- ⏩ **Trigger Downstream DAGs**: `trigger_dag_id` for ML pipeline integration
+- 🎯 **Pattern Filtering**: `model_pattern` for regex-based model selection
+
 ## ⚠️ Important: Gateway vs Environment
 
 **SQLMesh uses "gateways" to switch between environments, NOT an "environment" parameter.**

{sqlmesh_dag_generator-0.7.2 → sqlmesh_dag_generator-0.7.3}/README.md

@@ -16,6 +16,14 @@ Transform your SQLMesh models into production-ready Airflow DAGs with **full dat
 - 🛠️ **Dual Mode**: Dynamic (auto-discovery, default) or Static (full control)
 - 🚫 **No Vendor Lock-in**: Open source, no cloud dependencies
 
+### 🏢 Enterprise Features (NEW in v0.8.0)
+
+- 🔔 **Callbacks**: `on_failure_callback`, `on_success_callback`, `sla_miss_callback` for alerting
+- 🏷️ **Tag-Based Filtering**: `include_tags`, `exclude_tags` for Data Mesh team-specific DAGs
+- 🎱 **Pool Configuration**: `pool`, `pool_slots` for resource management
+- ⏩ **Trigger Downstream DAGs**: `trigger_dag_id` for ML pipeline integration
+- 🎯 **Pattern Filtering**: `model_pattern` for regex-based model selection
+
 ## ⚠️ Important: Gateway vs Environment
 
 **SQLMesh uses "gateways" to switch between environments, NOT an "environment" parameter.**

{sqlmesh_dag_generator-0.7.2 → sqlmesh_dag_generator-0.7.3}/setup.py

@@ -20,7 +20,7 @@ if requirements_file.exists():
 
 setup(
     name="sqlmesh-dag-generator",
-    version="0.7.2",
+    version="0.7.3",
     description="Open-source Airflow DAG generator for SQLMesh projects",
     long_description=long_description,
     long_description_content_type="text/markdown",

{sqlmesh_dag_generator-0.7.2 → sqlmesh_dag_generator-0.7.3}/sqlmesh_dag_generator/__init__.py

@@ -2,7 +2,7 @@
 SQLMesh DAG Generator - Open Source Airflow Integration for SQLMesh
 """
 
-__version__ = "0.7.2"
+__version__ = "0.8.0"
 
 
 from sqlmesh_dag_generator.generator import SQLMeshDAGGenerator

{sqlmesh_dag_generator-0.7.2 → sqlmesh_dag_generator-0.7.3}/sqlmesh_dag_generator/airflow_utils.py

@@ -268,7 +268,8 @@ def _build_config_from_connection(conn: Any, conn_type: str) -> Dict[str, Any]:
     # Add connection details based on type
     if conn_type == "redshift":
         # Redshift uses 2-part naming (schema.table), not 3-part (catalog.schema.table)
-        # Set default_catalog to the database name so SQLMesh omits it from generated SQL
+        # Note: default_catalog is NOT a valid Redshift connection config field
+        # It should be set at the SQLMesh config level, not connection level
         database = conn.schema or "dev"
         config.update({
             "host": conn.host,
@@ -276,7 +277,6 @@ def _build_config_from_connection(conn: Any, conn_type: str) -> Dict[str, Any]:
             "user": conn.login,
             "password": conn.password,
             "database": database,
-            "default_catalog": database,  # Tells SQLMesh to omit this from SQL generation
         })
     elif conn_type in ["postgres", "postgresql"]:
         config.update({

{sqlmesh_dag_generator-0.7.2 → sqlmesh_dag_generator-0.7.3}/sqlmesh_dag_generator/config.py

@@ -94,6 +94,11 @@ class AirflowConfig:
     max_active_runs: int = 1
     description: Optional[str] = None
     env_vars: Dict[str, str] = field(default_factory=dict)  # Environment variables for tasks
+    # Callback configuration - pass callable names (will be imported in generated DAG)
+    on_failure_callback: Optional[str] = None  # e.g., "my_module.slack_alert"
+    on_success_callback: Optional[str] = None  # e.g., "my_module.log_success"
+    sla_miss_callback: Optional[str] = None  # e.g., "my_module.sla_alert"
+    sla: Optional[int] = None  # SLA in seconds for all tasks
 
 
 @dataclass
@@ -116,6 +121,15 @@ class GenerationConfig:
     auto_replan_on_change: bool = False  # Automatically replan if models change
     skip_audits: bool = False  # Skip audit checks during execution
     enable_health_check: bool = False  # Add a pre-flight health check task
+    # Tag-based filtering - only include models with any of these tags
+    include_tags: Optional[List[str]] = None  # e.g., ["finance", "core"]
+    exclude_tags: Optional[List[str]] = None  # e.g., ["deprecated", "test"]
+    # Resource management
+    pool: Optional[str] = None  # Airflow pool for all tasks
+    pool_slots: int = 1  # Number of pool slots per task
+    # Trigger downstream DAG after completion
+    trigger_dag_id: Optional[str] = None  # DAG to trigger on success
+    trigger_dag_conf: Optional[Dict[str, Any]] = None  # Conf to pass to triggered DAG
 
 
 @dataclass

{sqlmesh_dag_generator-0.7.2 → sqlmesh_dag_generator-0.7.3}/sqlmesh_dag_generator/dag_builder.py

@@ -92,6 +92,14 @@ class AirflowDAGBuilder:
                 "from kubernetes.client.models import V1EnvVar",
             ])
 
+        # Add TriggerDagRunOperator if trigger_dag_id is configured
+        if self.config.generation.trigger_dag_id:
+            imports.append("from airflow.operators.trigger_dagrun import TriggerDagRunOperator")
+
+        # Add EmptyOperator for source tables
+        if self.config.generation.include_source_tables:
+            imports.append("from airflow.operators.empty import EmptyOperator")
+
         imports.extend([
             "",
             "from sqlmesh import Context",
@@ -99,6 +107,20 @@ class AirflowDAGBuilder:
             "logger = logging.getLogger(__name__)",
         ])
 
+        # Add callback imports if configured
+        if self.config.airflow.on_failure_callback:
+            module_path = self.config.airflow.on_failure_callback.rsplit('.', 1)
+            if len(module_path) == 2:
+                imports.insert(4, f"from {module_path[0]} import {module_path[1]}")
+        if self.config.airflow.on_success_callback:
+            module_path = self.config.airflow.on_success_callback.rsplit('.', 1)
+            if len(module_path) == 2:
+                imports.insert(4, f"from {module_path[0]} import {module_path[1]}")
+        if self.config.airflow.sla_miss_callback:
+            module_path = self.config.airflow.sla_miss_callback.rsplit('.', 1)
+            if len(module_path) == 2:
+                imports.insert(4, f"from {module_path[0]} import {module_path[1]}")
+
         return "\n".join(imports)
 
     def _build_config(self) -> str:
@@ -128,6 +150,11 @@ class AirflowDAGBuilder:
         else:
             start_date_str = "datetime.now() - timedelta(days=1)"  # Default to yesterday
 
+        # Build optional DAG arguments
+        optional_args = ""
+        if self.config.airflow.sla_miss_callback:
+            optional_args += f"\n    sla_miss_callback={self.config.airflow.sla_miss_callback},"
+
         return f"""# DAG Definition
 dag = DAG(
     dag_id="{self.config.airflow.dag_id}",
@@ -137,7 +164,7 @@ dag = DAG(
     start_date={start_date_str},
     catchup={self.config.airflow.catchup},
     max_active_runs={self.config.airflow.max_active_runs},
-    tags={tags},
+    tags={tags},{optional_args}
 )"""
 
     def _format_default_args(self) -> str:
@@ -237,11 +264,30 @@ dag = DAG(
     logger.info(f"Model {model_name_escaped} completed successfully")
     return result'''
 
-        # Build the operator
+        # Build the operator with additional configuration
+        operator_args = [
+            f'task_id="{task_id}"',
+            f'python_callable={function_name}',
+            'dag=dag',
+        ]
+
+        # Add pool if configured
+        if self.config.generation.pool:
+            operator_args.append(f'pool="{self.config.generation.pool}"')
+            operator_args.append(f'pool_slots={self.config.generation.pool_slots}')
+
+        # Add SLA if configured
+        if self.config.airflow.sla:
+            operator_args.append(f'sla=timedelta(seconds={self.config.airflow.sla})')
+
+        # Add callbacks if configured
+        if self.config.airflow.on_failure_callback:
+            operator_args.append(f'on_failure_callback={self.config.airflow.on_failure_callback}')
+        if self.config.airflow.on_success_callback:
+            operator_args.append(f'on_success_callback={self.config.airflow.on_success_callback}')
+
         operator_def = f'''{task_id} = PythonOperator(
-    task_id="{task_id}",
-    python_callable={function_name},
-    dag=dag,
+    {(","+chr(10)+"    ").join(operator_args)},
 )'''
 
         return f"{func_def}\n\n{operator_def}"
@@ -327,6 +373,26 @@ dag = DAG(
         if len(dep_lines) == 1:
             dep_lines.append("# No dependencies")
 
+        # Add trigger downstream DAG if configured
+        if self.config.generation.trigger_dag_id:
+            trigger_conf = repr(self.config.generation.trigger_dag_conf or {})
+            dep_lines.append("")
+            dep_lines.append("# Trigger downstream DAG on completion")
+            dep_lines.append(f'''trigger_downstream = TriggerDagRunOperator(
+    task_id="trigger_{self.config.generation.trigger_dag_id}",
+    trigger_dag_id="{self.config.generation.trigger_dag_id}",
+    conf={trigger_conf},
+    dag=dag,
+)''')
+            # Find leaf tasks and set them as upstream
+            leaf_tasks = [
+                info.get_task_id()
+                for name, info in self.dag_structure.models.items()
+                if name not in {dep for m in self.dag_structure.models.values() for dep in m.dependencies}
+            ]
+            if leaf_tasks:
+                dep_lines.append(f"[{', '.join(leaf_tasks)}] >> trigger_downstream")
+
         return "\n".join(dep_lines)
 
     # ========================================================================

{sqlmesh_dag_generator-0.7.2 → sqlmesh_dag_generator-0.7.3}/sqlmesh_dag_generator/generator.py

@@ -158,6 +158,10 @@ class SQLMeshDAGGenerator:
                 tags=kwargs.get("tags", ["sqlmesh"]),
                 catchup=kwargs.get("catchup", False),
                 max_active_runs=kwargs.get("max_active_runs", 1),
+                on_failure_callback=kwargs.get("on_failure_callback"),
+                on_success_callback=kwargs.get("on_success_callback"),
+                sla_miss_callback=kwargs.get("sla_miss_callback"),
+                sla=kwargs.get("sla"),
             )
 
             generation_config = GenerationConfig(
@@ -167,11 +171,18 @@ class SQLMeshDAGGenerator:
                 parallel_tasks=kwargs.get("parallel_tasks", True),
                 include_models=kwargs.get("include_models"),
                 exclude_models=kwargs.get("exclude_models"),
+                model_pattern=kwargs.get("model_pattern"),
                 include_source_tables=kwargs.get("include_source_tables", True),  # Default: enabled
                 return_value=kwargs.get("return_value", True),
                 auto_replan_on_change=kwargs.get("auto_replan_on_change", False),
                 skip_audits=kwargs.get("skip_audits", False),
                 enable_health_check=kwargs.get("enable_health_check", False),
+                include_tags=kwargs.get("include_tags"),
+                exclude_tags=kwargs.get("exclude_tags"),
+                pool=kwargs.get("pool"),
+                pool_slots=kwargs.get("pool_slots", 1),
+                trigger_dag_id=kwargs.get("trigger_dag_id"),
+                trigger_dag_conf=kwargs.get("trigger_dag_conf"),
             )
 
             self.config = DAGGeneratorConfig(
@@ -186,6 +197,33 @@ class SQLMeshDAGGenerator:
         self.merged_config = None  # Store merged config for runtime task execution
         self.runtime_gateway = None  # Store gateway name for runtime task execution
 
+        # Validate configuration and show helpful warnings
+        self._validate_config()
+
+    def _validate_config(self):
+        """Validate configuration and show helpful warnings."""
+        # Warn if using Redshift without default_catalog
+        if self.config.sqlmesh.connection_config:
+            conn_type = self.config.sqlmesh.connection_config.get("type", "").lower()
+            if conn_type == "redshift" and not self.config.sqlmesh.default_catalog:
+                import warnings
+                warnings.warn(
+                    f"\n{'='*80}\n"
+                    f"⚠️  Redshift detected without default_catalog setting!\n\n"
+                    f"Redshift uses 2-part naming (schema.table), not 3-part (catalog.schema.table).\n"
+                    f"Without default_catalog, SQLMesh may generate invalid SQL like:\n"
+                    f"   FROM \"your_database\".\"schema\".\"table\"  -- ERROR!\n\n"
+                    f"🔧 SOLUTION: Add default_catalog to your SQLMeshDAGGenerator:\n\n"
+                    f"   generator = SQLMeshDAGGenerator(\n"
+                    f"       ...\n"
+                    f"       default_catalog='your_database_name',  # Add this!\n"
+                    f"   )\n\n"
+                    f"📚 See docs/REDSHIFT_3PART_NAMING_FIX.md for more information.\n"
+                    f"{'='*80}\n",
+                    UserWarning,
+                    stacklevel=3
+                )
+
     def load_sqlmesh_context(self) -> Context:
         """
         Load the SQLMesh context from the project path.
@@ -361,8 +399,8 @@ class SQLMeshDAGGenerator:
             logger.warning("Could not find models in context")
 
         for model_name, model in sqlmesh_models.items():
-            # Filter models based on include/exclude patterns
-            if not self._should_include_model(model_name):
+            # Filter models based on include/exclude patterns and tags
+            if not self._should_include_model(model_name, model):
                 continue
 
             model_info = self._extract_model_info(model_name, model)
@@ -386,8 +424,10 @@ class SQLMeshDAGGenerator:
 
         return models
 
-    def _should_include_model(self, model_name: str) -> bool:
+    def _should_include_model(self, model_name: str, model: Model = None) -> bool:
         """Check if a model should be included based on filters"""
+        import re
+
         # Check include patterns
         if self.config.generation.include_models:
             if model_name not in self.config.generation.include_models:
@@ -398,6 +438,31 @@ class SQLMeshDAGGenerator:
             if model_name in self.config.generation.exclude_models:
                 return False
 
+        # Check model_pattern (regex)
+        if self.config.generation.model_pattern:
+            pattern = self.config.generation.model_pattern
+            if not re.match(pattern, model_name):
+                logger.debug(f"Model {model_name} excluded by pattern: {pattern}")
+                return False
+
+        # Tag-based filtering (requires model object)
+        if model is not None:
+            model_tags = set(getattr(model, 'tags', []) or [])
+
+            # Check include_tags - model must have at least one of these tags
+            if self.config.generation.include_tags:
+                include_tags = set(self.config.generation.include_tags)
+                if not model_tags.intersection(include_tags):
+                    logger.debug(f"Model {model_name} excluded: no matching include_tags")
+                    return False
+
+            # Check exclude_tags - model must not have any of these tags
+            if self.config.generation.exclude_tags:
+                exclude_tags = set(self.config.generation.exclude_tags)
+                if model_tags.intersection(exclude_tags):
+                    logger.debug(f"Model {model_name} excluded: has exclude_tags")
+                    return False
+
         return True
 
     def _extract_model_info(self, model_name: str, model: Model) -> SQLMeshModelInfo:
@@ -865,8 +930,10 @@ class SQLMeshDAGGenerator:
                             "model": m_fqn,
                         }
                     except Exception as e:
+                        error_msg = str(e)
+
                         # Check for "Environment not found" error
-                        if "Environment" in str(e) and "was not found" in str(e):
+                        if "Environment" in error_msg and "was not found" in error_msg:
                             env_name = self.config.sqlmesh.environment
                             raise RuntimeError(
                                 f"SQLMesh environment '{env_name}' was not found.\n\n"
@@ -886,6 +953,28 @@ class SQLMeshDAGGenerator:
                                 f"   See docs/SQLMESH_ENVIRONMENTS.md for complete explanation.\n\n"
                                 f"Original error: {e}"
                             ) from e
+
+                        # Check for Redshift catalog/3-part naming error
+                        elif "does not exist" in error_msg and (
+                            "redshift" in error_msg.lower() or
+                            "3D000" in error_msg or  # Redshift error code for invalid catalog
+                            ("." in error_msg and error_msg.count('"') >= 6)  # 3-part naming pattern
+                        ):
+                            raise RuntimeError(
+                                f"SQLMesh catalog error (likely 3-part naming issue):\n"
+                                f"{error_msg}\n\n"
+                                f"🔧 SOLUTION: For Redshift (2-part naming), set default_catalog:\n\n"
+                                f"   generator = SQLMeshDAGGenerator(\n"
+                                f"       sqlmesh_project_path='/path/to/project',\n"
+                                f"       connection='REDSHIFT',\n"
+                                f"       default_catalog='your_database_name',  # ✅ Add this!\n"
+                                f"   )\n\n"
+                                f"📚 Why? Redshift uses schema.table (2-part), not catalog.schema.table (3-part).\n"
+                                f"   Setting default_catalog tells SQLMesh to omit the catalog prefix.\n\n"
+                                f"   See docs/REDSHIFT_3PART_NAMING_FIX.md for more information.\n\n"
+                                f"Original error: {e}"
+                            ) from e
+
                         else:
                             # Re-raise other errors as-is
                             raise

{sqlmesh_dag_generator-0.7.2 → sqlmesh_dag_generator-0.7.3/sqlmesh_dag_generator.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh-dag-generator
-Version: 0.7.2
+Version: 0.7.3
 Summary: Open-source Airflow DAG generator for SQLMesh projects
 Home-page: https://github.com/kubolko/sqlmesh-dag-generator
 Author: Jakub Sumionka
@@ -63,6 +63,14 @@ Transform your SQLMesh models into production-ready Airflow DAGs with **full dat
 - 🛠️ **Dual Mode**: Dynamic (auto-discovery, default) or Static (full control)
 - 🚫 **No Vendor Lock-in**: Open source, no cloud dependencies
 
+### 🏢 Enterprise Features (NEW in v0.8.0)
+
+- 🔔 **Callbacks**: `on_failure_callback`, `on_success_callback`, `sla_miss_callback` for alerting
+- 🏷️ **Tag-Based Filtering**: `include_tags`, `exclude_tags` for Data Mesh team-specific DAGs
+- 🎱 **Pool Configuration**: `pool`, `pool_slots` for resource management
+- ⏩ **Trigger Downstream DAGs**: `trigger_dag_id` for ML pipeline integration
+- 🎯 **Pattern Filtering**: `model_pattern` for regex-based model selection
+
 ## ⚠️ Important: Gateway vs Environment
 
 **SQLMesh uses "gateways" to switch between environments, NOT an "environment" parameter.**

{sqlmesh_dag_generator-0.7.2 → sqlmesh_dag_generator-0.7.3}/sqlmesh_dag_generator.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ tests/test_auto_schedule.py
 tests/test_bug_fix_user_scenario.py
 tests/test_cache.py
 tests/test_config.py
+tests/test_enterprise_features.py
 tests/test_environment_default.py
 tests/test_environment_handling.py
 tests/test_generator.py

{sqlmesh_dag_generator-0.7.2 → sqlmesh_dag_generator-0.7.3}/tests/test_airflow_utils.py

@@ -21,8 +21,12 @@ class TestConnectionTypeMapping:
     def test_redshift_mapping(self):
         assert _map_airflow_conn_type_to_sqlmesh("redshift") == "redshift"
 
-    def test_redshift_default_catalog(self):
-        """Test that Redshift connections include default_catalog for 2-part naming"""
+    def test_redshift_no_default_catalog_in_connection(self):
+        """Test that Redshift connections do NOT include default_catalog.
+
+        default_catalog is a SQLMesh config-level setting, NOT a connection config field.
+        For Redshift 2-part naming, set default_catalog on SQLMeshDAGGenerator, not here.
+        """
         from sqlmesh_dag_generator.airflow_utils import _build_config_from_connection
 
         mock_conn = Mock()
@@ -36,11 +40,11 @@ class TestConnectionTypeMapping:
 
         result = _build_config_from_connection(mock_conn, "redshift")
 
-        # Redshift should have default_catalog set to database name
-        # This tells SQLMesh to use 2-part naming (schema.table) not 3-part (catalog.schema.table)
+        # Redshift connection should NOT have default_catalog
+        # default_catalog is set at SQLMesh config level, not in connection config
         assert result["type"] == "redshift"
         assert result["database"] == "stg_carrier_quality_redshift_db"
-        assert result["default_catalog"] == "stg_carrier_quality_redshift_db"
+        assert "default_catalog" not in result  # Must NOT be in connection config
         assert result["port"] == 5439
 
     def test_mysql_mapping(self):

sqlmesh_dag_generator-0.7.3/tests/test_enterprise_features.py

@@ -0,0 +1,240 @@
+"""
+Tests for enterprise features:
+- Callback support (on_failure, on_success, sla_miss)
+- Tag-based filtering
+- Pool configuration
+- Pattern-based model selection
+- Trigger downstream DAG
+"""
+import pytest
+from sqlmesh_dag_generator import SQLMeshDAGGenerator, DAGGeneratorConfig
+from sqlmesh_dag_generator.config import SQLMeshConfig, AirflowConfig, GenerationConfig
+from sqlmesh_dag_generator.models import SQLMeshModelInfo
+
+
+class TestCallbackSupport:
+    """Test callback configuration"""
+
+    def test_on_failure_callback_in_config(self):
+        """Test that on_failure_callback can be set"""
+        config = AirflowConfig(
+            dag_id="test_dag",
+            on_failure_callback="my_module.slack_alert",
+        )
+        assert config.on_failure_callback == "my_module.slack_alert"
+
+    def test_on_success_callback_in_config(self):
+        """Test that on_success_callback can be set"""
+        config = AirflowConfig(
+            dag_id="test_dag",
+            on_success_callback="my_module.log_success",
+        )
+        assert config.on_success_callback == "my_module.log_success"
+
+    def test_sla_miss_callback_in_config(self):
+        """Test that sla_miss_callback can be set"""
+        config = AirflowConfig(
+            dag_id="test_dag",
+            sla_miss_callback="my_module.sla_alert",
+        )
+        assert config.sla_miss_callback == "my_module.sla_alert"
+
+    def test_sla_seconds_in_config(self):
+        """Test that SLA can be set in seconds"""
+        config = AirflowConfig(
+            dag_id="test_dag",
+            sla=3600,  # 1 hour
+        )
+        assert config.sla == 3600
+
+    def test_generator_with_callbacks(self, tmp_path):
+        """Test generator accepts callback parameters"""
+        project_path = tmp_path / "project"
+        project_path.mkdir()
+        (project_path / "config.yaml").write_text("gateways:\n  default:\n    connection:\n      type: duckdb")
+
+        generator = SQLMeshDAGGenerator(
+            sqlmesh_project_path=str(project_path),
+            dag_id="test_callback_dag",
+            on_failure_callback="alerts.slack_notify",
+            on_success_callback="alerts.log_success",
+            sla=7200,
+        )
+
+        assert generator.config.airflow.on_failure_callback == "alerts.slack_notify"
+        assert generator.config.airflow.on_success_callback == "alerts.log_success"
+        assert generator.config.airflow.sla == 7200
+
+
+class TestTagBasedFiltering:
+    """Test tag-based model filtering"""
+
+    def test_include_tags_in_config(self):
+        """Test that include_tags can be set"""
+        config = GenerationConfig(
+            include_tags=["finance", "core"],
+        )
+        assert config.include_tags == ["finance", "core"]
+
+    def test_exclude_tags_in_config(self):
+        """Test that exclude_tags can be set"""
+        config = GenerationConfig(
+            exclude_tags=["deprecated", "test"],
+        )
+        assert config.exclude_tags == ["deprecated", "test"]
+
+    def test_generator_with_tags(self, tmp_path):
+        """Test generator accepts tag filter parameters"""
+        project_path = tmp_path / "project"
+        project_path.mkdir()
+        (project_path / "config.yaml").write_text("gateways:\n  default:\n    connection:\n      type: duckdb")
+
+        generator = SQLMeshDAGGenerator(
+            sqlmesh_project_path=str(project_path),
+            dag_id="test_tag_dag",
+            include_tags=["production", "tier1"],
+            exclude_tags=["experimental"],
+        )
+
+        assert generator.config.generation.include_tags == ["production", "tier1"]
+        assert generator.config.generation.exclude_tags == ["experimental"]
+
+
+class TestPoolConfiguration:
+    """Test Airflow pool configuration"""
+
+    def test_pool_in_config(self):
+        """Test that pool can be set"""
+        config = GenerationConfig(
+            pool="sqlmesh_pool",
+            pool_slots=2,
+        )
+        assert config.pool == "sqlmesh_pool"
+        assert config.pool_slots == 2
+
+    def test_pool_slots_default(self):
+        """Test that pool_slots defaults to 1"""
+        config = GenerationConfig()
+        assert config.pool_slots == 1
+
+    def test_generator_with_pool(self, tmp_path):
+        """Test generator accepts pool parameters"""
+        project_path = tmp_path / "project"
+        project_path.mkdir()
+        (project_path / "config.yaml").write_text("gateways:\n  default:\n    connection:\n      type: duckdb")
+
+        generator = SQLMeshDAGGenerator(
+            sqlmesh_project_path=str(project_path),
+            dag_id="test_pool_dag",
+            pool="db_pool",
+            pool_slots=3,
+        )
+
+        assert generator.config.generation.pool == "db_pool"
+        assert generator.config.generation.pool_slots == 3
+
+
+class TestTriggerDownstreamDAG:
+    """Test trigger downstream DAG configuration"""
+
+    def test_trigger_dag_id_in_config(self):
+        """Test that trigger_dag_id can be set"""
+        config = GenerationConfig(
+            trigger_dag_id="ml_training_dag",
+        )
+        assert config.trigger_dag_id == "ml_training_dag"
+
+    def test_trigger_dag_conf_in_config(self):
+        """Test that trigger_dag_conf can be set"""
+        config = GenerationConfig(
+            trigger_dag_id="ml_training_dag",
+            trigger_dag_conf={"model_version": "v2", "retrain": True},
+        )
+        assert config.trigger_dag_conf == {"model_version": "v2", "retrain": True}
+
+    def test_generator_with_trigger_dag(self, tmp_path):
+        """Test generator accepts trigger DAG parameters"""
+        project_path = tmp_path / "project"
+        project_path.mkdir()
+        (project_path / "config.yaml").write_text("gateways:\n  default:\n    connection:\n      type: duckdb")
+
+        generator = SQLMeshDAGGenerator(
+            sqlmesh_project_path=str(project_path),
+            dag_id="test_trigger_dag",
+            trigger_dag_id="downstream_dag",
+            trigger_dag_conf={"key": "value"},
+        )
+
+        assert generator.config.generation.trigger_dag_id == "downstream_dag"
+        assert generator.config.generation.trigger_dag_conf == {"key": "value"}
+
+
+class TestModelPatternFiltering:
+    """Test model pattern (regex) filtering"""
+
+    def test_model_pattern_in_config(self):
+        """Test that model_pattern can be set"""
+        config = GenerationConfig(
+            model_pattern=r"^analytics\..*",
+        )
+        assert config.model_pattern == r"^analytics\..*"
+
+    def test_generator_with_pattern(self, tmp_path):
+        """Test generator accepts model_pattern parameter"""
+        project_path = tmp_path / "project"
+        project_path.mkdir()
+        (project_path / "config.yaml").write_text("gateways:\n  default:\n    connection:\n      type: duckdb")
+
+        generator = SQLMeshDAGGenerator(
+            sqlmesh_project_path=str(project_path),
+            dag_id="test_pattern_dag",
+            model_pattern=r".*_fact$",
+        )
+
+        assert generator.config.generation.model_pattern == r".*_fact$"
+
+
+class TestCombinedEnterpriseFeatures:
+    """Test multiple enterprise features together"""
+
+    def test_full_enterprise_config(self, tmp_path):
+        """Test full enterprise configuration with all new features"""
+        project_path = tmp_path / "project"
+        project_path.mkdir()
+        (project_path / "config.yaml").write_text("gateways:\n  default:\n    connection:\n      type: duckdb")
+
+        generator = SQLMeshDAGGenerator(
+            sqlmesh_project_path=str(project_path),
+            dag_id="enterprise_dag",
+            # Callbacks
+            on_failure_callback="alerts.pagerduty_alert",
+            on_success_callback="metrics.record_success",
+            sla_miss_callback="alerts.sla_breach",
+            sla=1800,  # 30 minutes
+            # Tag filtering
+            include_tags=["production"],
+            exclude_tags=["deprecated"],
+            # Resource management
+            pool="prod_pool",
+            pool_slots=2,
+            # Pattern filtering
+            model_pattern=r"^prod\..*",
+            # Trigger downstream
+            trigger_dag_id="feature_store_update",
+            trigger_dag_conf={"source": "sqlmesh"},
+        )
+
+        # Verify all config values
+        assert generator.config.airflow.on_failure_callback == "alerts.pagerduty_alert"
+        assert generator.config.airflow.on_success_callback == "metrics.record_success"
+        assert generator.config.airflow.sla_miss_callback == "alerts.sla_breach"
+        assert generator.config.airflow.sla == 1800
+        assert generator.config.generation.include_tags == ["production"]
+        assert generator.config.generation.exclude_tags == ["deprecated"]
+        assert generator.config.generation.pool == "prod_pool"
+        assert generator.config.generation.pool_slots == 2
+        assert generator.config.generation.model_pattern == r"^prod\..*"
+        assert generator.config.generation.trigger_dag_id == "feature_store_update"
+        assert generator.config.generation.trigger_dag_conf == {"source": "sqlmesh"}
+
+