n6k 0.1.0__py3-none-any.whl

n6k-0.1.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: n6k
+Version: 0.1.0
+Summary: Arrow/Parquet REST server
+Requires-Python: >=3.12
+Requires-Dist: fastapi>=0.115
+Requires-Dist: pandas>=2
+Requires-Dist: pyarrow>=19
+Requires-Dist: uvicorn[standard]>=0.34

n6k-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+n6k_server/__init__.py,sha256=cRelU0AvkI-kzoA58FvX3TuuEF6cOfJovIL28Qvgmik,44
+n6k_server/app.py,sha256=Gg5lTHEAngRpwX1GyQmk12c8ge42-8mnbfE8EoiWdK4,1296
+n6k_server/formats.py,sha256=O9BFNyoYRB7kBohuFL7Sg_LbV7zF3bZ9CBE98y1Pomk,1635
+n6k_server/pushdown.py,sha256=2Mme6B6GTs8t1gDGWjjrwaPu9L8iau3AkjRFzl6n0NY,1793
+n6k_server/routes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+n6k_server/routes/tables.py,sha256=DKVHtsoCYBIj3HwFxGF5Nd4G7j3h2Yy91D6wmAC7bbw,1827
+n6k-0.1.0.dist-info/METADATA,sha256=g2qVb5btgxr0Zx3OanTT7MFXSAD1vGbHui5QKMrXETk,227
+n6k-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+n6k-0.1.0.dist-info/RECORD,,

n6k-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

n6k_server/__init__.py

@@ -0,0 +1 @@
+from n6k_server.app import create_app, data

n6k_server/app.py

@@ -0,0 +1,44 @@
+import pandas as pd
+import pyarrow as pa
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from starlette.exceptions import HTTPException as StarletteHTTPException
+from starlette.responses import PlainTextResponse
+
+from n6k_server.routes import tables
+
+
+def create_app() -> FastAPI:
+    application = FastAPI()
+    application.state.data_sources = {}
+
+    application.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    @application.exception_handler(StarletteHTTPException)
+    async def http_exception_handler(
+        request: Request, exc: StarletteHTTPException
+    ) -> PlainTextResponse:
+        return PlainTextResponse(exc.detail, status_code=exc.status_code)
+
+    @application.exception_handler(Exception)
+    async def plain_text_exception_handler(
+        request: Request, exc: Exception
+    ) -> PlainTextResponse:
+        status = getattr(exc, "status_code", 500)
+        return PlainTextResponse(str(exc), status_code=status)
+
+    application.include_router(tables.router, prefix="/tables")
+
+    return application
+
+
+def data(app: FastAPI, name: str):
+    def decorator(fn):
+        app.state.data_sources[name] = fn
+        return fn
+    return decorator

n6k_server/formats.py

@@ -0,0 +1,58 @@
+from enum import StrEnum
+from io import BytesIO
+
+import pyarrow as pa
+import pyarrow.ipc as ipc
+import pyarrow.parquet as pq
+from starlette.requests import Request
+from starlette.responses import Response
+
+
+class ArrowFormat(StrEnum):
+    IPC_STREAM = "application/vnd.apache.arrow.stream"
+    IPC_FILE = "application/vnd.apache.arrow.file"
+    PARQUET = "application/x-parquet"
+
+
+_ACCEPT_MAP: dict[str, ArrowFormat] = {f.value: f for f in ArrowFormat}
+
+
+def negotiate(request: Request) -> ArrowFormat:
+    accept = request.headers.get("accept", "")
+    for media_type in accept.split(","):
+        key = media_type.strip().split(";")[0].strip()
+        if key in _ACCEPT_MAP:
+            return _ACCEPT_MAP[key]
+    return ArrowFormat.IPC_STREAM
+
+
+def _serialize_ipc_stream(table: pa.Table) -> bytes:
+    sink = pa.BufferOutputStream()
+    with ipc.new_stream(sink, table.schema) as writer:
+        writer.write_table(table)
+    return sink.getvalue().to_pybytes()
+
+
+def _serialize_ipc_file(table: pa.Table) -> bytes:
+    sink = pa.BufferOutputStream()
+    with ipc.new_file(sink, table.schema) as writer:
+        writer.write_table(table)
+    return sink.getvalue().to_pybytes()
+
+
+def _serialize_parquet(table: pa.Table) -> bytes:
+    buf = BytesIO()
+    pq.write_table(table, buf)
+    return buf.getvalue()
+
+
+_SERIALIZERS = {
+    ArrowFormat.IPC_STREAM: _serialize_ipc_stream,
+    ArrowFormat.IPC_FILE: _serialize_ipc_file,
+    ArrowFormat.PARQUET: _serialize_parquet,
+}
+
+
+def arrow_response(table: pa.Table, fmt: ArrowFormat) -> Response:
+    body = _SERIALIZERS[fmt](table)
+    return Response(content=body, media_type=fmt.value)

