sirius-cli 0.1.0__py3-none-any.whl

sirius_cli/parser.py

@@ -0,0 +1,322 @@
+import os
+import re
+import sqlite3
+import json
+import pandas as pd
+
+# Irregular plural/singular mappings for FK heuristic resolution
+_IRREGULAR_PLURALS = {
+    "person": "people",
+    "man": "men",
+    "woman": "women",
+    "child": "children",
+    "tooth": "teeth",
+    "foot": "feet",
+    "mouse": "mice",
+    "goose": "geese",
+    "ox": "oxen",
+    "leaf": "leaves",
+    "life": "lives",
+    "knife": "knives",
+    "wife": "wives",
+    "half": "halves",
+    "loaf": "loaves",
+    "potato": "potatoes",
+    "tomato": "tomatoes",
+    "cactus": "cacti",
+    "focus": "foci",
+    "fungus": "fungi",
+    "nucleus": "nuclei",
+    "syllabus": "syllabi",
+    "analysis": "analyses",
+    "diagnosis": "diagnoses",
+    "oasis": "oases",
+    "thesis": "theses",
+    "crisis": "crises",
+    "phenomenon": "phenomena",
+    "criterion": "criteria",
+    "datum": "data",
+}
+_IRREGULAR_SINGULARS = {v: k for k, v in _IRREGULAR_PLURALS.items()}
+
+def _pluralize(word: str) -> str:
+    """Returns a best-guess plural of a singular English word."""
+    if word in _IRREGULAR_PLURALS:
+        return _IRREGULAR_PLURALS[word]
+    if word.endswith(("s", "sh", "ch", "x", "z")):
+        return word + "es"
+    if word.endswith("y") and len(word) > 1 and word[-2] not in "aeiou":
+        return word[:-1] + "ies"
+    if word.endswith(("f", "fe")):
+        return word.rstrip("e").rstrip("f") + "ves"
+    return word + "s"
+
+def _singularize(word: str) -> str:
+    """Returns a best-guess singular of a plural English word."""
+    if word in _IRREGULAR_SINGULARS:
+        return _IRREGULAR_SINGULARS[word]
+    if word.endswith("ies") and len(word) > 3:
+        return word[:-3] + "y"
+    if word.endswith("ves"):
+        # could be -f or -fe ending
+        return word[:-3] + "f"
+    if word.endswith("es") and word[:-2] in ("",) or word.endswith(("ses", "shes", "ches", "xes", "zes")):
+        return word[:-2]
+    if word.endswith("s") and not word.endswith("ss"):
+        return word[:-1]
+    return word
+
+def sanitize_table_name(name: str) -> str:
+    """Sanitizes file path/table name to a valid SQL identifier."""
+    base = os.path.splitext(os.path.basename(name))[0]
+    sanitized = re.sub(r'[^a-zA-Z0-9_]', '_', base).lower()
+    if sanitized and sanitized[0].isdigit():
+        sanitized = "_" + sanitized
+    return sanitized or "table"
+
+def sanitize_column_name(name: str) -> str:
+    """Sanitizes column name to a valid SQL/python attribute name."""
+    sanitized = re.sub(r'[^a-zA-Z0-9_]', '_', str(name)).lower()
+    if sanitized and sanitized[0].isdigit():
+        sanitized = "_" + sanitized
+    return sanitized or "column"
+
+def map_pandas_type(dtype, sample_values) -> str:
+    """Maps Pandas dtype to standard string types: Integer, Float, Boolean, DateTime, String."""
+    if pd.api.types.is_integer_dtype(dtype):
+        return "Integer"
+    elif pd.api.types.is_float_dtype(dtype):
+        return "Float"
+    elif pd.api.types.is_bool_dtype(dtype):
+        return "Boolean"
+    elif pd.api.types.is_datetime64_any_dtype(dtype):
+        return "DateTime"
+    else:
+        # Check string samples to see if they look like ISO dates or timestamps
+        for val in sample_values:
+            if isinstance(val, str):
+                try:
+                    pd.to_datetime(val)
+                    if len(val) >= 8 and any(char in val for char in ['-', '/', ':']):
+                        return "DateTime"
+                except (ValueError, TypeError):
+                    pass
+        return "String"
+
+def parse_config_file(config_path: str):
+    """Loads entities and schemas directly from a JSON configuration file."""
+    with open(config_path, "r", encoding="utf-8") as f:
+        config = json.load(f)
+    
+    project_name = config.get("project_name", "generated_project")
+    theme = config.get("theme", "blue")
+    entities = config.get("entities", {})
+    
+    schemas = {}
+    for table_name, table_info in entities.items():
+        san_table = sanitize_table_name(table_name)
+        columns = []
+        has_id = False
+        
+        for col in table_info.get("columns", []):
+            name = sanitize_column_name(col.get("name"))
+            c_type = col.get("type", "String")
+            is_pk = col.get("is_pk", False)
+            fk = col.get("foreign_key")
+            
+            col_dict = {"name": name, "type": c_type, "is_pk": is_pk}
+            if fk:
+                col_dict["foreign_key"] = fk
+                
+            if name == "id":
+                has_id = True
+                col_dict["is_pk"] = True
+                
+            columns.append(col_dict)
+            
+        if not has_id:
+            # Enforce an autoincrementing primary key
+            for c in columns:
+                if c["is_pk"]:
+                    c["is_pk"] = False
+            columns.insert(0, {"name": "id", "type": "Integer", "is_pk": True})
+            
+        schemas[san_table] = columns
+        
+    return schemas, project_name, theme
+
+def parse_csv_files(csv_paths: list) -> dict:
+    """Parses list of CSV paths, extracts schema types and infers relationships."""
+    schemas = {}
+    for path in csv_paths:
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"CSV file not found: {path}")
+        
+        table_name = sanitize_table_name(path)
+        df = pd.read_csv(path, nrows=100)
+        
+        columns = []
+        has_id = False
+        
+        for col in df.columns:
+            san_col = sanitize_column_name(col)
+            col_type = map_pandas_type(df[col].dtype, df[col].dropna().head(5).tolist())
+            
+            if san_col == "id":
+                has_id = True
+                columns.append({"name": "id", "type": "Integer", "is_pk": True})
+            else:
+                columns.append({"name": san_col, "type": col_type, "is_pk": False})
+                
+        if not has_id:
+            columns.insert(0, {"name": "id", "type": "Integer", "is_pk": True})
+            
+        schemas[table_name] = columns
+        
+    # Heuristic-based Relationship inference (shared by CSV and Excel parsers)
+    table_names = list(schemas.keys())
+    for table_name, columns in schemas.items():
+        for col in columns:
+            if col["name"].endswith("_id") and col["name"] != "id":
+                prefix = col["name"][:-3]  # strip '_id'
+                matched_table = None
+                for t in table_names:
+                    # Try exact match, then common plural/singular variants
+                    candidates = {
+                        prefix,
+                        _pluralize(prefix),
+                        _singularize(prefix),
+                        prefix + "s",
+                        prefix[:-1] if prefix.endswith("s") else prefix,
+                    }
+                    if t in candidates:
+                        matched_table = t
+                        break
+                if matched_table:
+                    col["foreign_key"] = f"{matched_table}.id"
+                    
+    return schemas
+
+def parse_excel_files(excel_paths: list) -> dict:
+    """Parses list of Excel (.xlsx/.xls) paths, extracts schema types and infers relationships."""
+    schemas = {}
+    for path in excel_paths:
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"Excel file not found: {path}")
+
+        table_name = sanitize_table_name(path)
+        df = pd.read_excel(path, nrows=100)
+
+        columns = []
+        has_id = False
+
+        for col in df.columns:
+            san_col = sanitize_column_name(str(col))
+            col_type = map_pandas_type(df[col].dtype, df[col].dropna().head(5).tolist())
+
+            if san_col == "id":
+                has_id = True
+                columns.append({"name": "id", "type": "Integer", "is_pk": True})
+            else:
+                columns.append({"name": san_col, "type": col_type, "is_pk": False})
+
+        if not has_id:
+            columns.insert(0, {"name": "id", "type": "Integer", "is_pk": True})
+
+        schemas[table_name] = columns
+
+    # Run same FK heuristic as CSV parser
+    table_names = list(schemas.keys())
+    for table_name, columns in schemas.items():
+        for col in columns:
+            if col["name"].endswith("_id") and col["name"] != "id":
+                prefix = col["name"][:-3]
+                matched_table = None
+                for t in table_names:
+                    candidates = {
+                        prefix,
+                        _pluralize(prefix),
+                        _singularize(prefix),
+                        prefix + "s",
+                        prefix[:-1] if prefix.endswith("s") else prefix,
+                    }
+                    if t in candidates:
+                        matched_table = t
+                        break
+                if matched_table:
+                    col["foreign_key"] = f"{matched_table}.id"
+
+    return schemas
+
+def map_sqlite_type(sqlite_type: str) -> str:
+    """Maps SQLite column type to standard schema types."""
+    t = sqlite_type.upper()
+    if any(x in t for x in ["INT", "INTEGER", "TINYINT", "SMALLINT", "MEDIUMINT", "BIGINT"]):
+        return "Integer"
+    elif any(x in t for x in ["REAL", "DOUBLE", "FLOAT"]):
+        return "Float"
+    elif any(x in t for x in ["BOOL", "BOOLEAN"]):
+        return "Boolean"
+    elif any(x in t for x in ["DATE", "DATETIME", "TIMESTAMP"]):
+        return "DateTime"
+    else:
+        return "String"
+
+def parse_sqlite_db(db_path: str) -> dict:
+    """Parses SQLite database extracting user tables and foreign key constraints."""
+    if not os.path.exists(db_path):
+        raise FileNotFoundError(f"SQLite database file not found: {db_path}")
+        
+    schemas = {}
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+    
+    # Query user tables
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';")
+    tables = [row[0] for row in cursor.fetchall()]
+    
+    for table in tables:
+        san_table = sanitize_table_name(table)
+        
+        # Query SQLite foreign key relationships for the table
+        # row structure: (id, seq, table, from, to, on_update, on_delete, match)
+        cursor.execute(f"PRAGMA foreign_key_list({table});")
+        fks = {}
+        for row in cursor.fetchall():
+            local_col = sanitize_column_name(row[3])
+            ref_table = sanitize_table_name(row[2])
+            ref_col = sanitize_column_name(row[4])
+            fks[local_col] = f"{ref_table}.{ref_col}"
+            
+        cursor.execute(f"PRAGMA table_info({table});")
+        columns_info = cursor.fetchall()
+        
+        columns = []
+        has_id = False
+        
+        for info in columns_info:
+            col_name = sanitize_column_name(info[1])
+            col_type = map_sqlite_type(info[2])
+            is_pk = bool(info[5])
+            
+            col_dict = {"name": col_name, "type": col_type, "is_pk": is_pk}
+            if col_name in fks:
+                col_dict["foreign_key"] = fks[col_name]
+                
+            if col_name == "id":
+                has_id = True
+                col_dict["is_pk"] = True
+                
+            columns.append(col_dict)
+            
+        if not has_id:
+            # Enforce PK id
+            for c in columns:
+                if c["is_pk"]:
+                    c["is_pk"] = False
+            columns.insert(0, {"name": "id", "type": "Integer", "is_pk": True})
+            
+        schemas[san_table] = columns
+        
+    conn.close()
+    return schemas

