feat: updated code

.gitignore

@@ -124,4 +124,5 @@ Pipfile.lock
 run_docker.py
 docs
 .claude
-start_docker.txt
+start_docker.txt
+Reconciliation-file-processing-service.postman_collection.json

README.md

@@ -1,5 +1,5 @@
 ---
-title: LLM Ready Data API — v2.1.0
+title: reconciliation-file-processing-service
 emoji: ⚡
 colorFrom: green
 colorTo: purple

app/core/config/settings.py

@@ -0,0 +1,28 @@
+"""Application settings via Pydantic Settings.
+
+Configuration is driven by environment variables with sensible defaults
+for local development.  In production, set these via the container's
+environment (Docker Compose, K8s ConfigMap/Secret, etc.).
+"""
+
+from __future__ import annotations
+
+import os
+
+
+class Settings:
+    """Simple settings container — no external dependencies required."""
+
+    SERVICE_NAME: str = "reconciliation-file-processing-service"
+    API_VERSION: str = "2.1.0"
+    ENVIRONMENT: str = os.getenv("ENVIRONMENT", "development")
+
+
+_settings: Settings | None = None
+
+
+def get_settings() -> Settings:
+    global _settings
+    if _settings is None:
+        _settings = Settings()
+    return _settings

banner.py

@@ -0,0 +1,21 @@
+import pyfiglet
+from rich.console import Console
+from rich.rule import Rule
+from rich.text import Text
+
+from app.core.config.settings import get_settings
+
+_console = Console()
+
+
+def print_banner() -> None:
+    settings = get_settings()
+
+    art = pyfiglet.figlet_format("ValidOps", font="slant")
+
+    _console.print(Text(art, style="bold cyan"))
+    _console.print(f"  [bold white]{'Service:':<14}[/bold white]  [cyan]{settings.SERVICE_NAME}[/cyan]")
+    _console.print(f"  [bold white]{'Version:':<14}[/bold white]  [cyan]v{settings.API_VERSION}[/cyan]")
+    _console.print(f"  [bold white]{'Environment:':<14}[/bold white]  [cyan]{settings.ENVIRONMENT}[/cyan]")
+    _console.print(Rule(style="dim cyan"))
+    _console.print()

logger.py

@@ -1,136 +1,87 @@
-"""
-Logging configuration for the MarkItDown API.
+"""Production-grade structured JSON logger.
+
+Emits newline-delimited JSON to stdout (12-factor app pattern) for
+seamless ingestion by log aggregators (Datadog, ELK, CloudWatch, etc.).
 
-Provides a structured plaintext formatter suitable for production log
-aggregation pipelines (stdout + optional log file). No ANSI colour codes
-are emitted, keeping output clean for log collectors and CI environments.
+Usage
+-----
+    from logger import get_logger
 
-Public surface
---------------
-    get_logger(name)  ->  logging.Logger
-        Returns the named logger, bootstrapping from the root application
-        logger if the logger has not been configured yet.
+    logger = get_logger(__name__)
+    logger.info("processed | file=%s | rows=%d", filename, n)
 
-    setup_logger(...)  ->  logging.Logger
-        Full configuration path used once at application startup.
+Configuration (environment variables):
 
-    app_logger
-        Pre-configured root logger instance used by all modules.
+    LOG_LEVEL     Minimum level (default: INFO)
 """
 
 from __future__ import annotations
 
+import json
 import logging
+import os
 import sys
-from pathlib import Path
-from typing import Optional
+from datetime import datetime, timezone
+from typing import Any
 
 
-# ---------------------------------------------------------------------------
-# Formatter
-# ---------------------------------------------------------------------------
+__all__ = ["get_logger", "app_logger"]
 
-class PlainFormatter(logging.Formatter):
-    """Structured pipe-delimited log line.
 
-    Example output::
-        2024-01-15 12:34:56 | INFO     | llm_ready_data_extractor.api.server | message text
+class JSONFormatter(logging.Formatter):
+    """Render log records as JSON lines.
+
+    Each line contains ``timestamp`` (ISO 8601 UTC), ``level``,
+    ``logger``, and ``message``.  Exception tracebacks are included
+    under ``exception`` when ``exc_info`` is set on the record.
     """
 
+    __slots__ = ()
+
     def format(self, record: logging.LogRecord) -> str:
-        timestamp = self.formatTime(record, self.datefmt)
-        line = (
-            f"{timestamp} | {record.levelname:<8} | "
-            f"{record.name} | {record.getMessage()}"
-        )
-        if record.exc_info:
-            line = f"{line}\n{self.formatException(record.exc_info)}"
-        return line
-
-
-# ---------------------------------------------------------------------------
-# Handler factories
-# ---------------------------------------------------------------------------
-
-def _build_console_handler() -> logging.StreamHandler:
-    """Return a StreamHandler writing structured lines to stdout."""
-    handler = logging.StreamHandler(sys.stdout)
-    handler.setFormatter(
-        PlainFormatter(datefmt="%Y-%m-%d %H:%M:%S")
-    )
-    return handler
-
-
-def _build_file_handler(log_file: str) -> logging.FileHandler:
-    """Return a FileHandler writing to *log_file*, creating parent dirs as needed."""
-    log_path = Path(log_file)
-    log_path.parent.mkdir(parents=True, exist_ok=True)
-    handler = logging.FileHandler(log_file, encoding="utf-8")
-    handler.setFormatter(
-        PlainFormatter(datefmt="%Y-%m-%d %H:%M:%S")
-    )
-    return handler
-
-
-# ---------------------------------------------------------------------------
-# Public API
-# ---------------------------------------------------------------------------
-
-def setup_logger(
-    name: str,
-    level: str = "INFO",
-    log_file: Optional[str] = None,
-    enable_console: bool = True,
-) -> logging.Logger:
-    """Configure and return a named logger.
-
-    Parameters
-    ----------
-    name:
-        Logger name — pass ``__name__`` from the calling module.
-    level:
-        Minimum log level string, e.g. ``"DEBUG"``, ``"INFO"``, ``"WARNING"``.
-    log_file:
-        Optional path to a persistent log file. When supplied, records are
-        written to both stdout and the file.
-    enable_console:
-        Set to ``False`` to suppress stdout output (useful in test environments).
+        payload: dict[str, Any] = {
+            "timestamp": datetime.fromtimestamp(
+                record.created, tz=timezone.utc
+            ).isoformat(),
+            "level": record.levelname,
+            "logger": record.name,
+            "message": record.getMessage(),
+        }
+        if record.exc_info and record.exc_info[0] is not None:
+            payload["exception"] = self.formatException(record.exc_info)
+        return json.dumps(payload, default=str, ensure_ascii=False, sort_keys=True)
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Return a named logger.
+
+    All loggers inherit handlers from the root logger, which is
+    configured once at import time with a :class:`JSONFormatter`.
     """
-    logger = logging.getLogger(name)
-    logger.setLevel(getattr(logging, level.upper(), logging.INFO))
-    logger.handlers.clear()
-    logger.propagate = False
+    return logging.getLogger(name)
 
-    if enable_console:
-        logger.addHandler(_build_console_handler())
 
-    if log_file:
-        logger.addHandler(_build_file_handler(log_file))
+_initialised: bool = False
 
-    return logger
 
+def _setup() -> None:
+    """Configure the root logger once from environment defaults."""
+    global _initialised
+    if _initialised:
+        return
+    _initialised = True
 
-def get_logger(name: str) -> logging.Logger:
-    """Return the named logger, configuring it with defaults if not yet set up.
+    level = os.getenv("LOG_LEVEL", "INFO").upper()
 
-    Intended usage in application modules::
+    root = logging.getLogger()
+    root.setLevel(getattr(logging, level, logging.INFO))
 
-        from logger import get_logger
-        logger = get_logger(__name__)
-    """
-    existing = logging.getLogger(name)
-    if existing.handlers:
-        return existing
-    return setup_logger(name)
-
-
-# ---------------------------------------------------------------------------
-# Root application logger — configured once at import time
-# ---------------------------------------------------------------------------
-
-app_logger = setup_logger(
-    "llm_ready_data_extractor",
-    level="INFO",
-    log_file="logs/markitdown.log",
-    enable_console=True,
-)
+    fmt = JSONFormatter()
+
+    console = logging.StreamHandler(sys.stdout)
+    console.setFormatter(fmt)
+    root.addHandler(console)
+
+
+_setup()
+app_logger = get_logger("docx")

main.py

@@ -10,11 +10,13 @@ from __future__ import annotations
 
 import uvicorn
 
+from banner import print_banner
 from logger import get_logger
 
 logger = get_logger(__name__)
 
 if __name__ == "__main__":
+    print_banner()
     logger.info("Starting MarkItDown API server")
     uvicorn.run(
         "api.server:app",

requirements.txt

@@ -19,3 +19,7 @@ pandas>=2.0.0
 
 # spaCy NER extraction for non-tabular file formats
 spacy>=3.7.0
+
+# CLI banner
+pyfiglet>=1.0.2
+rich>=13.0.0