nl2sql-api 0.1.0__py3-none-any.whl

nl2sql_api/dependencies.py

@@ -0,0 +1,44 @@
+from fastapi import Depends, Request
+
+from nl2sql import NL2SQL
+from nl2sql_api.services import (
+    DatasourceService,
+    QueryService,
+    LLMService,
+    IndexingService,
+    HealthService,
+)
+
+
+def get_engine(request: Request) -> NL2SQL:
+    return request.app.state.engine
+
+
+def get_datasource_service(
+    engine: NL2SQL = Depends(get_engine),
+) -> DatasourceService:
+    return DatasourceService(engine)
+
+
+def get_query_service(
+    engine: NL2SQL = Depends(get_engine),
+) -> QueryService:
+    return QueryService(engine)
+
+
+def get_llm_service(
+    engine: NL2SQL = Depends(get_engine),
+) -> LLMService:
+    return LLMService(engine)
+
+
+def get_indexing_service(
+    engine: NL2SQL = Depends(get_engine),
+) -> IndexingService:
+    return IndexingService(engine)
+
+
+def get_health_service(
+    engine: NL2SQL = Depends(get_engine),
+) -> HealthService:
+    return HealthService(engine)

nl2sql_api/main.py

@@ -0,0 +1,47 @@
+import os
+
+from fastapi import FastAPI
+from contextlib import asynccontextmanager
+
+from .routes import query, health, datasource, llm, indexing
+from fastapi.middleware.cors import CORSMiddleware
+from nl2sql import NL2SQL
+from nl2sql.common.logger import configure_logging
+from nl2sql.common.settings import settings
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # The library no longer configures logging on import, so the application
+    # entry point owns it - before anything that logs is constructed.
+    configure_logging(
+        level="INFO",
+        json_format=(settings.observability_exporter == "otlp"),
+    )
+    app.state.engine = NL2SQL()
+    yield
+
+
+app = FastAPI(
+    title="NL2SQL API",
+    version="0.1.0",
+    lifespan=lifespan,
+)
+
+app.include_router(query.router, prefix="/api/v1")
+app.include_router(health.router, prefix="/api/v1")
+app.include_router(datasource.router, prefix="/api/v1")
+app.include_router(llm.router, prefix="/api/v1")
+app.include_router(indexing.router, prefix="/api/v1")
+
+_origins = [o.strip() for o in os.getenv("NL2SQL_API_CORS_ORIGINS", "").split(",") if o.strip()]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=_origins,
+    allow_credentials=bool(_origins),
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+

nl2sql_api/models/datasource.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel
+from typing import Dict, Any, Optional
+
+class DatasourceRequest(BaseModel):
+    config: Dict[str, Any]
+
+
+class DatasourceResponse(BaseModel):
+    success: bool
+    message: str
+    datasource_id: Optional[str] = None

nl2sql_api/models/llm.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel
+from typing import Dict, Any, Optional
+
+class LLMRequest(BaseModel):
+    config: Dict[str, Any]
+
+
+class LLMResponse(BaseModel):
+    success: bool
+    message: str
+    llm_name: Optional[str] = None

nl2sql_api/models/query.py

@@ -0,0 +1,33 @@
+from pydantic import BaseModel, Field
+from typing import Optional, Dict, Any, List
+
+
+class QueryRequest(BaseModel):
+    natural_language: str
+    datasource_id: Optional[str] = None
+    execute: bool = True
+    user_context: Optional[Dict[str, Any]] = None
+
+
+class SubQueryResponse(BaseModel):
+    """One decomposed sub-query and the SQL generated for it."""
+    id: str = ""
+    intent: str = ""
+    sql: str = ""
+    datasource_id: str = ""
+    schema_version: str = ""
+
+
+class QueryResponse(BaseModel):
+    """Mirrors ``nl2sql.api.query_api.QueryResult``.
+
+    Result rows are not inlined; they live in artifact storage and are addressable
+    through ``artifact_refs``.
+    """
+    sub_queries: List[SubQueryResponse] = Field(default_factory=list)
+    final_answer: Optional[Dict[str, Any]] = None
+    errors: List[Dict[str, Any]] = Field(default_factory=list)
+    trace_id: Optional[str] = None
+    reasoning: List[Dict[str, Any]] = Field(default_factory=list)
+    warnings: List[Dict[str, Any]] = Field(default_factory=list)
+    artifact_refs: Dict[str, Dict[str, Any]] = Field(default_factory=dict)

