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

zebra_day/web/routers/api.py

@@ -4,23 +4,30 @@ 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 datetime import datetime
+from typing import Any
 
 from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import FileResponse
 from pydantic import BaseModel, Field
 
+from zebra_day import paths as xdg
+
 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")
+    label_zpl_style: str | None = 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")
@@ -33,44 +40,77 @@ class PrintRequest(BaseModel):
 
 class PrintResponse(BaseModel):
     """Response model for print request."""
+
     success: bool
     message: str
-    png_url: Optional[str] = None
+    png_url: str | None = None
 
 
 class PrinterInfo(BaseModel):
     """Printer information model (v2.0.0 schema)."""
+
     id: str = Field(..., description="Printer identifier/key in JSON")
     ip_address: str
-    printer_name: Optional[str] = Field(None, description="User-friendly display name")
-    lab_location: Optional[str] = Field(None, description="Location within the lab")
+    printer_name: str | None = Field(None, description="User-friendly display name")
+    lab_location: str | None = Field(None, description="Location within the lab")
     manufacturer: str = Field("zebra", description="Printer manufacturer")
     model: str
     serial: str
-    label_zpl_styles: List[str]
-    default_label_style: Optional[str] = Field(None, description="Default label style to use when none specified")
+    label_zpl_styles: list[str]
+    default_label_style: str | None = Field(
+        None, description="Default label style to use when none specified"
+    )
     print_method: str
-    notes: Optional[str] = Field("", description="Optional notes")
+    notes: str | None = Field("", description="Optional notes")
 
 
 class LabInfo(BaseModel):
     """Lab information model (v2.0.0 schema)."""
+
     id: str = Field(..., description="Lab identifier/key in JSON")
     lab_name: str = Field(..., description="Human-readable lab name")
-    available_locations: List[str] = Field(default_factory=list, description="Valid location options for printers")
-    printers: List[PrinterInfo]
+    available_locations: list[str] = Field(
+        default_factory=list, description="Valid location options for printers"
+    )
+    printers: list[PrinterInfo]
 
 
 class LabPrinters(BaseModel):
     """Lab and its printers (deprecated, use LabInfo)."""
+
     lab: str
-    printers: List[PrinterInfo]
+    printers: list[PrinterInfo]
+
+
+class RenderRequest(BaseModel):
+    """Request model for rendering ZPL to PNG."""
+
+    template: str | None = Field(None, description="ZPL template name (e.g., 'tube_2inX1in')")
+    zpl_content: str | None = Field(
+        None, description="Raw ZPL content (takes precedence over template)"
+    )
+    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")
+
+
+class RenderResponse(BaseModel):
+    """Response model for render request (when not returning PNG directly)."""
+
+    success: bool
+    message: str
+    png_url: str = Field(..., description="URL to download the generated PNG")
 
 
 # ----- Endpoints -----
 
-@router.get("/labs", response_model=List[str])
-async def list_labs(request: Request) -> List[str]:
+
+@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())
@@ -114,8 +154,8 @@ async def get_lab(request: Request, lab: str) -> LabInfo:
     )
 
 
-@router.get("/labs/{lab}/printers", response_model=List[PrinterInfo])
-async def list_printers(request: Request, lab: str) -> List[PrinterInfo]:
+@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", {})
@@ -146,10 +186,9 @@ async def list_printers(request: Request, lab: str) -> List[PrinterInfo]:
     return printers
 
 
-@router.get("/templates", response_model=List[str])
-async def list_templates(request: Request) -> List[str]:
+@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"
@@ -183,7 +222,7 @@ async def print_label(request: Request, print_req: PrintRequest) -> PrintRespons
         raise HTTPException(status_code=429, detail=reason)
 
     try:
-        result = zp.print_zpl(
+        zp.print_zpl(
             lab=print_req.lab,
             printer_name=print_req.printer,
             label_zpl_style=print_req.label_zpl_style,
@@ -197,45 +236,149 @@ async def print_label(request: Request, print_req: PrintRequest) -> PrintRespons
             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))
+        raise HTTPException(status_code=500, detail=str(e)) from None
     finally:
         rate_limiter.release()
 
 
