Added copies, different printing mode, tape cache

Author: corvis

examples/demo-lib/template1/manifest.yaml

@@ -11,6 +11,7 @@ params:
 
 layout:
   template: |
-    <p><strong>M</strong>:&nbsp;{{param.default}}</p>
+    <p>{{param.default}}</p>
   css: |
     p.test { color: red; }
+    .label {font-size: 0.8em;}

src/tapen/cli.py

@@ -2,6 +2,7 @@
 import argparse
 import logging
 import sys
+from enum import Enum
 from pathlib import Path
 from typing import List, Dict, Any, Optional
 
@@ -17,11 +18,40 @@
 from tapen.common.domain import PrintJob
 from tapen.library import TemplateLibrary
 from tapen.printer import get_print_factory, PrinterFactory, TapenPrinter
+from tapen.printer.common import PrintingMode, TapeInfo
 from tapen.renderer import get_default_renderer, Renderer
 
 LOGGER = logging.getLogger("cli")
 
 
+class EnumAction(argparse.Action):
+    """
+    Argparse action for handling Enums
+    """
+
+    def __init__(self, **kwargs):
+        # Pop off the type value
+        enum_type = kwargs.pop("type", None)
+
+        # Ensure an Enum subclass is provided
+        if enum_type is None:
+            raise ValueError("type must be assigned an Enum when using EnumAction")
+        if not issubclass(enum_type, Enum):
+            raise TypeError("type must be an Enum when using EnumAction")
+
+        # Generate choices from the Enum
+        kwargs.setdefault("choices", tuple(e.value for e in enum_type))
+
+        super(EnumAction, self).__init__(**kwargs)
+
+        self._enum = enum_type
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        # Convert value back into an Enum
+        value = self._enum(values)
+        setattr(namespace, self.dest, value)
+
+
 class GlobalConfigFile(GlobalArgsExtension):
 
     @classmethod
@@ -87,6 +117,9 @@ def get_printer(self) -> TapenPrinter:
         assert self.__printer_factory is not None, "Class is not initialized. Forgot self.init()?"
         return self.__printer_factory.get_first_printer()
 
+    def get_cached_tape_info(self, printer_id: Optional[str]=None) -> Optional[TapeInfo]:
+        return self.__printer_factory.get_cached_tape_info(printer_id)
+
 
 class ImportLibExtension(BaseCliExtension):
     COMMAND_NAME = "import-lib"
@@ -114,8 +147,18 @@ class PrintExtension(BaseCliExtension):
 
     @classmethod
     def setup_parser(cls, parser: argparse.ArgumentParser):
-        parser.add_argument("template", action="store", help="Template to use")
-        parser.add_argument("data", nargs="*", action="store", help="Data to be printed (will be passed into template)")
+        parser.add_argument("-m", "--mode", action=EnumAction, type=PrintingMode,
+                            choices=[x.value for x in PrintingMode], default=PrintingMode.HALF_CUT,
+                            help="Print mode (applicable for for more than one labels only)")
+        parser.add_argument("-c", "--copies", action="store", type=int, default=1,
+                            help="Print mode (applicable for for more than one labels only)")
+        parser.add_argument("-f", "--force-tape-detection", action="store_true", default=False,
+                            help="Forces tape detection even though there is a cached data")
+        parser.add_argument("-s", "--skip-printing", action="store_true", default=False,
+                            help="Renders data and skips printing on the real device")
+        parser.add_argument("template", action="store", type=str, help="Template to use")
+        parser.add_argument("data", nargs="*", action="store", type=str,
+                            help="Data to be printed (will be passed into template)")
 
     def __is_template_name(self, name: str) -> bool:
         return ":" in name
@@ -130,18 +173,39 @@ def handle(self, args: argparse.Namespace):
         template = self.template_library.load_template(template_name)
         # Load printer data
         printer = self.get_printer()