sirius_cli/templates/backend/Dockerfile.jinja2

@@ -0,0 +1,17 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE {{ port }}
+
+# We assume uvicorn is installed and backend is a python package
+CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "{{ port }}"]

sirius_cli/templates/backend/alembic/env.py.jinja2

@@ -0,0 +1,70 @@
+import sys
+import os
+# Add parent of the backend directory to sys.path so backend is importable
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')))
+
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# Import engine and Base from backend package
+from backend.database import Base, engine
+import backend.models  # ensures models are loaded for metadata extraction
+target_metadata = Base.metadata
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    """
+    url = str(engine.url)
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection, target_metadata=target_metadata
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

sirius_cli/templates/backend/alembic/script.py.mako.jinja2

@@ -0,0 +1,26 @@
+{% raw %}
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision}
+Create Date: ${create_date}
+
+"""
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision = ${repr(up_revision)}
+down_revision = ${repr(down_revision)}
+branch_labels = ${repr(branch_labels)}
+depends_on = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}
+{% endraw %}

sirius_cli/templates/backend/database.py.jinja2

@@ -0,0 +1,39 @@
+import os
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+{% if db_type == 'pg' %}
+# PostgreSQL connection — set DATABASE_URL environment variable for custom credentials
+DATABASE_URL = os.environ.get(
+    "DATABASE_URL",
+    "postgresql://postgres:postgres@localhost:5432/{{ project_name | default('app', true) }}"
+)
+engine = create_engine(DATABASE_URL)
+{% elif db_type == 'mysql' %}
+# MySQL connection — set DATABASE_URL environment variable for custom credentials
+DATABASE_URL = os.environ.get(
+    "DATABASE_URL",
+    "mysql+pymysql://root:root@localhost:3306/{{ project_name | default('app', true) }}"
+)
+engine = create_engine(DATABASE_URL)
+{% else %}
+# SQLite (default) — file lives alongside the backend package
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+db_path = os.path.join(BASE_DIR, "app.db")
+SQLALCHEMY_DATABASE_URL = f"sqlite:///{db_path}"
+engine = create_engine(
+    SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
+)
+{% endif %}
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

