tinyprint 0.2.1__tar.gz → 0.2.2__tar.gz

{tinyprint-0.2.1/tinyprint.egg-info → tinyprint-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinyprint
-Version: 0.2.1
+Version: 0.2.2
 Summary: ui & cli to print zines with esc/pos printer
 Author-email: Levin Eric Zimmermann <levin.eric.zimmermann@posteo.com>
 License: GPL

{tinyprint-0.2.1 → tinyprint-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tinyprint"
-version = "0.2.1"
+version = "0.2.2"
 authors = [
     {name = "Levin Eric Zimmermann", email = "levin.eric.zimmermann@posteo.com"},
 ]
@@ -28,7 +28,7 @@ dev = [
 text = "GPL"
 
 [tool.setuptools]
-packages = ["tinyprint"]
+packages = ["tinyprint", "tinyprint.patches", "tinyprint.printer"]
 
 [project.scripts]
 tinyprint = "tinyprint.__main__:main"

tinyprint-0.2.2/tinyprint/patches/__init__.py

@@ -0,0 +1,5 @@
+"""Monkey patches"""
+
+from . import mako
+from . import escpos
+

tinyprint-0.2.2/tinyprint/patches/escpos.py

@@ -0,0 +1,172 @@
+"""Patching escpos library to cut between images without whitespace between
+
+See comment at Job.print for more details.
+"""
+
+from dataclasses import dataclass
+import logging
+import time
+from typing import Optional
+
+import six  # type: ignore
+
+from escpos.image import EscposImage  # type: ignore
+from escpos.escpos import Escpos  # type: ignore
+from escpos.constants import ESC, GS  # type: ignore
+from escpos.exceptions import ImageWidthError  # type: ignore
+from escpos.printer.usb import Usb as UsbPrinter  # type: ignore
+
+
+@dataclass
+class PrinterCommand:
+    """Wrapper for ESC/POS commands with an index for tracking command sequence.
+
+    This is used to track the position of commands for special handling,
+    particularly for paper cutting between images.
+    """
+    index: int      # Position in command sequence
+    cmd: bytes      # Raw ESC/POS command bytes
+
+
+
+if 1:
+
+    def _image(
+        self,
+        img_source,
+        high_density_vertical: bool = True,
+        high_density_horizontal: bool = True,
+        impl: str = "bitImageRaster",
+        fragment_height: int = 960,
+        center: bool = False,
+        cmd_index_offset: int = 0,
+    ) -> Optional[int]:
+        """Print an image.
+
+        You can select whether the printer should print in high density or not. The default value is high density.
+        When printing in low density, the image will be stretched.
+
+        Esc/Pos supplies several commands for printing. This function supports three of them. Please try to vary the
+        implementations if you have any problems. For example the printer `IT80-002` will have trouble aligning
+        images that are not printed in Column-mode.
+
+        The available printing implementations are:
+
+            * `bitImageRaster`: prints with the `GS v 0`-command
+            * `graphics`: prints with the `GS ( L`-command
+            * `bitImageColumn`: prints with the `ESC *`-command
+
+        When trying to center an image make sure you have initialized the printer with a valid profile, that
+        contains a media width pixel field. Otherwise the centering will have no effect.
+
+        :param img_source: PIL image or filename to load: `jpg`, `gif`, `png` or `bmp`
+        :param high_density_vertical: print in high density in vertical direction *default:* True
+        :param high_density_horizontal: print in high density in horizontal direction *default:* True
+        :param impl: choose image printing mode between `bitImageRaster`, `graphics` or `bitImageColumn`
+        :param fragment_height: Images larger than this will be split into multiple fragments *default:* 960
+        :param center: Center image horizontally *default:* False
+
+        """
+        im = EscposImage(img_source)
+
+        try:
+            if self.profile.profile_data["media"]["width"]["pixels"] == "Unknown":
+                logging.debug(
+                    "The media.width.pixel field of the printer profile is not set. "
+                    + "The center flag will have no effect."
+                )
+
+            max_width = int(self.profile.profile_data["media"]["width"]["pixels"])
+
+            if im.width > max_width:
+                raise ImageWidthError(f"{im.width} > {max_width}")
+
+            if center:
+                im.center(max_width)
+        except KeyError:
+            # If the printer's pixel width is not known, print anyways...
+            pass
+        except ValueError:
+            # If the max_width cannot be converted to an int, print anyways...
+            pass
+
+        if im.height > fragment_height:
+            fragments = im.split(fragment_height)
+            cmd_index_offset = 0
+            for fragment in fragments:
+                cmd_index_offset = self.image(
+                    fragment,
+                    high_density_vertical=high_density_vertical,
+                    high_density_horizontal=high_density_horizontal,
+                    impl=impl,
+                    fragment_height=fragment_height,
+                    cmd_index_offset=cmd_index_offset,
+                )
+                # XXX dummy printer doesn't have '_sleep_in_fragment' method
+                # self._sleep_in_fragment()
+            return None
+
+        if impl == "bitImageRaster":
+            # GS v 0, raster format bit image
+            density_byte = (0 if high_density_horizontal else 1) + (
+                0 if high_density_vertical else 2
+            )
+            header = (
+                GS
+                + b"v0"
+                + bytes((density_byte,))
+                + self._int_low_high(im.width_bytes, 2)
+                + self._int_low_high(im.height, 2)
+            )
+            self._raw(header + im.to_raster_format())
+
+        if impl == "graphics":
+            # GS ( L raster format graphics
+            img_header = self._int_low_high(im.width, 2) + self._int_low_high(
+                im.height, 2
+            )
+            tone = b"0"
+            colors = b"1"
+            ym = b"\x01" if high_density_vertical else b"\x02"
+            xm = b"\x01" if high_density_horizontal else b"\x02"
+            header = tone + xm + ym + colors + img_header
+            raster_data = im.to_raster_format()
+            self._image_send_graphics_data(b"0", b"p", header + raster_data)
+            self._image_send_graphics_data(b"0", b"2", b"")
+
+        if impl == "bitImageColumn":
+            # ESC *, column format bit image
+            density_byte = (1 if high_density_horizontal else 0) + (
+                32 if high_density_vertical else 0
+            )
+            header = (
+                ESC
+                + b"*"
+                + six.int2byte(density_byte)
+                + self._int_low_high(im.width, 2)
+            )
+            self._raw(PrinterCommand(cmd_index_offset, ESC + b"3" + six.int2byte(16)))
+            for i, blob in enumerate(im.to_column_format(high_density_vertical)):
+                cmd_index = i + 1 + cmd_index_offset
+                self._raw(PrinterCommand(cmd_index, header + blob + b"\n"))
+            self._raw(ESC + b"2")
+            return cmd_index_offset + i + 1
+
+        return None
+
+    Escpos.image = _image
+
+
+if 1:
+
+    # Usb printer: reduce likelihood for timeout gibberish
+
+    _Usb_raw_original = UsbPrinter._raw
+
+    def _Usb_raw(self, *args, **kwargs) -> None:
+        _Usb_raw_original(self, *args, **kwargs)
+        # NOTE Patch to reduce likelihood for timeout gibberish
+        while self._read():
+            time.sleep(0.01)
+
+    UsbPrinter._raw = _Usb_raw

tinyprint-0.2.2/tinyprint/patches/mako.py

@@ -0,0 +1,26 @@
+from marko import block
+
+# Allow multiple blank lines to create multiple blank lines
+
+
+class BlankLine(block.BlockElement):
+    """Blank lines"""
+
+    priority = 5
+
+    def __init__(self, start: int) -> None:
+        self._anchor = start
+
+    @classmethod
+    def match(cls, source) -> bool:
+        line = source.next_line()
+        return line is not None and not line.strip()
+
+    @classmethod
+    def parse(cls, source) -> int:
+        m = source.match
+        source.consume()
+        return m
+
+
+block.BlankLine = BlankLine  # type: ignore

tinyprint-0.2.2/tinyprint/printer/__init__.py

@@ -0,0 +1,2 @@
+from . import manager
+from . import profile

tinyprint-0.2.2/tinyprint/printer/manager.py

@@ -0,0 +1,137 @@
+"""Printer communication manager for handling ESC/POS printer interactions."""
+
+import functools
+import logging
+import time
+import threading
+from typing import Optional
+
+import six
+import usb  # type: ignore
+
+from escpos.constants import GS  # type: ignore
+from escpos.config import Config as escpos_Config  # type: ignore
+from escpos.printer import Dummy  # type: ignore
+
+from tinyprint.printer.profile import patch_printer_profile
+
+
+class Manager:
+    """Manages printer communication including connection handling and command sending."""
+
+    def __init__(self, config):
+        """Initialize the printer manager.
+
+        Args:
+            config: Configuration object containing printer settings.
+        """
+        self.config = config
+        self._logger = logging.getLogger(f"{__name__}.Manager")
+        self._print_job: Optional[threading.Thread] = None
+        self.is_printing = False
+
+    @functools.cached_property
+    def printer(self):
+        if not self.config.printer_config:
+            self._logger.warning("no printer config: use dummy printer")
+            p = Dummy()
+        else:
+            c = escpos_Config()
+            c.load(self.config.printer_config)
+            p = c.printer()
+        patch_printer_profile(p)
+        return p
+
+    def print(self, cmd_list):
+        """Start printing in background thread"""
+        self.is_printing = True
+
+        def _():
+            self._print(cmd_list)
+            self.is_printing = False
+
+        self._print_job = threading.Thread(target=_)
+        self._print_job.start()
+
+    def _print(self, cmd_list: list[bytes]):
+        try:
+            for cmd in cmd_list:
+                if not self.is_printing:
+                    break
+                self._print1(cmd)
+        finally:
+            # No matter what happens - make final cut.
+            # Final cut
+            #   66 => move to cut position
+            #   00 => then make full cut
+            self.printer._raw(GS + b"V" + six.int2byte(66) + b"\x00")
+
+    def _print1(self, cmd: bytes):
+        printer = self.printer
+        sleep_time = self.config.sleep_time or printer.profile.sleep_time
+        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:
+                self._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:
+            self._logger.warning("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
+            self._sleep(10)
+            printer.close()
+            self._sleep(10)
+            printer.open()
+            self._sleep(10)
+            # Finally try send command again
+            printer._raw(cmd)
+
+    def _sleep(self, total_time: float):
+        """Sleep that returns immediatelly if no longer printing"""
+        check_interval: float = 1
+        end_time = time.monotonic() + total_time
+
+        while time.monotonic() < end_time:
+            if not self.is_printing:
+                return
+            time.sleep(min(check_interval, end_time - time.monotonic()))
+
+    def wait(self, timeout: Optional[float] = None):
+        """Wait/block until print 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 printing"""
+        if self._print_job and self._print_job.is_alive():
+            self.is_printing = False
+            self.wait()
+
+    def close(self):
+        self._logger.info("close printer")
+        self.stop()
+        self.printer.close()
+
+    def __del__(self):
+        self.close()

tinyprint-0.2.2/tinyprint/printer/profile.py

@@ -0,0 +1,91 @@
+"""Printer profile management for the tinyprint application.
+
+This module provides functionality to manage and configure printer profiles
+for different ESC/POS compatible printers. It handles printer-specific settings
+and configurations to ensure optimal printing results across different printer
+models.
+
+The module includes functionality to:
+- Apply custom configurations to printer profiles
+- Handle printer model-specific settings
+- Configure connection-specific parameters
+- Set default values for various printing parameters
+"""
+
+from escpos.printer.usb import Usb as UsbPrinter  # type: ignore
+
+
+def patch_printer_profile(printer):
+    """Apply custom configuration to a printer's profile.
+
+    This function extends the printer's profile with additional settings and
+    configurations that are not included in the default ESC/POS profile. It
+    handles model-specific configurations and sets appropriate defaults for
+    various printing parameters.
+    """
+    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
+
+    # How many characters fit on one line with normal font size.
+    # 42 is also default for TM-T88III.
+    profile.default_char_count = 42
+    # How many characters fit on one line with heading font size.
+    # 21 is also default for TM-T88III.
+    profile.big_char_count = 21
+
+    # 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.default_char_count = 42
+            profile.big_char_count = 21
+            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,
+            )
+            # NOTE Numbers need less space than letters in case of this
+            # printer (there is space for 40 numbers). Let's use the
+            # smaller number to make sure everything always fits in one
+            # line.
+            profile.default_char_count = 33
+            profile.big_char_count = 16
+            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

{tinyprint-0.2.1 → tinyprint-0.2.2/tinyprint.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinyprint
-Version: 0.2.1
+Version: 0.2.2
 Summary: ui & cli to print zines with esc/pos printer
 Author-email: Levin Eric Zimmermann <levin.eric.zimmermann@posteo.com>
 License: GPL

{tinyprint-0.2.1 → tinyprint-0.2.2}/tinyprint.egg-info/SOURCES.txt

@@ -17,4 +17,10 @@ tinyprint.egg-info/SOURCES.txt
 tinyprint.egg-info/dependency_links.txt
 tinyprint.egg-info/entry_points.txt
 tinyprint.egg-info/requires.txt
-tinyprint.egg-info/top_level.txt
+tinyprint.egg-info/top_level.txt
+tinyprint/patches/__init__.py
+tinyprint/patches/escpos.py
+tinyprint/patches/mako.py
+tinyprint/printer/__init__.py
+tinyprint/printer/manager.py
+tinyprint/printer/profile.py