-        if printer is None:
+        if printer is None and not args.skip_printing:
             CLI.print_error("Printer is not connected.")
             exit(1)
         else:
             CLI.print_info("Detected printer: {}".format(printer))
-        printer.init()
-        printer_status = printer.get_status()
-        CLI.print_info("\tTape: {}".format(printer_status.tape_info))
-        for x in data:
-            print_job = PrintJob(template, dict(default=x), cut_tape=False)
-            bitmap = self.renderer.render_bitmap(print_job, printer_status.tape_info)
-            printer.print_image(bitmap, print_job.cut_tape)
+            printer.init()
+        tape_info = self.get_cached_tape_info()
+        if tape_info is None or args.force_tape_detection:
+            if not args.skip_printing or args.force_tape_detection:
+                printer_status = printer.get_status()
+                CLI.print_info("\tTape: {}".format(printer_status.tape_info))
+                tape_info = printer_status.tape_info
+            else:
+                if args.skip_printing:
+                    CLI.print_error("Tape information is not available in cache. Skip printing mode is not available")
+                    exit(2)
+        else:
+            CLI.print_info("Assuming tape: {}".format(tape_info))
+        label_num = 0
+        total_labels = len(data) * args.copies
+        for i, x in enumerate(data):
+            print_job = PrintJob(template, dict(default=x))
+            bitmap = self.renderer.render_bitmap(print_job, tape_info)
+            if not args.skip_printing:
+                for c in range(args.copies):
+                    label_num += 1
+                    if args.mode == PrintingMode.HALF_CUT:
+                        cut_tape = label_num == total_labels    # Cut the last label
+                    else:
+                        cut_tape = True
+                    printer.print_image(bitmap, cut_tape)
+            else:
+                CLI.print_warn("Printing skipped as per user request.")
 
 
 def main(argv: List[str]):

src/tapen/printer/__init__.py

@@ -1,13 +1,16 @@
 from typing import List, Optional
 
 from tapen.printer.brother import PTouchFactory
-from tapen.printer.common import PrinterFactory, TapenPrinter
+from tapen.printer.common import PrinterFactory, TapenPrinter, TapeInfo
 
 __DEFAULT_PRINT_FACTORY: Optional['DefaultPrinterFactory'] = None
 
 
 class DefaultPrinterFactory(PrinterFactory):
 
+    def get_cached_tape_info(self, printer_id: Optional[str] = None) -> TapeInfo:
+        return self.__ptouch_fectory.get_cached_tape_info(printer_id)
+
     def __init__(self) -> None:
         super().__init__()
         self.__ptouch_fectory = PTouchFactory()

src/tapen/printer/brother.py

@@ -1,10 +1,17 @@
-from typing import List
+import pickle
+from pathlib import Path
+from typing import List, Optional
+
+from cli_rack.utils import ensure_dir
 
 from ptouch_py.core import Printer as PTouch_Printer, find_printers
 from ptouch_py.domain import PTStatus, TapeInfo as PTouch_TapeInfo, TAPE_PARAMS, BaseColorEnum, DEFAULT_DPI
+from tapen import config
 from tapen.printer.common import TapenPrinter, PrinterStatus, Color, TapeInfo, PrinterFactory
 from PIL.Image import Image
 
+TAPE_CACHE_DIR = Path(config.app_dirs.user_cache_dir) / "tape-cache"
+
 
 class PTouchTapeInfo(TapeInfo):
 
@@ -82,14 +89,41 @@ def print_image(self, image: Image, cut_tape=True):
         self._ptouch_printer.print_image(image, cut_tape)
 
     def get_status(self) -> PTouchPrinterStatus:
-        return PTouchPrinterStatus(self._ptouch_printer.get_status())
+        status = PTouchPrinterStatus(self._ptouch_printer.get_status())
+        self.__persist_tape_info(status.tape_info)
+        return status
 
     @property
     def verbose_name(self):
         return str(self._ptouch_printer)
 
