nl2sql-engine 0.1.0__py3-none-any.whl

nl2sql/cli/commands/setup.py

@@ -0,0 +1,415 @@
+
+import os
+import pathlib
+from rich.markup import escape
+from rich.panel import Panel
+from InquirerPy import inquirer
+from InquirerPy.validator import NumberValidator
+
+from nl2sql.cli.common.decorators import handle_cli_errors
+from nl2sql.cli.console import console, print_success, print_step
+from nl2sql.cli.config import ADAPTER_DRIVERS, KNOWN_ADAPTERS
+from nl2sql.cli.commands.install import install_package
+from nl2sql.cli.checks import check_package, verify_connectivity
+
+from nl2sql.common.logger import get_logger
+from nl2sql.configs import ConfigManager
+from nl2sql.configs import (
+    DatasourceConfig, 
+    DatasourceFileConfig,
+    ConnectionConfig, 
+    LLMFileConfig,
+    AgentConfig, 
+    PolicyFileConfig, 
+    RolePolicy
+)
+from nl2sql.cli.demo import DemoManager
+
+logger = get_logger(__name__)
+
+# The CLI writes where it is invoked. Do not resolve this from __file__:
+# that walks up out of the installed module and, in a source checkout,
+# lands on the repo root instead of the user's working directory.
+PROJECT_ROOT = pathlib.Path.cwd()
+
+CONFIG_DIR = PROJECT_ROOT / "configs"
+DATASOURCE_CONFIG = CONFIG_DIR / "datasources.yaml"
+LLM_CONFIG = CONFIG_DIR / "llm.yaml"
+POLICIES_CONFIG = CONFIG_DIR / "policies.json"
+
+
+from typing import Optional
+from nl2sql.configs import DatasourceConfig, ConnectionConfig
+
+def _configure_datasource(config_manager: ConfigManager):
+    """Interactively configures datasources."""
+    
+    if DATASOURCE_CONFIG.exists():
+        console.print(Panel("[bold]1. Datasource Configuration[/bold]", border_style="cyan"))
+        console.print("[dim]Existing configuration found.[/dim]")
+        return
+        
+    console.print(Panel("[bold]1. Datasource Configuration[/bold]", border_style="cyan"))
+    console.print("No datasource configuration found. Let's create one.")
+    
+    db_type = inquirer.select(
+        message="Select Database Type:",
+        choices=["postgres", "mysql", "mssql", "sqlite"],
+        default="postgres"
+    ).execute()
+    
+    ds_config = None
+    
+    if db_type == "sqlite":
+        db_path = inquirer.text(message="Database Path:", default="./my_database.db").execute()
+        conn = ConnectionConfig(type="sqlite", database=db_path)
+        ds_config = DatasourceConfig(
+            id="my_sqlite_db",
+            description="Main application database",
+            connection=conn
+        )
+    else:
+        host = inquirer.text(message="Host:", default="localhost").execute()
+        default_ports = {"postgres": "5432", "mysql": "3306", "mssql": "1433"}
+        port = inquirer.text(
+             message="Port:",
+             default=default_ports.get(db_type, "5432"),
+             validate=NumberValidator()
+        ).execute()
+
+        user = inquirer.text(
+            message="Username:",
+            default="postgres" if db_type == "postgres" else "root"
+        ).execute()
+
+        dbname = inquirer.text(message="Database Name:").execute()
+        
+        # Password & Secrets
+        password = inquirer.secret(message="Password:").execute()
+        final_password = password
+        
+        if inquirer.confirm(message="Secure this password with an Environment Variable?", default=True).execute():
+             env_var = inquirer.text(message="Environment Variable Name:", default="DB_PASSWORD").execute()
+             final_password = f"${{env:{env_var}}}"
+             console.print(f"[dim]Will save as: {escape(str(final_password))}[/dim]")
+             os.environ[env_var] = password # Set it for current session so validation passes
+        
+        conn_args = {
+            "type": db_type,
+            "host": host,
+            "port": int(port),
+            "user": user,
+            "password": final_password,
+            "database": dbname
+        }
+        
+        if db_type == "mssql":
+            conn_args["driver"] = "ODBC Driver 17 for SQL Server"
+            
+        conn = ConnectionConfig(**conn_args)
+        
+        ds_config = DatasourceConfig(
+            id="main_db", 
+            connection=conn,
+            options={}
+        )
+
+    # Write using Manager
+    # Write using Generator
+    ds_configs = [ds_config]
+    if ds_configs:
+        console.print(f"[green]Generated configuration for {len(ds_configs)} datasources.[/green]")
+        file_config = DatasourceFileConfig(datasources=ds_configs)
+        content = DatasourceGenerator.generate(file_config)
+        _write_config_file(DATASOURCE_CONFIG, content)
+
+
+from nl2sql.configs import LLMFileConfig, AgentConfig
+from nl2sql.cli.generators.llm import LLMGenerator
+
+
+def _configure_llm(config_manager: ConfigManager, api_key: Optional[str] = None):
+    """Interactively configures LLM."""
+    if LLM_CONFIG.exists():
+        console.print(Panel("[bold]2. LLM Configuration[/bold]", border_style="magenta"))
+        console.print("[dim]Existing configuration found.[/dim]")
+        return
+        
+    console.print(Panel("[bold]2. LLM Configuration[/bold]", border_style="magenta"))
+    
+    if api_key:
+         console.print("[green]API Key provided via CLI. Creating default OpenAI configuration.[/green]")
+         default_agent = AgentConfig(
+            provider="openai",
+            model="gpt-4o",
+            api_key="${env:OPENAI_API_KEY}"
+         )
+         llm_config = LLMFileConfig(default=default_agent)
+         content = LLMGenerator.generate(llm_config)
+         _write_config_file(LLM_CONFIG, content)
+         return
+
+    console.print("No LLM configuration found. Let's configure one.")
+    
+    # Only providers the engine can actually serve are offered here; anything
+    # else lets setup succeed and then fails on the first query.
+    provider = inquirer.select(
+        message="Select Provider:",
+        choices=["openai", "openrouter"],
+        default="openai"
+    ).execute()
+
+    default_agent = None
+
+    if provider == "openai":
+        api_key = inquirer.secret(message="OpenAI API Key:").execute()
+        default_agent = AgentConfig(
+            provider="openai",
+            model="gpt-4o",
+            api_key=api_key
+        )
+    elif provider == "openrouter":
+        console.print(
+            "[dim]OpenRouter is an OpenAI-compatible gateway: one key reaches "
+            "Anthropic, Google, Meta and hundreds of other models.[/dim]"
+        )
+        api_key = inquirer.secret(message="OpenRouter API Key:").execute()
+        model = inquirer.text(
+            message="OpenRouter model identifier (e.g. anthropic/claude-sonnet-4.5):",
+            default="anthropic/claude-sonnet-4.5"
+        ).execute()
+        env_var = "OPENROUTER_API_KEY"
+        os.environ[env_var] = api_key  # available to the rest of this session
+        default_agent = AgentConfig(
+            provider="openrouter",
+            model=model,
+            api_key=f"${{env:{env_var}}}"
+        )
+        console.print(f"[dim]Will save the key as: ${{env:{env_var}}}[/dim]")
+        console.print(
+            "[yellow]Note:[/yellow] embeddings still go through OpenAI, so "
+            "[cyan]nl2sql index[/cyan] needs OPENAI_API_KEY as well."
+        )
+
+    llm_config = LLMFileConfig(default=default_agent)
+    content = LLMGenerator.generate(llm_config)
+    _write_config_file(LLM_CONFIG, content)
+
+from nl2sql.configs import PolicyFileConfig, RolePolicy
+
+def _configure_policies(config_manager: ConfigManager):
+    """Generates default policies."""
+    if POLICIES_CONFIG.exists():
+        console.print(Panel("[bold]3. Policy Configuration[/bold]", border_style="yellow"))
+        console.print("[dim]Existing policies configuration found.[/dim]")
+        return
+
+    console.print(Panel("[bold]3. Policy Configuration[/bold]", border_style="yellow"))
+    console.print("Generating default RBAC policies...")
+    
+    admin_policy = RolePolicy(
+        description="System Administrator",
+        role="admin",
+        allowed_datasources=["*"],
+        allowed_tables=["*"]
+    )
+    
+    policy_config = PolicyFileConfig(roles={"admin": admin_policy})
+    
+    content = PolicyGenerator.generate(policy_config)
+    _write_config_file(POLICIES_CONFIG, content)
+
+
+
+from nl2sql.cli.generators.env import EnvFileGenerator
+from nl2sql.cli.generators.datasources import DatasourceGenerator
+from nl2sql.cli.generators.llm import LLMGenerator
+from nl2sql.cli.generators.policies import PolicyGenerator
+
+def _write_config_file(path: pathlib.Path, content: str):
+    """Helper to write generator output to file."""
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(content)
+        print_success(f"Created {path}")
+    except Exception as e:
+        console.print(f"[red]Failed to write {escape(str(path.name))}: {escape(str(e))}[/red]")
+
+
+def _configure_env_file(env: str, api_key: Optional[str] = None):
+    """Creates the .env.{env} file using the Universal Environment Protocol."""
+    target_file = PROJECT_ROOT / f".env.{env}"
+    
+    if target_file.exists():
+        console.print(Panel(f"[bold]Environment Configuration ({env})[/bold]", border_style="blue"))
+        console.print(f"[dim]Existing {target_file.name} found.[/dim]")
+        return
+    
+    console.print(Panel(f"[bold]Environment Configuration ({env})[/bold]", border_style="blue"))
+    console.print(f"Creating explicit configuration file: {target_file.name}")
+    
+    # Generate Content
+    secrets = {}
+    if api_key:
+        secrets["OPENAI_API_KEY"] = api_key
+        
+    content = EnvFileGenerator.generate(env, secrets=secrets)
+
+    try:
+        with open(target_file, "w", encoding="utf-8") as f:
+            f.write(content)
+        print_success(f"Created {target_file}")
+    except Exception as e:
+        console.print(f"[red]Failed to write env file: {escape(str(e))}[/red]")
+
+def _install_required_adapters(config_manager: ConfigManager):
+    """Reads config using ConfigManager and installs necessary adapters."""
+    if not DATASOURCE_CONFIG.exists():
+        return
+
+    try:
+        # Use ConfigManager to load standardized objects
+        # load_datasources returns List[Dict]
+        configs = config_manager.load_datasources()
+        
+        required = set()
+        for config in configs:
+            connection = config.get("connection", {})
+            engine = connection.get("type", "").lower() or config.get("type", "").lower()
+
+            for name, pkg in KNOWN_ADAPTERS.items():
+                if name in engine:
+                    required.add((name, pkg))
+                    break
+        
+        if required:
+            print_step("Checking Adapters...")
+            for name, pkg in sorted(required):
+                # The adapter ships with nl2sql; the extra supplies the driver.
+                if not check_package(ADAPTER_DRIVERS[name]):
+                    if inquirer.confirm(message=f"Required adapter {pkg} is missing. Install now?", default=True).execute():
+                        console.print(f"[yellow]Installing {escape(pkg)}...[/yellow]")
+                        install_package(pkg)
+                else:
+                    console.print(f"[dim]Adapter {escape(pkg)} is installed.[/dim]")
+                    
+    except Exception as e:
+        console.print(f"[red]Failed to check adapters: {escape(str(e))}[/red]")
+
+
+def _run_indexing_step():
+    """Offers schema indexing and runs it through a context built from config paths."""
+    from nl2sql.common.settings import settings
+    from nl2sql.context import NL2SQLContext
+    from nl2sql.indexing.vector_store import VectorStore
+    from nl2sql.cli.commands.indexing import run_indexing
+
+    try:
+        v_store = VectorStore(
+            collection_name=settings.vector_store_collection_name,
+            persist_directory=str(PROJECT_ROOT / settings.vector_store_path),
+        )
+        should_index = False
+
+        if not v_store.is_empty():
+            console.print("[yellow]Vector Store already contains data.[/yellow]")
+            if inquirer.confirm(message="Do you want to clear and re-index?", default=False).execute():
+                should_index = True
+        else:
+            if inquirer.confirm(message="Vector Store is empty. Run Schema Indexing now?", default=True).execute():
+                should_index = True
+
+        if not should_index:
+            return
+
+        print_step("Starting Indexer...")
+
+        # NL2SQLContext builds the datasource, LLM and vector store registries
+        # itself; it takes config *paths*, not pre-built registries.
+        ctx = NL2SQLContext(
+            ds_config_path=PROJECT_ROOT / settings.datasource_config_path,
+            secrets_config_path=PROJECT_ROOT / settings.secrets_config_path,
+            llm_config_path=PROJECT_ROOT / settings.llm_config_path,
+            vector_store_path=PROJECT_ROOT / settings.vector_store_path,
+            policies_config_path=PROJECT_ROOT / settings.policies_config_path,
+        )
+
+        run_indexing(ctx)
+        print_success("Indexing process finished.")
+
+    except Exception as e:
+        logger.debug("Indexing setup failed", exc_info=True)
+        console.print(f"[red]Indexing setup failed: {escape(str(e))}[/red]")
+
+
+@handle_cli_errors
+def setup_command(demo: bool = False, lite: bool = True, docker: bool = False, api_key: Optional[str] = None):
+    
+    # Instantiate Managers
+    config_manager = ConfigManager(PROJECT_ROOT)
+    demo_manager = DemoManager(console, PROJECT_ROOT)
+
+    if demo:
+        console.print(Panel("[bold green]Setting up Demo Environment...[/bold green]", border_style="green"))
+        
+        if lite:
+            demo_manager.setup_lite(api_key=api_key)
+        elif docker:
+            docker_dir = demo_manager.setup_docker(api_key=api_key)
+            if inquirer.confirm(message="Start Docker containers now?", default=True).execute():
+                demo_manager.start_docker_containers(docker_dir)
+                
+            console.print(Panel(f"""[bold yellow]Next Steps:[/bold yellow]
+                    1. [bold]Verify & Index[/bold]:
+                    Once database containers are healthy (~30s), run:
+                    [cyan]nl2sql --env demo index[/cyan]
+
+                    2. [bold]API[/bold]: the 'app' container serves the REST API on
+                    [cyan]http://localhost:8000[/cyan].
+
+                    3. [bold]MSSQL[/bold] is opt-in:
+                    [cyan]docker compose -f docker-compose.demo.yml --profile mssql up -d[/cyan]
+                    """, title="Docker Instructions", border_style="yellow")
+                )
+        
+        if not docker:
+            print_step("Indexing Demo Environment...")
+            demo_manager.index_demo_data()
+            console.print("Run: [cyan]nl2sql --env demo run \"Show me broken machines in Austin\"[/cyan]")
+            
+        return
+
+    # --- Standard Setup Wizard ---
+    console.print("[bold cyan]NL2SQL Setup Wizard[/bold cyan]\n")
+    
+    config_manager.ensure_config_dirs()
+    
+    # 1. Environment File
+    _configure_env_file("dev", api_key=api_key)
+    
+    # 2. Datasource
+    _configure_datasource(config_manager)
+    
+    # 2. LLM
+    _configure_llm(config_manager, api_key=api_key)
+
+    # 3. Policies
+    _configure_policies(config_manager)
+    
+    # 4. Adapters
+    _install_required_adapters(config_manager)
+
+    # 5. Connectivity Check
+    print_step("Checking Database Connectivity...")
+    if not verify_connectivity(print_table=True):
+        console.print("[yellow]Warning: Some datasources are failing validation.[/yellow]")
+        if not inquirer.confirm(message="Continue anyway?", default=False).execute():
+            return
+
+    # 6. Indexing Prompt
+    console.print("")
+    _run_indexing_step()
+
+    console.print("\n[bold green]Setup Complete![/bold green]")
+    console.print("Try running a query: [cyan]nl2sql run \"Show me all tables\"[/cyan]")

