tinyprint 0.2.4__py3-none-any.whl

tinyprint/__init__.py

@@ -0,0 +1,8 @@
+from . import patches
+del patches
+
+from . import config
+from . import gui
+from . import jobconfig
+from . import job
+from . import preprocessor

tinyprint/__main__.py

@@ -0,0 +1,21 @@
+"""Main entry point for the TinyPrint application."""
+
+import logging
+from tinyprint.gui import GUI
+
+
+def main():
+    """Entry point for the application."""
+    # Configure logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    )
+
+    # Start the application
+    with GUI() as gui:
+        gui.run()
+
+
+if __name__ == "__main__":
+    main()

tinyprint/config.py

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

tinyprint/gui.py

@@ -0,0 +1,251 @@
+"""TinyPrint GUI"""
+
+from __future__ import annotations
+
+import os
+import logging
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+from tkinter import Tk, filedialog
+from tkinter.ttk import Frame
+
+from tinyprint.jobconfig import JobConfig, Resource
+from tinyprint.job import Job
+from tinyprint.gui_misc import Block, Blocks, no_hidden_files
+
+
+class GUI:
+    """Main GUI class for the TinyPrint application."""
+
+    COLUMN_COUNT = 5
+
+    def __enter__(self):
+        self._tempdir = None
+        self._tempdir_context = tempfile.TemporaryDirectory(prefix="tinyprint")
+        self.tempdir = self._tempdir_context.name
+        self.setup()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.cleanup()
+
+    def setup(self):
+        """Set up the main window and all components."""
+        self.root = Tk()
+        no_hidden_files(self.root)
+        self.root.title("~ tiny print ~")
+        self.main_frame = Frame(self.root, padding=15)
+        self.main_frame.grid(sticky="nsew")
+        blk = self.blk = Blocks(self)
+        blk.ADD.job_controller(JobController)
+        blk.ADD.job_config_manager(JobConfigManager)
+        blk.ADD.job_config_editor(JobConfigEditor)
+        for i in range(GUI.COLUMN_COUNT):
+            self.main_frame.columnconfigure(i, weight=1)
+
+    def run(self):
+        """Start the main event loop."""
+        self.root.mainloop()
+
+    def cleanup(self):
+        """Clean up resources, including temporary directories."""
+        g = self
+        g.blk and g.blk.close()
+        g._tempdir_context and g._tempdir_context.cleanup()
+        g.blk, g.root, g.main_frame, g._tempdir_context, g._tempdir = [None] * 5
+
+
+class JobController(Block):
+    """Controls to start/stop print job."""
+
+    def __init__(self, *args, **kwargs):
+        self.job = None
+        super().__init__(*args, **kwargs)
+
+    def create_widgets(self):
+        btn = self.btn
+        for i, cmd in enumerate("print stop".split()):
+            b = btn.ADD(cmd, text=cmd, command=getattr(self, cmd))
+            b.grid(column=i, row=0)
+
+    def print(self):
+        if self.job and self.job.is_running:
+            return logging.warning("job already printing!")
+        self.stop()
+        config = self.gui.blk.job_config_manager.job_config
+        if config:
+            self.job = Job(config)
+            self.job.start()
+        else:
+            logging.warning("no job config set")
+
+    def stop(self):
+        if not self.job:
+            return
+        self.job.stop()
+        self.job.close()
+        self.job = None
+
+
+class JobConfigManager(Block):
+    """Load/save a job configuration"""
+
+    def __init__(self, gui, *args, **kwargs):
+        self.job_config = None
+        self.filename = None
+        super().__init__(gui, *args, **kwargs)
+        self.temp_resource = os.path.join(gui.tempdir, "tmp-resource.md")
+        with open(self.temp_resource, "w") as f:
+            f.write("tiny printer test")
+        self.new(os.path.join(self.gui.tempdir, "tmp-print-job.json"))
+
+    def create_widgets(self):
+        var, btn, lbl = self.var, self.btn, self.lbl
+        var.str.ADD.filename_indicator()
+        lbl.ADD.job_config(text="job config: ")
+        lbl.job_config.grid(column=0, row=0)
+        lbl.ADD.filename(textvariable=var.filename_indicator)
+        lbl.filename.grid(column=1, row=0, columnspan=3, pady=5, sticky="w")
+        for i, cmd in enumerate("new open save save_as reload".split()):
+            b = btn.ADD(cmd, text=cmd, command=getattr(self, cmd))
+            b.grid(column=i, row=1, pady=5, padx=2)
+
+    def new(self, *args, **kwargs):
+        self.job_config = JobConfig([Resource(self.temp_resource)])
+        self.save_as(*args, **kwargs)
+
+    def open(self):
+        if filename := self.select_file(
+            (("print job configuration", "*.json"), ("All files", "*.*"))
+        ):
+            self.set_filename(filename)
+            self.reload()
+
+    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 = filedialog.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 reload(self):
+        if not self.filename:
+            return logging.warning("can't load as no file loaded yet")
+        logging.info(f"load {self.filename}")
+        self.job_config = JobConfig.from_file(self.filename)
+        self.gui.blk.job_config_editor.sync_from_model()
+
+    def set_filename(self, filename: str):
+        self.filename = filename
+        self.var.filename_indicator.set(Path(filename).name)
+
+
+class JobConfigEditor(Block):
+    """Edit parameters of currently loaded job configuration"""
+
+    def __init__(self, *args, **kwargs):
+        self.temp_resource = None
+        super().__init__(*args, **kwargs)
+
+    def create_widgets(self):
+        var, btn, lbl, cbx, scl = self.var, self.btn, self.lbl, self.cbx, self.scl
+
+        var.str.ADD.resource_list()
+        var.str.ADD.printer_config()
+        var.double.ADD.sleep_time()
+
+        for i, t in enumerate(  # render names of parameters
+            ("resource", "printer configuration", "cut", "sleep time")
+        ):
+            label = lbl.ADD(f"arg{i}", text=f"{t}: ")
+            label.grid(column=0, row=i, columnspan=2, sticky="w", pady=2)
+
+        btn.ADD.select_resource(text="select", command=self.select_resource)
+        lbl.ADD.resource_list(textvariable=var.resource_list)
+        btn.select_resource.grid(column=2, row=0, sticky="w")
+        lbl.resource_list.grid(column=4, row=0, columnspan=2, sticky="w")
+
+        btn.ADD.select_printer(text="select", command=self.select_printer)
+        lbl.ADD.printer_value(textvariable=var.printer_config)
+        btn.select_printer.grid(column=2, row=1, sticky="w")
+        lbl.printer_value.grid(column=4, row=1, sticky="w")
+
+        cbx.ADD.cut(values=["yes", "no"])
+        cbx.cut.set("no")
+        cbx.cut.bind("<<ComboboxSelected>>", self.select_cut)
+        cbx.cut.grid(column=2, row=2)
+
+        lbl.ADD.sleep_value(textvariable=var.sleep_time)
+        scl.ADD.sleep_time(
+            from_=0,
+            to=2,
+            command=self.select_sleep_time,
+            variable=var.sleep_time,
+            length=500,
+        )
+        lbl.sleep_value.grid(column=2, row=3, sticky="w")
+        scl.sleep_time.grid(column=3, row=3, columnspan=2)
+
+    def sync_from_model(self):
+        job_config, var, cbx = self.job_config, self.var, self.cbx
+        if not job_config:
+            return
+        resource_list = "; ".join(
+            [r.path.split(os.sep)[-1] for r in job_config.resource_list]
+        )
+        if len(resource_list) > 25:
+            resource_list = resource_list[:30] + " ..."
+        var.resource_list.set(resource_list)
+        var.printer_config.set(job_config.printer_config)
+        var.sleep_time.set(job_config.sleep_time)
+        cbx.cut.set(("no", "yes")[job_config.cut])
+
+    def select_resource(self):
+        self.select_file(
+            "resource_list",
+            (("all files", "*.*"), ("pdf", "*.pdf"), ("images", "*.jpg")),
+            multiple=True,
+        )
+
+    def select_printer(self):
+        self.select_file(
+            "printer_config", (("printer config", "*.yml"), ("all files", "*.*"))
+        )
+
+    def select_file(self, attr, filetypes, multiple=False):
+        file_list = super().select_file(filetypes, multiple)
+        if multiple is False:
+            file_list = [file_list] if file_list else []
+        if file_list:
+            setattr(
+                self.job_config,
+                attr,
+                [Resource(f) for f in file_list] if multiple else file_list[0],
+            )
+            self.sync_from_model()
+
+    def select_cut(self, *_):
+        self.job_config.cut = {"yes": True, "no": False}[self.cbx.cut.get()]
+
+    def select_sleep_time(self, value: str):
+        v = round(float(value), 2)
+        self.job_config.sleep_time = v
+        # NOTE Since var.sleep_time is also 'variable' of scale, this
+        # already gets set automatically - yet we still re-set it here
+        # to get the rounded value.
+        self.var.sleep_time.set(v)
+
+    @property
+    def job_config(self):
+        return self.gui.blk.job_config_manager.job_config

