nl2sql-engine 0.1.0__py3-none-any.whl

nl2sql/cli/demo/defaults.py

@@ -0,0 +1,122 @@
+
+# Default Configurations for Demo
+
+SAMPLE_QUESTIONS = {
+    "manufacturing_ref": [
+        "List all factories in the US",
+        "Show me the capacity of Berlin Plant",
+        "What shifts are available?",
+        "List all machine types produced by TechCorp",
+        "Which factories have capacity greater than 4000?",
+        "Show all employee roles in the Maintenance department",
+        "List customer segments available for reporting"
+    ],
+    "manufacturing_ops": [
+        "Show me active employees in the Austin Gigafactory",
+        "Which machines have error logs in the last 7 days?",
+        "Who is the operator for machine 5?",
+        "Count the number of active machines per factory",
+        "List maintenance logs for Vibration sensor alerts",
+        "Which machines are overdue for maintenance based on last_maintenance_date?",
+        "Show employees hired in the last 12 months",
+        "Compare machine status counts by factory",
+        "List maintenance technicians with the most downtime hours logged"
+    ],
+    "manufacturing_supply": [
+        "Total sales amount for 'Industrial Controller'",
+        "Find suppliers for high value components",
+        "Check inventory levels for 'Bolt M5' in Berlin",
+        "List products with base cost greater than 500",
+        "Show me suppliers from Germany",
+        "List products with low inventory across all factories",
+        "Which suppliers provide EV Battery Pack Long Range?",
+        "Show inventory last updated more than 7 days ago",
+        "Compare inventory levels for Hardware category products"
+    ],
+    "manufacturing_history": [
+        "Show total sales orders in Q4",
+        "Calculate average production output per run",
+        "Summarize sales by customer for last year",
+        "List the top 5 largest orders",
+        "Show sales orders by status for the last 30 days",
+        "Compare production output by factory over the last quarter",
+        "List highest revenue products by month",
+        "Show average discount percentage by customer segment"
+    ]
+}
+
+DEMO_POLICIES = {
+    "admin": {
+        "description": "Demo Admin",
+        "role": "admin",
+        "allowed_datasources": ["*"],
+        "allowed_tables": ["*"]
+    }
+}
+
+DEMO_LLM_CONFIG = {
+    "default": {
+        "provider": "openai",
+        "model": "gpt-4o",
+        "api_key": "${env:OPENAI_API_KEY}"
+    }
+}
+
+DEMO_LITE_DATASOURCES = [
+    {"id": "manufacturing_ref", "connection": {"type": "sqlite", "database": "data/demo_lite/manufacturing_ref.db"}, "description": "Master Data (Factories)"},
+    {"id": "manufacturing_ops", "connection": {"type": "sqlite", "database": "data/demo_lite/manufacturing_ops.db"}, "description": "Operational Data (Employees, Machines)"},
+    {"id": "manufacturing_supply", "connection": {"type": "sqlite", "database": "data/demo_lite/manufacturing_supply.db"}, "description": "Supply Chain (Inventory)"},
+    {"id": "manufacturing_history", "connection": {"type": "sqlite", "database": "data/demo_lite/manufacturing_history.db"}, "description": "Historical Data (Sales)"},
+]
+
+DEMO_DOCKER_DATASOURCES = [
+    {
+        "id": "manufacturing_ref", 
+        "connection": {
+            "type": "postgres", 
+            "host": "localhost",
+            "port": 5433,
+            "user": "${env:DEMO_REF_USER}",
+            "password": "${env:DEMO_REF_PASSWORD}",
+            "database": "manufacturing_ref"
+        }, 
+        "description": "Master Data (Factories)"
+    },
+    {
+        "id": "manufacturing_ops", 
+        "connection": {
+            "type": "postgres", 
+            "host": "localhost",
+            "port": 5434,
+            "user": "${env:DEMO_OPS_USER}",
+            "password": "${env:DEMO_OPS_PASSWORD}",
+            "database": "manufacturing_ops"
+        }, 
+        "description": "Operational Data (Employees, Machines)"
+    },
+    {
+        "id": "manufacturing_supply", 
+        "connection": {
+            "type": "mysql", 
+            "host": "localhost",
+            "port": 3307,
+            "user": "${env:DEMO_SUPPLY_USER}",
+            "password": "${env:DEMO_SUPPLY_PASSWORD}",
+            "database": "manufacturing_supply"
+        }, 
+        "description": "Supply Chain (Inventory)"
+    },
+    {
+        "id": "manufacturing_history", 
+        "connection": {
+            "type": "mssql", 
+            "host": "localhost",
+            "port": 1434,
+            "user": "${env:DEMO_HISTORY_USER}",
+            "password": "${env:DEMO_HISTORY_PASSWORD}",
+            "database": "manufacturing_history",
+            "driver": "ODBC Driver 17 for SQL Server"
+        }, 
+        "description": "Historical Data (Sales)"
+    },
+]

