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

zebra_day/cli/printer.py

@@ -0,0 +1,168 @@
+"""Printer fleet management commands for zebra_day CLI."""
+
+import json
+import socket
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from zebra_day import paths as xdg
+
+printer_app = typer.Typer(help="Printer fleet management commands")
+console = Console()
+
+
+def _get_local_ip() -> str:
+    """Get local IP address."""
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("8.8.8.8", 80))
+        ip = s.getsockname()[0]
+        s.close()
+        return ip
+    except Exception:
+        return "127.0.0.1"
+
+
+@printer_app.command("scan")
+def scan(
+    ip_stub: Optional[str] = typer.Option(None, "--ip-stub", "-i", help="IP stub to scan (e.g., 192.168.1)"),
+    wait: float = typer.Option(0.25, "--wait", "-w", help="Seconds to wait per IP probe"),
+    lab: str = typer.Option("scan-results", "--lab", "-l", help="Lab name to assign found printers"),
+    json_output: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
+):
+    """Scan network for Zebra printers."""
+    # Determine IP stub if not provided
+    if not ip_stub:
+        local_ip = _get_local_ip()
+        ip_stub = ".".join(local_ip.split(".")[:-1])
+
+    if not json_output:
+        console.print(f"[cyan]→[/cyan] Scanning {ip_stub}.* for Zebra printers...")
+        console.print("[dim]  This may take a few minutes...[/dim]")
+
+    try:
+        import zebra_day.print_mgr as zdpm
+        zp = zdpm.zpl()
+        zp.probe_zebra_printers_add_to_printers_json(
+            ip_stub=ip_stub,
+            scan_wait=str(wait),
+            lab=lab,
+        )
+
+        found = []
+        if hasattr(zp, "printers") and "labs" in zp.printers and lab in zp.printers["labs"]:
+            for name, info in zp.printers["labs"][lab].items():
+                if isinstance(info, dict) and info.get("ip_address") not in ["dl_png"]:
+                    found.append({
+                        "name": name,
+                        "ip": info.get("ip_address"),
+                        "model": info.get("model", "unknown"),
+                        "serial": info.get("serial", "unknown"),
+                    })
+
+        if json_output:
+            console.print(json.dumps(found, indent=2))
+        else:
+            console.print(f"\n[green]✓[/green] Found {len(found)} printer(s)")
+            if found:
+                table = Table()
+                table.add_column("Name", style="cyan")
+                table.add_column("IP Address")
+                table.add_column("Model")
+                table.add_column("Serial")
+                for p in found:
+                    table.add_row(p["name"], p["ip"], p["model"], p["serial"])
+                console.print(table)
+
+    except Exception as e:
+        if json_output:
+            console.print(json.dumps({"error": str(e)}))
+        else:
+            console.print(f"[red]✗[/red] Scan error: {e}")
+        raise typer.Exit(1)
+
+
+@printer_app.command("list")
+def list_printers(
+    lab: Optional[str] = typer.Option(None, "--lab", "-l", help="Filter by lab name"),
+    json_output: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
+):
+    """List configured printers."""
+    try:
+        import zebra_day.print_mgr as zdpm
+        zp = zdpm.zpl()
+
+        printers = []
+        if hasattr(zp, "printers") and "labs" in zp.printers:
+            for lab_name, lab_printers in zp.printers["labs"].items():
+                if lab and lab_name != lab:
+                    continue
+                for name, info in lab_printers.items():
+                    if isinstance(info, dict):
+                        printers.append({
+                            "lab": lab_name,
+                            "name": name,
+                            "ip": info.get("ip_address", "unknown"),
+                            "model": info.get("model", "unknown"),
+                            "styles": info.get("label_zpl_styles", []),
+                        })
+
+        if json_output:
+            console.print(json.dumps(printers, indent=2))
+            return
+
+        if not printers:
+            console.print("[yellow]⚠[/yellow] No printers configured")
+            console.print("   Run [cyan]zday printer scan[/cyan] to discover printers")
+            return
+
+        table = Table(title="Configured Printers")
+        table.add_column("Lab", style="cyan")
+        table.add_column("Name")
+        table.add_column("IP Address")
+        table.add_column("Model")
+        table.add_column("Label Styles")
+        for p in printers:
+            styles = ", ".join(p["styles"][:2])
+            if len(p["styles"]) > 2:
+                styles += f" (+{len(p['styles'])-2})"
+            table.add_row(p["lab"], p["name"], p["ip"], p["model"], styles)
+        console.print(table)
+
+    except Exception as e:
+        if json_output:
+            console.print(json.dumps({"error": str(e)}))
+        else:
+            console.print(f"[red]✗[/red] Error: {e}")
+        raise typer.Exit(1)
+
+
+@printer_app.command("test")
+def test_print(
+    printer_name: str = typer.Argument(..., help="Printer name or IP address"),
+    lab: str = typer.Option("scan-results", "--lab", "-l", help="Lab containing the printer"),
+    label_style: str = typer.Option("tube_2inX1in", "--style", "-s", help="Label style to print"),
+):
+    """Send a test print to a specific printer."""
+    try:
+        import zebra_day.print_mgr as zdpm
+        zp = zdpm.zpl()
+
+        console.print(f"[cyan]→[/cyan] Sending test print to {printer_name}...")
+        result = zp.print_zpl(
+            lab=lab,
+            printer_name=printer_name,
+            uid_barcode="TEST-PRINT",
+            alt_a="Test Label",
+            alt_b="zebra_day CLI",
+            label_zpl_style=label_style,
+        )
+        console.print(f"[green]✓[/green] Test print sent successfully")
+
+    except Exception as e:
+        console.print(f"[red]✗[/red] Print error: {e}")
+        raise typer.Exit(1)
+

