nl2sql-engine 0.1.0__py3-none-any.whl

nl2sql/cli/demo/schemas.py

@@ -0,0 +1,336 @@
+
+# Templates for Demo Environment Generation
+
+REF_SQL_POSTGRES = """
+CREATE TABLE factories (
+    id SERIAL PRIMARY KEY,
+    name TEXT,
+    region TEXT,
+    capacity INTEGER
+);
+CREATE TABLE machine_types (
+    id SERIAL PRIMARY KEY,
+    model TEXT,
+    producer TEXT,
+    maintenance_interval_days INTEGER
+);
+CREATE TABLE shifts (
+    id SERIAL PRIMARY KEY,
+    name TEXT,
+    start_time TEXT,
+    end_time TEXT
+);
+CREATE TABLE departments (
+    id SERIAL PRIMARY KEY,
+    name TEXT
+);
+CREATE TABLE employee_roles (
+    id SERIAL PRIMARY KEY,
+    title TEXT,
+    department_id INTEGER
+);
+CREATE TABLE customer_segments (
+    id SERIAL PRIMARY KEY,
+    name TEXT
+);
+"""
+
+REF_SQL_SQLITE = """
+CREATE TABLE factories (
+    id INTEGER PRIMARY KEY,
+    name TEXT,
+    region TEXT,
+    capacity INTEGER
+);
+CREATE TABLE machine_types (
+    id INTEGER PRIMARY KEY,
+    model TEXT,
+    producer TEXT,
+    maintenance_interval_days INTEGER
+);
+CREATE TABLE shifts (
+    id INTEGER PRIMARY KEY,
+    name TEXT,
+    start_time TEXT,
+    end_time TEXT
+);
+CREATE TABLE departments (
+    id INTEGER PRIMARY KEY,
+    name TEXT
+);
+CREATE TABLE employee_roles (
+    id INTEGER PRIMARY KEY,
+    title TEXT,
+    department_id INTEGER
+);
+CREATE TABLE customer_segments (
+    id INTEGER PRIMARY KEY,
+    name TEXT
+);
+"""
+
+OPS_SQL_POSTGRES = """
+CREATE TABLE employees (
+    id SERIAL PRIMARY KEY,
+    name TEXT,
+    factory_id INTEGER,
+    shift_id INTEGER,
+    hire_date DATE,
+    role_id INTEGER,
+    department_id INTEGER,
+    status TEXT
+);
+CREATE TABLE machines (
+    id SERIAL PRIMARY KEY,
+    factory_id INTEGER,
+    type_id INTEGER,
+    status TEXT DEFAULT 'Active',
+    installation_date DATE,
+    last_maintenance_date DATE
+);
+CREATE TABLE maintenance_logs (
+    id SERIAL PRIMARY KEY,
+    machine_id INTEGER,
+    date DATE,
+    description TEXT,
+    technician_id INTEGER,
+    severity TEXT,
+    downtime_hours INTEGER
+);
+"""
+
+OPS_SQL_SQLITE = """
+CREATE TABLE employees (
+    id INTEGER PRIMARY KEY,
+    name TEXT,
+    factory_id INTEGER,
+    shift_id INTEGER,
+    hire_date DATE,
+    role_id INTEGER,
+    department_id INTEGER,
+    status TEXT
+);
+CREATE TABLE machines (
+    id INTEGER PRIMARY KEY,
+    factory_id INTEGER,
+    type_id INTEGER,
+    status TEXT,
+    installation_date DATE,
+    last_maintenance_date DATE
+);
+CREATE TABLE maintenance_logs (
+    id INTEGER PRIMARY KEY,
+    machine_id INTEGER,
+    date DATE,
+    description TEXT,
+    technician_id INTEGER,
+    severity TEXT,
+    downtime_hours INTEGER
+);
+"""
+
+SUPPLY_SQL_MYSQL = """
+CREATE TABLE products (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    sku VARCHAR(255),
+    name TEXT,
+    base_cost DECIMAL(10,2),
+    category VARCHAR(100)
+);
+CREATE TABLE suppliers (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    name TEXT,
+    country VARCHAR(100)
+);
+CREATE TABLE inventory (
+    product_id INT,
+    factory_id INT,
+    quantity INT,
+    last_updated DATE,
+    PRIMARY KEY (product_id, factory_id)
+);
+CREATE TABLE supplier_products (
+    supplier_id INT,
+    product_id INT,
+    PRIMARY KEY (supplier_id, product_id)
+);
+"""
+
+SUPPLY_SQL_SQLITE = """
+CREATE TABLE products (
+    id INTEGER PRIMARY KEY,
+    sku TEXT,
+    name TEXT,
+    base_cost REAL,
+    category TEXT
+);
+CREATE TABLE suppliers (
+    id INTEGER PRIMARY KEY,
+    name TEXT,
+    country TEXT
+);
+CREATE TABLE inventory (
+    product_id INTEGER,
+    factory_id INTEGER,
+    quantity INTEGER,
+    last_updated DATE,
+    PRIMARY KEY (product_id, factory_id)
+);
+CREATE TABLE supplier_products (
+    supplier_id INTEGER,
+    product_id INTEGER,
+    PRIMARY KEY (supplier_id, product_id)
+);
+"""
+
+HISTORY_SQL_MSSQL = """
+CREATE TABLE sales_orders (
+    id INT IDENTITY(1,1) PRIMARY KEY,
+    customer_name NVARCHAR(255),
+    order_date DATE,
+    total_amount DECIMAL(12,2),
+    status NVARCHAR(50),
+    customer_segment_id INT,
+    factory_id INT
+);
+CREATE TABLE sales_items (
+    id INT IDENTITY(1,1) PRIMARY KEY,
+    order_id INT,
+    product_id INT,
+    quantity INT,
+    unit_price DECIMAL(10,2),
+    discount_pct DECIMAL(5,2)
+);
+CREATE TABLE production_runs (
+    id INT IDENTITY(1,1) PRIMARY KEY,
+    factory_id INT,
+    date DATE,
+    output_quantity INT,
+    shift_id INT,
+    status NVARCHAR(50)
+);
+"""
+
+HISTORY_SQL_SQLITE = """
+CREATE TABLE sales_orders (
+    id INTEGER PRIMARY KEY,
+    customer_name TEXT,
+    order_date DATE,
+    total_amount REAL,
+    status TEXT,
+    customer_segment_id INTEGER,
+    factory_id INTEGER
+);
+CREATE TABLE sales_items (
+    id INTEGER PRIMARY KEY,
+    order_id INTEGER,
+    product_id INTEGER,
+    quantity INTEGER,
+    unit_price REAL,
+    discount_pct REAL
+);
+CREATE TABLE production_runs (
+    id INTEGER PRIMARY KEY,
+    factory_id INTEGER,
+    date DATE,
+    output_quantity INTEGER,
+    shift_id INTEGER,
+    status TEXT
+);
+"""
+
+DOCKER_COMPOSE_TEMPLATE = """version: '3.8'
+
+services:
+  manufacturing_ref:
+    image: postgres:15
+    container_name: manufacturing_ref
+    ports:
+      - "5433:5432"
+    environment:
+      POSTGRES_USER: ${DEMO_POSTGRES_USER}
+      POSTGRES_PASSWORD: ${DEMO_POSTGRES_PASSWORD}
+      POSTGRES_DB: manufacturing_ref
+      # Env vars for Init Scripts
+      DEMO_REF_USER: ${DEMO_REF_USER}
+      DEMO_REF_PASSWORD: ${DEMO_REF_PASSWORD}
+    volumes:
+      - ./init_ref.sql:/docker-entrypoint-initdb.d/init.sql
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${DEMO_POSTGRES_USER}"]
+      interval: 5s
+      retries: 5
+
+  manufacturing_ops:
+    image: postgres:15
+    container_name: manufacturing_ops
+    ports:
+      - "5434:5432"
+    environment:
+      POSTGRES_USER: ${DEMO_POSTGRES_USER}
+      POSTGRES_PASSWORD: ${DEMO_POSTGRES_PASSWORD}
+      POSTGRES_DB: manufacturing_ops
+      # Env vars for Init Scripts
+      DEMO_OPS_USER: ${DEMO_OPS_USER}
+      DEMO_OPS_PASSWORD: ${DEMO_OPS_PASSWORD}
+    volumes:
+      - ./init_ops.sql:/docker-entrypoint-initdb.d/init.sql
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${DEMO_POSTGRES_USER}"]
+      interval: 5s
+      retries: 5
+
+  manufacturing_supply:
+    image: mysql:8
+    container_name: manufacturing_supply
+    ports:
+      - "3307:3306"
+    environment:
+      MYSQL_ROOT_PASSWORD: ${DEMO_MYSQL_ROOT_PASSWORD}
+      MYSQL_USER: ${DEMO_SUPPLY_USER}
+      MYSQL_PASSWORD: ${DEMO_SUPPLY_PASSWORD}
+      MYSQL_DATABASE: manufacturing_supply
+    volumes:
+      - ./init_supply.sql:/docker-entrypoint-initdb.d/init.sql
+    healthcheck:
+      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
+      interval: 5s
+      retries: 5
+
+  # Opt-in: `docker compose --profile mssql up`. The image is a ~1.6 GB pull, so
+  # the default stack leaves it out. Nothing outside this profile depends on it.
+  manufacturing_history:
+    image: mcr.microsoft.com/mssql/server:2022-latest
+    container_name: manufacturing_history
+    profiles: ["mssql"]
+    ports:
+      - "1434:1433"
+    environment:
+      ACCEPT_EULA: "Y"
+      MSSQL_SA_PASSWORD: "${DEMO_MSSQL_SA_PASSWORD}"
+      MSSQL_PID: "Express"
+    user: root # Needed to run the init script wrapper if we mount it
+    command: /bin/bash -c "/opt/mssql/bin/sqlservr & sleep 20 && /opt/mssql-tools/bin/sqlcmd -S localhost -U sa -P '${DEMO_MSSQL_SA_PASSWORD}' -i /init.sql -v HISTORY_USER='${DEMO_HISTORY_USER}' HISTORY_PASS='${DEMO_HISTORY_PASSWORD}' && wait"
+    volumes:
+      - ./init_history.sql:/init.sql
+
+  app:
+    build:
+      context: ..
+      dockerfile: packages/api/Dockerfile
+    container_name: nl2sql_app
+    ports:
+      - "8000:8000"
+    env_file:
+      - ../.env.demo
+    volumes:
+      - ../configs:/app/configs
+      - ../data:/app/data
+    depends_on:
+      manufacturing_ref:
+        condition: service_healthy
+      manufacturing_ops:
+        condition: service_healthy
+      manufacturing_supply:
+        condition: service_healthy
+"""