+@router.post("/render", response_model=RenderResponse)
+async def render_label(request: Request, render_req: RenderRequest) -> RenderResponse:
+    """
+    Render ZPL to PNG image.
+
+    This endpoint generates a PNG image from ZPL content without sending to a printer.
+    You can provide either:
+    - A template name (e.g., 'tube_2inX1in') with field values
+    - Raw ZPL content directly
+
+    Returns a URL to download the generated PNG.
+    """
+    zp = request.app.state.zp
+
+    # Validate that we have either template or zpl_content
+    if not render_req.template and not render_req.zpl_content:
+        raise HTTPException(
+            status_code=400, detail="Either 'template' or 'zpl_content' must be provided"
+        )
+
+    try:
+        # Generate ZPL string from template if not provided directly
+        if render_req.zpl_content:
+            zpl_string = render_req.zpl_content
+        else:
+            zpl_string = zp.formulate_zpl(
+                uid_barcode=render_req.uid_barcode,
+                alt_a=render_req.alt_a,
+                alt_b=render_req.alt_b,
+                alt_c=render_req.alt_c,
+                alt_d=render_req.alt_d,
+                alt_e=render_req.alt_e,
+                alt_f=render_req.alt_f,
+                label_zpl_style=render_req.template,
+            )
+
+        # Generate unique filename
+        timestamp = datetime.now().strftime("%Y-%m-%d_%H:%M:%S.%f")
+        template_name = render_req.template or "custom"
+        png_filename = f"zpl_render_{template_name}_{timestamp}.png"
+        png_path = xdg.get_generated_files_dir() / png_filename
+
+        # Render to PNG
+        zp.generate_label_png(zpl_string, str(png_path), relative=False)
+
+        return RenderResponse(
+            success=True,
+            message="PNG rendered successfully",
+            png_url=f"/generated/{png_filename}",
+        )
+    except FileNotFoundError as e:
+        raise HTTPException(status_code=404, detail=f"Template not found: {e}") from None
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Render failed: {e}") from None
+
+
+@router.post("/render/png")
+async def render_label_png(request: Request, render_req: RenderRequest):
+    """
+    Render ZPL to PNG and return the image directly.
+
+    Same as /render but returns the PNG file directly instead of a URL.
+    Useful for programmatic access where you want the image bytes.
+    """
+    zp = request.app.state.zp
+
+    # Validate that we have either template or zpl_content
+    if not render_req.template and not render_req.zpl_content:
+        raise HTTPException(
+            status_code=400, detail="Either 'template' or 'zpl_content' must be provided"
+        )
+
+    try:
+        # Generate ZPL string from template if not provided directly
+        if render_req.zpl_content:
+            zpl_string = render_req.zpl_content
+        else:
+            zpl_string = zp.formulate_zpl(
+                uid_barcode=render_req.uid_barcode,
+                alt_a=render_req.alt_a,
+                alt_b=render_req.alt_b,
+                alt_c=render_req.alt_c,
+                alt_d=render_req.alt_d,
+                alt_e=render_req.alt_e,
+                alt_f=render_req.alt_f,
+                label_zpl_style=render_req.template,
+            )
+
+        # Generate unique filename
+        timestamp = datetime.now().strftime("%Y-%m-%d_%H:%M:%S.%f")
+        template_name = render_req.template or "custom"
+        png_filename = f"zpl_render_{template_name}_{timestamp}.png"
+        png_path = xdg.get_generated_files_dir() / png_filename
+
+        # Render to PNG
+        zp.generate_label_png(zpl_string, str(png_path), relative=False)
+
+        # Return the file directly
+        return FileResponse(
+            path=str(png_path),
+            media_type="image/png",
+            filename=png_filename,
+        )
+    except FileNotFoundError as e:
+        raise HTTPException(status_code=404, detail=f"Template not found: {e}") from None
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Render failed: {e}") from None
+
+
 @router.get("/config")
-async def get_config(request: Request) -> Dict[str, Any]:
+async def get_config(request: Request) -> dict[str, Any]:
     """Get the current printer configuration."""
     zp = request.app.state.zp
-    return zp.printers
+    return dict(zp.printers)
 
 
 # ----- Lab Settings Endpoints -----
 
+
 class LabUpdateRequest(BaseModel):
     """Request model for updating lab settings."""
-    lab_name: Optional[str] = Field(None, description="Human-readable lab name")
-    available_locations: Optional[List[str]] = Field(None, description="List of valid locations")
+
+    lab_name: str | None = Field(None, description="Human-readable lab name")
+    available_locations: list[str] | None = Field(None, description="List of valid locations")
 
 
 class PrinterUpdateRequest(BaseModel):
     """Request model for updating printer settings."""