zebra_day/cli/template.py

@@ -0,0 +1,176 @@
+"""ZPL template management commands for zebra_day CLI."""
+
+import json
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from zebra_day import paths as xdg
+
+template_app = typer.Typer(help="ZPL template management commands")
+console = Console()
+
+
+def _get_template_dirs() -> list[Path]:
+    """Get all template directories."""
+    from importlib.resources import files
+
+    dirs = []
+    # XDG data directory
+    xdg_styles = xdg.get_label_styles_dir()
+    if xdg_styles.exists():
+        dirs.append(xdg_styles)
+
+    # Package directory
+    try:
+        pkg_styles = Path(str(files("zebra_day"))) / "etc" / "label_styles"
+        if pkg_styles.exists():
+            dirs.append(pkg_styles)
+    except Exception:
+        pass
+
+    return dirs
+
+
+def _find_template(name: str) -> Optional[Path]:
+    """Find a template file by name."""
+    for template_dir in _get_template_dirs():
+        # Try exact match
+        for ext in ["", ".zpl", ".txt"]:
+            path = template_dir / f"{name}{ext}"
+            if path.exists():
+                return path
+        # Try with zpl_ prefix
+        for ext in ["", ".zpl", ".txt"]:
+            path = template_dir / f"zpl_{name}{ext}"
+            if path.exists():
+                return path
+    return None
+
+
+@template_app.command("list")
+def list_templates(
+    json_output: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show full paths"),
+):
+    """List available ZPL templates."""
+    templates = []
+
+    for template_dir in _get_template_dirs():
+        for f in template_dir.iterdir():
+            if f.is_file() and not f.name.startswith("."):
+                if f.suffix in [".zpl", ".txt", ""] or f.name.startswith("zpl_"):
+                    templates.append({
+                        "name": f.stem,
+                        "path": str(f),
+                        "size": f.stat().st_size,
+                        "source": "user" if "zebra_day" not in str(template_dir) else "package",
+                    })
+
+    # Dedupe by name, prefer user templates
+    seen = {}
+    for t in templates:
+        if t["name"] not in seen or t["source"] == "user":
+            seen[t["name"]] = t
+    templates = list(seen.values())
+
+    if json_output:
+        console.print(json.dumps(templates, indent=2))
+        return
+
+    if not templates:
+        console.print("[yellow]⚠[/yellow] No templates found")
+        return
+
+    table = Table(title="ZPL Templates")
+    table.add_column("Name", style="cyan")
+    table.add_column("Source")
+    table.add_column("Size")
+    if verbose:
+        table.add_column("Path", style="dim")
+
+    for t in sorted(templates, key=lambda x: x["name"]):
+        source_style = "[green]user[/green]" if t["source"] == "user" else "[dim]package[/dim]"
+        if verbose:
+            table.add_row(t["name"], source_style, f"{t['size']} bytes", t["path"])
+        else:
+            table.add_row(t["name"], source_style, f"{t['size']} bytes")
+
+    console.print(table)
+
+
+@template_app.command("preview")
+def preview(
+    template_name: str = typer.Argument(..., help="Template name to preview"),
+    output: Optional[str] = typer.Option(None, "--output", "-o", help="Output PNG file path"),
+):
+    """Generate a PNG preview of a ZPL template."""
+    template_path = _find_template(template_name)
+    if not template_path:
+        console.print(f"[red]✗[/red] Template not found: {template_name}")
+        raise typer.Exit(1)
+
+    console.print(f"[cyan]→[/cyan] Generating preview for {template_name}...")
+
+    try:
+        import zebra_day.print_mgr as zdpm
+        zp = zdpm.zpl()
+
+        # Read template
+        zpl_content = template_path.read_text()
+
+        # Generate PNG
+        if not output:
+            output_path = xdg.get_generated_files_dir() / f"{template_name}_preview.png"
+        else:
+            output_path = Path(output)
+
+        result = zp.generate_label_png(zpl_content, str(output_path), False)
+        console.print(f"[green]✓[/green] Preview generated: {output_path}")
+
+    except Exception as e:
+        console.print(f"[red]✗[/red] Preview error: {e}")
+        raise typer.Exit(1)
+
+
+@template_app.command("edit")
+def edit(
+    template_name: str = typer.Argument(..., help="Template name to edit"),
+    editor: Optional[str] = typer.Option(None, "--editor", "-e", help="Editor command"),
+):
+    """Open a ZPL template in an editor."""
+    template_path = _find_template(template_name)
+    if not template_path:
+        console.print(f"[red]✗[/red] Template not found: {template_name}")
+        raise typer.Exit(1)
+
+    # Determine editor
+    if not editor:
+        editor = os.environ.get("VISUAL") or os.environ.get("EDITOR") or "vi"
+
+    console.print(f"[cyan]→[/cyan] Opening {template_path} with {editor}...")
+    try:
+        subprocess.run([editor, str(template_path)])
+    except Exception as e:
+        console.print(f"[red]✗[/red] Error opening editor: {e}")
+        raise typer.Exit(1)
+
+
+@template_app.command("show")
+def show(
+    template_name: str = typer.Argument(..., help="Template name to display"),
+):
+    """Display the contents of a ZPL template."""
+    template_path = _find_template(template_name)
+    if not template_path:
+        console.print(f"[red]✗[/red] Template not found: {template_name}")
+        raise typer.Exit(1)
+
+    console.print(f"[dim]# {template_path}[/dim]\n")
+    console.print(template_path.read_text())
+