nl2sql/cli/demo/writers/docker.py

@@ -0,0 +1,182 @@
+
+import pathlib
+from typing import List, Dict, Any
+from ..schemas import (
+    REF_SQL_POSTGRES,
+    OPS_SQL_POSTGRES,
+    SUPPLY_SQL_MYSQL,
+    HISTORY_SQL_MSSQL,
+    DOCKER_COMPOSE_TEMPLATE
+)
+
+class DockerWriter:
+    """Writes Demo Artifacts (SQL, .env, docker-compose) for Docker environment."""
+
+    @staticmethod
+    def write_docker(output_dir: pathlib.Path,
+                     secrets: Dict[str, str],
+                     ref_data: tuple,
+                     ops_data: tuple,
+                     supply_data: tuple,
+                     history_data: tuple):
+        """Main entry point."""
+        output_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Unpack
+        factories, mtypes, shifts, departments, roles, segments = ref_data
+        employees, machines, logs = ops_data
+        products, suppliers, inventory, supplier_products = supply_data
+        orders, items, runs = history_data
+        
+        # 1. SQL Scripts
+        DockerWriter._write_sql(output_dir / "init_ref.sql", REF_SQL_POSTGRES, secrets["DEMO_REF_PASSWORD"], "ref_admin", "manufacturing_ref", {
+            "factories": factories,
+            "machine_types": mtypes,
+            "shifts": shifts,
+            "departments": departments,
+            "employee_roles": roles,
+            "customer_segments": segments
+        })
+        
+        DockerWriter._write_sql(output_dir / "init_ops.sql", OPS_SQL_POSTGRES, secrets["DEMO_OPS_PASSWORD"], "ops_admin", "manufacturing_ops", {
+            "employees": employees, "machines": machines, "maintenance_logs": logs
+        })
+        
+        DockerWriter._write_mysql(output_dir / "init_supply.sql", SUPPLY_SQL_MYSQL, {
+            "products": products, "suppliers": suppliers, "inventory": inventory, "supplier_products": supplier_products
+        })
+        
+        DockerWriter._write_mssql(output_dir / "init_history.sql", HISTORY_SQL_MSSQL, secrets, {
+            "sales_orders": orders, "sales_items": items, "production_runs": runs
+        })
+        
+        # 2. .env
+        DockerWriter._write_env(output_dir / ".env", secrets)
+        
+        # 3. docker-compose
+        (output_dir / "docker-compose.demo.yml").write_text(DOCKER_COMPOSE_TEMPLATE, encoding="utf-8")
+
+    @staticmethod
+    def _to_insert(table: str, rows: List[Dict]) -> str:
+        if not rows:
+            return ""
+        
+        columns = ", ".join(rows[0].keys())
+        values_list = []
+        for r in rows:
+            vals = []
+            for v in r.values():
+                if isinstance(v, str):
+                    clean = v.replace("'", "''") # Basic HTML escape for SQL
+                    vals.append(f"'{clean}'")
+                else:
+                    vals.append(str(v))
+            values_list.append(f"({', '.join(vals)})")
+            
+        # Bulk Insert
+        # Postgres supports multi-value INSERT
+        return f"INSERT INTO {table} ({columns}) VALUES\n" + ",\n".join(values_list) + ";"
+
+    @staticmethod
+    def _write_sql(path: pathlib.Path, schema: str, password: str, user: str, db: str, data: Dict[str, List[Dict]]):
+        inserts = []
+        for tbl, rows in data.items():
+            inserts.append(DockerWriter._to_insert(tbl, rows))
+            
+        inserts_str = "\n\n".join(inserts)
+        
+        script = f"""
+-- Create User and Database
+CREATE USER {user} WITH PASSWORD '{password}';
+CREATE DATABASE {db} OWNER {user};
+
+-- Connect and Populate
+\\c {db};
+
+{schema}
+
+{inserts_str}
+
+-- Grant Ownership
+GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO {user};
+"""
+        path.write_text(script, encoding="utf-8")
+
+    @staticmethod
+    def _write_mysql(path: pathlib.Path, schema: str, data: Dict[str, List[Dict]]):
+        inserts = []
+        for tbl, rows in data.items():
+            inserts.append(DockerWriter._to_insert(tbl, rows))
+            
+        inserts_str = "\n\n".join(inserts)
+            
+        script = f"""
+CREATE DATABASE IF NOT EXISTS manufacturing_supply;
+USE manufacturing_supply;
+
+{schema}
+
+{inserts_str}
+"""
+        path.write_text(script, encoding="utf-8")
+
+    @staticmethod
+    def _write_mssql(path: pathlib.Path, schema: str, secrets: Dict[str, str], data: Dict[str, List[Dict]]):
+        inserts = []
+        for tbl, rows in data.items():
+            inserts.append(DockerWriter._to_insert(tbl, rows))
+        
+        inserts_str = "\nGO\n".join(inserts)
+            
+        script = f"""
+IF NOT EXISTS(SELECT * FROM sys.databases WHERE name = 'manufacturing_history')
+BEGIN
+    CREATE DATABASE manufacturing_history
+END
+GO
+USE manufacturing_history;
+GO
+
+-- Create User (Passed via sqlcmd -v vars)
+CREATE LOGIN [$(HISTORY_USER)] WITH PASSWORD = '$(HISTORY_PASS)';
+CREATE USER [$(HISTORY_USER)] FOR LOGIN [$(HISTORY_USER)];
+ALTER ROLE [db_owner] ADD MEMBER [$(HISTORY_USER)];
+GO
+
+{schema}
+GO
+
+{inserts_str}
+GO
+"""
+        path.write_text(script, encoding="utf-8")
+
+    @staticmethod
+    def _write_env(path: pathlib.Path, secrets: Dict[str, str]):
+        # Matches the template we removed
+        content = f"""# NL2SQL Demo Environment Secrets
+# Generated automatically. DO NOT COMMIT TO VERSION CONTROL.
+
+# 1. Manufacturing Ref (Postgres)
+DEMO_REF_USER=ref_admin
+DEMO_REF_PASSWORD={secrets["DEMO_REF_PASSWORD"]}
+
+# 2. Manufacturing Ops (Postgres)
+DEMO_OPS_USER=ops_admin
+DEMO_OPS_PASSWORD={secrets["DEMO_OPS_PASSWORD"]}
+
+# Postgres Superuser (Container Root)
+DEMO_POSTGRES_USER=postgres
+DEMO_POSTGRES_PASSWORD={secrets["DEMO_POSTGRES_PASSWORD"]}
+
+# 3. Manufacturing Supply (MySQL)
+DEMO_SUPPLY_USER=supply_admin
+DEMO_SUPPLY_PASSWORD={secrets["DEMO_SUPPLY_PASSWORD"]}
+DEMO_MYSQL_ROOT_PASSWORD={secrets["DEMO_MYSQL_ROOT_PASSWORD"]}
+
+# 4. Manufacturing History (MSSQL)
+DEMO_HISTORY_USER=history_admin
+DEMO_HISTORY_PASSWORD={secrets["DEMO_HISTORY_PASSWORD"]}
+DEMO_MSSQL_SA_PASSWORD={secrets["DEMO_MSSQL_SA_PASSWORD"]}
+"""
+        path.write_text(content, encoding="utf-8")

