auto-rest-api 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

auto_rest/__main__.py

@@ -1,9 +1,6 @@
 """Application entrypoint triggered by calling the packaged CLI command."""
 
 import logging
-from pathlib import Path
-
-import yaml
 
 from .app import *
 from .cli import *
@@ -12,19 +9,18 @@ from .routers import *
 
 __all__ = ["main", "run_application"]
 
-logger = logging.getLogger(__name__)
+logger = logging.getLogger("auto_rest")
 
 
 def main() -> None:  # pragma: no cover
-    """Parse command-line arguments and launch an API server."""
+    """Application entry point called when executing the command line interface.
 
-    try:
-        parser = create_cli_parser()
-        args = vars(parser.parse_args())
-        log_level = args.pop("log_level")
+    This is a wrapper around the `run_application` function used to provide
+    graceful error handling.
+    """
 
-        configure_cli_logging(log_level)
-        run_application(**args)
+    try:
+        run_application()
 
     except KeyboardInterrupt:
         pass
@@ -33,62 +29,42 @@ def main() -> None:  # pragma: no cover
         logger.critical(str(e), exc_info=True)
 
 
-def run_application(
-    enable_docs: bool,
-    enable_write: bool,
-    db_driver: str,
-    db_host: str,
-    db_port: int,
-    db_name: str,
-    db_user: str,
-    db_pass: str,
-    db_config: Path | None,
-    server_host: str,
-    server_port: int,
-    app_title: str,
-    app_version: str,
-) -> None:  # pragma: no cover
+def run_application(cli_args: list[str] = None, /) -> None:  # pragma: no cover
     """Run an Auto-REST API server.
 
     This function is equivalent to launching an API server from the command line
-    and accepts the same arguments as those provided in the CLI.
+    and accepts the same arguments as those provided in the CLI. Arguments are
+    parsed from STDIN by default, unless specified in the function call.
 
     Args:
-        enable_docs: Whether to enable the 'docs' API endpoint.
-        enable_write: Whether to enable support for write operations.
-        db_driver: SQLAlchemy-compatible database driver.
-        db_host: Database host address.
-        db_port: Database port number.
-        db_name: Database name.
-        db_user: Database authentication username.
-        db_pass: Database authentication password.
-        db_config: Path to a database configuration file.
-        server_host: API server host address.
-        server_port: API server port number.
-        app_title: title for the generated OpenAPI schema.
-        app_version: version number for the generated OpenAPI schema.
+        A list of commandline arguments used to run the application.
     """
 
-    logger.info(f"Mapping database schema for {db_name}.")
-
-    # Resolve database connection settings
-    db_url = create_db_url(driver=db_driver, host=db_host, port=db_port, database=db_name, username=db_user, password=db_pass)
-    db_kwargs = yaml.safe_load(db_config.read_text()) if db_config else {}
-
-    # Connect to and map the database.
+    # Parse application arguments
+    args = create_cli_parser().parse_args(cli_args)
+    configure_cli_logging(args.log_level)
+
+    logger.info(f"Resolving database connection settings.")
+    db_kwargs = parse_db_settings(args.db_config)
+    db_url = create_db_url(
+        driver=args.db_driver,
+        host=args.db_host,
+        port=args.db_port,
+        database=args.db_name,
+        username=args.db_user,
+        password=args.db_pass
+    )
+
+    logger.info("Mapping database schema.")
     db_conn = create_db_engine(db_url, **db_kwargs)
     db_meta = create_db_metadata(db_conn)
 
-    # Build an empty application and dynamically add the requested functionality.
-    logger.info("Creating API application.")
-    app = create_app(app_title, app_version, enable_docs)
+    logger.info("Creating application.")
+    app = create_app(args.app_title, args.app_version)
     app.include_router(create_welcome_router(), prefix="")
-    app.include_router(create_meta_router(db_conn, db_meta, app_title, app_version), prefix="/meta")
-
+    app.include_router(create_meta_router(db_conn, db_meta, args.app_title, args.app_version), prefix="/meta")
     for table_name, table in db_meta.tables.items():