zebra_day/cmd_mgr.py

@@ -0,0 +1,35 @@
+"""
+  Tools to manage a zebra printer fleet and expose an API for routing print requests.
+"""
+
+import socket
+
+class ZebraPrinter:
+
+    def __init__(self, ip_address, port=9100, buffer_size=1024):
+        self.ip_address = ip_address
+        self.port = port
+        self.buffer_size = buffer_size
+
+        
+    def send_command(self, command):
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.connect((self.ip_address, self.port))
+            s.sendall(command.encode())
+            response = s.recv(self.buffer_size)
+        return response.decode()
+
+    
+    def get_configuration(self):
+        """Retrieve printer configuration using ^HH command"""
+        return self.send_command("^XA^HH^XZ")
+
+    
+    def set_configuration(self, config):
+        """
+        Set printer configuration. 
+        The `config` parameter should contain the necessary ZPL commands to adjust the configuration.
+        After sending the configuration commands, the ^JUS command saves the configuration.
+        """
+        self.send_command(config)
+        return self.send_command("^XA^JUS^XZ")

zebra_day/etc/label_styles/cornersStripOf4Squares_1inX1in.zpl

@@ -0,0 +1,55 @@
+^XA
+^FO25,10
+^ADN,20,12
+^FDWW^FS
+^FO180,10
+^ADN,20,12
+^FDXX^FS
+^FO180,150
+^ADN,20,12
+^FDYY^FS
+^FO25,150
+^ADN,20,12
+^FDZZ^FS
+
+^FO225,10
+^ADN,20,12
+^FDWW^FS
+^FO380,10
+^ADN,20,12
+^FDXX^FS
+^FO380,150
+^ADN,20,12
+^FDYY^FS
+^FO225,150
+^ADN,20,12
+^FDZZ^FS
+
+^FO450,10
+^ADN,20,12
+^FDWW^FS
+^FO570,10
+^ADN,20,12
+^FDXX^FS
+^FO570,150
+^ADN,20,12
+^FDYY^FS
+^FO450,150
+^ADN,20,12
+^FDZZ^FS
+
+
+^FO660,10
+^ADN,20,12
+^FDWW^FS
+^FO780,10
+^ADN,20,12
+^FDXX^FS
+^FO780,150
+^ADN,20,12
+^FDYY^FS
+^FO660,150
+^ADN,20,12
+^FDZZ^FS
+
+^XZ