nl2sql/cli/demo/writers/sqlite.py

@@ -0,0 +1,88 @@
+
+import sqlite3
+import pathlib
+from typing import List, Dict
+from ..schemas import (
+    REF_SQL_SQLITE,
+    OPS_SQL_SQLITE,
+    SUPPLY_SQL_SQLITE,
+    HISTORY_SQL_SQLITE
+)
+
+class SQLiteWriter:
+    """Writes Demo Data to SQLite databases."""
+
+    @staticmethod
+    def write_lite(output_dir: pathlib.Path, 
+                   ref_data: tuple, 
+                   ops_data: tuple, 
+                   supply_data: tuple, 
+                   history_data: tuple):
+        """Main entry point to write all 4 databases."""
+        output_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Unpack Data
+        factories, mtypes, shifts, departments, roles, segments = ref_data
+        employees, machines, logs = ops_data
+        products, suppliers, inventory, supplier_products = supply_data
+        orders, items, runs = history_data
+        
+        # 1. Ref
+        SQLiteWriter._create_db(output_dir / "manufacturing_ref.db", REF_SQL_SQLITE, {
+            "factories": factories,
+            "machine_types": mtypes,
+            "shifts": shifts,
+            "departments": departments,
+            "employee_roles": roles,
+            "customer_segments": segments
+        })
+        
+        # 2. Ops
+        SQLiteWriter._create_db(output_dir / "manufacturing_ops.db", OPS_SQL_SQLITE, {
+            "employees": employees,
+            "machines": machines,
+            "maintenance_logs": logs
+        })
+        
+        # 3. Supply
+        SQLiteWriter._create_db(output_dir / "manufacturing_supply.db", SUPPLY_SQL_SQLITE, {
+            "products": products,
+            "suppliers": suppliers,
+            "inventory": inventory,
+            "supplier_products": supplier_products
+        })
+        
+        # 4. History
+        SQLiteWriter._create_db(output_dir / "manufacturing_history.db", HISTORY_SQL_SQLITE, {
+            "sales_orders": orders,
+            "sales_items": items,
+            "production_runs": runs
+        })
+        
+    @staticmethod
+    def _create_db(path: pathlib.Path, schema_sql: str, data_map: Dict[str, List[Dict]]):
+        """Creates a DB, runs schema, and inserts data."""
+        if path.exists():
+            path.unlink()
+            
+        conn = sqlite3.connect(str(path))
+        cursor = conn.cursor()
+        
+        # 1. Schema
+        cursor.executescript(schema_sql)
+        
+        # 2. Data
+        for table_name, rows in data_map.items():
+            if not rows:
+                continue
+                
+            # Assume all rows have same keys
+            keys = list(rows[0].keys())
+            cols = ", ".join(keys)
+            placeholders = ", ".join(f":{k}" for k in keys)
+            sql = f"INSERT INTO {table_name} ({cols}) VALUES ({placeholders})"
+            
+            cursor.executemany(sql, rows)
+            
+        conn.commit()
+        conn.close()