tinyprint/gui_misc.py

@@ -0,0 +1,160 @@
+"""Provides helper for the tiny print GUI"""
+
+from pathlib import Path
+
+from tkinter import TclError, filedialog
+from tkinter.ttk import Separator, Frame, Scale, Button, Label, Combobox
+from tkinter import StringVar, DoubleVar, BooleanVar
+
+
+class Block(Frame):
+    """A block represents one visual and logical unit in the GUI"""
+
+    def __init__(self, gui, *args, **kwargs):
+        super().__init__(gui.main_frame, *args, **kwargs)
+        self.gui = gui
+        self.var = _VarFactory()
+        self.btn, self.lbl, self.cbx, self.scl = (
+            _WidgetFactory(self, w) for w in (Button, Label, Combobox, Scale)
+        )
+        self.create_widgets()
+
+    def create_widgets(self):
+        raise NotImplementedError
+
+    def close(self):
+        pass
+
+    def select_file(self, filetypes, multiple=False):
+        k = dict(title="Open a file", filetypes=filetypes, initialdir=Path.home())
+        file_list = (
+            filedialog.askopenfilenames(**k)
+            if multiple
+            else [filedialog.askopenfilename(**k)]
+        )
+        if file_list:
+            if multiple:
+                return file_list
+            return file_list[0]
+
+    def __del__(self):
+        self.close()
+
+
+class _WidgetFactory:
+    def __init__(self, frame, widget_type):
+        self._frame = frame
+        self._widget_type = widget_type
+        self._widget_key_list = []
+        self.ADD = _WidgetFactory.Add(self)
+
+    def __iter__(self):
+        return (getattr(self, k) for k in self._widget_key_list)
+
+    class Add:
+        def __init__(self, factory):
+            self.factory = factory
+
+        def __call__(self, key, *args, **kwargs):
+            return getattr(self, key)(*args, **kwargs)
+
+        def __getattr__(self, key):
+            def _(*args, **kwargs):
+                f = self.factory
+                widget = f._widget_type(self.factory._frame, *args, **kwargs)
+                f._widget_key_list.append(key)
+                setattr(f, key, widget)
+                return widget
+
+            return _
+
+
+class _VarFactory:
+    """Factory for creating Tkinter variables with consistent ADD pattern."""
+
+    class VarTypeFactory:
+        def __init__(self, var_type, parent):
+            self.var_type = var_type
+            self.parent = parent
+            self.ADD = self.Add(self)
+
+        class Add:
+            def __init__(self, factory):
+                self.factory = factory
+
+            def __getattr__(self, name):
+                def _(value=None):
+                    var = self.factory.var_type(value=value)
+                    setattr(self.factory.parent, name, var)
+                    return var
+
+                return _
+
+    def __init__(self):
+        self.str = self.VarTypeFactory(StringVar, self)
+        self.double = self.VarTypeFactory(DoubleVar, self)
+        self.bool = self.VarTypeFactory(BooleanVar, self)
+
+
+class Blocks:
+    """Namespace for the collection of all GUI blocks."""
+
+    def __init__(self, gui):
+        self.gui = gui
+        self.ADD = self.Add(self)
+        self._block_list = []
+
+    class Add:
+        def __init__(self, blocks):
+            self._blocks = blocks
+            self.block_row = 0
+
+        def __getattr__(self, name):
+            def _(block_class, **kwargs):
+                gui = self._blocks.gui
+                assert gui.COLUMN_COUNT == 5
+                block = block_class(gui, **kwargs)
+                block.grid(
+                    row=self.block_row,
+                    column=0,
+                    columnspan=gui.COLUMN_COUNT,
+                    sticky="w",
+                )
+                Separator(gui.main_frame, orient="horizontal").grid(
+                    row=self.block_row + 1,
+                    column=0,
+                    columnspan=gui.COLUMN_COUNT,
+                    sticky="ew",
+                    pady=10,
+                )
+                self.block_row += 2
+                setattr(self._blocks, name, block)
+                self._blocks._block_list.append(block)
+                return block
+
+            return _
+
+    def close(self):
+        for blk in self._block_list:
+            blk.close()
+
+    def __del__(self):
+        self.close()
+
+
+def no_hidden_files(root):
+    try:
+        _no_hidden_files(root)
+    except Exception:
+        pass  # support macos
+
+
+def _no_hidden_files(root):
+    """Configure file dialogs to show hidden files (macOS support)."""
+    call = root.tk.call
+    try:
+        call("tk_getOpenFile", "-foobarbaz")
+    except TclError:
+        pass
+    call("set", "::tk::dialog::file::showHiddenBtn", "1")
+    call("set", "::tk::dialog::file::showHiddenVar", "0")