zebra_day/etc/label_styles/corners_1inX2in.zpl

@@ -0,0 +1,28 @@
+^XA          ; Start of ZPL
+^MMT         ; Print mode: Tear-off
+^PW406       ; Label width: 2 inches x 203 DPI = 406 dots
+^LL203       ; Label length: 1 inch x 203 DPI = 203 dots
+^LS0         ; Label shift: no shift
+
+; Top-left 'X'
+^FO5,5       ; Position: 5 dots from left, 5 dots from top
+^A0N,24,24   ; Font: scalable, height: 24 dots, width: 24 dots
+^FDX^FS      ; Data: 'X'
+
+; Top-right 'X'
+^FO376,5     ; Position: (2 inches - width of 'X' - 5 dots) from left, 5 dots from top
+^A0N,24,24
+^FDX^FS
+
+; Bottom-left 'X'
+^FO5,174     ; Position: 5 dots from left, (1 inch - height of 'X' - 5 dots) from top
+^A0N,24,24
+^FDX^FS
+
+; Bottom-right 'X'
+^FO376,174
+^A0N,24,24
+^FDX^FS
+
+^PQ1         ; Print quantity: 1 label
+^XZ          ; End of ZPL

zebra_day/etc/label_styles/corners_20cmX30cm.zpl

@@ -0,0 +1,6 @@
+^XA
+^FO300,10^FDX^FS
+^FO100,10^FDX^FS    
+^FO300,150^FDX^FS  
+^FO100,150^FDX^FS  
+^XZ

zebra_day/etc/label_styles/corners_smallTube.zpl

@@ -0,0 +1,7 @@
+^XA
+^FO120,10^FDX^FS
+^FO120,110^FDX^FS
+^FO355,10^FDX^FS  
+^FO355,110^FDX^FS
+^FO433,63^FDX^FS  
+^XZ

zebra_day/etc/label_styles/corners_unspecifiedDimensions.zpl

@@ -0,0 +1,15 @@
+^XA
+^FO30,10
+^ADN,30,20
+^FD{XX}^FS
+^FO300,10
+^ADN,30,20
+^FD{YY}^FS
+^FO300,200
+^ADN,25,12
+^FD{ZZ}^FS
+^FO250,10
+^FO30,170
+^ADN,30,20
+^FD{WW}^FS
+^XZ

zebra_day/etc/label_styles/generic_2inX1in.zpl

@@ -0,0 +1,21 @@
+^XA
+^FO235,20
+^BY1
+^B3N,N,40,N,N
+^FD{uid_barcode}^FS
+^FO235,70
+^ADN,30,20
+^FD{uid_barcode}^FS
+^FO235,115
+^ADN,25,12
+^FD{alt_a}^FS
+^FO235,145
+^ADN,25,12
+^FD{alt_b}^FS
+^FO235,170
+^ADN,26,20
+^FD{alt_c}^FS
+^FO410,140
+^ADN,22,10
+^FD{alt_d}^FS
+^XZ

zebra_day/etc/label_styles/plate_1inX0.25in.zpl

@@ -0,0 +1,9 @@
+^XA
+^FO232,13
+^BY1
+^B3N,N,22,N,N
+^FD{uid_barcode}^FS
+^FO232,39
+^ADN,20,11
+^FD{uid_barcode} : {alt_a}^FS
+^XZ

zebra_day/etc/label_styles/plate_1inX0.25inHD.zpl

@@ -0,0 +1,9 @@
+^XA
+^FO220,15
+^BY1
+^B3N,N,33,N,N
+^FD{uid_barcode}^FS
+^FO220,53
+^ADN,30,17
+^FD{uid_barcode} : {alt_a}^FS
+^XZ