nl2sql/cli/demo/factory.py

@@ -0,0 +1,289 @@
+import random
+import datetime
+from typing import List, Dict, Any, Tuple
+from .data import (
+    FACTORIES,
+    SHIFTS,
+    MACHINE_TYPES,
+    PRODUCTS,
+    SUPPLIERS,
+    DEPARTMENTS,
+    CUSTOMER_SEGMENTS,
+    EMPLOYEE_ROLES,
+    SUPPLIER_PRODUCTS,
+)
+
+class DemoDataFactory:
+    """
+    Generates pure Python data structures (Lists of Dicts) for the Demo Environment.
+    Ensures consistency between Lite (SQLite) and Docker (SQL Scripts) by being the single source of truth.
+    """
+
+    def __init__(self, seed: int = 42):
+        self.seed = seed
+        self._reset_random()
+
+    def _reset_random(self):
+        random.seed(self.seed)
+
+    def _weighted_choice(self, values: List[int], weights: List[float]) -> int:
+        total = sum(weights)
+        pick = random.random() * total
+        cumulative = 0.0
+        for value, weight in zip(values, weights):
+            cumulative += weight
+            if pick <= cumulative:
+                return value
+        return values[-1]
+
+    def generate_secrets(self) -> Dict[str, str]:
+        """Generates random passwords for the demo environment."""
+        self._reset_random() # Consistent secrets if called deterministically
+        
+        def _gen(length=24):
+            chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+            return "".join(random.choice(chars) for _ in range(length))
+
+        return {
+            "DEMO_REF_PASSWORD": _gen(),
+            "DEMO_OPS_PASSWORD": _gen(),
+            "DEMO_POSTGRES_PASSWORD": _gen(),
+            "DEMO_SUPPLY_PASSWORD": _gen(),
+            "DEMO_MYSQL_ROOT_PASSWORD": _gen(),
+            "DEMO_HISTORY_PASSWORD": f"StrongP@ss{_gen(8)}!",
+            "DEMO_MSSQL_SA_PASSWORD": f"StrongP@ss{_gen(8)}!",
+        }
+
+    def get_ref_data(self) -> Tuple[List[Dict], List[Dict], List[Dict], List[Dict], List[Dict], List[Dict]]:
+        """Returns reference data for shared dimensions."""
+        return FACTORIES, MACHINE_TYPES, SHIFTS, DEPARTMENTS, EMPLOYEE_ROLES, CUSTOMER_SEGMENTS
+
+    def get_ops_data(self) -> Tuple[List[Dict], List[Dict], List[Dict]]:
+        """Generates (employees, machines, maintenance_logs)."""
+        self._reset_random()
+
+        factory_ids = [f["id"] for f in FACTORIES]
+        factory_weights = [0.45, 0.2, 0.15, 0.12, 0.08]
+
+        # 1. Employees
+        employees = []
+        role_ids = [r["id"] for r in EMPLOYEE_ROLES]
+        role_weights = [0.45, 0.12, 0.12, 0.1, 0.16, 0.05]
+        shift_ids = [s["id"] for s in SHIFTS]
+        shift_weights = [0.5, 0.35, 0.15]
+        last_names = ["Smith", "Garcia", "Kim", "Muller", "Chen", "Patel", "Jones", "Brown", "Nguyen", "Singh"]
+        first_names = ["John", "Maria", "Wei", "Hans", "Rahul", "Sarah", "Aisha", "Luis", "Mina", "Kenji"]
+
+        for i in range(1, 501):
+            fid = self._weighted_choice(factory_ids, factory_weights)
+            sid = self._weighted_choice(shift_ids, shift_weights)
+            role_id = self._weighted_choice(role_ids, role_weights)
+            role = next(r for r in EMPLOYEE_ROLES if r["id"] == role_id)
+            hire_date = (datetime.date.today() - datetime.timedelta(days=random.randint(30, 365 * 8))).isoformat()
+            status = "Active"
+            roll = random.random()
+            if roll < 0.07:
+                status = "Leave"
+            elif roll < 0.1:
+                status = "Contractor"
+
+            employees.append({
+                "id": i,
+                "name": f"{random.choice(first_names)} {random.choice(last_names)}",
+                "factory_id": fid,
+                "shift_id": sid,
+                "hire_date": hire_date,
+                "role_id": role_id,
+                "department_id": role["department_id"],
+                "status": status
+            })
+
+        # 2. Machines
+        machines = []
+        mach_id = 1
+        total_capacity = sum(f["capacity"] for f in FACTORIES)
+        for factory in FACTORIES:
+            base = max(10, int((factory["capacity"] / total_capacity) * 150))
+            count = base + random.randint(-2, 3)
+            for _ in range(count):
+                mtype = random.choice(MACHINE_TYPES)
+                install_date = datetime.date.today() - datetime.timedelta(days=random.randint(120, 2000))
+                last_maint = install_date + datetime.timedelta(days=random.randint(30, 900))
+                if last_maint > datetime.date.today():
+                    last_maint = datetime.date.today() - datetime.timedelta(days=random.randint(7, 90))
+                status = "Active"
+                if (datetime.date.today() - last_maint).days > int(mtype["maintenance_interval_days"] * 1.2):
+                    status = "Maintenance"
+                elif random.random() < 0.02:
+                    status = "Error"
+
+                machines.append({
+                    "id": mach_id,
+                    "factory_id": factory["id"],
+                    "type_id": mtype["id"],
+                    "status": status,
+                    "installation_date": install_date.isoformat(),
+                    "last_maintenance_date": last_maint.isoformat()
+                })
+                mach_id += 1
+
+        # 3. Logs
+        logs = []
+        log_id = 1
+        technician_ids = [e["id"] for e in employees if e["role_id"] == 5]
+        severities = ["Low", "Medium", "High", "Critical"]
+        descriptions = [
+            "Vibration sensor alert triggered",
+            "Unusual noise reported",
+            "Temperature threshold exceeded",
+            "Calibration drift detected",
+            "Unexpected shutdown",
+            "Hydraulic pressure drop",
+        ]
+        for _ in range(250):
+            machine = random.choice(machines)
+            tech_id = random.choice(technician_ids) if technician_ids else random.choice(employees)["id"]
+            sev = random.choices(severities, weights=[0.45, 0.3, 0.2, 0.05], k=1)[0]
+            downtime = random.randint(1, 4) if sev in ["Low", "Medium"] else random.randint(4, 12)
+            log_date = datetime.date.today() - datetime.timedelta(days=random.randint(0, 120))
+            logs.append({
+                "id": log_id,
+                "machine_id": machine["id"],
+                "date": log_date.isoformat(),
+                "description": random.choice(descriptions),
+                "technician_id": tech_id,
+                "severity": sev,
+                "downtime_hours": downtime
+            })
+            log_id += 1
+
+        return employees, machines, logs
+
+    def get_supply_data(self) -> Tuple[List[Dict], List[Dict], List[Dict], List[Dict]]:
+        """Generates (products, suppliers, inventory, supplier_products)."""
+        self._reset_random()
+        
+        # Products & Suppliers are static
+        products = PRODUCTS
+        suppliers = SUPPLIERS
+        supplier_products = SUPPLIER_PRODUCTS
+        
+        # Inventory
+        inventory = []
+        for p in PRODUCTS:
+            for f in FACTORIES:
+                if p["id"] in [1, 2, 3]:
+                    qty = random.randint(20, 200)
+                else:
+                    qty = random.randint(200, 2000)
+                # Scenario: Low Stock
+                if p["id"] == 4 and f["id"] == 2:
+                    qty = 5
+                if p["id"] == 2 and f["id"] == 4:
+                    qty = 12
+                last_updated = (datetime.date.today() - datetime.timedelta(days=random.randint(0, 14))).isoformat()
+                
+                inventory.append({
+                    "product_id": p["id"],
+                    "factory_id": f["id"],
+                    "quantity": qty,
+                    "last_updated": last_updated
+                })
+        
+        return products, suppliers, inventory, supplier_products
+
+    def get_history_data(self) -> Tuple[List[Dict], List[Dict], List[Dict]]:
+        """Generates (sales_orders, sales_items, production_runs)."""
+        self._reset_random()
+        
+        start_date = datetime.date.today() - datetime.timedelta(days=365)
+        customers = ["Acme Inc", "Cyberdyne", "Wayne Ent", "Stark Ind", "Massive Dynamic"]
+        segment_ids = [s["id"] for s in CUSTOMER_SEGMENTS]
+        factory_ids = [f["id"] for f in FACTORIES]
+        factory_weights = [0.45, 0.2, 0.15, 0.12, 0.08]
+        order_statuses = ["Pending", "Shipped", "Delivered", "Cancelled"]
+        
+        orders = []
+        items = []
+        item_id_counter = 1
+        monthly_volume = {m: 0 for m in range(1, 13)}
+        
+        # 5000 Orders
+        for i in range(1, 5001):
+            cust = random.choice(customers)
+            if random.random() < 0.6:
+                delta = random.randint(270, 365)
+            else:
+                delta = random.randint(0, 270)
+            
+            order_date = start_date + datetime.timedelta(days=delta)
+            date_str = order_date.isoformat()
+            fid = self._weighted_choice(factory_ids, factory_weights)
+            status = random.choices(order_statuses, weights=[0.12, 0.25, 0.58, 0.05], k=1)[0]
+            segment_id = random.choice(segment_ids)
+            
+            order_total = 0.0
+            num_items = random.randint(1, 6)
+            
+            # Generate Items
+            for _ in range(num_items):
+                prod = random.choices(PRODUCTS, weights=[1, 1, 2, 6, 6, 4, 3, 4, 3], k=1)[0]
+                qty = random.randint(1, 120)
+                markup = random.uniform(1.3, 1.8)
+                discount = 0.0
+                if qty >= 50:
+                    discount = random.choice([0.02, 0.05, 0.08])
+                price = prod["base_cost"] * markup
+                line_total = qty * price * (1 - discount)
+                order_total += line_total
+                
+                items.append({
+                    "id": item_id_counter,
+                    "order_id": i,
+                    "product_id": prod["id"],
+                    "quantity": qty,
+                    "unit_price": round(price, 2),
+                    "discount_pct": round(discount * 100, 2)
+                })
+                item_id_counter += 1
+                monthly_volume[order_date.month] += qty
+                
+            orders.append({
+                "id": i,
+                "customer_name": cust,
+                "order_date": date_str,
+                "total_amount": round(order_total, 2),
+                "status": status,
+                "customer_segment_id": segment_id,
+                "factory_id": fid
+            })
+            
+        # Production Runs
+        runs = []
+        run_id = 1
+        for day_offset in range(0, 365):
+            run_date = start_date + datetime.timedelta(days=day_offset)
+            month = run_date.month
+            season_multiplier = 1.0
+            if month in [10, 11, 12]:
+                season_multiplier = 1.35
+            elif month in [6, 7, 8]:
+                season_multiplier = 1.15
+
+            for factory in FACTORIES:
+                base = int((factory["capacity"] / 10) * season_multiplier)
+                qty = max(250, base + random.randint(-120, 150))
+                run_shift = self._weighted_choice([s["id"] for s in SHIFTS], [0.5, 0.35, 0.15])
+                run_status = "Complete" if random.random() > 0.03 else "Delayed"
+
+                runs.append({
+                    "id": run_id,
+                    "factory_id": factory["id"],
+                    "date": run_date.isoformat(),
+                    "output_quantity": qty,
+                    "shift_id": run_shift,
+                    "status": run_status
+                })
+                run_id += 1
+            
+        return orders, items, runs