nl2sql_api/models/response.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel
+from typing import Optional, List, Dict, Any
+
+class ErrorResponse(BaseModel):
+    error_code: str
+    message: str
+    details: Optional[Dict[str, Any]] = None
+
+
+class SuccessResponse(BaseModel):
+    success: bool
+    data: Optional[Dict[str, Any]] = None
+    message: Optional[str] = None

nl2sql_api/models/schema.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel
+from typing import Optional, List, Dict, Any
+
+class SchemaResponse(BaseModel):
+    datasource_id: str
+    tables: List[Dict[str, Any]]
+    relationships: List[Dict[str, Any]]
+    metadata: Optional[Dict[str, Any]] = None

nl2sql_api/routes/datasource.py

@@ -0,0 +1,57 @@
+from fastapi import APIRouter, HTTPException, Depends
+from typing import Dict, Any, Annotated
+
+from nl2sql_api.models.datasource import DatasourceRequest, DatasourceResponse
+from nl2sql_api.dependencies import get_datasource_service
+from nl2sql_api.services import DatasourceService
+
+router = APIRouter()
+
+DatasourceSvc = Annotated[DatasourceService, Depends(get_datasource_service)]
+
+
+@router.post("/datasource", response_model=DatasourceResponse)
+def add_datasource(
+    payload: DatasourceRequest,
+    service: DatasourceSvc,
+):
+    try:
+        return service.add_datasource(payload)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/datasource", response_model=Dict[str, Any])
+def list_datasources(
+    service: DatasourceSvc,
+):
+    try:
+        return {"datasources": service.list_datasources()}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/datasource/{datasource_id}", response_model=Dict[str, Any])
+def get_datasource(
+    datasource_id: str,
+    service: DatasourceSvc,
+):
+    try:
+        return service.get_datasource(datasource_id)
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/datasource/{datasource_id}", response_model=Dict[str, Any])
+def remove_datasource(
+    datasource_id: str,
+    service: DatasourceSvc,
+):
+    try:
+        return service.remove_datasource(datasource_id)
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

nl2sql_api/routes/health.py

@@ -0,0 +1,22 @@
+from fastapi import APIRouter, Depends
+from typing import Annotated
+from nl2sql_api.models.response import SuccessResponse
+from nl2sql_api.dependencies import get_health_service
+from nl2sql_api.services import HealthService
+
+router = APIRouter()
+
+HealthSvc = Annotated[HealthService, Depends(get_health_service)]
+
+@router.get("/health", response_model=SuccessResponse)
+async def health_check(
+    service: HealthSvc
+):
+    return service.health_check()
+
+
+@router.get("/ready", response_model=SuccessResponse)
+async def readiness_check(
+    service: HealthSvc,
+):
+    return service.readiness_check()

nl2sql_api/routes/indexing.py

@@ -0,0 +1,73 @@
+from fastapi import APIRouter, HTTPException, Depends
+from typing import Dict, Any, Annotated
+
+from nl2sql_api.dependencies import get_indexing_service
+from nl2sql_api.services import IndexingService
+router = APIRouter()
+
+IndexingSvc = Annotated[IndexingService, Depends(get_indexing_service)]
+
+@router.post("/index/{datasource_id}", response_model=Dict[str, Any])
+def index_datasource(
+    datasource_id: str,
+    service: IndexingSvc
+):
+    try:
+        result = service.index_datasource(datasource_id)
+
+        return {
+            "success": True,
+            "datasource_id": datasource_id,
+            "indexing_stats": result,
+            "message": f"Successfully indexed datasource '{datasource_id}'",
+        }
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to index datasource '{datasource_id}': {str(e)}",
+        )
+
+
+@router.post("/index-all", response_model=Dict[str, Any])
+def index_all_datasources(
+    service: IndexingSvc
+):
+    try:
+        results = service.index_all_datasources()
+
+        return {
+            "success": True,
+            "indexing_results": results,
+            "message": "Successfully initiated indexing for all datasources",
+        }
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to index all datasources: {str(e)}",
+        )
+
+
+@router.delete("/index", response_model=Dict[str, Any])
+def clear_index(
+    service: IndexingSvc
+):
+    try:
+        return service.clear_index()
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to clear index: {str(e)}",
+        )
+
+
+@router.get("/index/status", response_model=Dict[str, Any])
+def get_index_status(
+    service: IndexingSvc
+):
+    try:
+        return service.get_index_status()
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to get index status: {str(e)}",
+        )

