tinyprint 0.2.1__tar.gz → 0.2.3__tar.gz

{tinyprint-0.2.1 → tinyprint-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinyprint
-Version: 0.2.1
+Version: 0.2.3
 Summary: ui & cli to print zines with esc/pos printer
 Author-email: Levin Eric Zimmermann <levin.eric.zimmermann@posteo.com>
 License: GPL
@@ -23,3 +23,31 @@ Dynamic: license-file
 # tinyprint
 
 Software for printing tiny zines with ESC/POS printer.
+
+![gui screenshot](screenshot.jpg)
+
+## Installation
+
+### MacOS
+
+Open a console and type:
+
+```bash
+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)
+brew install python
+brew install python-tk
+brew install pipx
+pipx install tinyprint
+```
+
+## Linux
+
+Install python, and then just use pip:
+
+```bash
+pip3 install tinyprint
+```
+
+## Windows
+
+I don't know, but if someone manages, please let us know.

tinyprint-0.2.3/README.md

@@ -0,0 +1,31 @@
+# tinyprint
+
+Software for printing tiny zines with ESC/POS printer.
+
+![gui screenshot](screenshot.jpg)
+
+## Installation
+
+### MacOS
+
+Open a console and type:
+
+```bash
+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)
+brew install python
+brew install python-tk
+brew install pipx
+pipx install tinyprint
+```
+
+## Linux
+
+Install python, and then just use pip:
+
+```bash
+pip3 install tinyprint
+```
+
+## Windows
+
+I don't know, but if someone manages, please let us know.

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

@@ -1,6 +1,6 @@
 [project]
 name = "tinyprint"
-version = "0.2.1"
+version = "0.2.3"
 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.3/tests/test_gui.py

@@ -0,0 +1,312 @@
+"""Tests for the TinyPrint GUI."""
+
+import json
+import pytest
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+import tempfile
+import shutil
+
+# Import the GUI components
+from tinyprint.gui import GUI, JobConfigManager
+from tinyprint.jobconfig import JobConfig, Resource
+
+
+@pytest.fixture
+def temp_dir():
+    """Create and cleanup a temporary directory for test files."""
+    temp_dir = tempfile.mkdtemp(prefix="tinyprint-test-")
+    yield temp_dir
+    shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+@pytest.fixture
+def gui_app(temp_dir):
+    """Create a GUI instance for testing with a temporary directory."""
+    with GUI() as gui:
+        yield gui
+
+
+@pytest.fixture
+def job_controller(gui_app):
+    """Return the JobController instance from the GUI."""
+    return gui_app.blk.job_controller
+
+
+def test_print_button_starts_job(job_controller):
+    """Test that clicking the print button starts a print job."""
+    # Setup - mock the Job class
+    mock_job = MagicMock()
+    mock_job.is_running = False
+
+    with patch("tinyprint.gui.Job", return_value=mock_job) as mock_job_class:
+        # Simulate clicking the print button
+        job_controller.btn.print.invoke()
+
+        # Verify a job was created with the correct config
+        mock_job_class.assert_called_once()
+        assert isinstance(mock_job_class.call_args[0][0], JobConfig)
+
+        # Verify the job was started
+        mock_job.start.assert_called_once()
+        assert job_controller.job == mock_job
+
+
+def test_stop_button_stops_job(job_controller):
+    """Test that clicking the stop button stops a running print job."""
+    # Setup - create a mock job
+    mock_job = MagicMock()
+    mock_job.is_running = True
+    job_controller.job = mock_job
+
+    # Simulate clicking the stop button
+    job_controller.btn.stop.invoke()
+
+    # Verify the job was stopped and cleaned up
+    mock_job.stop.assert_called_once()
+    mock_job.close.assert_called_once()
+    assert job_controller.job is None
+
+
+@pytest.fixture
+def job_config_manager(gui_app):
+    """Create a JobConfigManager instance for testing."""
+    gui_app.blk = MagicMock()
+    gui_app.blk.job_config_editor = MagicMock()
+    gui_app.blk.job_config_editor.sync_from_model = MagicMock()
+    gui_app.tempdir = tempfile.mkdtemp()
+    return JobConfigManager(gui_app)
+
+
+def test_job_config_manager_initialization(job_config_manager):
+    """Test that JobConfigManager initializes correctly."""
+    assert job_config_manager.job_config is not None
+    assert isinstance(job_config_manager.job_config, JobConfig)
+    assert len(job_config_manager.job_config.resource_list) == 1
+    assert "tmp-resource.md" in job_config_manager.job_config.resource_list[0].path
+    assert job_config_manager.filename is not None
+    assert job_config_manager.filename.endswith("tmp-print-job.json")
+
+
+def test_job_config_manager_new_config(job_config_manager, tmp_path):
+    """Test creating a new configuration."""
+    test_file = tmp_path / "test_config.json"
+
+    # Set up the save_as dialog to return our test file
+    with patch(
+        "tkinter.filedialog.asksaveasfilename", return_value=str(test_file)
+    ) as mock_save_as:
+        # Simulate clicking the new button
+        job_config_manager.btn.new.invoke()
+
+    assert job_config_manager.filename == str(test_file)
+    assert test_file.exists()
+
+    # Verify the file contains valid JSON with expected structure
+    with open(test_file, "r") as f:
+        config_data = json.load(f)
+    assert "resource_list" in config_data
+    assert isinstance(config_data["resource_list"], list)
+    assert len(config_data["resource_list"]) == 1
+
+
+@patch("tkinter.filedialog.asksaveasfilename")
+def test_job_config_manager_save_as(mock_save_as, job_config_manager, tmp_path):
+    """Test saving configuration to a new file."""
+    test_file = tmp_path / "test_save_as.json"
+    mock_save_as.return_value = str(test_file)
+
+    # Simulate clicking the save_as button
+    job_config_manager.btn.save_as.invoke()
+
+    mock_save_as.assert_called_once()
+    assert job_config_manager.filename == str(test_file)
+    assert test_file.exists()
+    # Verify the filename label is updated
+    assert (
+        job_config_manager.lbl.filename["textvariable"]
+        == job_config_manager.var.filename_indicator._name
+    )
+    assert job_config_manager.var.filename_indicator.get() == "test_save_as.json"
+
+
+@patch("tkinter.filedialog.askopenfilename")
+def test_job_config_manager_open_config(mock_open_file, job_config_manager, tmp_path):
+    """Test opening an existing configuration file."""
+    # Create a test config file
+    test_file = tmp_path / "test_open.json"
+    test_config = {
+        "resource_list": [{"path": "test.txt"}],
+        "printer_config": None,
+        "copy_count": 1,
+        "cut": True,
+        "orientation": 0,  # 0 = Orientation.HORIZONTAL
+        "page_size": None,
+        "sleep_time": 0.5,
+    }
+    with open(test_file, "w") as f:
+        json.dump(test_config, f)
+
+    mock_open_file.return_value = str(test_file)
+
+    # Simulate clicking the open button
+    job_config_manager.btn.open.invoke()
+
+    mock_open_file.assert_called_once()
+    assert job_config_manager.filename == str(test_file)
+    assert job_config_manager.job_config is not None
+    assert len(job_config_manager.job_config.resource_list) == 1
+    assert job_config_manager.job_config.resource_list[0].path == "test.txt"
+    assert job_config_manager.job_config.sleep_time == 0.5
+    # Verify the filename label is updated
+    assert (
+        job_config_manager.lbl.filename["textvariable"]
+        == job_config_manager.var.filename_indicator._name
+    )
+    assert job_config_manager.var.filename_indicator.get() == "test_open.json"
+
+
+def test_job_config_manager_reload_config(job_config_manager, tmp_path):
+    """Test reloading the current configuration from disk."""
+    # Create a test config file
+    test_file = tmp_path / "test_reload.json"
+    test_config = {
+        "resource_list": [{"path": "reload.txt"}],
+        "orientation": 0,  # 0 = Orientation.HORIZONTAL
+        "sleep_time": 0.3,
+    }
+    with open(test_file, "w") as f:
+        json.dump(test_config, f)
+
+    # Set the filename and reload
+    job_config_manager.set_filename(str(test_file))
+    # Simulate clicking the reload button
+    job_config_manager.btn.reload.invoke()
+
+    # Verify the config was loaded correctly
+    assert job_config_manager.job_config is not None
+    assert len(job_config_manager.job_config.resource_list) == 1
+    assert job_config_manager.job_config.resource_list[0].path == "reload.txt"
+    assert job_config_manager.job_config.sleep_time == 0.3
+
+    # Verify the editor was synced
+    job_config_manager.gui.blk.job_config_editor.sync_from_model.assert_called_once()
+
+
+def test_job_config_manager_set_filename(job_config_manager):
+    """Test updating the filename and UI indicator."""
+    test_path = "/path/to/test_config.json"
+    job_config_manager.set_filename(test_path)
+
+    assert job_config_manager.filename == test_path
+
+
+def test_job_config_editor_initialization(gui_app):
+    """Test that JobConfigEditor initializes correctly."""
+    editor = gui_app.blk.job_config_editor
+    assert editor is not None
+    # Verify all expected variables are created
+    assert hasattr(editor.var, "resource_list")
+    assert hasattr(editor.var, "printer_config")
+    assert hasattr(editor.var, "sleep_time")
+    # Verify widgets are created
+    assert hasattr(editor.lbl, "resource_list")
+    assert hasattr(editor.lbl, "printer_value")
+    assert hasattr(editor.lbl, "sleep_value")
+    assert hasattr(editor.btn, "select_resource")
+    assert hasattr(editor.btn, "select_printer")
+    assert hasattr(editor.cbx, "cut")
+
+
+@patch("tkinter.filedialog.askopenfilenames")
+def test_select_resource(mock_file_dialog, gui_app):
+    """Test selecting resources updates the job config and UI."""
+    editor = gui_app.blk.job_config_editor
+    test_files = ["/path/to/file1.pdf", "/path/to/file2.jpg"]
+    mock_file_dialog.return_value = test_files
+    editor.btn.select_resource.invoke()
+    mock_file_dialog.assert_called_once()
+    assert len(editor.job_config.resource_list) == 2
+    assert editor.job_config.resource_list[0].path == test_files[0]
+    assert editor.job_config.resource_list[1].path == test_files[1]
+    assert test_files[0].split("/")[-1] in editor.var.resource_list.get()
+
+
+@patch("tkinter.filedialog.askopenfilename")
+def test_select_printer_config(mock_file_dialog, gui_app):
+    """Test selecting a printer config updates the job config and UI."""
+    editor = gui_app.blk.job_config_editor
+    test_file = "/path/to/printer.yml"
+    mock_file_dialog.return_value = test_file
+
+    # Simulate clicking the select printer button
+    editor.btn.select_printer.invoke()
+
+    # Get the actual call arguments
+    args, kwargs = mock_file_dialog.call_args
+    assert kwargs.get("title") == "Open a file"
+    assert kwargs.get("filetypes") == (
+        ("printer config", "*.yml"),
+        ("all files", "*.*"),
+    )
+    assert str(kwargs.get("initialdir")) == str(Path.home())
+
+    # Verify the printer config was updated
+    assert editor.job_config.printer_config == test_file
+    assert editor.var.printer_config.get() == test_file
+
+
+def test_toggle_cut(gui_app):
+    """Test toggling the cut option updates the job config."""
+    editor = gui_app.blk.job_config_editor
+    initial_cut = editor.job_config.cut
+
+    # Set the combobox to the opposite of current cut state
+    new_value = "no" if initial_cut else "yes"
+    editor.cbx.cut.set(new_value)
+
+    # Trigger the combobox selection event
+    editor.cbx.cut.event_generate("<<ComboboxSelected>>")
+
+    # Verify the cut value has been toggled
+    assert editor.job_config.cut != initial_cut
+    assert editor.job_config.cut == (new_value == "yes")
+
+
+def test_change_sleep_time(gui_app):
+    """Test changing the sleep time updates the job config and UI."""
+    editor = gui_app.blk.job_config_editor
+    new_sleep_time = 1.5
+    editor.scl.sleep_time.set(new_sleep_time)
+    assert editor.job_config.sleep_time == new_sleep_time
+    assert editor.var.sleep_time.get() == new_sleep_time
+    assert float(editor.lbl.sleep_value["text"]) == new_sleep_time
+
+
+def test_sync_from_model(gui_app):
+    """Test that sync_from_model updates the UI correctly."""
+    editor = gui_app.blk.job_config_editor
+    job_config_manager = editor.gui.blk.job_config_manager
+
+    # Create a test config
+    test_config = JobConfig(
+        resource_list=[Resource("test.txt")],
+        printer_config="test_printer.yml",
+        cut=True,
+        sleep_time=1.0,
+    )
+
+    # Set the job config and sync
+    job_config_manager.job_config = test_config
+    editor.sync_from_model()
+
+    # Verify UI is in sync with the model
+    assert "test.txt" in editor.var.resource_list.get()
+    assert editor.var.printer_config.get() == "test_printer.yml"
+    assert editor.cbx.cut.get() == "yes"
+    assert editor.var.sleep_time.get() == 1.0
+
+    # Verify filename indicator if it exists
+    if hasattr(job_config_manager.var, "filename_indicator"):
+        # The filename should be the default one set in JobConfigManager.__init__
+        assert job_config_manager.var.filename_indicator.get() == "tmp-print-job.json"

{tinyprint-0.2.1 → tinyprint-0.2.3}/tests/test_integration.py

@@ -13,7 +13,7 @@ from tinyprint.job import Job
 from tinyprint.jobconfig import JobConfig, Resource, Orientation
 
 # Test data directory
-TEST_DATA = Path(__file__).parent / "data"
+TEST_DATA = Path(__file__).absolute().parent / "data"
 
 # Test configurations
 RESOURCES = {
@@ -69,4 +69,4 @@ def test_print(snapshot, resource_path_list, config_kwargs):
     job.start()
     job.wait()
 
-    assert snapshot == job.manager.printer.output
+    assert snapshot == job.manager.printer.output, resource_path_list

{tinyprint-0.2.1 → tinyprint-0.2.3}/tinyprint/gui.py

@@ -224,7 +224,10 @@ class JobConfigEditor(Block):
         )
 
     def select_file(self, attr, filetypes, multiple=False):
-        if file_list := super().select_file(filetypes, multiple):
+        file_list = super().select_file(filetypes, multiple)
+        if multiple is False:
+            file_list = [file_list]
+        if file_list:
             setattr(
                 self.job_config,
                 attr,

tinyprint-0.2.3/tinyprint/patches/__init__.py

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

tinyprint-0.2.3/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.3/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.1 → tinyprint-0.2.3}/tinyprint/preprocessor.py

@@ -4,6 +4,7 @@ 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
 
@@ -144,6 +145,7 @@ class MarkdownPreprocessor(Preprocessor):
             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)