+    @property
+    def id(self) -> str:
+        return self._ptouch_printer.serial_number
+
+    def __persist_tape_info(self, tape_info: TapeInfo):
+        ensure_dir(str(TAPE_CACHE_DIR))
+        cache_file = TAPE_CACHE_DIR / (self.id + ".bin")
+        with open(cache_file, "wb") as f:
+            pickle.dump(tape_info, f)
+
 
 class PTouchFactory(PrinterFactory):
 
+    def get_cached_tape_info(self, printer_id: Optional[str] = None) -> Optional[TapeInfo]:
+        ensure_dir(str(TAPE_CACHE_DIR))
+        cache_file: Optional[Path] = None
+        if printer_id:
+            cache_file = TAPE_CACHE_DIR / (printer_id + ".bin")
+        else:
+            for x in TAPE_CACHE_DIR.iterdir():
+                if x.is_file() and x.name.endswith(".bin"):
+                    cache_file = x
+                    continue
+        if cache_file is None or not cache_file.exists():
+            return
+        with open(cache_file, "rb") as f:
+            return pickle.load(f)
+
     def discover_printers(self) -> List[TapenPrinter]:
         return [PTouchPrinter(x) for x in find_printers()]

src/tapen/printer/common.py

@@ -1,11 +1,9 @@
 import abc
+from enum import Enum
 from typing import List, Optional
 
 from PIL.Image import Image
 
-from ptouch_py.core import find_printers
-
-
 class Color:
 
     def __init__(self, id: int, name: str, css_name: str) -> None:
@@ -85,10 +83,20 @@ def get_status(self) -> PrinterStatus:
     def verbose_name(self):
         raise NotImplementedError
 
+    @property
+    @abc.abstractmethod
+    def id(self) -> str:
+        pass
+
     def __str__(self) -> str:
         return self.verbose_name
 
 
+class PrintingMode(Enum):
+    HALF_CUT = "half-cut"
+    CUT = "cut"
+
+
 class PrinterFactory(abc.ABC):
 
     @abc.abstractmethod
@@ -98,3 +106,7 @@ def discover_printers(self) -> List[TapenPrinter]:
     def get_first_printer(self) -> Optional[TapenPrinter]:
         printers = self.discover_printers()
         return printers[0] if len(printers) > 0 else None
+
+    @abc.abstractmethod
+    def get_cached_tape_info(self, printer_id: Optional[str]=None) -> TapeInfo:
+        pass

src/tapen/renderer/common.py

@@ -20,6 +20,7 @@ class Renderer(abc.ABC):
     def __init__(self) -> None:
         super().__init__()
         self.persist_rendered_image_as_file = False
+        self.job_num = 0
 
     @abc.abstractmethod
     def render(self, print_job: PrintJob, tape_params: TapeInfo):

src/tapen/renderer/weasyprint.py

@@ -123,8 +123,9 @@ def render(self, print_job: PrintJob, tape_params: TapeInfo, is_preview=False, d
         rendered_label.write_png(result_png, resolution=dpi)
         result_png.flush()
         result_png.seek(0)
+        self.job_num += 1
         if self.persist_rendered_image_as_file:
-            path = self.__generate_temp_file("rendered-label.png")
+            path = self.__generate_temp_file("rendered-label-{}.png".format(self.job_num))
             with open(path, "wb") as f:
                 LOGGER.debug("Persisting generated image at {}".format(path))
                 f.write(result_png.read())
@@ -134,7 +135,7 @@ def render_bitmap(self, print_job: PrintJob, tape_params: TapeInfo, is_preview=F
         png = self.render(print_job, tape_params, is_preview, dpi)
         bitmap = Image.open(png, "r", ("png",)).convert("1", dither=0)
         if self.persist_rendered_image_as_file:
-            path = self.__generate_temp_file("rendered-label.bmp")
+            path = self.__generate_temp_file("rendered-label-{}.bmp".format(self.job_num))
             LOGGER.debug("Persisting rendered bitmap at {}".format(path))
             bitmap.save(path)