nl2sql_api/routes/llm.py

@@ -0,0 +1,41 @@
+from fastapi import APIRouter, HTTPException, Depends
+from typing import Dict, Any, Annotated
+
+from nl2sql_api.models.llm import LLMRequest, LLMResponse
+from nl2sql_api.dependencies import get_llm_service
+from nl2sql_api.services import LLMService
+
+router = APIRouter()
+
+LLMSvc = Annotated[LLMService, Depends(get_llm_service)]
+
+@router.post("/llm", response_model=LLMResponse)
+def configure_llm(
+    payload: LLMRequest,
+    service: LLMSvc,
+):
+    try:
+        return service.configure_llm(payload)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/llm", response_model=Dict[str, Any])
+def list_llms(
+    service: LLMSvc,
+):
+    try:
+        return {"llms": service.list_llms()}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/llm/{llm_name}", response_model=Dict[str, Any])
+def get_llm(
+    llm_name: str,
+    service: LLMSvc,
+):
+    try:
+        return service.get_llm(llm_name)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

nl2sql_api/routes/query.py

@@ -0,0 +1,29 @@
+import logging
+
+from fastapi import APIRouter, HTTPException, Depends
+from typing import Annotated
+from nl2sql_api.models.query import QueryRequest, QueryResponse
+from nl2sql_api.dependencies import get_query_service
+from nl2sql_api.services import QueryService
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+QuerySvc = Annotated[QueryService, Depends(get_query_service)]
+
+
+# Synchronous on purpose: the pipeline performs blocking LLM and database calls,
+# so Starlette runs this handler in its threadpool instead of on the event loop.
+@router.post("/query", response_model=QueryResponse)
+def execute_query(
+    payload: QueryRequest,
+    service: QuerySvc,
+):
+    try:
+        return service.execute_query(payload)
+    except Exception:
+        # Pipeline failures are reported in QueryResponse.errors with a 200; reaching
+        # here means something genuinely unexpected broke.
+        logger.exception("Unexpected failure while executing query")
+        raise HTTPException(status_code=500, detail="Failed to execute query.")

nl2sql_api/server.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python
+"""
+NL2SQL API Startup Script
+
+This script starts the NL2SQL API server.
+"""
+
+import argparse
+import sys
+from nl2sql_api.main import app
+import uvicorn
+
+def main():
+    parser = argparse.ArgumentParser(description='NL2SQL API Server')
+    parser.add_argument('--host', default='127.0.0.1', help='Host to bind to (default: 127.0.0.1)')
+    parser.add_argument('--port', type=int, default=8000, help='Port to bind to (default: 8000)')
+    parser.add_argument('--reload', action='store_true', help='Enable auto-reload (development)')
+    
+    args = parser.parse_args()
+    
+    uvicorn.run(
+        'nl2sql_api.main:app',
+        host=args.host,
+        port=args.port,
+        reload=args.reload,
+        log_level="info"
+    )
+
+if __name__ == '__main__':
+    main()

nl2sql_api/services/__init__.py

@@ -0,0 +1,15 @@
+
+from .datasource import DatasourceService
+from .llm import LLMService
+from .health import HealthService
+from .query import QueryService
+from .indexing import IndexingService
+
+
+__all__ = [
+    "DatasourceService",
+    "LLMService",
+    "HealthService",
+    "QueryService",
+    "IndexingService"
+]

nl2sql_api/services/datasource.py

@@ -0,0 +1,43 @@
+from typing import Dict, Any, Optional
+
+from nl2sql import NL2SQL
+from nl2sql_api.models.datasource import DatasourceRequest, DatasourceResponse
+
+
+class DatasourceService:
+    def __init__(self, engine: NL2SQL):
+        self.engine = engine
+
+    def add_datasource(self, request: DatasourceRequest) -> DatasourceResponse:
+        """Add a new datasource programmatically."""
+        self.engine.add_datasource(request.config)
+        return DatasourceResponse(
+            success=True,
+            message=f"Datasource '{request.config.get('id')}' added successfully",
+            datasource_id=request.config.get('id')
+        )
+
+    def list_datasources(self) -> list:
+        """List all registered datasources."""
+        return self.engine.list_datasources()
+
+    def get_datasource(self, datasource_id: str) -> dict:
+        """Get details of a specific datasource."""
+        datasource_ids = self.engine.list_datasources()
+        if datasource_id not in datasource_ids:
+            raise ValueError(f"Datasource '{datasource_id}' not found")
+        
+        # In a real implementation, we would return detailed information about the datasource
+        return {"datasource_id": datasource_id, "exists": True}
+
+    def remove_datasource(self, datasource_id: str) -> dict:
+        """Remove a datasource (not directly supported by the engine, but could be implemented)."""
+        datasource_ids = self.engine.list_datasources()
+        if datasource_id not in datasource_ids:
+            raise ValueError(f"Datasource '{datasource_id}' not found")
+        
+        return {
+            "success": False,
+            "message": "Removing datasources is not currently supported by the engine",
+            "datasource_id": datasource_id
+        }

