tinyprint 0.2.0__tar.gz → 0.2.1__tar.gz

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

@@ -1,18 +1,20 @@
 Metadata-Version: 2.4
 Name: tinyprint
-Version: 0.2.0
+Version: 0.2.1
 Summary: ui & cli to print zines with esc/pos printer
-Author-email: Levin Eric Zimmermann <levin.eric.zimmermann@posteo.eu>
+Author-email: Levin Eric Zimmermann <levin.eric.zimmermann@posteo.com>
 License: GPL
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: python-escpos>=3.1
+Requires-Dist: python-escpos[serial,usb]>=3.1
 Requires-Dist: dataclasses-json>=0.6.0
 Requires-Dist: marko>=2.1.2
 Requires-Dist: pdf2image>=1.17.0
 Provides-Extra: dev
+Requires-Dist: coverage; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
+Requires-Dist: syrupy; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: types-six; extra == "dev"
 Requires-Dist: types-pillow; extra == "dev"

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

@@ -1,14 +1,14 @@
 [project]
 name = "tinyprint"
-version = "0.2.0"
+version = "0.2.1"
 authors = [
-    {name = "Levin Eric Zimmermann", email = "levin.eric.zimmermann@posteo.eu"},
+    {name = "Levin Eric Zimmermann", email = "levin.eric.zimmermann@posteo.com"},
 ]
 description = "ui & cli to print zines with esc/pos printer"
 requires-python = ">=3.10"
 readme = "README.md"
 dependencies = [
-    'python-escpos>=3.1',
+    'python-escpos[serial,usb]>=3.1',
     'dataclasses-json>=0.6.0',
     'marko>=2.1.2',
     'pdf2image>=1.17.0',
@@ -16,7 +16,9 @@ dependencies = [
 
 [project.optional-dependencies]
 dev = [
+    "coverage",
     "pytest",
+    "syrupy",
     "mypy",
     "types-six",
     "types-pillow",

tinyprint-0.2.1/tests/test_integration.py

@@ -0,0 +1,72 @@
+"""Integration tests for the tinyprint package.
+
+This module contains end-to-end tests that verify the printing functionality
+with different types of resources and job configurations using a dummy printer.
+"""
+
+from itertools import product
+from pathlib import Path
+
+import pytest
+
+from tinyprint.job import Job
+from tinyprint.jobconfig import JobConfig, Resource, Orientation
+
+# Test data directory
+TEST_DATA = Path(__file__).parent / "data"
+
+# Test configurations
+RESOURCES = {
+    "text": ["text/test.md"],
+    "image": [f"images/test-{i}.png" for i in range(4)],
+    "pdf": ["pdfs/test.pdf"],
+}
+ORIENTATIONS = list(Orientation)
+COPY_COUNTS = [1, 2]
+CUT_OPTIONS = [True, False]
+
+
+def generate_test_cases():
+    """Generate test cases for all combinations of resource types and config options."""
+    test_cases = []
+    # Define all possible combinations
+    combinations = product(RESOURCES.items(), ORIENTATIONS, COPY_COUNTS, CUT_OPTIONS)
+    for (rname, rpath_list), orient, copy_count, cut in combinations:
+        test_id = f"{rname}-{orient.name.lower()}-copies_{copy_count}-{'cut' if cut else 'nocut'}"
+        test_cases.append(
+            pytest.param(
+                rpath_list,
+                {"orientation": orient, "copy_count": copy_count, "cut": cut},
+                id=test_id,
+            )
+        )
+    return test_cases
+
+
+@pytest.mark.parametrize("resource_path_list,config_kwargs", generate_test_cases())
+def test_print(snapshot, resource_path_list, config_kwargs):
+    """
+    Test printing with various resource types and job configurations.
+
+    Args:
+        snapshot: The snapshot fixture for assertion
+        resource_path_list: List of relative path to the resource
+            files (from TEST_DATA)
+        config_kwargs: Configuration options for JobConfig
+    """
+    config = JobConfig(
+        resource_list=[Resource(str(TEST_DATA / p)) for p in resource_path_list],
+        **config_kwargs,
+    )
+
+    job = Job(config)
+
+    # Set a default width to prevent
+    #   'AssertionError: max_width of printer unknown!'
+    profile = job.manager.printer.profile
+    profile.profile_data["media"]["width"]["pixels"] = 384
+
+    job.start()
+    job.wait()
+
+    assert snapshot == job.manager.printer.output

tinyprint-0.2.1/tests/test_jobconfig.py

@@ -0,0 +1,157 @@
+import pytest
+from pathlib import Path
+
+from tinyprint.jobconfig import (
+    JobConfig,
+    PageSize,
+    Resource,
+    Orientation,
+    _parse_str,
+)
+
+
+def test_orientation_enum():
+    """Test Orientation enum values and string parsing."""
+    # Test enum values
+    assert Orientation.HORIZONTAL.value == 0
+    assert Orientation.VERTICAL.value == 1
+
+    # Test string parsing
+    assert Orientation.parse("horizontal") == Orientation.HORIZONTAL
+    assert Orientation.parse("HORIZONTAL") == Orientation.HORIZONTAL
+    assert Orientation.parse("vertical") == Orientation.VERTICAL
+    assert Orientation.parse("VERTICAL") == Orientation.VERTICAL
+
+    # Test invalid enum value
+    with pytest.raises(AttributeError):
+        Orientation.parse("invalid")
+
+
+def test_parse_str_utility():
+    """Test the _parse_str utility function."""
+
+    class TestEnum:
+        FOO = 1
+        BAR = 2
+
+    assert _parse_str(TestEnum, "foo") == TestEnum.FOO
+    assert _parse_str(TestEnum, "BAR") == TestEnum.BAR
+
+    with pytest.raises(AttributeError):
+        _parse_str(TestEnum, "baz")
+
+
+def test_page_size_creation():
+    """Test PageSize creation and from_any method."""
+    # Test direct creation
+    size1 = PageSize(10.5, 20.5)
+    assert size1.width == 10.5
+    assert size1.heigth == 20.5
+
+    # Test from_any with PageSize
+    size2 = PageSize.from_any(size1)
+    assert size2 == size1
+
+    # Test from_any with tuple
+    size3 = PageSize.from_any((30.0, 40.0))
+    assert size3.width == 30.0
+    assert size3.heigth == 40.0
+
+    # Test from_any with list
+    size4 = PageSize.from_any([50.0, 60.0])
+    assert size4.width == 50.0
+    assert size4.heigth == 60.0
+
+    # Test invalid type
+    with pytest.raises(NotImplementedError):
+        PageSize.from_any("invalid")
+
+
+def test_resource_creation():
+    """Test Resource creation and default values."""
+    # Test with required fields only
+    res1 = Resource("path/to/file.pdf")
+    assert res1.path == "path/to/file.pdf"
+    assert res1.fragment_height is None
+    assert res1.color == 0
+
+    # Test with all fields
+    res2 = Resource("path/to/other.pdf", fragment_height=100, color=1)
+    assert res2.path == "path/to/other.pdf"
+    assert res2.fragment_height == 100
+    assert res2.color == 1
+
+
+def test_job_config_creation():
+    """Test JobConfig creation and default values."""
+    resources = [
+        Resource("file1.pdf"),
+        Resource("file2.pdf", fragment_height=200, color=1),
+    ]
+
+    # Test with required fields only
+    c1 = JobConfig(resource_list=resources)
+    assert c1.resource_list == resources
+    assert c1.printer_config is None
+    assert c1.copy_count == 1
+    assert c1.cut is True
+    assert c1.orientation == Orientation.HORIZONTAL
+    assert c1.page_size is None
+    assert c1.sleep_time is None
+
+    # Test with all fields
+    page_size = PageSize(70.0, 30.0)
+    c2 = JobConfig(
+        resource_list=resources,
+        printer_config="myprinter.yml",
+        copy_count=3,
+        cut=False,
+        orientation=Orientation.VERTICAL,
+        page_size=page_size,
+        sleep_time=1.5,
+    )
+    assert c2.printer_config == "myprinter.yml"
+    assert c2.copy_count == 3
+    assert c2.cut is False
+    assert c2.orientation == Orientation.VERTICAL
+    assert c2.page_size == page_size
+    assert c2.sleep_time == 1.5
+
+
+def test_job_config_serialization(tmp_path: Path):
+    """Test JobConfig serialization to/from JSON file."""
+    # Create test resources
+    resources = [
+        Resource("file1.pdf"),
+        Resource("file2.pdf", fragment_height=200, color=1),
+    ]
+    page_size = PageSize(70.0, 30.0)
+
+    # Create and save config
+    config = JobConfig(
+        resource_list=resources,
+        printer_config="myprinter.yml",
+        copy_count=2,
+        cut=True,
+        orientation=Orientation.VERTICAL,
+        page_size=page_size,
+        sleep_time=0.5,
+    )
+
+    # Test serialization/deserialization
+    json_path = tmp_path / "config.json"
+    config.to_file(str(json_path))
+    loaded_config = JobConfig.from_file(str(json_path))
+
+    # Verify all fields are preserved
+    assert loaded_config.resource_list[0].path == "file1.pdf"
+    assert loaded_config.resource_list[1].fragment_height == 200
+    assert loaded_config.resource_list[1].color == 1
+    assert loaded_config.printer_config == "myprinter.yml"
+    assert loaded_config.copy_count == 2
+    assert loaded_config.cut is True
+    assert loaded_config.orientation == Orientation.VERTICAL
+    assert loaded_config.page_size is not None
+    assert loaded_config.page_size.width == 70.0
+    assert loaded_config.page_size.heigth == 30.0
+    assert loaded_config.sleep_time == 0.5

{tinyprint-0.2.0 → tinyprint-0.2.1}/tinyprint/__init__.py

@@ -2,7 +2,7 @@ from . import patches
 del patches
 
 from . import config
-from . import xescpos
+from . import gui
 from . import jobconfig
 from . import job
 from . import preprocessor

tinyprint-0.2.1/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-0.2.1/tinyprint/gui.py

@@ -0,0 +1,248 @@
+"""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):
+        if file_list := super().select_file(filetypes, multiple):
+            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