-        logger.info(f"Adding `/db/{table_name}` endpoint.")
-        app.include_router(create_table_router(db_conn, table, enable_write), prefix=f"/db/{table_name}")
+        app.include_router(create_table_router(db_conn, table), prefix=f"/db/{table_name}")
 
-    # Launch the API server.
-    logger.info(f"Launching API server on http://{server_host}:{server_port}.")
-    run_server(app, server_host, server_port)
+    logger.info(f"Launching server on http://{args.server_host}:{args.server_port}.")
+    run_server(app, args.server_host, args.server_port)

auto_rest/app.py

@@ -8,20 +8,62 @@ deploying Fast-API applications.
     ```python
     from auto_rest.app import create_app, run_server
 
-    app = create_app(app_title="My Application", app_version="1.2.3", enable_docs=True)
+    app = create_app(app_title="My Application", app_version="1.2.3")
     ... # Add endpoints to the application here
     run_server(app, host="127.0.0.1", port=8081)
     ```
 """
 
+import logging
+from http import HTTPStatus
+
 import uvicorn
-from fastapi import FastAPI
+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.access")
+
+
+async def logging_middleware(request: Request, call_next: callable) -> Response:
+    """FastAPI middleware for logging response status codes.
+
+    Args:
+        request: The incoming HTTP request.
+        call_next: The next middleware in the middleware chain.
+
+    Returns:
+        The outgoing HTTP response.
+    """
+
+    # Extract metadata from the request
+    request_meta = {
+        "ip": request.client.host,
+        "port": request.client.port,
+        "method": request.method,
+        "endpoint": f"{request.url.path}?{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)
 
-def create_app(app_title: str, app_version: str, enable_docs: bool) -> FastAPI:
+    return response
+
+
+def create_app(app_title: str, app_version: str) -> FastAPI:
     """Create and configure a FastAPI application instance.
 
     This function initializes a FastAPI app with a customizable title, version,
@@ -31,7 +73,6 @@ def create_app(app_title: str, app_version: str, enable_docs: bool) -> FastAPI:
     Args:
         app_title: The title of the FastAPI application.
         app_version: The version of the FastAPI application.
-        enable_docs: Whether to enable the `/docs/` endpoint.
 
     Returns:
         FastAPI: A configured FastAPI application instance.
@@ -40,14 +81,16 @@ def create_app(app_title: str, app_version: str, enable_docs: bool) -> FastAPI:
     app = FastAPI(
         title=app_title,
         version=app_version,
-        docs_url="/docs/" if enable_docs else None,
+        docs_url="/docs/",
         redoc_url=None,
     )
 
+    app.middleware("http")(logging_middleware)
+    app.add_middleware(CorrelationIdMiddleware)
     app.add_middleware(
         CORSMiddleware,
-        allow_origins=["*"],
         allow_credentials=True,
+        allow_origins=["*"],
         allow_methods=["*"],
         allow_headers=["*"],
     )
@@ -55,7 +98,7 @@ def create_app(app_title: str, app_version: str, enable_docs: bool) -> FastAPI:
     return app
 
 
-def run_server(app: FastAPI, host: str, port: int) -> None: # pragma: no cover
+def run_server(app: FastAPI, host: str, port: int) -> None:  # pragma: no cover
     """Deploy a FastAPI application server.
 
     Args:
@@ -64,4 +107,5 @@ def run_server(app: FastAPI, host: str, port: int) -> None: # pragma: no cover
         port: The port number for the server to listen on.
     """
 
-    uvicorn.run(app, host=host, port=port, log_level="error")
+    # Uvicorn overwrites its logging level when run and needs to be manually disabled here.
+    uvicorn.run(app, host=host, port=port, log_level=1000)

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 = 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,15 +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,
-        level=level,
-        format="%(levelprefix)s %(message)s",
-        handlers=[handler],
-    )
+    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:
@@ -95,10 +135,6 @@ def create_cli_parser(exit_on_error: bool = True) -> ArgumentParser:
         help="Set the logging level."
     )
 