nl2sql/cli/commands/visualize.py

@@ -0,0 +1,34 @@
+from typing import List, Dict, Any
+from langgraph.graph.state import CompiledStateGraph
+from nl2sql.cli.reporting import ConsolePresenter
+
+from nl2sql.cli.common.decorators import handle_cli_errors
+
+@handle_cli_errors
+def draw_execution_trace(
+    trace: List[Dict[str, Any]], 
+    graph: CompiledStateGraph, 
+    execution_subgraph: CompiledStateGraph, 
+    agentic_execution_loop: CompiledStateGraph
+):
+    """Visualizes the execution trace in the CLI and saves the graph structure.
+
+    Args:
+        trace (List[Dict[str, Any]]): The execution trace.
+        graph (CompiledStateGraph): The main graph.
+        execution_subgraph (CompiledStateGraph): The execution subgraph.
+        agentic_execution_loop (CompiledStateGraph): The agentic loop subgraph.
+    """
+    presenter = ConsolePresenter()
+
+    try:
+        png_bytes = graph.get_graph(xray=True).draw_mermaid_png()
+        import os
+        output_path = "graph_trace.png"
+        abs_path = os.path.abspath(output_path)
+        with open(output_path, "wb") as f:
+            f.write(png_bytes)
+
+        presenter.print_graph_saved(abs_path)
+    except Exception as e:
+        presenter.print_graph_save_error(str(e))