nl2sql_api/services/health.py

@@ -0,0 +1,22 @@
+from typing import Dict, Any, Optional
+from nl2sql import NL2SQL
+
+
+class HealthService:
+    def __init__(self, engine: NL2SQL):
+        self.engine = engine
+
+    def health_check(self) -> dict:
+        """Perform health check."""
+        return {
+            "success": True,
+            "message": "NL2SQL API is running"
+        }
+
+    def readiness_check(self) -> dict:
+        """Perform readiness check."""
+        # Add actual readiness checks (database connections, etc.)
+        return {
+            "success": True,
+            "message": "NL2SQL API is ready"
+        }

nl2sql_api/services/indexing.py

@@ -0,0 +1,30 @@
+from typing import Dict, Any, Optional
+from nl2sql import NL2SQL
+
+
+class IndexingService:
+    def __init__(self, engine: NL2SQL):
+        self.engine = engine
+
+    def index_datasource(self, datasource_id: str) -> Dict[str, int]:
+        """Index schema for a specific datasource."""
+        return self.engine.indexing.index_datasource(datasource_id)
+
+    def index_all_datasources(self) -> Dict[str, Dict[str, int]]:
+        """Index schema for all registered datasources."""
+        return self.engine.indexing.index_all_datasources()
+
+    def clear_index(self) -> None:
+        """Clear the vector store index."""
+        self.engine.indexing.clear_index()
+        return {"success": True, "message": "Index cleared successfully"}
+
+    def get_index_status(self) -> Dict[str, Any]:
+        """Get the status of the index."""
+        # This would typically return information about the vector store
+        # For now, we'll return a placeholder
+        return {
+            "status": "operational",
+            "indexed_datasources": self.engine.list_datasources(),
+            "total_indexes": len(self.engine.list_datasources())  # Placeholder
+        }

nl2sql_api/services/llm.py

@@ -0,0 +1,25 @@
+from typing import Dict, Any, Optional
+from nl2sql import NL2SQL
+from nl2sql_api.models.llm import LLMRequest, LLMResponse
+
+
+class LLMService:
+    def __init__(self, engine: NL2SQL):
+        self.engine = engine
+
+    def configure_llm(self, request: LLMRequest) -> LLMResponse:
+        """Configure an LLM programmatically."""
+        self.engine.configure_llm(request.config)
+        return LLMResponse(
+            success=True,
+            message=f"LLM '{request.config.get('name', 'default')}' configured successfully",
+            llm_name=request.config.get('name', 'default')
+        )
+
+    def list_llms(self) -> list:
+        """List all configured LLMs."""
+        return self.engine.list_llms()
+
+    def get_llm(self, llm_name: str) -> dict:
+        """Get details of a specific LLM."""
+        return self.engine.get_llm(llm_name)

nl2sql_api/services/query.py

@@ -0,0 +1,34 @@
+from nl2sql import NL2SQL
+from nl2sql_api.models.query import QueryRequest, QueryResponse
+from nl2sql.auth.models import UserContext
+
+
+class QueryService:
+    def __init__(self, engine: NL2SQL):
+        self.engine = engine
+
+    def execute_query(self, request: QueryRequest) -> QueryResponse:
+        # Convert user_context if provided
+        user_context = None
+        if request.user_context:
+            user_context = UserContext(**request.user_context)
+
+        result = self.engine.run_query(
+            request.natural_language,
+            datasource_id=request.datasource_id,
+            execute=request.execute,
+            user_context=user_context,
+        )
+
+        return QueryResponse(
+            sub_queries=[sub_query.model_dump() for sub_query in result.sub_queries],
+            final_answer=result.final_answer,
+            errors=result.errors,
+            trace_id=result.trace_id,
+            reasoning=result.reasoning,
+            warnings=result.warnings,
+            artifact_refs={
+                node_id: ref.model_dump(mode="json")
+                for node_id, ref in result.artifact_refs.items()
+            },
+        )

