sqlalchemy-studio 0.1.0__py3-none-any.whl

sqlalchemy_studio-0.1.0.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: sqlalchemy-studio
+Version: 0.1.0
+Summary: Add your description here
+Author-email: Xursand Qarlibayev <coderxuz2009@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/coderxuz/sqlalchemy-studio
+Project-URL: Source, https://github.com/coderxuz/sqlalchemy-studio
+Keywords: sqlalchemy,database,inspector,studio
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: build>=1.5.0
+Requires-Dist: fastapi>=0.136.3
+Requires-Dist: sqlalchemy>=2.0.50
+Requires-Dist: twine>=6.2.0
+Requires-Dist: uvicorn>=0.48.0
+
+# sqlalchemy-studio-backend
+
+Backend utilities for inspecting and serving database tables via a FastAPI `Studio`.
+
+This package exposes a small FastAPI app that can be embedded in your application or run
+standalone to inspect a SQLAlchemy-accessible database.
+
+Quick summary
+- API endpoints (when using the packaged server):
+	- `GET /api/tables` — list tables and columns
+	- `GET /api/tables/{name}` — describe a single table
+	- `POST /api/{table_name}/query` — run the UI's advanced query payload
+
+Install
+
+```
+pip install sqlalchemy-studio-backend
+```
+
+Or install from the repository for development/testing:
+
+```
+pip install --upgrade git+https://github.com/yourusername/sqlalchemy-studio.git@main#subdirectory=sqlalchemy-studio-backend
+```
+
+Quickstart
+
+```py
+from sqlalchemy import create_engine
+from sqlalchemy.orm import declarative_base
+from db.main import Studio
+
+Base = declarative_base()
+engine = create_engine("sqlite:///test.db")
+
+studio = Studio(engine, Base)
+# Starts uvicorn and serves API under /api
+studio.run(port=9000)
+# API available at http://localhost:9000/api
+```
+
+Serving a built frontend (optional)
+
+If you build the Vite frontend, copy its `dist` output into the backend `static` folder
+and the backend will serve the SPA from `/` while keeping the API under `/api`.
+
+Example:
+
+```bash
+# from repository root
+npm --prefix sqlalchemy-studio-front install
+npm --prefix sqlalchemy-studio-front run build
+rm -rf sqlalchemy-studio-backend/static
+mkdir -p sqlalchemy-studio-backend/static
+cp -r sqlalchemy-studio-front/dist/* sqlalchemy-studio-backend/static/
+```
+
+Configuration notes
+- By default the package mounts static files at `/` and prefixes API routes with `/api` to
+	avoid SPA route collisions. Adjust `db/main.py` if you need a different layout.
+- CORS: `Studio` registers a small set of development origins. When serving the SPA
+	from the same server you won't need CORS; keep/update `Studio._set_cors` for other setups.
+
+Publishing
+
+1. Build the distribution locally:
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+```
+
+2. Upload to PyPI (CI should set `PYPI_API_TOKEN`):
+
+```bash
+python -m twine upload dist/*
+```
+
+License
+MIT — update as appropriate.

sqlalchemy_studio-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+studio/Studio.py,sha256=12CFpZmNoWL0P0-fh3DuSbpfmBbOv24wFY1Cy0pV9UE,7832
+studio/__init__.py,sha256=cqNNSMf6N4vlXjnzC_Izcja2h7wETpUoQlO4sLtN4u4,33
+studio/backend.py,sha256=VHIGezDrkvGnPWsfH-szug2-dkYBmJLcheTUwDcgO9k,1814
+sqlalchemy_studio-0.1.0.dist-info/METADATA,sha256=veS9ZqdEm0hyN3f_4veL8ni6ZXRT2lZZvoRLoXUcxiw,3077
+sqlalchemy_studio-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+sqlalchemy_studio-0.1.0.dist-info/top_level.txt,sha256=ZizOFiNZ7-jB61UbqOKLnpCYVrdXYlDLrGmFz16x1rs,7
+sqlalchemy_studio-0.1.0.dist-info/RECORD,,

sqlalchemy_studio-0.1.0.dist-info/WHEEL

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

sqlalchemy_studio-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+studio

studio/Studio.py

@@ -0,0 +1,232 @@
+from sqlalchemy import and_, create_engine, func, inspect, Engine, or_, select, Table
+from sqlalchemy.engine.interfaces import ReflectedColumn
+from sqlalchemy.orm import DeclarativeBase
+from fastapi import FastAPI, HTTPException, status
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+import uvicorn
+
+
+from studio .backend import create_tables_router
+
+from typing import Self, TypedDict, Any, cast, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from studio.backend import FilterRequest
+
+engine = create_engine("sqlite:///test.db")
+
+
+class TablesType(TypedDict):
+    table: str
+    columns: list[dict]
+
+
+class ColumnDetails(TypedDict):
+    name: str
+    type: str
+    nullable: bool
+    default: Any
+    primary_key: bool
+
+
+class SingleTableType(TypedDict):
+    table: str
+    primary_keys: list[str]
+    columns: list[ColumnDetails]
+
+
+class GetRowsResponse(TypedDict):
+    rows: list[dict[str, Any]]
+    total_count: int
+
+
+class Studio:
+    def __init__(self: Self, engine: Engine, base: DeclarativeBase) -> None:
+        self.engine = engine
+        self.inspector = inspect(self.engine)
+        self.app = FastAPI()
+        self._register_routes()
+        # Serve built frontend from the `static` directory at the project root.
+        # Keep this catch-all mount after API routes so `/api/*` resolves first.
+        
+        self._set_cors()
+        self.base = base
+
+    def _set_cors(self):
+        origins = [
+            "http://localhost:5500",
+            "http://localhost:5173",
+            "http://localhost:8000",
+            "http://localhost:3000",
+        ]
+        self.app.add_middleware(
+            CORSMiddleware,
+            allow_origins=origins,
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+
+    def _register_routes(self):
+        self.app.include_router(create_tables_router(self))
+        self.app.mount("/", StaticFiles(directory="./studio/static", html=True), name="static")
+
+    def run(self, port: int = 8000):
+        print("-"*50)
+        print("-"*50)
+        print(f"link:http://localhost:{port}")
+        print("-"*50)
+        print("-"*50)
+        uvicorn.run(self.app, host="0.0.0.0", port=port)
+
+    def show_tables(self: Self) -> list[TablesType]:
+
+        tables_list: list[TablesType] = []
+        tables = self.inspector.get_table_names()
+        for table in tables:
+            tables_list.append(
+                {
+                    "table": table,
+                    "columns": [
+                        {
+                            **c,
+                            "type": str(c["type"]),
+                        }
+                        for c in self.inspector.get_columns(table)
+                    ],
+                }
+            )
+        return tables_list
+
+    def show_table(self: Self, table_name: str) -> SingleTableType:
+        """
+        Returns the structural data (columns, types, primary keys)
+        for a single specified table with strict typing for MyPy.
+        """
+        # 1. Check if the table exists
+        if not self.inspector.has_table(table_name):
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Table '{table_name}' not found.",
+            )
+
+        # 2. Reflect the table (keeps metadata clean/extended)
+        Table(
+            table_name,
+            self.base.metadata,
+            autoload_with=self.engine,
+            extend_existing=True,
+        )
+
+        # 3. Extract primary key details safely
+        pk_constraint = self.inspector.get_pk_constraint(table_name) or {}
+        # MyPy needs to know this evaluates cleanly to a list of strings
+        primary_keys = cast(list[str], pk_constraint.get("constrained_columns", []))
+        # 4. Extract and type-cast column information
+        columns_data: list[ColumnDetails] = []
+
+        # self.inspector.get_columns returns a list of dictionaries
+        raw_columns = self.inspector.get_columns(table_name)
+
+        for col in raw_columns:
+            columns_data.append(
+                {
+                    "name": cast(str, col["name"]),
+                    "type": str(col["type"]),  # Stringify the type object for JSON
+                    "nullable": bool(col["nullable"]),
+                    "default": col.get("default"),
+                    "primary_key": col.get("primary_key", 0) > 0,
+                }
+            )
+
+        # 5. Construct the final strictly typed response
+        response_data: SingleTableType = {
+            "table": table_name,
+            "primary_keys": primary_keys,
+            "columns": columns_data,
+        }
+
+        return response_data
+
+    def get_rows_advanced(
+        self: Self, table_name: str, payload: "FilterRequest"
+    ) -> GetRowsResponse:
+        """
+        Advanced filtering using logical operator trees matching custom UI filters.
+        """
+        if not self.inspector.has_table(table_name):
+            raise HTTPException(
+                status_code=404, detail=f"Table '{table_name}' not found."
+            )
+
+        table = Table(
+            table_name,
+            self.base.metadata,
+            autoload_with=self.engine,
+            extend_existing=True,
+        )
+
+        rows_query = select(table)
+        count_query = select(func.count()).select_from(table)
+
+        # Build dynamic expressions clauses
+        if payload.filters:
+            conditions = []
+
+            for cond in payload.filters:
+                if cond.column not in table.c:
+                    continue  # Guard against non-existent columns safely
+
+                col = table.c[cond.column]
+                val = cond.value
+
+                # Map string operators to SQLAlchemy expressions
+                if cond.operator == "equals":
+                    expr = col == val
+                elif cond.operator == "not_equals":
+                    expr = col != val
+                elif cond.operator == "contains":
+                    expr = col.ilike(f"%{val}%")
+                elif cond.operator == "starts_with":
+                    expr = col.ilike(f"{val}%")
+                elif cond.operator == "ends_with":
+                    expr = col.ilike(f"%{val}")
+                elif cond.operator == "greater_than":
+                    expr = col > val
+                elif cond.operator == "less_than":
+                    expr = col < val
+                elif cond.operator == "greater_than_or_equals":
+                    expr = col >= val
+                elif cond.operator == "less_than_or_equals":
+                    expr = col <= val
+                else:
+                    continue
+
+                # Combine them based on the link field ('and' / 'or')
+                if not conditions:
+                    conditions.append(expr)
+                else:
+                    if cond.link == "or":
+                        # Merge last expression with current one via OR
+                        prev_expr = conditions.pop()
+                        conditions.append(or_(prev_expr, expr))
+                    else:
+                        # Default to AND chaining
+                        prev_expr = conditions.pop()
+                        conditions.append(and_(prev_expr, expr))
+
+            if conditions:
+                rows_query = rows_query.where(*conditions)
+                count_query = count_query.where(*conditions)
+
+        # Apply Pagination
+        rows_query = rows_query.limit(payload.limit).offset(payload.offset)
+
+        # Execute
+        with self.engine.connect() as connection:
+            total = int(connection.execute(count_query).scalar_one())
+            result = connection.execute(rows_query)
+            rows = [dict(row) for row in result.mappings()]
+
+        return {"rows": rows, "total_count": total}

studio/__init__.py

@@ -0,0 +1 @@
+from studio.Studio import Studio

studio/backend.py

@@ -0,0 +1,68 @@
+from fastapi import APIRouter, Query, HTTPException,status
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from backend.Studio import Studio
+
+from typing import Any, Literal, Self, TypedDict
+from pydantic import BaseModel, Field
+
+# Define acceptable operators matching your UI
+OperatorType = Literal[
+    "equals",
+    "not_equals",
+    "contains",
+    "starts_with",
+    "ends_with",
+    "greater_than",
+    "less_than",
+    "greater_than_or_equals",
+    "less_than_or_equals",
+]
+LinkType = Literal["and", "or"]
+
+
+class FilterCondition(BaseModel):
+    column: str
+    operator: OperatorType
+    value: Any
+    link: LinkType = "and"  # Connects this condition to the previous one
+
+
+class FilterRequest(BaseModel):
+    limit: int = Field(default=10, ge=1)
+    offset: int = Field(default=0, ge=0)
+    filters: list[FilterCondition] = Field(default_factory=list)
+
+
+def create_tables_router(studio: "Studio"):
+    router = APIRouter()
+
+    @router.get("/api/tables")
+    def get_tables():
+        return studio.show_tables()
+
+    @router.get("/api/tables/{name}")
+    def get_tables(name: str):
+        return studio.show_table(name)
+
+    @router.post("/api/{table_name}/query")
+    async def query_table_rows(
+        table_name: str,
+        payload: FilterRequest
+    ) -> Any:
+        """
+        Exposes advanced database table operations to handle compound UI filters.
+        """
+        try:
+            # Assuming `studio` is accessible in your router scope
+            return studio.get_rows_advanced(table_name, payload)
+        except HTTPException as e:
+            raise e
+        except Exception as e:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail=f"Query builder failed: {str(e)}"
+            )
+    return router