@@ -192,7 +194,8 @@ class _EscposRenderer(marko.renderer.Renderer):
         return ""
 
     def render_image(self, element) -> str:
-        resource = Resource(path=element.dest)
+        path = _resolve_path(element.dest, self._markdown_path)
+        resource = Resource(path=path)
         get_image_page(resource, self._config, self._printer_profile)(self._printer)
         return ""
 
@@ -241,6 +244,9 @@ class _EscposRenderer(marko.renderer.Renderer):
     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)
@@ -273,3 +279,13 @@ class _EscposRenderer(marko.renderer.Renderer):
     @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-0.2.3/tinyprint/printer/__init__.py

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

tinyprint-0.2.3/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.3/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.3}/tinyprint.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinyprint
-Version: 0.2.1
+Version: 0.2.3
 Summary: ui & cli to print zines with esc/pos printer
 Author-email: Levin Eric Zimmermann <levin.eric.zimmermann@posteo.com>
 License: GPL
@@ -23,3 +23,31 @@ Dynamic: license-file
 # tinyprint
 
 Software for printing tiny zines with ESC/POS printer.
+
+![gui screenshot](screenshot.jpg)
+
+## Installation
+
+### MacOS
+
+Open a console and type:
+
+```bash
+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)
+brew install python
+brew install python-tk
+brew install pipx
+pipx install tinyprint
+```
+
+## Linux
+
+Install python, and then just use pip:
+
+```bash
+pip3 install tinyprint
+```
+
+## Windows
+
+I don't know, but if someone manages, please let us know.

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

@@ -1,6 +1,7 @@
 LICENSE
 README.md
 pyproject.toml
+tests/test_gui.py
 tests/test_integration.py
 tests/test_job.py
 tests/test_jobconfig.py
@@ -17,4 +18,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

tinyprint-0.2.1/README.md

@@ -1,3 +0,0 @@
-# tinyprint
-
-Software for printing tiny zines with ESC/POS printer.