zebra-day 2.0.0__py3-none-any.whl → 2.1.4__py3-none-any.whl

zebra_day/templates/modern/print_request.html

@@ -96,9 +96,14 @@
             <a href="/" class="btn btn-outline">
                 <i class="fas fa-arrow-left"></i> Cancel
             </a>
-            <button type="submit" class="btn btn-primary btn-lg" onclick="showLoading('Sending print request...')">
-                <i class="fas fa-print"></i> Print Label
-            </button>
+            <div class="d-flex" style="gap: var(--spacing-md);">
+                <button type="button" class="btn btn-secondary btn-lg" onclick="downloadPNG()">
+                    <i class="fas fa-download"></i> Download PNG
+                </button>
+                <button type="submit" class="btn btn-primary btn-lg" onclick="showLoading('Sending print request...')">
+                    <i class="fas fa-print"></i> Print Label
+                </button>
+            </div>
         </div>
     </div>
 </form>
@@ -140,6 +145,59 @@
             updatePrinters();
         }
     });
+
+    async function downloadPNG() {
+        var form = document.getElementById('print-form');
+        var template = form.querySelector('select[name="label_zpl_style"]').value;
+
+        if (!template) {
+            showToast('error', 'Error', 'Please select a label template');
+            return;
+        }
+
+        showLoading('Rendering PNG...');
+
+        try {
+            var response = await fetch('/api/v1/render/png', {
+                method: 'POST',
+                headers: {'Content-Type': 'application/json'},
+                body: JSON.stringify({
+                    template: template,
+                    uid_barcode: form.querySelector('input[name="uid_barcode"]').value || '',
+                    alt_a: form.querySelector('input[name="alt_a"]').value || '',
+                    alt_b: form.querySelector('input[name="alt_b"]').value || '',
+                    alt_c: form.querySelector('input[name="alt_c"]').value || '',
+                    alt_d: form.querySelector('input[name="alt_d"]').value || '',
+                    alt_e: form.querySelector('input[name="alt_e"]').value || '',
+                    alt_f: form.querySelector('input[name="alt_f"]').value || ''
+                })
+            });
+
+            hideLoading();
+
+            if (!response.ok) {
+                var error = await response.json();
+                showToast('error', 'Render Failed', error.detail || 'Unknown error');
+                return;
+            }
+
+            // Download the PNG file
+            var blob = await response.blob();
+            var url = window.URL.createObjectURL(blob);
+            var a = document.createElement('a');
+            a.href = url;
+            a.download = template + '_label.png';
+            document.body.appendChild(a);
+            a.click();
+            window.URL.revokeObjectURL(url);
+            a.remove();
+
+            showToast('success', 'Success', 'PNG downloaded');
+        } catch (e) {
+            hideLoading();
+            showToast('error', 'Error', 'Failed to render PNG: ' + e.message);
+        }
+    }
 </script>
 {% endblock %}
 

zebra_day/web/__init__.py

@@ -3,7 +3,7 @@ zebra_day web application module.
 
 FastAPI-based web interface for managing Zebra printers and label templates.
 """
+
 from zebra_day.web.app import create_app
 
 __all__ = ["create_app"]
-

zebra_day/web/app.py

@@ -3,20 +3,21 @@ FastAPI application factory for zebra_day.
 
 This module provides the main FastAPI application for the zebra_day web interface.
 """
+
 from __future__ import annotations
 
 import os
 import subprocess
+from importlib.resources import files
 from pathlib import Path
-from typing import Literal, Optional
+from typing import Literal
 
-from fastapi import FastAPI, Request
+from fastapi import FastAPI
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
-from importlib.resources import files
 
-from zebra_day.logging_config import get_logger
 from zebra_day import paths as xdg
+from zebra_day.logging_config import get_logger
 from zebra_day.web.middleware import RequestLoggingMiddleware, print_rate_limiter
 
 _log = get_logger(__name__)