nl2sql_api-0.1.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: nl2sql-api
+Version: 0.1.0
+Summary: API layer for NL2SQL engine
+Requires-Python: >=3.9
+Requires-Dist: nl2sql-engine~=0.1
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: uvicorn>=0.20.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: python-multipart>=0.0.6
+Requires-Dist: python-dotenv>=1.0.0

nl2sql_api-0.1.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+nl2sql_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nl2sql_api/dependencies.py,sha256=Vob6_ylRqX7A9mtLAk6P6C-dYaVj-sD6x_bgT1g7650,890
+nl2sql_api/main.py,sha256=zqD6eVoBxuhLpb-KIaW8czwyu24EXLaIrMWrcQwXRkY,1287
+nl2sql_api/server.py,sha256=spmORkrbdnRT5F0ayW5JqE60xaAEGItS-f_GYGvjzjc,787
+nl2sql_api/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nl2sql_api/models/datasource.py,sha256=05fWM3Oo3m86NsjwCU1fCyIVDRA6xU-WT2ayGwRO0us,247
+nl2sql_api/models/llm.py,sha256=8WEtUg0vkW7v3fzsuMhhcUvHjrCrc0tH0Hy36devAhk,228
+nl2sql_api/models/query.py,sha256=k2lC35rYLBJgz66QELc5kRW2N8LazQb89qIVbmqKNQA,1106
+nl2sql_api/models/response.py,sha256=unon5gOq3FeLKULMNjgP5dmy3b_eF9b9EybuhbL4MBU,320
+nl2sql_api/models/schema.py,sha256=9npDcphba7ZZ19d11wQKv6iNcwBwuedrBNleNi5aejE,251
+nl2sql_api/routes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nl2sql_api/routes/datasource.py,sha256=MCOwfA9xAr2CIoVJ5QFu3gdRr6TghLcFYWoHFEGHcq4,1728
+nl2sql_api/routes/health.py,sha256=KzcYxGZvvi-Bt_Ltl2Z8vmQ9ycrbiy3_AAxflm6tkqk,600
+nl2sql_api/routes/indexing.py,sha256=_UwxBZrGh66yMrWVtq2qQvfS3gAOgXm_S8y11mxu6-8,2021
+nl2sql_api/routes/llm.py,sha256=t4sKlQpkHE1JRH_J1NFyEwBUbXbRFoNWxkPdGA0Cyis,1078
+nl2sql_api/routes/query.py,sha256=lkeX8vlOTc7ULsqdm7K0TAG-AVSAINf6hUz9I0MOGk4,1046
+nl2sql_api/services/__init__.py,sha256=wai2Xe8XI6FIbEqrfwQD2Ghm19YuGM0l1xzzgAjT9IM,296
+nl2sql_api/services/datasource.py,sha256=XHioCMbZw0YDnFzYYxSSXd7R-T6ObQf6t0SZP510qx8,1753
+nl2sql_api/services/health.py,sha256=hmv4IN4HqXqJXRHbdYuQdPnwUYUJ84Shdsa6-4CsTqY,579
+nl2sql_api/services/indexing.py,sha256=TCqJFNqtO4RNsyFTfcmgVoH6FODsOer6bQTWdD1zVKs,1158
+nl2sql_api/services/llm.py,sha256=U4GmHI4Np2kuELEqYS1xI0lnApYRY2x8Nw8C9-mo-W8,843
+nl2sql_api/services/query.py,sha256=tk-RowcxnOKQxd6JAVuvaiuyAc_PkgLBaOpbBxjqnGU,1159
+nl2sql_api-0.1.0.dist-info/METADATA,sha256=8hV-DfQ_fV4p0dxtIqceb4JDzh6AGKafe2cvx1xZywI,315
+nl2sql_api-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+nl2sql_api-0.1.0.dist-info/entry_points.txt,sha256=p5MLHkru6-8adKBwwpySsJgAsEvKHF8LDedWdw9w23M,54
+nl2sql_api-0.1.0.dist-info/top_level.txt,sha256=c_OEDdzXMoZTtOaZS8l4qKaNF0Cz5AesYzLye2pOSvA,11
+nl2sql_api-0.1.0.dist-info/RECORD,,

nl2sql_api-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nl2sql_api-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nl2sql-api = nl2sql_api.server:main

nl2sql_api-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+nl2sql_api