tinyprint 0.1.0__py3-none-any.whl

tinyprint/__init__.py

@@ -0,0 +1,5 @@
+from . import config
+from . import xescpos
+from . import jobconfig
+from . import job
+from . import preprocessor

tinyprint/__main__.py

@@ -0,0 +1,254 @@
+"""GUI for tinyprint"""
+
+from dataclasses import dataclass
+import os
+import logging
+from pathlib import Path
+import tempfile
+from typing import Optional
+
+from tkinter import Tk
+from tkinter import ttk
+import tkinter as tk
+
+from tkinter.filedialog import (
+    askopenfilename,
+    askopenfilenames,
+    asksaveasfilename,
+)
+
+from tinyprint.jobconfig import JobConfig
+from tinyprint.job import Job
+
+
+def main():
+    tempdir = tempfile.TemporaryDirectory(prefix="tinyprint")
+    try:
+        _main(tempdir.name)
+    finally:
+        tempdir.cleanup()
+
+
+def _main(tempdir: str):
+    root = Tk()
+    root.title("~ tiny print ~")
+    frm = ttk.Frame(root, padding=15)
+    frm.grid()
+
+    _no_hidden_files(root)
+
+    jcm = JobConfigManager(
+        JobConfigFields(frm), tempdir, filename_indicator=tk.StringVar(value="")
+    )
+    jm = JobManager(jcm)
+
+    ymax = 8
+
+    ttk.Button(frm, text="print", command=jm.print).grid(column=0, row=0)
+    ttk.Button(frm, text="stop", command=jm.stop).grid(column=1, row=0)
+
+    ttk.Separator(frm).grid(row=1, columnspan=ymax, sticky="ew", pady=10)
+
+    ttk.Label(frm, text="job config: ").grid(column=0, row=2)
+    ttk.Label(frm, textvariable=jcm.fields.filename).grid(
+        column=1, row=2, columnspan=3, pady=5, sticky="w"
+    )
+
+    ttk.Button(frm, text="new", command=jcm.new).grid(column=0, row=3, pady=5, padx=2)
+    ttk.Button(frm, text="open", command=jcm.open).grid(column=1, row=3, padx=2)
+    ttk.Button(frm, text="save", command=jcm.save).grid(column=2, row=3, padx=2)
+    ttk.Button(frm, text="save as ...", command=jcm.save_as).grid(
+        column=3, row=3, padx=2
+    )
+    ttk.Button(frm, text="reload", command=jcm.load).grid(column=4, row=3, padx=2)
+
+    ttk.Separator(frm).grid(row=4, columnspan=ymax, sticky="ew", pady=10)
+
+    ttk.Label(frm, text="resource: ").grid(
+        column=0, row=5, columnspan=2, sticky="w", pady=2
+    )
+    ttk.Button(frm, text="select", command=jcm.select_resource).grid(
+        column=2, row=5, sticky="w"
+    )
+    ttk.Label(frm, textvariable=jcm.fields.resource_list).grid(
+        column=4, row=5, columnspan=2, sticky="w"
+    )
+
+    ttk.Label(frm, text="printer configuration: ").grid(
+        column=0, row=6, columnspan=2, sticky="w", pady=2
+    )
+    ttk.Button(frm, text="select", command=jcm.select_printer_configuration).grid(
+        column=2, row=6, sticky="w"
+    )
+    ttk.Label(frm, textvariable=jcm.fields.printer_config).grid(
+        column=4, row=6, sticky="w"
+    )
+
+    ttk.Label(frm, text="cut: ").grid(column=0, row=7, columnspan=2, sticky="w", pady=2)
+    jcm.fields.cut.grid(column=2, row=7)
+    jcm.fields.cut.bind("<<ComboboxSelected>>", jcm.select_cut)
+
+    ttk.Label(frm, text="sleep time: ").grid(
+        column=0, row=8, columnspan=2, sticky="w", pady=2
+    )
+    ttk.Label(frm, textvariable=jcm.fields.sleep_time).grid(column=2, row=8, sticky="w")
+    ttk.Scale(frm, from_=0, to=2, command=jcm.select_sleep_time, length=500).grid(
+        column=3, row=8, columnspan=2
+    )
+
+    root.mainloop()
+
+
+# See https://stackoverflow.com/a/54068050
+def _no_hidden_files(root):
+    # call a dummy dialog with an impossible option to initialize the file
+    # dialog without really getting a dialog window; this will throw a
+    # TclError, so we need a try...except :
+    try:
+        root.tk.call("tk_getOpenFile", "-foobarbaz")
+    except tk.TclError:
+        pass
+    # now set the magic variables accordingly
+    root.tk.call("set", "::tk::dialog::file::showHiddenBtn", "1")
+    root.tk.call("set", "::tk::dialog::file::showHiddenVar", "0")
+
+
+class JobConfigFields:
+    def __init__(self, frm):
+        self.filename = tk.StringVar()
+        self.resource_list = tk.StringVar()
+        self.printer_config = tk.StringVar()
+        self.cut = ttk.Combobox(frm, values=["yes", "no"])
+        self.sleep_time = tk.DoubleVar()
+
+    def update(self, job_config: JobConfig):
+        resource_list = "; ".join(
+            [r[0].split(os.sep)[-1] for r in job_config.resource_list]
+        )
+        if len(resource_list) > 25:
+            resource_list = resource_list[:30] + " ..."
+        self.resource_list.set(resource_list)
+        self.printer_config.set(job_config.printer_config)
+        self.cut.set(("no", "yes")[job_config.cut])
+        self.sleep_time.set(job_config.sleep_time or 0)
+
+
+@dataclass
+class JobConfigManager:
+    fields: JobConfigFields
+
+    tempdir: str
+    temp_resource: Optional[str] = None
+
+    job_config: Optional[JobConfig] = None
+    filename: Optional[str] = None
+    filename_indicator: Optional[tk.StringVar] = None
+
+    def __post_init__(self):
+        self.temp_resource = f"{self.tempdir}/tmp-resource.md"
+        with open(self.temp_resource, "w") as f:
+            f.write("tiny printer test")
+        self.new(f"{self.tempdir}/tmp-print-job.json")
+
+    def new(self, *args, **kwargs):
+        self.job_config = JobConfig([(self.temp_resource, None)])
+        self.save_as(*args, **kwargs)
+        self.updatefields()
+
+    def open(self):
+        filetypes = (("print job configuration", "*.json"), ("All files", "*.*"))
+        if filename := askopenfilename(
+            title="Open a file", initialdir=str(Path.home()), filetypes=filetypes
+        ):
+            self.set_filename(filename)
+            self.load()
+
+    def save(self):
+        self.job_config.to_file(self.filename)
+
+    def save_as(self, filename: Optional[str] = None):
+        if not filename:
+            filetypes = (("print job configuration", "*.json"), ("All files", "*.*"))
+            filename = asksaveasfilename(
+                title="File path", filetypes=filetypes, initialdir=str(Path.home())
+            )
+            if not filename:
+                return
+        if not filename.endswith(".json"):
+            filename = f"{filename}.json"
+        self.set_filename(filename)
+        self.save()
+
+    def load(self):
+        if not self.filename:
+            return logging.warn("can't load as no file loaded yet")
+        logging.info(f"load {self.filename}")
+        self.job_config = JobConfig.from_file(self.filename)
+        self.updatefields()
+
+    def updatefields(self):
+        self.fields.update(self.job_config)
+
+    def set_filename(self, filename: str):
+        self.filename = filename
+        self.fields.filename.set(self.filename.split(os.sep)[-1])
+
+    def select_resource(self):
+        filetypes = (
+            ("all files", "*.*"),
+            ("pdf file", "*.pdf"),
+            ("image file", "*.jpg"),
+        )
+        file_tuple = askopenfilenames(
+            title="Open a file", initialdir=str(Path.home()), filetypes=filetypes
+        )
+        if not file_tuple:
+            return
+
+        resource_list = [(p, None) for p in file_tuple]
+
+        self.job_config.resource_list = resource_list
+        self.updatefields()
+
+    def select_printer_configuration(self):
+        filetypes = (
+            ("printer configuration", "*.yml"),
+            ("all files", "*.*"),
+        )
+        filename = askopenfilename(
+            title="Open a file", initialdir=str(Path.home()), filetypes=filetypes
+        )
+        if filename:
+            self.job_config.printer_config = filename
+            self.updatefields()
+
+    def select_cut(self, *_):
+        self.job_config.cut = {"yes": True, "no": False}[self.fields.cut.get()]
+
+    def select_sleep_time(self, value: str):
+        if self.job_config:
+            v = round(float(value), 2)
+            self.job_config.sleep_time = v
+            self.fields.sleep_time.set(v)
+
+
+@dataclass
+class JobManager:
+    job_config_manager: JobConfigManager
+    job: Optional[Job] = None
+
+    def print(self):
+        if self.job and self.job.is_printing:
+            return logging.warn("job already printing!")
+
+        config = self.job_config_manager.job_config
+        if config:
+            self.job = Job(config)
+            self.job.print()
+        else:
+            logging.warn("no job config set")
+
+    def stop(self):
+        if self.job:
+            self.job.stop()
+            self.job = None