-    features = parser.add_argument_group(title="API features")
-    features.add_argument("--enable-docs", action="store_true", help="enable the 'docs' endpoint.")
-    features.add_argument("--enable-write", action="store_true", help="enable support for write operations.")
-
     driver = parser.add_argument_group("database type")
     db_type = driver.add_mutually_exclusive_group(required=True)
     db_type.add_argument("--sqlite", action="store_const", dest="db_driver", const="sqlite+aiosqlite", help="use a SQLite database driver.")

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(__name__)
-
 
 def create_welcome_handler() -> Callable[[], Awaitable[PydanticModel]]:
     """Create an endpoint handler that returns an application welcome message.
@@ -191,7 +188,6 @@ 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())
 
     async def list_records_handler(
@@ -207,14 +203,25 @@ def create_list_records_handler(engine: DBEngine, table: Table) -> Callable[...,
         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_)
+        # 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_)
 
+        # Fetch data per the request parameters
         query = select(table)
-        query = apply_pagination_params(query, _limit_, _offset_)
-        query = apply_ordering_params(query, _order_by_, _direction_)
+        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_))
 
         result = await execute_session_query(session, query)
         return [row._mapping for row in result.all()]

auto_rest/models.py

@@ -34,6 +34,7 @@ import logging
 from pathlib import Path
 from typing import Callable
 
+import yaml
 from sqlalchemy import create_engine, Engine, MetaData, URL
 from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, create_async_engine
 from sqlalchemy.orm import Session
@@ -45,15 +46,34 @@ __all__ = [
     "create_db_metadata",
     "create_db_url",
     "create_session_iterator",
+    "parse_db_settings"
 ]
 
-logger = logging.getLogger(__name__)
+logger = logging.getLogger("auto_rest")
 
 # Base classes and typing objects.
 DBEngine = Engine | AsyncEngine
 DBSession = Session | AsyncSession
 
 
+def parse_db_settings(path: Path | None) -> dict[str, any]:
+    """Parse engine configuration settings from a given file path.
+
+    Args:
+        path: Path to the configuration file.
+
+    Returns:
+        Engine configuration settings.
+    """
+
+    if path is not None:
+        logger.debug(f"Parsing engine configuration from {path}.")
+        return yaml.safe_load(path.read_text()) or dict()
+
+    logger.debug("No configuration file specified.")
+    return {}
+
+
 def create_db_url(
     driver: str,
     database: str,
@@ -76,21 +96,23 @@ def create_db_url(
         A fully qualified database URL.
     """
 
-    logger.debug("Resolving database URL.")
-
     # Handle special case where SQLite uses file paths.
     if "sqlite" in driver:
         path = Path(database).resolve()
-        return URL.create(drivername=driver, database=str(path))
+        url = URL.create(drivername=driver, database=str(path))
 
-    return URL.create(
-        drivername=driver,
-        username=username,
-        password=password,
-        host=host,
-        port=port,
-        database=database,
-    )
+    else:
+        url = URL.create(
+            drivername=driver,
+            username=username,
+            password=password,
+            host=host,
+            port=port,
+            database=database,
+        )
+
+    logger.debug(f"Resolved URL: {url}")
+    return url
 
 
 def create_db_engine(url: URL, **kwargs: dict[str: any]) -> DBEngine:
@@ -107,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.")

auto_rest/queries.py

@@ -19,81 +19,24 @@ handling and provides a streamlined interface for database interactions.
         result = await execute_session_query(async_session, query)
     ```
 """
-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:
@@ -123,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)
 
@@ -143,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/routers.py

@@ -23,6 +23,8 @@ routers to be added directly to an API application instance.
     ```
 """
 
+import logging
+
 from fastapi import APIRouter
 from sqlalchemy import MetaData, Table
 from starlette import status
@@ -36,6 +38,8 @@ __all__ = [
     "create_welcome_router",
 ]
 
+logger = logging.getLogger("auto_rest")
+
 
 def create_welcome_router() -> APIRouter:
     """Create an API router for returning a welcome message.
@@ -44,6 +48,8 @@ def create_welcome_router() -> APIRouter:
         An `APIRouter` with a single route for retrieving a welcome message.
     """
 
+    logger.debug("Creating welcome endpoint.")
+
     router = APIRouter()
     router.add_api_route(
         path="/",
@@ -71,11 +77,13 @@ def create_meta_router(engine: DBEngine, metadata: MetaData, name: str, version:
         An `APIRouter` with a routes for retrieving application metadata.
     """
 