sirius_cli/templates/backend/main.py.jinja2

@@ -0,0 +1,178 @@
+import io
+import json
+from fastapi import FastAPI, Depends, HTTPException, Query, status
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+from sqlalchemy import or_, cast, String as SAString, desc as sa_desc, asc as sa_asc
+from sqlalchemy.orm import Session
+from typing import List, Optional
+
+from .database import engine, get_db
+from . import models, schemas
+
+# Automatically create tables if they do not exist
+models.Base.metadata.create_all(bind=engine)
+
+app = FastAPI(title="Proto-CLI Generated Backend API", version="0.1.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/")
+def read_root():
+    return {"message": "Welcome to the generated Proto-CLI API!"}
+
+@app.get("/api/metadata")
+def get_metadata(db: Session = Depends(get_db)):
+    meta = []
+    {% for table_name, columns in schemas.items() %}
+    {% set model_name = table_name.replace('_', ' ').title().replace(' ', '') + "Model" %}
+    meta.append({
+        "name": "{{ table_name }}",
+        "count": db.query(models.{{ model_name }}).count(),
+        "columns": json.loads("""{{ columns | tojson }}""")
+    })
+    {% endfor %}
+    return meta
+
+{% for table_name, columns in schemas.items() %}
+{% set model_name = table_name.replace('_', ' ').title().replace(' ', '') + "Model" %}
+{% set schema_response = table_name.replace('_', ' ').title().replace(' ', '') + "Response" %}
+{% set schema_create = table_name.replace('_', ' ').title().replace(' ', '') + "Create" %}
+{% set schema_update = table_name.replace('_', ' ').title().replace(' ', '') + "Update" %}
+
+# --- Endpoints for {{ table_name }} ---
+
+@app.get("/api/{{ table_name }}", response_model=List[schemas.{{ schema_response }}])
+def list_{{ table_name }}(
+    limit: int = 100,
+    offset: int = 0,
+    search: Optional[str] = Query(None, description="Search across all text columns"),
+    order_by: Optional[str] = Query(None, description="Column name to sort by"),
+    dir: Optional[str] = Query("asc", description="Sort direction: asc or desc"),
+    db: Session = Depends(get_db)
+):
+    query = db.query(models.{{ model_name }})
+
+    # Server-side search: filter across all string-castable columns
+    if search:
+        search_term = f"%{search}%"
+        search_filters = []
+        for col in models.{{ model_name }}.__table__.columns:
+            search_filters.append(cast(col, SAString).ilike(search_term))
+        if search_filters:
+            query = query.filter(or_(*search_filters))
+
+    # Column sorting
+    if order_by and hasattr(models.{{ model_name }}, order_by):
+        col_attr = getattr(models.{{ model_name }}, order_by)
+        query = query.order_by(sa_desc(col_attr) if dir == "desc" else sa_asc(col_attr))
+
+    records = query.offset(offset).limit(limit).all()
+    return records
+
+@app.get("/api/{{ table_name }}/export")
+def export_{{ table_name }}(
+    fmt: Optional[str] = Query("csv", description="Export format: csv or xlsx"),
+    db: Session = Depends(get_db)
+):
+    records = db.query(models.{{ model_name }}).all()
+    col_names = [c.name for c in models.{{ model_name }}.__table__.columns]
+
+    if fmt == "xlsx":
+        try:
+            from openpyxl import Workbook
+        except ImportError:
+            raise HTTPException(status_code=500, detail="openpyxl is not installed on the server")
+
+        wb = Workbook()
+        ws = wb.active
+        ws.title = "{{ table_name }}"
+        ws.append(col_names)
+        for record in records:
+            row = []
+            for col in col_names:
+                val = getattr(record, col)
+                row.append(val if val is not None else "")
+            ws.append(row)
+
+        buf = io.BytesIO()
+        wb.save(buf)
+        buf.seek(0)
+
+        return StreamingResponse(
+            buf,
+            media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            headers={"Content-Disposition": "attachment; filename={{ table_name }}.xlsx"}
+        )
+
+    # Default: CSV export
+    def generate():
+        yield ",".join(col_names) + "\n"
+        for record in records:
+            row_values = []
+            for col in col_names:
+                val = getattr(record, col)
+                if val is None:
+                    row_values.append("")
+                elif isinstance(val, bool):
+                    row_values.append(str(val))
+                else:
+                    val_str = str(val).replace('"', '""')
+                    if ',' in val_str or '\n' in val_str or '"' in val_str:
+                        row_values.append(f'"{val_str}"')
+                    else:
+                        row_values.append(val_str)
+            yield ",".join(row_values) + "\n"
+
+    return StreamingResponse(
+        generate(),
+        media_type="text/csv",
+        headers={"Content-Disposition": "attachment; filename={{ table_name }}.csv"}
+    )
+
+@app.get("/api/{{ table_name }}/{id}", response_model=schemas.{{ schema_response }})
+def get_{{ table_name }}(id: int, db: Session = Depends(get_db)):
+    record = db.query(models.{{ model_name }}).filter(models.{{ model_name }}.id == id).first()
+    if not record:
+        raise HTTPException(status_code=404, detail="Record not found in {{ table_name }}")
+    return record
+
+@app.post("/api/{{ table_name }}", response_model=schemas.{{ schema_response }}, status_code=status.HTTP_201_CREATED)
+def create_{{ table_name }}(payload: schemas.{{ schema_create }}, db: Session = Depends(get_db)):
+    db_record = models.{{ model_name }}(**payload.model_dump())
+    db.add(db_record)
+    db.commit()
+    db.refresh(db_record)
+    return db_record
+
+@app.put("/api/{{ table_name }}/{id}", response_model=schemas.{{ schema_response }})
+def update_{{ table_name }}(id: int, payload: schemas.{{ schema_update }}, db: Session = Depends(get_db)):
+    db_record = db.query(models.{{ model_name }}).filter(models.{{ model_name }}.id == id).first()
+    if not db_record:
+        raise HTTPException(status_code=404, detail="Record not found in {{ table_name }}")
+    
+    update_data = payload.model_dump(exclude_unset=True)
+    for key, value in update_data.items():
+        setattr(db_record, key, value)
+        
+    db.commit()
+    db.refresh(db_record)
+    return db_record
+
+@app.delete("/api/{{ table_name }}/{id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_{{ table_name }}(id: int, db: Session = Depends(get_db)):
+    db_record = db.query(models.{{ model_name }}).filter(models.{{ model_name }}.id == id).first()
+    if not db_record:
+        raise HTTPException(status_code=404, detail="Record not found in {{ table_name }}")
+    
+    db.delete(db_record)
+    db.commit()
+    return None
+
+{% endfor %}

sirius_cli/templates/backend/models.py.jinja2

@@ -0,0 +1,31 @@
+from sqlalchemy import Column, Integer, Float, String, Boolean, DateTime, ForeignKey
+from sqlalchemy.orm import relationship
+from .database import Base
+
+
+{% for table_name, columns in schemas.items() %}
+{% set class_name = table_name.replace('_', ' ').title().replace(' ', '') + "Model" %}
+class {{ class_name }}(Base):
+    __tablename__ = "{{ table_name }}"
+
+    {% for col in columns %}
+    {% if col.is_pk %}
+    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
+    {% elif col.foreign_key %}
+    {{ col.name }} = Column({{ col.type }}, ForeignKey('{{ col.foreign_key }}'), nullable=True)
+    {% else %}
+    {{ col.name }} = Column({{ col.type }}, nullable=True)
+    {% endif %}
+    {% endfor %}
+
+    # Relationships
+    {% for col in columns %}
+    {% if col.foreign_key %}
+    {% set ref_table = col.foreign_key.split('.')[0] %}
+    {% set ref_class = ref_table.replace('_', ' ').title().replace(' ', '') + "Model" %}
+    {% set prop_name = col.name[:-3] if col.name.endswith('_id') else ref_table %}
+    {{ prop_name }} = relationship("{{ ref_class }}")
+    {% endif %}
+    {% endfor %}
+
+{% endfor %}