-    printer_name: Optional[str] = Field(None, description="User-friendly display name")
-    lab_location: Optional[str] = Field(None, description="Location within the lab")
-    notes: Optional[str] = Field(None, description="Optional notes")
-    label_zpl_styles: Optional[List[str]] = Field(None, description="Allowed ZPL styles")
-    default_label_style: Optional[str] = Field(None, description="Default label style to use when none specified")
+
+    printer_name: str | None = Field(None, description="User-friendly display name")
+    lab_location: str | None = Field(None, description="Location within the lab")
+    notes: str | None = Field(None, description="Optional notes")
+    label_zpl_styles: list[str] | None = Field(None, description="Allowed ZPL styles")
+    default_label_style: str | None = Field(
+        None, description="Default label style to use when none specified"
+    )
 
 
 @router.patch("/labs/{lab}", response_model=LabInfo)
@@ -274,7 +417,9 @@ async def update_printer(
 
     lab_printers = labs[lab].get("printers", {})
     if printer_id not in lab_printers:
-        raise HTTPException(status_code=404, detail=f"Printer '{printer_id}' not found in lab '{lab}'")
+        raise HTTPException(
+            status_code=404, detail=f"Printer '{printer_id}' not found in lab '{lab}'"
+        )
 
     printer_data = lab_printers[printer_id]
 
@@ -288,12 +433,16 @@ async def update_printer(
         printer_data["label_zpl_styles"] = update.label_zpl_styles
     if update.default_label_style is not None:
         # Validate that the style exists in label_zpl_styles (if it's not empty string)
-        if update.default_label_style and update.default_label_style not in printer_data.get("label_zpl_styles", []):
+        if update.default_label_style and update.default_label_style not in printer_data.get(
+            "label_zpl_styles", []
+        ):
             raise HTTPException(
                 status_code=400,
-                detail=f"Default label style '{update.default_label_style}' must be one of: {printer_data.get('label_zpl_styles', [])}"
+                detail=f"Default label style '{update.default_label_style}' must be one of: {printer_data.get('label_zpl_styles', [])}",
             )
-        printer_data["default_label_style"] = update.default_label_style if update.default_label_style else None
+        printer_data["default_label_style"] = (
+            update.default_label_style if update.default_label_style else None
+        )
 
     # Save changes
     zp.save_printer_json(zp.printers_filename, relative=False)

zebra_day/web/routers/ui.py

@@ -4,22 +4,20 @@ UI router for zebra_day web interface.
 Provides HTML endpoints for the web-based management interface.
 All routes use the modern UI design with responsive layouts.
 """
+
 from __future__ import annotations
 
 import json
-import os
-import subprocess
 import tempfile
 import time
 from datetime import datetime
 from pathlib import Path
-from typing import Optional
 
-from fastapi import APIRouter, Request, Form, HTTPException
+from fastapi import APIRouter, Form, HTTPException, Request
 from fastapi.responses import HTMLResponse, RedirectResponse, Response
 
-from zebra_day.logging_config import get_logger
 import zebra_day.cmd_mgr as zdcm
+from zebra_day.logging_config import get_logger
 
 _log = get_logger(__name__)
 
@@ -92,6 +90,7 @@ def get_stats(zp, pkg_path: Path) -> dict:
 # MODERN UI ROUTES (root level)
 # =============================================================================
 
+
 @router.get("/", response_class=HTMLResponse)
 async def modern_dashboard(request: Request):
     """Modern dashboard - home page."""
@@ -145,19 +144,21 @@ async def modern_printers_by_lab(request: Request, lab: str):
 
     printers = []
     for name, info in lab_printers.items():
-        printers.append({
-            "id": name,
-            "name": info.get("printer_name") or name,  # Display name or fallback to ID
-            "printer_name": info.get("printer_name"),
-            "ip_address": info.get("ip_address", ""),
-            "lab_location": info.get("lab_location"),
-            "manufacturer": info.get("manufacturer", "zebra"),
-            "model": info.get("model", ""),
-            "serial": info.get("serial", ""),
-            "label_zpl_styles": info.get("label_zpl_styles", []),
-            "status": "online" if info.get("ip_address") else "unknown",
-            "notes": info.get("notes", ""),
-        })
+        printers.append(
+            {
+                "id": name,
+                "name": info.get("printer_name") or name,  # Display name or fallback to ID
+                "printer_name": info.get("printer_name"),
+                "ip_address": info.get("ip_address", ""),
+                "lab_location": info.get("lab_location"),
+                "manufacturer": info.get("manufacturer", "zebra"),
+                "model": info.get("model", ""),
+                "serial": info.get("serial", ""),
+                "label_zpl_styles": info.get("label_zpl_styles", []),
+                "status": "online" if info.get("ip_address") else "unknown",
+                "notes": info.get("notes", ""),
+            }
+        )
 
     ip_root = ".".join(request.app.state.local_ip.split(".")[:-1])
 
@@ -332,13 +333,13 @@ async def modern_template_preview(
         template_name = filepath.stem
         output_path = output_dir / f"{template_name}_preview.png"
 
-        result = zp.generate_label_png(zpl_content, str(output_path), False)
+        zp.generate_label_png(zpl_content, str(output_path), False)
 
         # Return redirect to the generated file
         return RedirectResponse(url=f"/files/{template_name}_preview.png", status_code=303)
 
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Preview generation failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Preview generation failed: {e}") from None
 
 
 @router.get("/config", response_class=HTMLResponse)
@@ -360,12 +361,16 @@ async def modern_config(request: Request):
         "backups": stats["backups"],
     }
 
+    # Get the config file path that was loaded
+    config_file_path = getattr(zp, "printers_filename", "Unknown")
+
     context = get_modern_context(
         request,
         active_page="config",
         labs=labs,
         ip_root=ip_root,
         config_summary=config_summary,
+        config_file_path=config_file_path,
     )
     return templates.TemplateResponse("modern/config.html", context)
 
@@ -388,7 +393,7 @@ async def modern_config_view(request: Request):
 
 
 @router.get("/config/edit", response_class=HTMLResponse)
-async def modern_config_edit(request: Request, error_msg: Optional[str] = None):
+async def modern_config_edit(request: Request, error_msg: str | None = None):
     """Edit printer configuration JSON."""
     zp = request.app.state.zp
     templates = request.app.state.templates
@@ -433,10 +438,7 @@ async def modern_config_save(request: Request, json_data: str = Form(...)):
         return RedirectResponse(url="/config", status_code=303)
 
     except json.JSONDecodeError as e:
-        return RedirectResponse(
-            url=f"/config/edit?error_msg=Invalid JSON: {e}",
-            status_code=303
-        )
+        return RedirectResponse(url=f"/config/edit?error_msg=Invalid JSON: {e}", status_code=303)
 
 
 @router.get("/config/backups", response_class=HTMLResponse)
@@ -504,9 +506,7 @@ async def modern_config_scan(
 ):
     """Scan network for printers."""
     zp = request.app.state.zp
-    zp.probe_zebra_printers_add_to_printers_json(
-        ip_stub=ip_stub, scan_wait=scan_wait, lab=lab
-    )
+    zp.probe_zebra_printers_add_to_printers_json(ip_stub=ip_stub, scan_wait=scan_wait, lab=lab)
     time.sleep(2.2)
     return RedirectResponse(url=f"/printers/{lab}", status_code=303)
 
@@ -514,7 +514,7 @@ async def modern_config_scan(
 @router.get("/_print_label", response_class=HTMLResponse)
 async def modern_print_label(
     request: Request,
-    lab: Optional[str] = None,
+    lab: str | None = None,
     printer: str = "",
     printer_ip: str = "",
     label_zpl_style: str = "",
@@ -565,7 +565,7 @@ async def modern_print_label(
     png_url = None
     if result and ".png" in str(result):
         png_name = str(result).split("/")[-1]
-        png_url = f"/files/{png_name}"
+        png_url = f"/generated/{png_name}"
 
     context = get_modern_context(
         request,
@@ -623,9 +623,7 @@ async def modern_png_renderer(
     files_dir = pkg_path / "files"
     files_dir.mkdir(parents=True, exist_ok=True)
 
-    png_tmp_f = tempfile.NamedTemporaryFile(
-        suffix=".png", dir=str(files_dir), delete=False
-    ).name
+    png_tmp_f = tempfile.NamedTemporaryFile(suffix=".png", dir=str(files_dir), delete=False).name
 
     zp.generate_label_png(content, png_fn=png_tmp_f)