tinyprint/config.py

@@ -0,0 +1,5 @@
+import logging
+
+LOGGING_LEVEL = logging.INFO
+
+del logging

tinyprint/job.py

@@ -0,0 +1,306 @@
+from dataclasses import dataclass
+import functools
+import logging
+import mimetypes
+import threading
+import traceback
+import time
+from typing import Optional
+
+from escpos.config import Config as escpos_Config  # type: ignore
+from escpos.constants import ESC, PAPER_PART_CUT, GS  # type: ignore
+from escpos.printer import Dummy  # type: ignore
+from escpos.printer.usb import Usb as UsbPrinter  # type: ignore
+import six
+
+import usb  # type: ignore
+
+import tinyprint
+from tinyprint.jobconfig import JobConfig, Resource
+from tinyprint import xescpos
+
+
+@dataclass
+class Job:
+    """Pre-process input files & prints them with ESC/POS printer."""
+
+    config: JobConfig
+    is_printing: bool = False
+    _print_job: Optional[threading.Thread] = None
+
+    def print(self):
+        self.is_printing = True
+        self._print_job = threading.Thread(target=self._print)
+        self._print_job.start()
+
+    def wait(self, timeout: Optional[float] = None):
+        """Wait/block until print job is finished"""
+        if self._print_job:
+            self._print_job.join(timeout)
+            self._print_job = None
+            self.is_printing = False
+
+    def stop(self):
+        """Stop currently running print job"""
+        if self._print_job and self._print_job.is_alive():
+            self._logger.info("  stop print! >")
+            self.is_printing = False
+            self.wait()
+
+    def _print(self):
+        self._logger.info("< preprocess input ...")
+        page_tuple = self._generate_page_tuple()
+        self._logger.info("  finished preprocessing >")
+        self._logger.info("< create ESC/POS codes ...")
+        cmd_list = self._generate_cmd_list(page_tuple)
+        self._logger.info("  finished creating ESC/POS codes >")
+        self._logger.info("< start printing")
+        self._send_to_printer(cmd_list)
+        self._logger.info("  finished printing >")
+        self.is_printing = False
+
+    def close(self):
+        self._logger.info("close printer")
+        self.stop()
+        self.printer.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args, **kwargs):
+        self.wait()
+        self.close()
+
+    def __del__(self):
+        self.close()
+
+    def _generate_cmd_list(self, page_tuple):
+        dummy = Dummy()
+        for copy_index in range(self.config.copy_count):
+            for i, page in enumerate(page_tuple):
+                try:
+                    page(dummy)
+                except Exception:
+                    tb = traceback.format_exc()
+                    self._logger.warn(f"error when printing page {i+1}: {tb}")
+        output_list = dummy._output_list
+        if self.config.cut:
+            return self._add_auto_cut(output_list)
+        else:
+            return [getattr(cmd, "cmd", cmd) for cmd in output_list]
+
+    def _add_auto_cut(self, output_list: list[bytes | xescpos.Cmd]) -> list[bytes]:
+        # NOTE In case we want to cut the paper after each image,
+        # we need to take special care to avoid whitespace between
+        # each image. This whitespace happens if we just use the
+        # default 'cut' method, because then the printer needs to
+        # feed the paper until it reaches the cutting point (when
+        # finished printing an image, some parts of the paper are
+        # still inside the printer). So what we need to do is:
+        #
+        #   - print image 1
+        #   - print image 2 partially
+        #   - cut paper
+        #   - print image 2 partially
+        #   - print image 3 partially
+        #   - cut paper
+        #   - ...
+        #
+        # XXX This cutting currently only works for 'bitImageColumn' images
+        # XXX This cutting currently only works for RessourceType PDF/ImageList
+        processed_list = []
+        img_cut_index = self.printer.profile.img_cut_index
+        for cmd in output_list:
+            match cmd:
+                case xescpos.Cmd():
+                    processed_list.append(cmd.cmd)
+                    if cmd.index == img_cut_index:
+                        processed_list.extend(
+                            [
+                                ESC + b"2",
+                                PAPER_PART_CUT,
+                                ESC + b"3" + six.int2byte(16),
+                            ]
+                        )
+                case _:
+                    processed_list.append(cmd)
+        return processed_list
+
+    def _generate_page_tuple(self):
+        page_list = []
+        for resource in self.config.resource_list:
+            preprocessor = self.resource_to_preprocessor(resource)
+            page_list.append(preprocessor(resource))
+        return tuple(page_list)
+
+    def _send_to_printer(self, cmd_list: list[bytes]):
+        printer = self.printer
+        sleep_time = self.config.sleep_time or printer.profile.sleep_time
+        try:
+            for cmd in cmd_list:
+                if not self.is_printing:
+                    break
+                try:
+                    printer._raw(cmd)
+                    # NOTE ( USB device printer fix )
+                    #
+                    # Do not lose any command:
+                    # Python sends faster commands than the matrix
+                    # printer can print. And the USB device doesn't
+                    # block until one print command is finished, but
+                    # returns immediately. If we run into a USBTimeout,
+                    # this becomes a serious problem, because then
+                    # we restart the printer & only resend the last command.
+                    # In case the previous command wasn't processed yet,
+                    # we'd lose this command (usually the paper cut).
+                    # To avoid this, we wait for a little time, to better
+                    # synchronize Python and the Matrix printer.
+                    if sleep_time and len(cmd) > 5:
+                        time.sleep(sleep_time)
+                # NOTE ( USB device printer fix )
+                # Don't give up when a time out happens - it seems USB
+                # connection is sometimes unstable & breaks.
+                except usb.core.USBTimeoutError:
+                    logging.warn("timed out ... reset printer")
+                    # We first read all data from printer to reduce the
+                    # likelihood that the printer outputs glitchy gibberish
+                    # to the print.
+                    while printer._read():
+                        time.sleep(0.01)
+                    # Then reset printer to make it workable again
+                    time.sleep(10)
+                    printer.close()
+                    time.sleep(10)
+                    printer.open()
+                    time.sleep(10)
+                    # Finally try send command again
+                    printer._raw(cmd)
+        finally:
+            # No matter what happens - make final cut.
+            # Final cut
+            #   66 => move to cut position
+            #   00 => then make full cut
+            printer._raw(GS + b"V" + six.int2byte(66) + b"\x00")
+
+    @functools.cached_property
+    def printer(self):
+        if not self.config.printer_config:
+            self._logger.warn("no printer config: use dummy printer")
+            return Dummy()
+        c = escpos_Config()
+        c.load(self.config.printer_config)
+        p = c.printer()
+        patch_printer_profile(p)
+        return p
+
+    @functools.cached_property
+    def _logger(self):
+        """The class based logger."""
+        cls = type(self)
+        logger = logging.getLogger(f"{cls.__module__}.{cls.__name__}")
+        logger.setLevel(tinyprint.config.LOGGING_LEVEL)
+        return logger
+
+    def resource_to_preprocessor(self, resource: Resource):
+        path = resource[0]
+        p = None
+        if _is_binary_file(path):
+            m = mimetypes.guess_type(path)
+            if m[0]:
+                if m[0].startswith("image"):
+                    p = _ImagePreprocessor()
+                elif m[0] == "application/pdf":
+                    p = _PdfPreprocessor()
+        else:
+            p = _MarkdownPreprocessor()
+        if not p:
+            raise NotImplementedError(f"can't guess type of {path}")
+        return p(self)
+
+
+def patch_printer_profile(printer):
+    """Auto-add printer-dependent options that aren't in escpos profile"""
+    profile = printer.profile
+
+    # Default values in case printer is unknown
+    profile.img_kwargs = {}
+    profile.img_cut_index = 3
+    profile.img_scale_factor = 1
+    profile.img_x_scale_factor = 1
+    profile.img_y_scale_factor = 1
+    profile.sleep_time = 0
+
+    # Special treatment for specific printer models.
+    match profile.profile_data["name"]:
+        case "TM-T88III":
+            profile.img_kwargs = dict(
+                impl="bitImageColumn",
+                high_density_vertical=True,
+                high_density_horizontal=True,
+                center=False,
+            )
+            profile.img_cut_index = 4
+        case "TM-U220B":
+            profile.img_kwargs = dict(
+                impl="bitImageColumn",
+                high_density_vertical=False,
+                high_density_horizontal=False,
+                center=False,
+                fragment_height=32,
+            )
+            profile.img_cut_index = 9
+            # Profile is wrong, it's 200 dots, not 400
+            # https://files.support.epson.com/pdf/pos/bulk/tm-u220_trg_en_std_reve.pdf
+            # https://github.com/receipt-print-hq/escpos-printer-db/pull/87/commits/242299097
+            profile.profile_data["media"]["width"]["pixels"] = 200
+
+        case _:
+            pass
+
+    # Special treatment for specific connections to printer.
+    match printer:
+        case UsbPrinter():
+            # Usb printer immediately returns, but is usually slower
+            # than Python - improve synchronicity & sleep after each
+            # print command. Otherwise we get a lot of timeouts &
+            # printed gibberish. The time here seems to depend on the
+            # printed material. If it's more dense & blackish / colorful,
+            # then we need a higher value to not run into any trouble.
+            # More spare material seems to be less problematic. Also
+            # the problem becomes bigger if we print multiple pages.
+            profile.sleep_time = 0.3
+        case _:
+            pass
+
+
+def _is_binary_file(path):
+    with open(path, "rb") as f:
+        header = f.read(1024)
+    textchars = bytearray({7, 8, 9, 10, 12, 13, 27} | set(range(0x20, 0x100)) - {0x7F})
+    return bool(header.translate(None, textchars))
+
+
+# XXX Fix circular import error
+
+
+@functools.cache
+def _ImagePreprocessor():
+    from tinyprint.preprocessor import ImagePreprocessor
+
+    return ImagePreprocessor
+
+
+@functools.cache
+def _PdfPreprocessor():
+
+    from tinyprint.preprocessor import PdfPreprocessor
+
+    return PdfPreprocessor
+
+
+@functools.cache
+def _MarkdownPreprocessor():
+
+    from tinyprint.preprocessor import MarkdownPreprocessor
+
+    return MarkdownPreprocessor

