zebra-day 0.0.32__py3-none-any.whl → 1.0.2__py3-none-any.whl

zebra_day/web/middleware.py

@@ -0,0 +1,159 @@
+"""
+Middleware for the zebra_day FastAPI application.
+
+Provides request logging and rate limiting functionality.
+"""
+from __future__ import annotations
+
+import asyncio
+import time
+from collections import defaultdict
+from typing import Callable
+
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from zebra_day.logging_config import get_logger
+
+_log = get_logger(__name__)
+
+
+class RequestLoggingMiddleware(BaseHTTPMiddleware):
+    """
+    Middleware for structured request logging.
+
+    Logs client IP, request path, method, timing, and response status.
+    """
+
+    async def dispatch(self, request: Request, call_next: Callable) -> Response:
+        """Process request and log structured data."""
+        start_time = time.perf_counter()
+
+        # Extract client info
+        client_ip = request.client.host if request.client else "unknown"
+        method = request.method
+        path = request.url.path
+        query = str(request.query_params) if request.query_params else ""
+
+        # Extract relevant parameters for print operations
+        lab = request.query_params.get("lab", "")
+        printer = request.query_params.get("printer", "")
+        template = request.query_params.get("label_zpl_style", "")
+
+        try:
+            response = await call_next(request)
+            status_code = response.status_code
+            outcome = "success" if status_code < 400 else "error"
+        except Exception as exc:
+            status_code = 500
+            outcome = "exception"
+            _log.exception(
+                "Request failed",
+                extra={
+                    "client_ip": client_ip,
+                    "method": method,
+                    "path": path,
+                    "error": str(exc),
+                },
+            )
+            raise
+
+        elapsed_ms = (time.perf_counter() - start_time) * 1000
+
+        # Build log context
+        log_context = {
+            "client_ip": client_ip,
+            "method": method,
+            "path": path,
+            "status_code": status_code,
+            "elapsed_ms": round(elapsed_ms, 2),
+            "outcome": outcome,
+        }
+
+        # Add print-specific context if relevant
+        if lab:
+            log_context["lab"] = lab
+        if printer:
+            log_context["printer"] = printer
+        if template:
+            log_context["template"] = template
+
+        # Log at appropriate level
+        if status_code >= 500:
+            _log.error("Request completed", extra=log_context)
+        elif status_code >= 400:
+            _log.warning("Request completed", extra=log_context)
+        else:
+            _log.info("Request completed", extra=log_context)
+
+        return response
+
+
+class PrintRateLimiter:
+    """
+    Simple rate limiter for print endpoints.
+
+    Uses a sliding window approach with configurable limits.
+    """
+
+    def __init__(
+        self,
+        max_requests: int = 10,
+        window_seconds: float = 60.0,
+        max_concurrent: int = 3,
+    ):
+        """
+        Initialize rate limiter.
+
+        Args:
+            max_requests: Maximum requests per window per client IP
+            window_seconds: Time window in seconds
+            max_concurrent: Maximum concurrent print operations
+        """
+        self.max_requests = max_requests
+        self.window_seconds = window_seconds
+        self.max_concurrent = max_concurrent
+
+        self._request_times: dict[str, list[float]] = defaultdict(list)
+        self._semaphore = asyncio.Semaphore(max_concurrent)
+        self._lock = asyncio.Lock()
+
+    async def acquire(self, client_ip: str) -> tuple[bool, str]:
+        """
+        Try to acquire a print slot.
+
+        Returns:
+            Tuple of (allowed, reason)
+        """
+        now = time.time()
+
+        async with self._lock:
+            # Clean old entries
+            cutoff = now - self.window_seconds
+            self._request_times[client_ip] = [
+                t for t in self._request_times[client_ip] if t > cutoff
+            ]
+
+            # Check rate limit
+            if len(self._request_times[client_ip]) >= self.max_requests:
+                return False, f"Rate limit exceeded: {self.max_requests} requests per {self.window_seconds}s"
+
+            # Try to acquire semaphore (non-blocking check)
+            if self._semaphore.locked() and self._semaphore._value == 0:
+                return False, f"Too many concurrent print operations (max {self.max_concurrent})"
+
+            # Record this request
+            self._request_times[client_ip].append(now)
+
+        # Acquire semaphore for actual operation
+        await self._semaphore.acquire()
+        return True, ""
+
+    def release(self) -> None:
+        """Release a print slot after operation completes."""
+        self._semaphore.release()
+
+
+# Global rate limiter instance
+print_rate_limiter = PrintRateLimiter()
+

zebra_day/web/routers/__init__.py

@@ -0,0 +1,2 @@
+"""FastAPI routers for zebra_day web application."""
+

zebra_day/web/routers/api.py

