tinyprint 0.2.4__py3-none-any.whl

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/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/patches.py

@@ -0,0 +1,28 @@
+"""Monkey patches"""
+
+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

tinyprint/preprocessor.py

@@ -0,0 +1,291 @@
+from __future__ import annotations
+
+import abc
+from functools import cached_property
+import mimetypes
+import os
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import Callable, TypeAlias, Optional
+
+from escpos.escpos import Escpos  # type: ignore
+from escpos.constants import TXT_STYLE  # type: ignore[import-untyped]
+import marko  # type: ignore
+from PIL import Image  # type: ignore
+from pdf2image import convert_from_path  # type: ignore
+
+from tinyprint.jobconfig import JobConfig, Resource, Orientation
+
+Page: TypeAlias = Callable[[Escpos], None]
+
+
+def create_pages_from_resources(config, printer_profile) -> tuple[Page, ...]:
+    """Convert a list of resources into printable page functions."""
+    page_list: list[Page] = []
+    for resource in config.resource_list:
+        preprocessor_class = get_preprocessor_for_resource(resource)
+        preprocessor = preprocessor_class(config, printer_profile)
+        page_list.extend(preprocessor(resource))
+    return tuple(page_list)
+
+
+def get_preprocessor_for_resource(resource: Resource) -> type[Preprocessor]:
+    """Return the appropriate preprocessor class for the given resource."""
+    path = resource.path
+    if _is_text_file(path):
+        return MarkdownPreprocessor
+    else:
+        m = mimetypes.guess_type(path)
+        if m[0]:
+            if m[0].startswith("image"):
+                return ImagePreprocessor
+            elif m[0] == "application/pdf":
+                return PdfPreprocessor
+    raise NotImplementedError(f"can't guess type of {path}")
+
+
+# helper
+def _is_text_file(path, blocksize=4096):
+    try:
+        with open(path, "rb") as f:
+            f.read(blocksize).decode("utf-8")
+        return True
+    except UnicodeDecodeError:
+        return False
+
+
+class Preprocessor(abc.ABC):
+    def __init__(self, config: JobConfig, printer_profile):
+        self.config = config
+        self.printer_profile = printer_profile
+
+    @abc.abstractmethod
+    def __call__(self, resource: Resource) -> tuple[Page, ...]: ...
+
+
+class ImagePreprocessor(Preprocessor):
+    def __call__(self, resource: Resource):
+        return (get_image_page(resource, self.config, self.printer_profile),)
+
+
+def get_image_page(resource, config, printer_profile):
+    path, fragment_height = resource.path, resource.fragment_height
+
+    # Immediately load & process image - in case image path is volatile
+    # (as it's the case if PdfPreprocessor parses us an img path), we
+    # don't loose the image. The downside of this is that we need to keep
+    # the image in our RAM. But because we resize, and the resolution of
+    # the ESC/POS printer is usually quite low, this is acceptable and
+    # should only create problem in case of very large books.
+    with Image.open(path) as im:
+        if config.orientation != Orientation.HORIZONTAL:
+            im = im.rotate(angle=-90, expand=True)
+        max_width = printer_profile.profile_data["media"]["width"]["pixels"]
+        assert max_width != "Unknown", "max_width of printer unknown!"
+        max_width = int(max_width * printer_profile.img_scale_factor)
+        width = im.width
+        heigth = im.height
+        factor = max_width / width
+        final_im = im.resize(
+            (
+                int(width * factor * printer_profile.img_x_scale_factor),
+                int(heigth * factor * printer_profile.img_y_scale_factor),
+            )
+        )
+
+    color = ("black", "red")[resource.color]
+
+    def _(printer):
+        printer._raw(TXT_STYLE["color"][color])
+        try:
+            # Add extra space between to make spaces between cuts even
+            # XXX Does number '10' need to change depending on printer?
+            if config.cut:
+                printer.line_spacing(10)
+                printer.ln()
+                printer.line_spacing()
+
+            img_kwargs = dict(printer_profile.img_kwargs)
+            if fragment_height:
+                img_kwargs["fragment_height"] = fragment_height
+
+            printer.image(
+                final_im,
+                **img_kwargs,
+            )
+        finally:
+            final_im.close()
+
+    return _
+
+
+class PdfPreprocessor(ImagePreprocessor):
+    def __call__(self, resource: Resource):
+        pdf_path = resource.path
+        with TemporaryDirectory() as tmp_path:
+            image_list = convert_from_path(pdf_path, output_folder=tmp_path, dpi=600)
+            if self.config.orientation == Orientation.HORIZONTAL:
+                image_list = [im.rotate(angle=-90, expand=True) for im in image_list]
+            page_list = []
+            for i, img in enumerate(image_list):
+                p = os.path.join(tmp_path, f"{i}.png")
+                img.save(p)
+                page_list.extend(super().__call__(Resource(p, 0)))
+        return tuple(page_list)
+
+
+class MarkdownPreprocessor(Preprocessor):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.markdown = marko.Markdown(renderer=_EscposRenderer)
+        self.markdown._setup_extensions()
+
+    def __call__(self, resource: Resource):
+        with open(resource.path, "r") as f:
+            md = f.read()
+
+        def _(printer):
+            self.markdown.renderer.set_markdown_path(resource.path)
+            self.markdown.renderer.set_printer(printer)
+            self.markdown.renderer.set_config(self.config)
+            self.markdown.renderer.set_printer_profile(self.printer_profile)
+            self.markdown(md)
+
+        return (_,)
+
+
+class _EscposRenderer(marko.renderer.Renderer):
+    # Ref: https://github.com/frostming/marko/blob/master/marko/html_renderer.py
+
+    # TODO Add auto page breaks
+
+    def render_raw_text(self, element) -> str:
+        self._printer.text(element.children)
+        # XXX: Temporarily disable auto-line break until it can be configured in UI
+        # word_list = element.children.split(" ")
+        # max_char_count = self.max_char_count
+        # for word in word_list:
+        #     char_count = len(word)
+        #     # If word is too big for one line, just skip line breaking.
+        #     if char_count > max_char_count:
+        #         self._printer.text(word)
+        #         self.line_position = self.line_position % max_char_count
+        #         continue
+        #     add_whitespace = self.line_position > 0
+        #     new_pos = self.line_position + char_count + add_whitespace
+        #     diff = new_pos - max_char_count
+        #     if diff <= 0:
+        #         if add_whitespace:
+        #             self._printer.text(" ")
+        #         self._printer.text(word)
+        #         self.line_position = new_pos
+        #     else:  # diff > 0
+        #         space_count = max_char_count - self.line_position
+        #         if space_count:
+        #             self._printer.text(" " * space_count)
+        #         self._printer.text(word)
+        #         self.line_position = char_count
+        return ""
+
+    def render_emphasis(self, element) -> str:
+        self._set(bold=True)
+        self.render_children(element)
+        self._set(bold=False)
+        return ""
+
+    def render_image(self, element) -> str:
+        path = _resolve_path(element.dest, self._markdown_path)
+        resource = Resource(path=path)
+        get_image_page(resource, self._config, self._printer_profile)(self._printer)
+        return ""
+
+    def render_strong_emphasis(self, element) -> str:
+        return self.render_emphasis(element)
+
+    def render_blank_line(self, element=None):
+        self.render_line_break(line_count=1)
+        return ""
+
+    def render_line_break(self, element=None, line_count: Optional[int] = None) -> str:
+        soft = element.soft if element else True
+        if line_count is None:
+            if soft:
+                line_count = 1
+            else:
+                line_count = 2
+        self._printer.ln(line_count)
+        self.line_position = 0
+        return ""
+
+    def render_thematic_break(self, element) -> str:
+        self._printer.cut()
+        return ""
+
+    def render_paragraph(self, element) -> str:
+        self.render_children(element)
+        self.render_line_break()
+        return ""
+
+    def render_heading(self, element) -> str:
+        self.max_char_count = self.printer_profile.big_char_count
+        self._set(double_height=True, double_width=True)
+        self.render_children(element)
+        self._set(double_height=False, double_width=False, normal_textsize=True)
+        self.render_line_break(line_count=3)
+        self.max_char_count = self.printer_profile.default_char_count
+        return ""
+
+    def set_printer(self, printer):
+        self._printer = printer
+
+    def set_config(self, config):
+        self._config = config
+
+    def set_printer_profile(self, printer_profile):
+        self._printer_profile = printer_profile
+
+    def set_markdown_path(self, markdown_path):
+        self._markdown_path = markdown_path
+
+    def _set(self, *args, **kwargs):
+        if self._printer:
+            self._printer.set(*args, **kwargs)
+        else:
+            raise RuntimeError("printer not yet set")
+
+    @property
+    def line_position(self):
+        try:
+            return self._line_position
+        except AttributeError:
+            return 0
+
+    @line_position.setter
+    def line_position(self, line_position: int):
+        self._line_position = line_position
+
+    @cached_property
+    def printer_profile(self):
+        return self._printer_profile
+
+    @property
+    def max_char_count(self):
+        try:
+            return self._max_char_count
+        except AttributeError:
+            self.max_char_count = self.printer_profile.default_char_count
+            return self.max_char_count
+
+    @max_char_count.setter
+    def max_char_count(self, max_char_count: int):
+        self._max_char_count = max_char_count
+
+
+def _resolve_path(path: str, markdown_path: str) -> str:
+    p = Path(path)
+
+    if p.is_absolute():
+        return path
+
+    markdown_dir = Path(markdown_path).parent
+    return str((markdown_dir / p).resolve())

tinyprint/printer/__init__.py

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

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()