nl2sql/cli/common/decorators.py

@@ -0,0 +1,34 @@
+from functools import wraps
+import sys
+import traceback
+from rich.console import Console
+from rich.markup import escape
+from nl2sql.common.exceptions import NL2SQLError
+
+console = Console()
+
+def handle_cli_errors(func):
+    """
+    Decorator to wrap CLI commands with unified error handling.
+    
+    - NL2SQLError: Prints a clean red error message.
+    - KeyboardInterrupt: Exits gracefully.
+    - Unexpected Exception: Prints stack trace and error.
+    """
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except NL2SQLError as e:
+            console.print(f"[bold red]Error:[/bold red] {escape(str(e))}")
+            sys.exit(1)
+        except KeyboardInterrupt:
+            console.print("\n[yellow]Operation cancelled by user.[/yellow]")
+            sys.exit(130)  # Standard SIGINT exit code
+        except Exception as e:
+            console.print(f"[bold red]Unexpected Error:[/bold red] {escape(str(e))}")
+            console.print(traceback.format_exc(), markup=False)
+            console.print("[dim]Please report this bug to the nl2sql team.[/dim]")
+            sys.exit(1)
+            
+    return wrapper

nl2sql/cli/config.py

@@ -0,0 +1,24 @@
+
+CORE_PACKAGE = "nl2sql"
+CORE_MODULE = "nl2sql.cli"
+
+# Every dialect adapter now ships inside the single `nl2sql-engine`
+# distribution, so the adapter module is always importable. What is optional
+# is the DB driver each one needs to actually connect, carried by an extra.
+KNOWN_ADAPTERS = {
+    "sqlite": "nl2sql-engine",
+    "duckdb": "nl2sql-engine[duckdb]",
+    "postgresql": "nl2sql-engine[postgres]",
+    "mysql": "nl2sql-engine[mysql]",
+    "mssql": "nl2sql-engine[mssql]",
+}
+
+# The driver module that must import for the adapter above to be usable.
+# sqlite needs none beyond the standard library.
+ADAPTER_DRIVERS = {
+    "sqlite": "sqlite3",
+    "duckdb": "duckdb_engine",
+    "postgresql": "psycopg2",
+    "mysql": "pymysql",
+    "mssql": "pyodbc",
+}