nl2sql/cli/demo/manager.py

@@ -0,0 +1,230 @@
+from typing import Dict, Any, Optional
+import pathlib
+import subprocess
+import yaml
+from rich.console import Console
+from rich.markup import escape
+from nl2sql.configs import (
+    ConfigManager, 
+    LLMFileConfig, 
+    DatasourceConfig, 
+    DatasourceFileConfig,
+    PolicyFileConfig
+)
+
+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
+
+from .factory import DemoDataFactory
+from .writers.sqlite import SQLiteWriter
+from .writers.docker import DockerWriter
+from .defaults import (
+    SAMPLE_QUESTIONS, 
+    DEMO_POLICIES,
+    DEMO_LLM_CONFIG,
+    DEMO_LITE_DATASOURCES,
+    DEMO_DOCKER_DATASOURCES
+)
+
+class DemoManager:
+    """
+    Manages the creation of the Demo Environment (Lite or Docker).
+    Orchestrates Data Factory, Writers, and Generators.
+    """
+
+    def __init__(self, console: Console, project_root: pathlib.Path):
+        self.console = console
+        self.project_root = project_root
+        self.config_manager = ConfigManager(project_root)
+        self.factory = DemoDataFactory(seed=42)
+
+    def print_step(self, msg: str):
+        self.console.print(f"[dim]{escape(str(msg))}[/dim]")
+    
+    def print_success(self, msg: str):
+        self.console.print(f"[green][OK][/green] {escape(str(msg))}")
+
+    def print_error(self, msg: str):
+        self.console.print(f"[red][ERROR] {escape(str(msg))}[/red]")
+
+    def setup_lite(self, api_key: Optional[str] = None):
+        """Sets up the SQLite-based demo environment."""
+        data_dir = self.project_root / "data" / "demo_lite"
+        self.print_step(f"Generating SQLite Databases in {data_dir}...")
+        
+        # 1. Generate Data
+        ref = self.factory.get_ref_data()
+        ops = self.factory.get_ops_data()
+        supply = self.factory.get_supply_data()
+        history = self.factory.get_history_data()
+        
+        # 2. Write DBs
+        SQLiteWriter.write_lite(data_dir, ref, ops, supply, history)
+        
+        configs = DEMO_LITE_DATASOURCES
+        
+        # Write using Generator (Strict Typed)
+        ds_configs = [DatasourceConfig(**c) for c in configs]
+        file_config = DatasourceFileConfig(datasources=ds_configs)
+        content = DatasourceGenerator.generate(file_config)
+        ds_path = self.project_root / "configs" / "datasources.demo.yaml"
+        ds_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(ds_path, "w", encoding="utf-8") as f:
+            f.write(content)
+        
+        self._write_common_artifacts()
+        
+        self.print_step("Writing .env.demo configuration...")
+        
+        secrets = {}
+        if api_key:
+            secrets["OPENAI_API_KEY"] = api_key
+            
+        env_content = EnvFileGenerator.generate("demo", secrets=secrets)
+        env_path = self.project_root / ".env.demo"
+        with open(env_path, "w", encoding="utf-8") as f:
+            f.write(env_content)
+            
+        self.print_success("Lite Demo Setup Complete")
+
+
+    def setup_docker(self, api_key: Optional[str] = None):
+        """Sets up the Docker-based demo environment."""
+        docker_dir = self.project_root / "demo_docker"
+        self.print_step(f"Generating Docker Configuration in {docker_dir}...")
+        
+        # 1. Generate Data & Secrets
+        secrets = self.factory.generate_secrets()
+        if api_key:
+            secrets["OPENAI_API_KEY"] = api_key
+            
+        ref = self.factory.get_ref_data()
+        ops = self.factory.get_ops_data()
+        supply = self.factory.get_supply_data()
+        history = self.factory.get_history_data()
+        
+        # 2. Write Artifacts
+        DockerWriter.write_docker(docker_dir, secrets, ref, ops, supply, history)
+        
+        self.print_step("Writing datasources config...")
+        # Use defaults from configuration
+        configs = DEMO_DOCKER_DATASOURCES
+        
+
+        ds_configs = [DatasourceConfig(**c) for c in configs]
+        file_config = DatasourceFileConfig(datasources=ds_configs)
+        content = DatasourceGenerator.generate(file_config)
+        ds_path = self.project_root / "configs" / "datasources.demo.yaml"
+        ds_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(ds_path, "w", encoding="utf-8") as f:
+            f.write(content)
+            
+        self._write_common_artifacts()
+        
+        # The app container reads the same .env.demo the lite path writes, so it
+        # has to exist before `docker compose up` (and before `docker compose config`).
+        self.print_step("Writing .env.demo configuration...")
+        self.copy_docker_env_to_root(docker_dir)
+        
+        self.print_success("Docker Configuration Generated")
+        return docker_dir
+
+    def _write_common_artifacts(self):
+        """Writes policies and sample questions."""
+        self.print_step("Writing policies...")
+        policy_config = PolicyFileConfig(roles=DEMO_POLICIES)
+        content = PolicyGenerator.generate(policy_config)
+        policy_path = self.project_root / "configs" / "policies.demo.json"
+        
+        if not policy_path.parent.exists():
+             policy_path.parent.mkdir(parents=True, exist_ok=True)
+             
+        with open(policy_path, "w", encoding="utf-8") as f:
+            f.write(content)
+        
+        self.print_step("Writing sample questions...")
+        samples_path = self.project_root / "configs" / "sample_questions.demo.yaml"
+        with open(samples_path, "w") as f:
+            yaml.dump(SAMPLE_QUESTIONS, f, sort_keys=False)
+            
+        self.print_step("Writing LLM config...")
+        llm_config = LLMFileConfig(**DEMO_LLM_CONFIG)
+        content = LLMGenerator.generate(llm_config)
+        llm_path = self.project_root / "configs" / "llm.demo.yaml"
+        with open(llm_path, "w", encoding="utf-8") as f:
+            f.write(content)
+            
+    def start_docker_containers(self, docker_dir: pathlib.Path) -> bool:
+        """Starts the docker containers using subprocess."""
+        try:
+            subprocess.run(
+                ["docker", "compose", "-f", "docker-compose.demo.yml", "up", "-d"],
+                cwd=docker_dir,
+                check=True
+            )
+            return True
+        except Exception as e:
+            self.print_error(f"Failed to start Docker: {e}")
+            return False
+
+    def copy_docker_env_to_root(self, docker_dir: pathlib.Path) -> bool:
+        """Copies the generated .env from docker dir to project root as .env.demo, using Protocol."""
+        try:
+            src = docker_dir / ".env"
+            dest = self.project_root / ".env.demo"
+            
+            # Read secrets from source env
+            secrets = {}
+            if src.exists():
+                with open(src, "r", encoding="utf-8") as f:
+                    for line in f:
+                        line = line.strip()
+                        if line and not line.startswith("#") and "=" in line:
+                            k, v = line.split("=", 1)
+                            secrets[k.strip()] = v.strip()
+            
+            # Generate Standard Env Content with secrets injected
+            content = EnvFileGenerator.generate("demo", secrets=secrets)
+            
+            # Write content
+            with open(dest, "w", encoding="utf-8") as f:
+                f.write(content)
+                
+            return True
+        except Exception:
+            return False
+
+    def index_demo_data(self):
+        """Triggers the indexing process for the demo."""
+
+        from dotenv import load_dotenv
+        from nl2sql.common.settings import settings, reload_settings
+
+        env_path = self.project_root / ".env.demo"
+        if not env_path.exists():
+            self.print_error(f"Could not find {env_path}")
+            return False
+
+        # The demo environment must be active before the context is built:
+        # NL2SQLContext validates vector store settings during construction.
+        load_dotenv(env_path, override=True)
+        reload_settings()
+
+        from nl2sql.context import NL2SQLContext
+        from nl2sql.cli.commands.indexing import run_indexing
+
+        try:
+            ctx = NL2SQLContext(
+                ds_config_path=self.project_root / settings.datasource_config_path,
+                secrets_config_path=self.project_root / settings.secrets_config_path,
+                llm_config_path=self.project_root / settings.llm_config_path,
+                vector_store_path=self.project_root / settings.vector_store_path,
+                policies_config_path=self.project_root / settings.policies_config_path,
+            )
+            run_indexing(ctx)
+            return True
+        except Exception as e:
+            self.print_error(f"Indexing Failed: {e}")
+            return False