+    logger.debug("Creating metadata endpoints.")
+
     router = APIRouter()
     tags = ["Application Metadata"]
 
     router.add_api_route(
-        path="/app",
+        path="/app/",
         methods=["GET"],
         endpoint=create_about_handler(name, version),
         summary="Fetch application metadata.",
@@ -83,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.",
@@ -91,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.",
@@ -101,25 +109,25 @@ def create_meta_router(engine: DBEngine, metadata: MetaData, name: str, version:
     return router
 
 
-def create_table_router(engine: DBEngine, table: Table, writeable: bool = False) -> APIRouter:
+def create_table_router(engine: DBEngine, table: Table) -> APIRouter:
     """Create an API router with endpoint handlers for a given database table.
 
     Args:
         engine: The SQLAlchemy engine connected to the database.
         table: The database table to create API endpoints for.
-        writeable: Whether the router should include support for write operations.
 
     Returns:
         An APIRouter instance with routes for database operations on the table.
     """
 
+    logger.debug(f"Creating endpoints for table `{table.name}`.")
     router = APIRouter()
 
     # Construct path parameters from primary key columns
     pk_columns = sorted(column.name for column in table.primary_key.columns)
     path_params_url = "/".join(f"{{{col_name}}}" for col_name in pk_columns)
 
-    # Add route for read operations against the table
+    # Add routes for operations against the table
     router.add_api_route(
         path="/",
         methods=["GET"],
@@ -129,16 +137,14 @@ def create_table_router(engine: DBEngine, table: Table, writeable: bool = False)
         tags=[table.name],
     )
 
-    # Add route for write operations against the table
-    if writeable:
-        router.add_api_route(
-            path="/",
-            methods=["POST"],
-            endpoint=create_post_record_handler(engine, table),
-            status_code=status.HTTP_201_CREATED,
-            summary="Create a new record.",
-            tags=[table.name],
-        )
+    router.add_api_route(
+        path="/",
+        methods=["POST"],
+        endpoint=create_post_record_handler(engine, table),
+        status_code=status.HTTP_201_CREATED,
+        summary="Create a new record.",
+        tags=[table.name],
+    )
 
     # Add route for read operations against individual records
     if pk_columns:
@@ -151,8 +157,6 @@ def create_table_router(engine: DBEngine, table: Table, writeable: bool = False)
             tags=[table.name],
         )
 
-    # Add routes for write operations against individual records
-    if pk_columns and writeable:
         router.add_api_route(
             path=f"/{path_params_url}/",
             methods=["PUT"],

{auto_rest_api-0.1.3.dist-info → auto_rest_api-0.1.5.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.3
 Name: auto-rest-api
-Version: 0.1.3
+Version: 0.1.5
 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)
@@ -34,7 +36,7 @@ Description-Content-Type: text/markdown
 
 # Auto-REST
 
-A command line tool for deploying dynamically generated REST APIs against relational databases.
+A light-weight CLI tool for deploying dynamically generated REST APIs against relational databases.
 See the [project documentation](https://better-hpc.github.io/auto-rest/) for detailed usage instructions.
 
 ## Supported Databases
@@ -70,10 +72,6 @@ Launch an API by providing connection arguments to a database of your choice.
 
 ```shell
 auto-rest \
-  # Enable optional endpoints / functionality
-  --enable-docs \
-  --enable-write \
-  # Define the database type and connection arguments
   --psql 
   --db-host localhost
   --db-port 5432

auto_rest_api-0.1.5.dist-info/RECORD

@@ -0,0 +1,14 @@
+auto_rest/__init__.py,sha256=9ICmv2urSoAo856FJylKdorF19UsUGc4eyORYLptf1Q,69
+auto_rest/__main__.py,sha256=VkLZ9j1Q9I0isYvO0Bj1HHCQ9Ew_r5O7a0Dn4fUi5Lo,2233
+auto_rest/app.py,sha256=AnBb2jt0yMxTLj_ICWB1mXLgu2pchjlapfdIk2CwNsQ,3128
+auto_rest/cli.py,sha256=3emee1GrUkQZ-DVAboy5O65jPE0vwmdcy-wfaxh2kBs,6239
+auto_rest/handlers.py,sha256=gwMiE5TKA65nrMizQ472A5iCNmYK7B7vlFDWL0Vrphw,12943
+auto_rest/interfaces.py,sha256=WB_0eMDjGF8DpnDN9INHqo7u4x3aklvzAYK4t3JwC7s,3779
+auto_rest/models.py,sha256=pi97l2PsDqjhW52tAIAZKx6bl2QvC-q5kM5OsVP3V_M,5887
+auto_rest/queries.py,sha256=2e6f_S4n1xvaSY8rYJG-koDmqiXHreOIRUteRuqZlv8,3058
+auto_rest/routers.py,sha256=SZoOugauKdCk2Kqzzp9o6tGENusAsP1-YP-6Aam53tc,5636
+auto_rest_api-0.1.5.dist-info/LICENSE.md,sha256=zFRw_u1mGSOH8GrpOu0L1P765aX9fB5UpKz06mTxAos,34893
+auto_rest_api-0.1.5.dist-info/METADATA,sha256=cgh43Yv81K8gaf9B-mAAiWX72VnJAGGuQHWa7Qi5-K4,2914
+auto_rest_api-0.1.5.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
+auto_rest_api-0.1.5.dist-info/entry_points.txt,sha256=zFynmBrHyYo3Ds0Uo4-bTFe1Tdr5mIXV4dPQOFb-W1w,53
+auto_rest_api-0.1.5.dist-info/RECORD,,

{auto_rest_api-0.1.3.dist-info → auto_rest_api-0.1.5.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.0.1
+Generator: poetry-core 2.0.0
 Root-Is-Purelib: true
 Tag: py3-none-any

auto_rest_api-0.1.3.dist-info/RECORD

@@ -1,14 +0,0 @@
-auto_rest/__init__.py,sha256=9ICmv2urSoAo856FJylKdorF19UsUGc4eyORYLptf1Q,69
-auto_rest/__main__.py,sha256=lz6-LEpbu51Ah3QCzUzZhevjWhK5kmOxhuuqhX5t-io,3093
-auto_rest/app.py,sha256=I6ZeHzKuhPTS1svLhMTvefjzTkMJgGpwVz1kdJ_9mtE,1887
-auto_rest/cli.py,sha256=A7-kMTNNzqZB7jTUJBAVqfYm9RyYjENr0g_vK9JE0N4,5199
-auto_rest/handlers.py,sha256=Z8DMv3KRYLBXlUKoE4e-2qE9YvG-IPgS57C0RpUDWv4,12603
-auto_rest/interfaces.py,sha256=WB_0eMDjGF8DpnDN9INHqo7u4x3aklvzAYK4t3JwC7s,3779
-auto_rest/models.py,sha256=HCJUQPBmkkfVFv9CRcPzMP66pQk_UIb3j3cdwHqodwE,5388
-auto_rest/queries.py,sha256=Z2ATkcSYldV6BkcrmLogmBoDkPEkyFzFqI7qPcq86uc,4705
-auto_rest/routers.py,sha256=RqBwLqVFU1OIFSCUuwOtTis8mT_zyWTaB_8SyIXjfe0,5727
-auto_rest_api-0.1.3.dist-info/LICENSE.md,sha256=zFRw_u1mGSOH8GrpOu0L1P765aX9fB5UpKz06mTxAos,34893
-auto_rest_api-0.1.3.dist-info/METADATA,sha256=Cs7u-2jZGTTlvBprPzdLVWl1uSAAjjLgeh5PuHo3tUk,2951
-auto_rest_api-0.1.3.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-auto_rest_api-0.1.3.dist-info/entry_points.txt,sha256=zFynmBrHyYo3Ds0Uo4-bTFe1Tdr5mIXV4dPQOFb-W1w,53
-auto_rest_api-0.1.3.dist-info/RECORD,,