auto-rest-api 0.1.4__tar.gz → 0.1.6__tar.gz

{auto_rest_api-0.1.4 → auto_rest_api-0.1.6}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.3
 Name: auto-rest-api
-Version: 0.1.4
+Version: 0.1.6
 Summary: Automatically map database schemas and deploy per-table REST API endpoints.
 License: GPL-3.0-only
 Keywords: Better,HPC,automatic,rest,api
 Author: Better HPC LLC
-Requires-Python: >=3.11
+Requires-Python: >=3.11,<4
 Classifier: Environment :: Web Environment
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
@@ -21,7 +21,9 @@ Classifier: Typing :: Typed
 Requires-Dist: aiomysql (>=0.2,<1.0)
 Requires-Dist: aioodbc (>=0.5,<1.0)
 Requires-Dist: aiosqlite (>=0.20,<1.0)
+Requires-Dist: asgi-correlation-id (>=4.3.4,<5.0.0)
 Requires-Dist: asyncpg (>=0.30,<1.0)
+Requires-Dist: colorlog (>=6.9.0,<7.0.0)
 Requires-Dist: fastapi (>=0.115,<1.0)
 Requires-Dist: greenlet (>=3.1,<4.0)
 Requires-Dist: httpx (>=0.28,<1.0)

{auto_rest_api-0.1.4 → auto_rest_api-0.1.6}/auto_rest/__main__.py

@@ -9,7 +9,7 @@ from .routers import *
 
 __all__ = ["main", "run_application"]
 
-logger = logging.getLogger("auto-rest")
+logger = logging.getLogger("auto_rest")
 
 
 def main() -> None:  # pragma: no cover

{auto_rest_api-0.1.4 → auto_rest_api-0.1.6}/auto_rest/app.py

@@ -15,19 +15,21 @@ deploying Fast-API applications.
 """
 
 import logging
+from http import HTTPStatus
 
 import uvicorn
+from asgi_correlation_id import CorrelationIdMiddleware
 from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from starlette.responses import Response
 
 __all__ = ["create_app", "run_server"]
 
-logger = logging.getLogger("auto-rest")
+logger = logging.getLogger("auto_rest.access")
 
 
 async def logging_middleware(request: Request, call_next: callable) -> Response:
-    """FastAPI middleware for the logging response status codes.
+    """FastAPI middleware for logging response status codes.
 
     Args:
         request: The incoming HTTP request.
@@ -37,9 +39,30 @@ async def logging_middleware(request: Request, call_next: callable) -> Response:
         The outgoing HTTP response.
     """
 
-    response = await call_next(request)
-    level = logging.INFO if response.status_code < 400 else logging.ERROR
-    logger.log(level, f"{request.method} ({response.status_code}) {request.client.host} - {request.url.path}")
+    # Extract metadata from the request
+    request_meta = {
+        "ip": request.client.host,
+        "port": request.client.port,
+        "method": request.method,
+        "endpoint": request.url.path,
+    }
+
+    if request.url.query:
+        request_meta["endpoint"] += "?" + request.url.query
+
+    # Execute handling logic
+    try:
+        response = await call_next(request)
+
+    except Exception as exc:
+        logger.error(str(exec), exc_info=exc, extra=request_meta)
+        raise
+
+    # Log the outgoing response
+    status = HTTPStatus(response.status_code)
+    level = logging.INFO if status < 400 else logging.ERROR
+    logger.log(level, f"{status} {status.phrase}", extra=request_meta)
+
     return response
 
 
@@ -66,6 +89,7 @@ def create_app(app_title: str, app_version: str) -> FastAPI:
     )
 
     app.middleware("http")(logging_middleware)