tinyprint/job.py

@@ -0,0 +1,151 @@
+import functools
+import logging
+import threading
+import traceback
+from typing import Optional
+
+from escpos.constants import ESC, PAPER_PART_CUT  # type: ignore
+from escpos.printer import Dummy  # type: ignore
+import six
+
+import tinyprint
+from tinyprint.jobconfig import JobConfig
+from tinyprint.patches.escpos import PrinterCommand
+from tinyprint.printer.manager import Manager
+from tinyprint.preprocessor import create_pages_from_resources
+
+
+class Job:
+    """Pre-process input files & prints them with ESC/POS printer."""
+
+    def __init__(self, config: JobConfig):
+        self.config = config
+        self._job: Optional[threading.Thread] = None
+        self.manager = Manager(config)
+        self.command_generator = CommandGenerator(config, self.manager.printer.profile)
+
+    @property
+    def is_running(self):
+        return self._job and self._job.is_alive()
+
+    def start(self):
+        """Start printing in background thread"""
+        self._job = threading.Thread(target=self._run)
+        self._job.start()
+
+    def wait(self, timeout: Optional[float] = None):
+        """Wait/block until print job is finished"""
+        if self._job:
+            self._job.join(timeout)
+            self._job = None
+
+    def stop(self):
+        """Stop currently running print job"""
+        if self.is_running:
+            self._logger.info("  stop print! >")
+            self.manager.stop()
+            self.wait()
+
+    def close(self):
+        try:
+            self.stop()
+        finally:
+            self.manager.close()
+
+    def _run(self):
+        """Run printing job"""
+        i = self._logger.info
+
+        i("< preprocess input ...")
+        page_tuple = create_pages_from_resources(
+            self.config, self.manager.printer.profile
+        )
+        i("  finished preprocessing >")
+
+        i("< create ESC/POS codes ...")
+        cmd_list = self.command_generator(page_tuple)
+        i("  finished creating ESC/POS codes >")
+
+        i("< start printing")
+        self.manager.print(cmd_list)
+        self.manager.wait()
+        i("  finished printing >")
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args, **kwargs):
+        self.wait()
+        self.close()
+
+    def __del__(self):
+        self.close()
+
+    @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
+
+
+class CommandGenerator:
+    """Generates ESC/POS commands from printable pages."""
+
+    def __init__(self, config, printer_profile):
+        self.config = config
+        self.printer_profile = printer_profile
+        self._logger = logging.getLogger(f"{__name__}.{type(self).__name__}")
+
+    def __call__(self, page_tuple):
+        dummy = Dummy()
+        for i, page in enumerate(page_tuple):
+            try:
+                page(dummy)
+            except Exception:
+                tb = traceback.format_exc()
+                self._logger.warning(f"error when printing page {i+1}: {tb}")
+        output_list = dummy._output_list
+        if self.config.cut:
+            cmd_list = self._add_auto_cut(output_list)
+        else:
+            cmd_list = [getattr(cmd, "cmd", cmd) for cmd in output_list]
+        return cmd_list * self.config.copy_count
+
+    def _add_auto_cut(self, output_list: list[bytes | PrinterCommand]) -> 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 PrinterCommand():
+                    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

tinyprint/jobconfig.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import enum
+from typing import Any, Optional
+
+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")
+
+
+@dataclass
+class Resource:
+    path: str
+    fragment_height: Optional[int] = None
+    # Either 0 (= black) or 1 (= red)
+    color: int = 0
+
+
+@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())

tinyprint/patches/__init__.py

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