@@ -39,7 +40,7 @@ def create_app(
     *,
     debug: bool = False,
     css_theme: str = "lsmc.css",
-    auth: Optional[Literal["none", "cognito"]] = None,
+    auth: Literal["none", "cognito"] | None = None,
 ) -> FastAPI:
     """
     Create and configure the FastAPI application.
@@ -76,7 +77,7 @@ def create_app(
         from zebra_day.web.auth import CognitoAuthMiddleware, setup_cognito_auth
 
         cognito_auth = setup_cognito_auth(app)
-        app.add_middleware(CognitoAuthMiddleware, cognito_auth=cognito_auth)
+        app.add_middleware(CognitoAuthMiddleware, cognito_auth=cognito_auth)  # type: ignore[arg-type]
         app.state.cognito_auth = cognito_auth
         app.state.auth_mode = "cognito"
         _log.info("Cognito authentication middleware enabled")
@@ -96,9 +97,14 @@ def create_app(
     app.mount("/static", StaticFiles(directory=str(_STATIC_PATH)), name="static")
 
     # Also mount package directories that need to be served
-    files_dir = _PKG_PATH / "files"
-    if files_dir.exists():
-        app.mount("/files", StaticFiles(directory=str(files_dir)), name="files")
+    # Package files directory (for templates, previews generated in-package)
+    pkg_files_dir = _PKG_PATH / "files"
+    pkg_files_dir.mkdir(parents=True, exist_ok=True)
+    app.mount("/files", StaticFiles(directory=str(pkg_files_dir)), name="files")
+
+    # XDG generated files directory (for PNG downloads from dl_png printer)
+    xdg_generated_dir = xdg.get_generated_files_dir()
+    app.mount("/generated", StaticFiles(directory=str(xdg_generated_dir)), name="generated")
 
     etc_dir = _PKG_PATH / "etc"
     if etc_dir.exists():
@@ -109,7 +115,7 @@ def create_app(
     app.state.templates = templates
 
     # Register routers
-    from zebra_day.web.routers import ui, api
+    from zebra_day.web.routers import api, ui
 
     app.include_router(ui.router)
     app.include_router(api.router, prefix="/api/v1", tags=["api"])
@@ -141,7 +147,7 @@ def create_app(
     return app
 
 
-def get_default_cert_paths() -> tuple[Optional[Path], Optional[Path]]:
+def get_default_cert_paths() -> tuple[Path | None, Path | None]:
     """
     Get default certificate paths from XDG config directory.
 
@@ -163,8 +169,8 @@ def run_server(
     port: int = 8118,
     reload: bool = False,
     auth: Literal["none", "cognito"] = "none",
-    ssl_certfile: Optional[str] = None,
-    ssl_keyfile: Optional[str] = None,
+    ssl_certfile: str | None = None,
+    ssl_keyfile: str | None = None,
 ):
     """
     Run the FastAPI server using uvicorn.
@@ -228,7 +234,7 @@ def run_server(
         )
 
     # Build uvicorn config
-    uvicorn_kwargs = {
+    uvicorn_kwargs: dict[str, str | int | bool | None] = {
         "host": host,
         "port": port,
         "reload": reload,
@@ -244,5 +250,4 @@ def run_server(
 
     _log.info("Starting server at %s://%s:%d", protocol, host, port)
 
-    uvicorn.run("zebra_day.web.app:create_app", **uvicorn_kwargs)
-
+    uvicorn.run("zebra_day.web.app:create_app", **uvicorn_kwargs)  # type: ignore[arg-type]

zebra_day/web/auth.py

@@ -5,10 +5,10 @@ Provides optional Cognito authentication support via the daylily-cognito library
 
 from __future__ import annotations
 
-import os
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
 
-from fastapi import Depends, HTTPException, Request, status
+from fastapi import HTTPException, Request, status
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.responses import Response
 
@@ -20,7 +20,7 @@ if TYPE_CHECKING:
 _log = get_logger(__name__)
 
 # Endpoints that should never require authentication
-PUBLIC_PATHS: List[str] = [
+PUBLIC_PATHS: list[str] = [
     "/healthz",
     "/readyz",
     "/docs",
@@ -30,7 +30,7 @@ PUBLIC_PATHS: List[str] = [
 
 # Try to import daylily-cognito components
 _COGNITO_AVAILABLE = False
-_COGNITO_IMPORT_ERROR: Optional[str] = None
+_COGNITO_IMPORT_ERROR: str | None = None
 
 try:
     from daylily_cognito import CognitoAuth, CognitoConfig, create_auth_dependency
@@ -38,9 +38,9 @@ try:
     _COGNITO_AVAILABLE = True
 except ImportError as e:
     _COGNITO_IMPORT_ERROR = str(e)
-    CognitoAuth = None  # type: ignore[misc, assignment]
-    CognitoConfig = None  # type: ignore[misc, assignment]
-    create_auth_dependency = None  # type: ignore[misc, assignment]
+    CognitoAuth = None
+    CognitoConfig = None
+    create_auth_dependency = None
 
 
 def is_cognito_available() -> bool:
@@ -48,7 +48,7 @@ def is_cognito_available() -> bool:
     return _COGNITO_AVAILABLE
 
 
-def get_cognito_import_error() -> Optional[str]:
+def get_cognito_import_error() -> str | None:
     """Get the import error message if daylily-cognito is not available."""
     return _COGNITO_IMPORT_ERROR
 
@@ -59,7 +59,7 @@ class CognitoAuthMiddleware(BaseHTTPMiddleware):
     Exempts health check endpoints and other public paths.
     """
 