nl2sql/cli/console.py

@@ -0,0 +1,52 @@
+import sys
+
+from rich.console import Console
+from rich.markup import escape
+from rich.theme import Theme
+
+
+def configure_output_encoding() -> None:
+    """Make CLI output safe on a console whose code page is not UTF-8.
+
+    Rich renders symbols such as U+2713 that the default Windows code page
+    (cp1252) cannot encode, so writing them raised UnicodeEncodeError and
+    aborted the command -- `nl2sql setup --demo --lite` died this way.
+    Reconfiguring the streams once, at the entry point, is what
+    PYTHONIOENCODING=utf-8 did for users who knew to set it; rich reads
+    ``sys.stdout`` and its encoding lazily, so consoles built at import time
+    pick this up too.
+
+    ``errors="replace"`` is the backstop: if a stream cannot become UTF-8, an
+    unencodable symbol degrades to a placeholder instead of killing the
+    process. Streams that are not text wrappers -- pytest capture, some
+    redirections -- have no ``reconfigure`` and are left alone.
+    """
+    for stream in (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, "reconfigure", None)
+        if reconfigure is None:
+            continue
+        try:
+            reconfigure(encoding="utf-8", errors="replace")
+        except (OSError, ValueError):
+            # A detached or already-closed stream. Nothing to configure.
+            pass
+
+
+custom_theme = Theme({
+    "info": "cyan",
+    "warning": "yellow",
+    "error": "bold red",
+    "success": "bold green",
+    "command": "bold white on blue",
+})
+
+console = Console(theme=custom_theme)
+
+def print_step(message: str) -> None:
+    console.print(f"[bold blue]Step:[/bold blue] {escape(str(message))}")
+
+def print_success(message: str) -> None:
+    console.print(f"[success][OK] {escape(str(message))}[/success]")
+
+def print_error(message: str) -> None:
+    console.print(f"[error][ERROR] {escape(str(message))}[/error]")