+    app.add_middleware(CorrelationIdMiddleware)
     app.add_middleware(
         CORSMiddleware,
         allow_credentials=True,

{auto_rest_api-0.1.4 → auto_rest_api-0.1.6}/auto_rest/cli.py

@@ -31,13 +31,11 @@ Python `logging` library.
 """
 
 import importlib.metadata
-import logging
+import logging.config
 from argparse import ArgumentParser, HelpFormatter
 from pathlib import Path
 
-from uvicorn.logging import DefaultFormatter
-
-__all__ = ["VERSION", "configure_cli_logging", "create_cli_parser"]
+__all__ = ["configure_cli_logging", "create_cli_parser", "VERSION"]
 
 VERSION = importlib.metadata.version("auto-rest-api")
 
@@ -49,7 +47,7 @@ def configure_cli_logging(level: str) -> None:
     logging configurations.
 
     Args:
-        level: The Python logging level.
+        level: The Python logging level (e.g., "DEBUG", "INFO", etc.).
     """
 
     # Normalize and validate the logging level.
@@ -57,17 +55,57 @@ def configure_cli_logging(level: str) -> None:
     if level not in ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"):
         raise ValueError(f"Invalid logging level: {level}")
 
-    # Set up logging with a stream handler.
-    handler = logging.StreamHandler()
-    handler.setFormatter(DefaultFormatter(fmt="%(levelprefix)s %(message)s"))
-    logging.basicConfig(
-        force=True,
-        format="%(levelprefix)s %(message)s",
-        handlers=[handler],
-    )
-
-    logging.getLogger("auto-rest").setLevel(level)
-    logging.getLogger("sqlalchemy").setLevel(1000)
+    msg_prefix = "%(log_color)s%(levelname)-8s%(reset)s (%(asctime)s) [%(correlation_id)s] "
+    logging.config.dictConfig({
+        "version": 1,
+        "disable_existing_loggers": True,
+        "filters": {
+            "correlation_id": {
+                "()": "asgi_correlation_id.CorrelationIdFilter",
+                "uuid_length": 8,
+                "default_value": "-" * 8
+            },
+        },
+        "formatters": {
+            "app": {
+                "()": "colorlog.ColoredFormatter",
+                "format": msg_prefix + "%(message)s",
+            },
+            "access": {
+                "()": "colorlog.ColoredFormatter",
+                "format": msg_prefix + "%(ip)s:%(port)s - %(method)s %(endpoint)s - %(message)s",
+            }
+        },
+        "handlers": {
+            "app": {
+                "class": "colorlog.StreamHandler",
+                "formatter": "app",
+                "filters": ["correlation_id"],
+            },
+            "access": {
+                "class": "colorlog.StreamHandler",
+                "formatter": "access",
+                "filters": ["correlation_id"],
+            }
+        },
+        "loggers": {
+            "auto_rest": {
+                "handlers": ["app"],
+                "level": level,
+                "propagate": False
+            },
+            "auto_rest.access": {
+                "handlers": ["access"],
+                "level": level,
+                "propagate": False
+            },
+            "auto_rest.query": {
+                "handlers": ["app"],
+                "level": level,
+                "propagate": False
+            }
+        }
+    })
 
 
 def create_cli_parser(exit_on_error: bool = True) -> ArgumentParser:

{auto_rest_api-0.1.4 → auto_rest_api-0.1.6}/auto_rest/handlers.py

@@ -50,13 +50,12 @@ This makes it easy to incorporate handlers into a FastAPI application.
     should always be tested within the context of a FastAPI application.
 """
 
-import logging
 from typing import Awaitable, Callable, Literal, Optional
 
 from fastapi import Depends, Query, Response
 from pydantic import create_model
 from pydantic.main import BaseModel as PydanticModel
-from sqlalchemy import insert, MetaData, select, Table
+from sqlalchemy import asc, desc, func, insert, MetaData, select, Table
 
 from .interfaces import *
 from .models import *
@@ -75,8 +74,6 @@ __all__ = [
     "create_welcome_handler",
 ]
 
-logger = logging.getLogger("auto-rest")
-
 
 def create_welcome_handler() -> Callable[[], Awaitable[PydanticModel]]:
     """Create an endpoint handler that returns an application welcome message.
@@ -192,32 +189,54 @@ def create_list_records_handler(engine: DBEngine, table: Table) -> Callable[...,
 
     interface = create_interface(table)
     interface_opt = create_interface(table, mode="optional")
-    columns = tuple(table.columns.keys())
+    col_names = tuple(table.columns.keys())
 
     async def list_records_handler(
         response: Response,
         session: DBSession = Depends(create_session_iterator(engine)),
+        filters: interface_opt = Depends(),
         _limit_: int = Query(0, ge=0, description="The maximum number of records to return."),
         _offset_: int = Query(0, ge=0, description="The starting index of the returned records."),
-        _order_by_: Optional[Literal[*columns]] = Query(None, description="The field name to sort by."),
-        _direction_: Literal["asc", "desc"] = Query("asc", description="Sort results in 'asc' or 'desc' order.")
+        _order_by_: Optional[Literal[*col_names]] = Query(None, description="The field name to sort by."),
+        _direction_: Literal["asc", "desc"] = Query("asc", description="Sort results in 'asc' or 'desc' order."),
     ) -> list[interface]:
         """Fetch a list of records from the database.
 
         URL query parameters are used to enable filtering, ordering, and paginating returned values.
         """
 
-        response.headers["X-Pagination-Limit"] = str(_limit_)
-        response.headers["X-Pagination-Offset"] = str(_offset_)
-        response.headers["X-Order-By"] = str(_order_by_)
-        response.headers["X-Order-Direction"] = str(_direction_)
-
         query = select(table)
-        query = apply_pagination_params(query, _limit_, _offset_)
-        query = apply_ordering_params(query, _order_by_, _direction_)
 
-        result = await execute_session_query(session, query)
-        return [row._mapping for row in result.all()]
+        # Fetch data per the request parameters
+        for param, value in filters:
+            if value is not None:
+                column = getattr(table.c, param)
+                if value.lower() == "_null_":
+                    query = query.filter(column.is_(None))
+
+                else:
+                    query = query.filter(column.ilike(f"%{value}%"))
+
+        if _limit_ > 0:
+            query = query.offset(_offset_).limit(_limit_)
+
+        if _order_by_ is not None:
+            direction = {'desc': desc, 'asc': asc}[_direction_]
+            query = query.order_by(direction(_order_by_))
+
+        # Determine total record count
+        total_count_query = select(func.count()).select_from(table)
+        total_count = await execute_session_query(session, total_count_query)
+
+        # Set headers
+        response.headers["x-pagination-limit"] = str(_limit_)
+        response.headers["x-pagination-offset"] = str(_offset_)
+        response.headers["x-pagination-total"] = str(total_count.first()[0])
+        response.headers["x-order-by"] = str(_order_by_)
+        response.headers["x-order-direction"] = str(_direction_)
+
+        # noinspection PyTypeChecker
+        return await execute_session_query(session, query)
 
     return list_records_handler
 
@@ -250,7 +269,7 @@ def create_get_record_handler(engine: DBEngine, table: Table) -> Callable[..., A
     return get_record_handler
 
 
-def create_post_record_handler(engine: DBEngine, table: Table) -> Callable[..., Awaitable[PydanticModel]]:
+def create_post_record_handler(engine: DBEngine, table: Table) -> Callable[..., Awaitable[None]]:
     """Create a function for handling POST requests against a record in the database.
 
     Args:
@@ -269,7 +288,7 @@ def create_post_record_handler(engine: DBEngine, table: Table) -> Callable[...,
     ) -> None:
         """Create a new record in the database."""
 
-        query = insert(table).values(**data.dict())
+        query = insert(table).values(**data.model_dump())
         await execute_session_query(session, query)
         await commit_session(session)
 

{auto_rest_api-0.1.4 → auto_rest_api-0.1.6}/auto_rest/models.py

@@ -32,7 +32,7 @@ connection and session handling are configured accordingly.
 import asyncio
 import logging
 from pathlib import Path
-from typing import Callable
+from typing import AsyncGenerator, Callable, Generator
 
 import yaml
 from sqlalchemy import create_engine, Engine, MetaData, URL
@@ -49,7 +49,7 @@ __all__ = [
     "parse_db_settings"
 ]
 
-logger = logging.getLogger("auto-rest")
+logger = logging.getLogger("auto_rest")
 
 # Base classes and typing objects.
 DBEngine = Engine | AsyncEngine
@@ -70,7 +70,7 @@ def parse_db_settings(path: Path | None) -> dict[str, any]:
         logger.debug(f"Parsing engine configuration from {path}.")
         return yaml.safe_load(path.read_text()) or dict()
 
-    logger.debug("No connection file specified.")
+    logger.debug("No configuration file specified.")
     return {}
 
 
@@ -129,8 +129,6 @@ def create_db_engine(url: URL, **kwargs: dict[str: any]) -> DBEngine:
         A SQLAlchemy `Engine` or `AsyncEngine` instance.
     """
 
-    logger.debug(f"Building database engine for {url}.")
-
     if url.get_dialect().is_async:
         engine = create_async_engine(url, **kwargs)
         logger.debug("Asynchronous connection established.")
@@ -171,7 +169,7 @@ def create_db_metadata(engine: DBEngine) -> MetaData:
     return metadata
 
 
-def create_session_iterator(engine: DBEngine) -> Callable[[], DBSession]:
+def create_session_iterator(engine: DBEngine) -> Callable[[], Generator[Session, None, None] | AsyncGenerator[AsyncSession, None]]:
     """Create a generator for database sessions.
 
     Returns a synchronous or asynchronous function depending on whether
@@ -187,12 +185,12 @@ def create_session_iterator(engine: DBEngine) -> Callable[[], DBSession]:
     """
 
     if isinstance(engine, AsyncEngine):
-        async def session_iterator() -> AsyncSession:
+        async def session_iterator() -> AsyncGenerator[AsyncSession, None]:
             async with AsyncSession(bind=engine, autocommit=False, autoflush=True) as session:
                 yield session
 
     else:
-        def session_iterator() -> Session:
+        def session_iterator() -> Generator[Session, None, None]:
             with Session(bind=engine, autocommit=False, autoflush=True) as session:
                 yield session
 

{auto_rest_api-0.1.4 → auto_rest_api-0.1.6}/auto_rest/queries.py

@@ -20,81 +20,23 @@ handling and provides a streamlined interface for database interactions.
     ```
 """
 
-from typing import Literal
+import logging
 
 from fastapi import HTTPException
-from sqlalchemy import asc, desc, Executable, Result, Select
+from sqlalchemy import Executable, Result
 from sqlalchemy.ext.asyncio import AsyncSession
 from starlette import status
 
 from auto_rest.models import DBSession
 
 __all__ = [
-    "apply_ordering_params",
-    "apply_pagination_params",
     "commit_session",
     "delete_session_record",
     "execute_session_query",
     "get_record_or_404"
 ]
 
-
-def apply_ordering_params(
-    query: Select,
-    order_by: str | None = None,
-    direction: Literal["desc", "asc"] = "asc"
-) -> Select:
-    """Apply ordering to a database query.
-
-    Returns a copy of the provided query with ordering parameters applied.
-
-    Args:
-        query: The database query to apply parameters to.
-        order_by: The name of the column to order by.
-        direction: The direction to order by (defaults to "asc").
-
-    Returns:
-        A copy of the query modified to return ordered values.
-    """
-
-    if order_by is None:
-        return query
-
-    if order_by not in query.columns:
-        raise ValueError(f"Invalid column name: {order_by}")
-
-    # Default to ascending order for an invalid ordering direction
-    if direction == "desc":
-        return query.order_by(desc(order_by))
-
-    elif direction == "asc":
-        return query.order_by(asc(order_by))
-
-    raise ValueError(f"Invalid direction, use 'asc' or 'desc': {direction}")
-
-
-def apply_pagination_params(query: Select, limit: int = 0, offset: int = 0) -> Select:
-    """Apply pagination to a database query.
-
-    Returns a copy of the provided query with offset and limit parameters applied.
-
-    Args:
-        query: The database query to apply parameters to.
-        limit: The number of results to return.
-        offset: The offset to start with.
-
-    Returns:
-        A copy of the query modified to only return the paginated values.
-    """
-
-    if offset < 0 or limit < 0:
-        raise ValueError("Pagination parameters cannot be negative")
-
-    # Do not apply pagination if not requested
-    if limit == 0:
-        return query
-
-    return query.offset(offset or 0).limit(limit)
+logger = logging.getLogger("auto_rest.query")
 
 
 async def commit_session(session: DBSession) -> None:
@@ -124,6 +66,7 @@ async def delete_session_record(session: DBSession, record: Result) -> None:
         record: The record to be deleted.
     """
 
+    logger.debug("Deleting record.")
     if isinstance(session, AsyncSession):
         await session.delete(record)
 
@@ -144,6 +87,7 @@ async def execute_session_query(session: DBSession, query: Executable) -> Result
         The result of the executed query.
     """
 
+    logger.debug(str(query).replace("\n", " "))
     if isinstance(session, AsyncSession):
         return await session.execute(query)
 

{auto_rest_api-0.1.4 → auto_rest_api-0.1.6}/auto_rest/routers.py

@@ -38,7 +38,7 @@ __all__ = [
     "create_welcome_router",
 ]
 
-logger = logging.getLogger("auto-rest")
+logger = logging.getLogger("auto_rest")
 
 
 def create_welcome_router() -> APIRouter:
@@ -83,7 +83,7 @@ def create_meta_router(engine: DBEngine, metadata: MetaData, name: str, version:
     tags = ["Application Metadata"]
 
     router.add_api_route(
-        path="/app",
+        path="/app/",
         methods=["GET"],
         endpoint=create_about_handler(name, version),
         summary="Fetch application metadata.",
@@ -91,7 +91,7 @@ def create_meta_router(engine: DBEngine, metadata: MetaData, name: str, version:
     )
 
     router.add_api_route(
-        path="/engine",
+        path="/engine/",
         methods=["GET"],
         endpoint=create_engine_handler(engine),
         summary="Fetch database metadata.",
@@ -99,7 +99,7 @@ def create_meta_router(engine: DBEngine, metadata: MetaData, name: str, version:
     )
 
     router.add_api_route(
-        path="/schema",
+        path="/schema/",
         methods=["GET"],
         endpoint=create_schema_handler(metadata),
         summary="Fetch the database schema.",

{auto_rest_api-0.1.4 → auto_rest_api-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "auto-rest-api"
-version = "0.1.4"
+version = "0.1.6"
 readme = "README.md"
 description = "Automatically map database schemas and deploy per-table REST API endpoints."
 authors = [{ name = "Better HPC LLC" }]
@@ -24,20 +24,22 @@ classifiers = [
     "Topic :: Software Development",
     "Typing :: Typed"
 ]
-requires-python = ">=3.11"
+requires-python = ">=3.11,<4"
 dependencies = [
     "aiomysql~=0.2",
     "aioodbc~=0.5",
     "aiosqlite~=0.20",
+    "asgi-correlation-id (>=4.3.4,<5.0.0)",
     "asyncpg~=0.30",
+    "colorlog (>=6.9.0,<7.0.0)",
     "fastapi~=0.115",
     "greenlet~=3.1",
     "httpx~=0.28",
     "oracledb~=2.5",
     "pydantic~=2.10",
+    "pyyaml (>=6.0.2,<7.0.0)",
     "sqlalchemy~=2.0",
     "uvicorn~=0.34",
-    "pyyaml (>=6.0.2,<7.0.0)",
 ]
 
 [tool.poetry]