-    def __init__(self, app: "FastAPI", cognito_auth: Any) -> None:
+    def __init__(self, app: FastAPI, cognito_auth: Any) -> None:
         super().__init__(app)
         self.cognito_auth = cognito_auth
         self.get_current_user = create_auth_dependency(cognito_auth, optional=False)
@@ -70,11 +70,13 @@ class CognitoAuthMiddleware(BaseHTTPMiddleware):
 
         # Allow public endpoints without authentication
         if any(path.startswith(public) for public in PUBLIC_PATHS):
-            return await call_next(request)
+            response = await call_next(request)
+            return response  # type: ignore[no-any-return]
 
         # Allow static files without authentication
         if path.startswith("/static") or path.startswith("/files") or path.startswith("/etc"):
-            return await call_next(request)
+            response = await call_next(request)
+            return response  # type: ignore[no-any-return]
 
         # Check for Authorization header
         auth_header = request.headers.get("Authorization")
@@ -116,10 +118,11 @@ class CognitoAuthMiddleware(BaseHTTPMiddleware):
                 headers={"WWW-Authenticate": "Bearer"},
             )
 
-        return await call_next(request)
+        response = await call_next(request)
+        return response  # type: ignore[no-any-return]
 
 
-def setup_cognito_auth(app: "FastAPI") -> Any:
+def setup_cognito_auth(app: FastAPI) -> Any:
     """Configure Cognito authentication for the FastAPI app.
 
     Reads configuration from environment variables:
@@ -169,4 +172,3 @@ def setup_cognito_auth(app: "FastAPI") -> Any:
     )
 
     return cognito_auth
-

zebra_day/web/middleware.py

@@ -3,12 +3,13 @@ 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 collections.abc import Callable
 
 from fastapi import Request, Response
 from starlette.middleware.base import BaseHTTPMiddleware
@@ -33,7 +34,7 @@ class RequestLoggingMiddleware(BaseHTTPMiddleware):
         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 ""
+        str(request.query_params) if request.query_params else ""
 
         # Extract relevant parameters for print operations
         lab = request.query_params.get("lab", "")
@@ -86,7 +87,7 @@ class RequestLoggingMiddleware(BaseHTTPMiddleware):
         else:
             _log.info("Request completed", extra=log_context)
 
-        return response
+        return response  # type: ignore[no-any-return]
 
 
 class PrintRateLimiter:
@@ -136,7 +137,10 @@ class PrintRateLimiter:
 
             # 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"
+                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:
@@ -156,4 +160,3 @@ class PrintRateLimiter:
 
 # Global rate limiter instance
 print_rate_limiter = PrintRateLimiter()
-

zebra_day/web/routers/__init__.py

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