nl2sql/cli/demo/__init__.py

@@ -0,0 +1 @@
+from .manager import DemoManager

nl2sql/cli/demo/data.py

@@ -0,0 +1,87 @@
+from typing import List, Dict, Any
+
+# Shared Constants (The "Glue")
+
+FACTORIES: List[Dict[str, Any]] = [
+    {"id": 1, "name": "Austin Gigafactory", "region": "US", "capacity": 5000},
+    {"id": 2, "name": "Berlin Plant", "region": "EU", "capacity": 3500},
+    {"id": 3, "name": "Shanghai Facility", "region": "CN", "capacity": 8000},
+    {"id": 4, "name": "Tokyo Hub", "region": "JP", "capacity": 4200},
+    {"id": 5, "name": "Mumbai Plant", "region": "IN", "capacity": 3000},
+]
+
+SHIFTS: List[Dict[str, Any]] = [
+    {"id": 1, "name": "Morning", "start_time": "06:00", "end_time": "14:00"},
+    {"id": 2, "name": "Evening", "start_time": "14:00", "end_time": "22:00"},
+    {"id": 3, "name": "Night", "start_time": "22:00", "end_time": "06:00"},
+]
+
+MACHINE_TYPES: List[Dict[str, Any]] = [
+    {"id": 1, "model": "Robotic Arm v1", "producer": "TechCorp", "maintenance_interval_days": 30},
+    {"id": 2, "model": "Conveyor Belt Gen3", "producer": "MoveIt", "maintenance_interval_days": 180},
+    {"id": 3, "model": "Stamping Press 500T", "producer": "HeavyMetal", "maintenance_interval_days": 90},
+    {"id": 4, "model": "Painting Station", "producer": "ColorsInc", "maintenance_interval_days": 14},
+    {"id": 5, "model": "Quality Scanner", "producer": "VisionAI", "maintenance_interval_days": 60},
+    {"id": 6, "model": "Laser Cutter L2", "producer": "PhotonWorks", "maintenance_interval_days": 45},
+    {"id": 7, "model": "CNC Mill Pro", "producer": "Machina", "maintenance_interval_days": 120},
+]
+
+PRODUCTS: List[Dict[str, Any]] = [
+    # High Value
+    {"id": 1, "sku": "IC-5000", "name": "Industrial Controller", "base_cost": 4500.00, "category": "Electronics"},
+    {"id": 2, "sku": "BAT-EV-X", "name": "EV Battery Pack Long Range", "base_cost": 8000.00, "category": "Components"},
+    {"id": 3, "sku": "MOT-HI-T", "name": "High Torque Motor", "base_cost": 1200.00, "category": "Components"},
+    # High Volume
+    {"id": 4, "sku": "BOLT-M5", "name": "Bolt M5 Stainless", "base_cost": 0.50, "category": "Hardware"},
+    {"id": 5, "sku": "WASH-M5", "name": "Washer M5", "base_cost": 0.10, "category": "Hardware"},
+    {"id": 6, "sku": "CAB-USB-C", "name": "USB-C Data Cable", "base_cost": 2.50, "category": "Electronics"},
+    {"id": 7, "sku": "BRK-SET", "name": "Brake Assembly Set", "base_cost": 350.00, "category": "Components"},
+    {"id": 8, "sku": "SNS-TEMP", "name": "Temperature Sensor Pack", "base_cost": 85.00, "category": "Electronics"},
+    {"id": 9, "sku": "PNL-AL", "name": "Aluminum Panel Sheet", "base_cost": 40.00, "category": "Materials"},
+]
+
+SUPPLIERS: List[Dict[str, Any]] = [
+    {"id": 1, "name": "Global Tech Components", "country": "Taiwan"},
+    {"id": 2, "name": "SteelCorp International", "country": "Germany"},
+    {"id": 3, "name": "ChemSafe Solutions", "country": "USA"},
+    {"id": 4, "name": "Nippon Metals", "country": "Japan"},
+    {"id": 5, "name": "Indus Industrial", "country": "India"},
+]
+
+DEPARTMENTS: List[Dict[str, Any]] = [
+    {"id": 1, "name": "Assembly"},
+    {"id": 2, "name": "Quality Assurance"},
+    {"id": 3, "name": "Logistics"},
+    {"id": 4, "name": "Maintenance"},
+    {"id": 5, "name": "Engineering"},
+]
+
+CUSTOMER_SEGMENTS: List[Dict[str, Any]] = [
+    {"id": 1, "name": "Enterprise"},
+    {"id": 2, "name": "SMB"},
+    {"id": 3, "name": "Retail"},
+]
+
+EMPLOYEE_ROLES: List[Dict[str, Any]] = [
+    {"id": 1, "title": "Operator", "department_id": 1},
+    {"id": 2, "title": "Line Supervisor", "department_id": 1},
+    {"id": 3, "title": "QA Analyst", "department_id": 2},
+    {"id": 4, "title": "Logistics Coordinator", "department_id": 3},
+    {"id": 5, "title": "Maintenance Technician", "department_id": 4},
+    {"id": 6, "title": "Process Engineer", "department_id": 5},
+]
+
+SUPPLIER_PRODUCTS: List[Dict[str, Any]] = [
+    {"supplier_id": 1, "product_id": 1},
+    {"supplier_id": 1, "product_id": 2},
+    {"supplier_id": 1, "product_id": 8},
+    {"supplier_id": 2, "product_id": 4},
+    {"supplier_id": 2, "product_id": 5},
+    {"supplier_id": 2, "product_id": 9},
+    {"supplier_id": 3, "product_id": 6},
+    {"supplier_id": 3, "product_id": 7},
+    {"supplier_id": 4, "product_id": 3},
+    {"supplier_id": 4, "product_id": 9},
+    {"supplier_id": 5, "product_id": 7},
+    {"supplier_id": 5, "product_id": 4},
+]