zebra_day/etc/label_styles/smallTubeWdotHD_prod.zpl

@@ -0,0 +1,8 @@
+^XA
+^FO395,23^BY1.5^BCN,75,N,N,N^FD{uid_barcode}^FS
+^FO395,105^A0N,48,48^FD{uid_barcode}^FS
+^FO395,150^A0N,48,48^FD{alt_a}^FS
+^FO815,75
+^BXN,4.5,300
+^FD{uid_barcode}^FS
+^XZ

zebra_day/etc/label_styles/smallTubeWdot_corners.zpl

@@ -0,0 +1,7 @@
+^XA
+^FO240,10^FDX^FS
+^FO240,110^FDX^FS
+^FO465,10^FDX^FS  
+^FO465,110^FDX^FS
+^FO553,63^FDX^FS  
+^XZ

zebra_day/etc/label_styles/smallTubeWdot_prod.zpl

@@ -0,0 +1,8 @@
+^XA
+^FO250,15^BY1^BCN,50,N,N,N^FD{uid_barcode}^FS
+^FO250,70^A0N,32,32^FD{uid_barcode}^FS
+^FO250,100^A0N,32,32^FD{alt_a}^FS
+^FO535,50
+^BXN,3,200
+^FD{uid_barcode}^FS
+^XZ

zebra_day/etc/label_styles/smallTubeWdot_prodAlt1.zpl

@@ -0,0 +1,6 @@
+^XA
+^FO250,15^BY1^BCN,50,N,N,N^FD{uid_barcode}^FS
+^FO250,70^A0N,32,32^FD{uid_barcode}^FS
+^FO250,100^A0N,32,32^FD{alt_a}^FS
+^FO510,65^A0N,16,16^FD{alt_a}^FS
+^XZ

zebra_day/etc/label_styles/smallTubeWdot_prodAlt1b.zpl

@@ -0,0 +1,3 @@
+^XA
+^FO250,50^A0N,26,26^FD{alt_b}^FS
+^XZ

zebra_day/etc/label_styles/smallTubeWdot_prodV2.zpl

@@ -0,0 +1,8 @@
+^XA
+^FO350,15^A0N,32,32^FD{alt_a}^FS
+^FO350,50^A0N,16,16^FD{uid_barcode}^FS
+^FO350,70^BY1^BCN,50,N,N,N^FD{uid_barcode}^FS
+^FO265,30
+^BXN,3,200
+^FD{uid_barcode}^FS
+^XZ

zebra_day/etc/label_styles/smallTubeWdot_reagent.zpl

@@ -0,0 +1,29 @@
+^XA
+^FO150,12
+^A0N, 12, 12
+^FDName:^FS
+^A0N, 12, 12
+^FO150,27
+^FDLot Number:^FS
+^FO150,40
+^A0N, 12, 12
+^FDPrep Date: DDMMMYYYY^FS  
+^FO82,40
+^A0N, 12, 12
+^FD123456^FS
+^FO90,58
+^A0N, 12, 12
+^FD123^FS
+^FO150,54
+^A0N, 12, 12
+^FDExp Date: DDMMMYYYY^FS
+^FO150,68
+^A0N, 12, 12
+^FDStore At:^FS
+^FO150,82
+^A0N, 12, 12
+^FDMade By:^FS
+^FO300,27
+^BQN,2,3
+^FDNameLotPrepEXP^FS  
+^XZ

zebra_day/etc/label_styles/stripOf4Squares_1inX1in.zpl

@@ -0,0 +1,32 @@
+^XA
+^FO30,30
+^ADN,30,24
+^FD{alt_a}^FS
+^FO30,85
+^ADN,20,12
+^FD{alt_b}^FS
+
+^FO230,30
+^ADN,30,24
+^FD{alt_a}^FS
+^FO230,85
+^ADN,20,12
+^FD{alt_b}^FS
+
+
+^FO450,30
+^ADN,30,24
+^FD{alt_a}^FS
+^FO450,85
+^ADN,20,12
+^FD{alt_b}^FS
+
+
+^FO650,30
+^ADN,30,24
+^FD{alt_a}^FS
+^FO650,85
+^ADN,20,12
+^FD{alt_b}^FS
+
+^XZ