tinyprint/jobconfig.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import enum
+from typing import Any, Optional, TypeAlias
+
+from dataclasses_json import DataClassJsonMixin
+
+
+class Orientation(enum.Enum):
+    """Set if book has vertical or horizontal layout
+
+    Horizontal: | | |
+
+                __
+    Vertical:   __
+                __
+    """
+
+    HORIZONTAL = 0
+    VERTICAL = 1
+
+    @classmethod
+    def parse(cls, v: str):
+        return _parse_str(cls, v)
+
+
+def _parse_str(cls, v):
+    try:
+        return getattr(cls, v.upper())
+    except Exception:
+        raise AttributeError("{cls}: enum {v} not found")
+
+
+@dataclass
+class PageSize(DataClassJsonMixin):
+    width: float
+    heigth: float
+
+    @classmethod
+    def from_any(cls, obj: Any) -> PageSize:
+        match obj:
+            case PageSize():
+                return obj
+            case tuple() | list():
+                return PageSize(*obj)
+            case _:
+                raise NotImplementedError(f"can't parse {obj} to PageSize")
+
+
+ResourcePath: TypeAlias = str
+FragmentHeight: TypeAlias = Optional[int]
+Resource: TypeAlias = tuple[ResourcePath, FragmentHeight]
+
+
+@dataclass
+class JobConfig(DataClassJsonMixin):
+    resource_list: list[Resource]
+    printer_config: Optional[str] = None
+    copy_count: int = 1
+    cut: bool = True
+    orientation: Orientation = Orientation.HORIZONTAL
+    page_size: Optional[PageSize] = None
+    sleep_time: Optional[float] = None
+
+    def to_file(self, path: str):
+        with open(path, "w") as f:
+            f.write(self.to_json())
+
+    @classmethod
+    def from_file(cls, path: str):
+        with open(path, "r") as f:
+            return cls.from_json(f.read())