nl2sql/cli/generators/datasources/__init__.py

@@ -0,0 +1,3 @@
+from .generator import DatasourceGenerator
+
+__all__ = ["DatasourceGenerator"]

nl2sql/cli/generators/datasources/generator.py

@@ -0,0 +1,24 @@
+import yaml
+from nl2sql.configs import DatasourceFileConfig
+
+class DatasourceGenerator:
+    """Generates the content for datasources.yaml."""
+
+    HEADER = "# NL2SQL Datasource Configuration\n\n"
+
+    @staticmethod
+    def generate(config: DatasourceFileConfig) -> str:
+        """
+        Generates YAML content for Datasource configuration.
+        
+        Args:
+            config: DatasourceFileConfig object (Envelope).
+            
+        Returns:
+            Formatted YAML string.
+        """
+        dumped_config = config.model_dump(exclude_none=True)
+        
+        yaml_block = yaml.safe_dump(dumped_config, sort_keys=False)
+        
+        return DatasourceGenerator.HEADER + yaml_block

nl2sql/cli/generators/datasources/templates.py

@@ -0,0 +1,7 @@
+
+# Valid placeholders for injection: {version}, {datasources_yaml_block}
+DATASOURCE_TEMPLATE = """version: {version}
+  
+datasources:
+{datasources_yaml_block}
+"""