n6k_server/pushdown.py

@@ -0,0 +1,70 @@
+import json
+
+import pyarrow as pa
+import pyarrow.compute as pc
+
+
+def apply_columns(table: pa.Table, columns_param: str | None) -> pa.Table:
+    if not columns_param:
+        return table
+    names = [c.strip() for c in columns_param.split(",") if c.strip()]
+    valid = [n for n in names if n in table.schema.names]
+    if not valid:
+        return table
+    return table.select(valid)
+
+
+_OPS = {
+    "=": pc.equal,
+    "!=": pc.not_equal,
+    ">": pc.greater,
+    ">=": pc.greater_equal,
+    "<": pc.less,
+    "<=": pc.less_equal,
+}
+
+
+def apply_filters(table: pa.Table, filters_param: str | None) -> pa.Table:
+    if not filters_param:
+        return table
+    try:
+        predicates = json.loads(filters_param)
+    except (json.JSONDecodeError, TypeError):
+        return table
+    if not isinstance(predicates, list):
+        return table
+
+    mask: pa.ChunkedArray | None = None
+
+    for pred in predicates:
+        if not isinstance(pred, dict):
+            continue
+        col = pred.get("col")
+        op = pred.get("op")
+        if col not in table.schema.names or op is None:
+            continue
+
+        column = table.column(col)
+
+        if op == "is_null":
+            m = pc.is_null(column)
+        elif op == "is_not_null":
+            m = pc.is_valid(column)
+        elif op == "in":
+            value = pred.get("value")
+            if not isinstance(value, list):
+                continue
+            m = pc.is_in(column, pa.array(value))
+        elif op in _OPS:
+            value = pred.get("value")
+            if value is None:
+                continue
+            m = _OPS[op](column, pa.scalar(value))
+        else:
+            continue
+
+        mask = m if mask is None else pc.and_(mask, m)
+
+    if mask is None:
+        return table
+    return table.filter(mask)

n6k_server/routes/tables.py

@@ -0,0 +1,47 @@
+import pandas as pd
+import pyarrow as pa
+from fastapi import APIRouter, Request
+from starlette.responses import Response
+
+from n6k_server.formats import arrow_response, negotiate
+from n6k_server.pushdown import apply_columns, apply_filters
+
+router = APIRouter()
+
+
+@router.get("/")
+async def list_tables(request: Request) -> Response:
+    names = list(request.app.state.data_sources.keys())
+    table = pa.table({
+        "name": pa.array(names, type=pa.utf8()),
+        "path": pa.array([f"/tables/{n}" for n in names], type=pa.utf8()),
+        "schema_path": pa.array([f"/tables/{n}/_schema" for n in names], type=pa.utf8()),
+    })
+    return arrow_response(table, negotiate(request))
+
+
+@router.get("/{name}")
+async def get_table(name: str, request: Request, columns: str | None = None, filters: str | None = None) -> Response:
+    fn = request.app.state.data_sources.get(name)
+    if fn is None:
+        return Response(content=f"table not found: {name}", status_code=404)
+    df = fn()
+    if not isinstance(df, pd.DataFrame):
+        raise TypeError(f"data source '{name}' must return a DataFrame, got {type(df).__name__}")
+    table = pa.Table.from_pandas(df)
+    table = apply_filters(table, filters)
+    table = apply_columns(table, columns)
+    return arrow_response(table, negotiate(request))
+
+
+@router.get("/{name}/_schema")
+async def get_schema(name: str, request: Request) -> Response:
+    fn = request.app.state.data_sources.get(name)
+    if fn is None:
+        return Response(content=f"table not found: {name}", status_code=404)
+    df = fn()
+    if not isinstance(df, pd.DataFrame):
+        raise TypeError(f"data source '{name}' must return a DataFrame, got {type(df).__name__}")
+    table = pa.Table.from_pandas(df)
+    empty = table.schema.empty_table()
+    return arrow_response(empty, negotiate(request))