@@ -0,0 +1,163 @@
+"""
+Versioned JSON API router for zebra_day.
+
+Provides programmatic access to printer management and label printing.
+All endpoints return JSON and are prefixed with /api/v1/.
+"""
+from __future__ import annotations
+
+from typing import Optional, List, Dict, Any
+
+from fastapi import APIRouter, HTTPException, Request
+from pydantic import BaseModel, Field
+
+router = APIRouter()
+
+
+# ----- Request/Response Models -----
+
+class PrintRequest(BaseModel):
+    """Request model for printing a label."""
+    lab: str = Field(..., description="Lab identifier")
+    printer: str = Field(..., description="Printer name")
+    label_zpl_style: Optional[str] = Field(None, description="ZPL template name")
+    uid_barcode: str = Field("", description="UID for barcode")
+    alt_a: str = Field("", description="Alternative field A")
+    alt_b: str = Field("", description="Alternative field B")
+    alt_c: str = Field("", description="Alternative field C")
+    alt_d: str = Field("", description="Alternative field D")
+    alt_e: str = Field("", description="Alternative field E")
+    alt_f: str = Field("", description="Alternative field F")
+    copies: int = Field(1, ge=1, le=100, description="Number of copies")
+
+
+class PrintResponse(BaseModel):
+    """Response model for print request."""
+    success: bool
+    message: str
+    png_url: Optional[str] = None
+
+
+class PrinterInfo(BaseModel):
+    """Printer information model."""
+    name: str
+    ip_address: str
+    model: str
+    serial: str
+    label_zpl_styles: List[str]
+    print_method: str
+
+
+class LabPrinters(BaseModel):
+    """Lab and its printers."""
+    lab: str
+    printers: List[PrinterInfo]
+
+
+# ----- Endpoints -----
+
+@router.get("/labs", response_model=List[str])
+async def list_labs(request: Request) -> List[str]:
+    """List all available labs."""
+    zp = request.app.state.zp
+    return list(zp.printers.get("labs", {}).keys())
+
+
+@router.get("/labs/{lab}/printers", response_model=List[PrinterInfo])
+async def list_printers(request: Request, lab: str) -> List[PrinterInfo]:
+    """List all printers in a lab."""
+    zp = request.app.state.zp
+    labs = zp.printers.get("labs", {})
+
+    if lab not in labs:
+        raise HTTPException(status_code=404, detail=f"Lab '{lab}' not found")
+
+    printers = []
+    for name, info in labs[lab].items():
+        printers.append(
+            PrinterInfo(
+                name=name,
+                ip_address=info.get("ip_address", ""),
+                model=info.get("model", ""),
+                serial=info.get("serial", ""),
+                label_zpl_styles=info.get("label_zpl_styles", []),
+                print_method=info.get("print_method", ""),
+            )
+        )
+    return printers
+
+
+@router.get("/templates", response_model=List[str])
+async def list_templates(request: Request) -> List[str]:
+    """List all available ZPL templates."""
+    from pathlib import Path
+
+    pkg_path = request.app.state.pkg_path
+    styles_dir = pkg_path / "etc" / "label_styles"
+
+    templates = []
+    if styles_dir.exists():
+        for f in styles_dir.iterdir():
+            if f.is_file() and f.suffix == ".zpl":
+                templates.append(f.stem)
+
+    # Also include drafts
+    tmps_dir = styles_dir / "tmps"
+    if tmps_dir.exists():
+        for f in tmps_dir.iterdir():
+            if f.is_file() and f.suffix == ".zpl":
+                templates.append(f.stem)
+
+    return sorted(templates)
+
+
+@router.post("/print", response_model=PrintResponse)
+async def print_label(request: Request, print_req: PrintRequest) -> PrintResponse:
+    """Send a print request to a printer."""
+    zp = request.app.state.zp
+    rate_limiter = request.app.state.print_rate_limiter
+    client_ip = request.client.host if request.client else "unknown"
+
+    # Check rate limit
+    allowed, reason = await rate_limiter.acquire(client_ip)
+    if not allowed:
+        raise HTTPException(status_code=429, detail=reason)
+
+    try:
+        result = zp.print_zpl(
+            lab=print_req.lab,
+            printer_name=print_req.printer,
+            label_zpl_style=print_req.label_zpl_style,
+            uid_barcode=print_req.uid_barcode,
+            alt_a=print_req.alt_a,
+            alt_b=print_req.alt_b,
+            alt_c=print_req.alt_c,
+            alt_d=print_req.alt_d,
+            alt_e=print_req.alt_e,
+            alt_f=print_req.alt_f,
+            print_n=print_req.copies,
+            client_ip=client_ip,
+        )
+
+        # Check if result is a PNG file path
+        if result and ".png" in str(result):
+            png_name = str(result).split("/")[-1]
+            return PrintResponse(
+                success=True,
+                message="PNG generated successfully",
+                png_url=f"/files/{png_name}",
+            )
+
+        return PrintResponse(success=True, message="Print request sent successfully")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        rate_limiter.release()
+
+
+@router.get("/config")
+async def get_config(request: Request) -> Dict[str, Any]:
+    """Get the current printer configuration."""
+    zp = request.app.state.zp
+    return zp.printers
+