nl2sql/cli/generators/env/__init__.py

@@ -0,0 +1,3 @@
+from .generator import EnvFileGenerator
+
+__all__ = ["EnvFileGenerator"]

nl2sql/cli/generators/env/generator.py

@@ -0,0 +1,46 @@
+from typing import Dict, Optional
+from .templates import ENV_FILE_TEMPLATE, ENV_SECRETS_HEADER, ENV_SPECIFIC_SETTINGS
+
+class EnvFileGenerator:
+    """Standard generator for .env files complying with Universal Environment Protocol."""
+    
+    @staticmethod
+    def generate(env: str, secrets: Optional[Dict[str, str]] = None) -> str:
+        """Generates the content for a .env.<env> file.
+
+        This method constructs the standard configuration paths based on the
+        environment name and optionally appends provided secrets.
+
+        Args:
+            env: The environment name (e.g., 'dev', 'demo', 'prod').
+            secrets: Optional dictionary of secret key-values to append.
+
+        Returns:
+            The formatted string content for the .env file.
+        """
+        suffix = f".{env}" if env != "dev" else ""
+        
+        # Populate template
+        content = ENV_FILE_TEMPLATE.format(env=env, suffix=suffix)
+        content += ENV_SPECIFIC_SETTINGS.get(env, "")
+        content += ENV_SECRETS_HEADER
+
+        used_keys = set()
+        
+        if secrets:
+            for key, value in secrets.items():
+                content += f"{key}={value}\n"
+                used_keys.add(key)
+        
+        critical_placeholders = ["OPENAI_API_KEY"]
+        appended_placeholders = False
+        
+        for ph in critical_placeholders:
+            if ph not in used_keys:
+                content += f"{ph}=\n"
+                appended_placeholders = True
+        
+        if appended_placeholders and not secrets:
+            content += "# Please fill in the required secrets above.\n"
+            
+        return content