Apply formating, light linting

printers

README.md

@@ -15,6 +15,7 @@ To make this project work, you will need :
 - A Thermal Printer :
     - I used *Adafruit's thermal printer* at first, but it broke down. You can get it [here](https://www.adafruit.com/product/597).
     - I then used an *EPSON TM-T2OIII*. It's expensive, but it's also high quality, and has better CUPS and specific library support.
+    - Sometime after, a friend leant me a *Brother QL-650TD* to add support for this type of printer.
 - A Raspberry Pi or any computer with USB or Serial.
 - Some electric wires.
 - Some knowledge of the command line,
@@ -37,13 +38,15 @@ You can also get some information from [here](https://learn.adafruit.com/mini-th
 
 LittlePrynter itself does not require any other software than the ones installed with it, i.e the ones listed in the `pyproject.toml` file.
 
-The version for the EPSON TM-T20III uses a library called `python-escpos`, which doesn't need a CUPS driver or anything else. It's included in the Python dependencies.
+The project supports EPSON label printers as well as Brother label printers, and you can try to adapt it for other printers. For example, using `adafruit-thermal`.
 
-The project only supports the EPSON printer, but you can try to adapt it for other printers. For example, using `adafruit-thermal`, or `brother-ql`.
+For the EPSON TM-T20III, LittlePrynter uses a library called `python-escpos`, which doesn't need a CUPS driver or anything else. It's included in the Python dependencies. For the Brother-QL, we use the `brother-ql` library, which is also included.
 
 ### Install & setup the project :
 
-Theses commands will copy the software on your computer, go into the directory, then activate a virtual environnement and install all of the project's dependecies.
+We use [Poetry](https://python-poetry.org/) to manage the Python environnement and packages. You will need to install it on your computer to install LittlePrynter.
+
+The following commands will copy the software on your computer, go into the directory, then activate a virtual environnement and install all of the project's dependecies.
 
 ```
 $ git clone https://git.n07070.xyz/n07070/LittlePrynter
@@ -69,6 +72,8 @@ $ flask run --cert=adhoc
 
 The `--cert=adhoc` argument will make LittlePrinter accessible in HTTPS with a [self-signed SSL certificate](https://en.wikipedia.org/wiki/Self-signed_certificate). This provides a free and easy way to use HTTPS, but does not provide any trust value. It is, on the other hand, a good way to access the webcam in developpement mode or on a local network, because a HTTPS connexion is required by browsers to access the needed APIs.
 
+You can also use the `run.sh` for this.
+
 This command should start a web server with which you can test your configuration. If you plan on exposing your printer to the Internet, and give it an IP / URL, _please, please, please_, don't run it this way. Look at Flask's documentation and read about running a production server. It's a little more work, but it will prevent your computer/server being hacked in too easily.
 
 Voilà !
@@ -81,11 +86,11 @@ Please also say if you had a printer to test your code, and which printer you've
 
 ### Code structure
 
-The app is written about the Flask framework. You can start by looking at the code in the `src/` folder, in the `main.py` file. There, you will see that a few classes are initialized. In general, they are two parts to the program :
+The app is written around the Flask framework. You can start by looking at the code in the `src/` folder, in the `main.py` file. There, you will see that a few classes are initialized. In general, they are two parts to the program :
 
 The Web pages and the API, which are the user-facing parts. This is with what the users will interact, and define how the program is going to be used. The web pages are renderer from the `include/` folder where Jinj2 templates are defined.
 
-The Worker and Printer Queue are the internal parts. When a new thing needs to be printed, usually sent from the Web or API interfaces, a new Task in the type of the document is created, and added to a print queue. Then, a Worker thread looks up the state of the queue every so often and picks jobs to execute on the printers connected to the system.
+The Worker and Printer Queue are the internal parts. When a new thing needs to be printed, usually sent from the Web or API interfaces, a new Task of the type of the document is created, and added to a print queue. Then, a Worker thread looks up the state of the queue every so often and picks jobs to execute on the printers connected to the system.
 
 The last part of the program is the Raspberry Pi class, that handles to Photomaton mode, which handles button presses, and LED indicator and a flash.
 
@@ -130,7 +135,7 @@ If you liked this project, feel free to support my work !
 - [A link to buy one in Europe](https://rlx.sk/sk/various-boards/1829-mini-thermal-receipt-printer-adafruit-597.html)
 - [Another link to buy one, direct from factory](https://www.cashinotech.com/csn-a2-58mm-mini-panel-thermal-receipt-printer_p11.html)
 - [Diagnostickoeur](https://framagit.org/stickoeur/diagnostickoeur), another printer software mainly around Brother QL printers.
-
+- [FaxTheSystem](https://github.com/hackstub/faxthesystem/tree/main), another printer software, also around an Epson TM printer
 
 ## Licence
 

configuration/config.toml

@@ -1,13 +1,28 @@
 # Configuration file the LittlePrynter
 
 [defaults]
-signature = "Anonymous"
+signature = ""
+
 
 # Printer settings
 [printer]
-vendor_id = 0x04b8
-device_id = 0x0e28
 upload_folder = "src/static/uploads"
+# How long do we wait before giving up on waiting for a printer connexion
+waiting_time = 5
+
+[printer.epson]
+# Configurations for EPSON printers
+profile = "TM-T20III"
+label_type = 80 # 80 or 58 ( label width in mm )
+align_text = "center"
+text_max_length = 4096
+signature_max_length = 256
+
+[printer.brother]
+# Configurations for Brother printers
+label_type = "62" # See https://github.com/pklaus/brother_ql#usage for label types
+text_max_length = 4096
+signature_max_length = 256
 
 # Raspberry Pi Configuration
 [rpi]

configuration/config.toml.sample

@@ -5,8 +5,25 @@ signature = "Anonymous"
 
 # Printer settings
 [printer]
-vendor_id = "0x04b8"
-device_id = "0x0e28"
+# Where do we upload the pictures and such
+upload_folder = "src/static/uploads"
+
+# How long do we wait before giving up on waiting for a printer connexion
+waiting_time = 5
+
+[printer.epson]
+# Configurations for EPSON printers
+profile = "TM-T20III"
+label_type = 80 # 80 or 58 ( label width in mm )
+align_text = "center"
+text_max_length = 4096
+signature_max_length = 256
+
+[printer.brother]
+# Configurations for Brother printers
+label_type = 62 # See https://github.com/pklaus/brother_ql#usage for label types
+text_max_length = 4096
+signature_max_length = 256
 
 # Raspberry Pi Configuration
 [rpi]

poetry.lock

@@ -651,6 +651,18 @@ enabler = ["pytest-enabler (>=3.4)"]
 test = ["jaraco.test (>=5.4)", "pytest (>=6,!=8.1.*)", "zipp (>=3.17)"]
 type = ["pytest-mypy (>=1.0.1) ; platform_python_implementation != \"PyPy\""]
 
+[[package]]
+name = "iniconfig"
+version = "2.3.1"
+description = "brain-dead simple config-ini parsing"
+optional = false
+python-versions = ">=3.10"
+groups = ["main"]
+files = [
+    {file = "iniconfig-2.3.1-py3-none-any.whl", hash = "sha256:9121e2c1fdb355232495be3194c8dfe87ccc2d5dee45947b78e68f499790d7a7"},
+    {file = "iniconfig-2.3.1.tar.gz", hash = "sha256:67f4b9c50da0dedf52af349e7749a80a9057a5031199791b906c3bb3ae878960"},
+]
+
 [[package]]
 name = "isort"
 version = "8.0.1"
@@ -1137,6 +1149,18 @@ files = [
     {file = "platformdirs-4.9.6.tar.gz", hash = "sha256:3bfa75b0ad0db84096ae777218481852c0ebc6c727b3168c1b9e0118e458cf0a"},
 ]
 
+[[package]]
+name = "pluggy"
+version = "1.7.0"
+description = "plugin and hook calling mechanisms for python"
+optional = false
+python-versions = ">=3.10"
+groups = ["main"]
+files = [
+    {file = "pluggy-1.7.0-py3-none-any.whl", hash = "sha256:7dd7b0d8832ba3cb632c306926ded123429211b83641b35dc5c41ad2d34f9bec"},
+    {file = "pluggy-1.7.0.tar.gz", hash = "sha256:d1eaa46ebb595891b860ab086b4d09c8588af65ebd4361b8e8f4bb8920b90ba8"},
+]
+
 [[package]]
 name = "pycparser"
 version = "3.0"
@@ -1201,6 +1225,21 @@ files = [
     {file = "pycryptodomex-3.23.0.tar.gz", hash = "sha256:71909758f010c82bc99b0abf4ea12012c98962fbf0583c2164f8b84533c2e4da"},
 ]
 
+[[package]]
+name = "pygments"
+version = "2.21.0"
+description = "Pygments is a syntax highlighting package written in Python."
+optional = false
+python-versions = ">=3.9"
+groups = ["main"]
+files = [
+    {file = "pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9"},
+    {file = "pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c"},
+]
+
+[package.extras]
+windows-terminal = ["colorama (>=0.4.6)"]
+
 [[package]]
 name = "pylint"
 version = "4.0.5"
@@ -1253,6 +1292,28 @@ files = [
 [package.extras]
 cp2110 = ["hidapi"]
 
+[[package]]
+name = "pytest"
+version = "9.2.0"
+description = "pytest: simple powerful testing with Python"
+optional = false
+python-versions = ">=3.10"
+groups = ["main"]
+files = [
+    {file = "pytest-9.2.0-py3-none-any.whl", hash = "sha256:07acdcf88ec174f907dc01af70bf52d49b014bbab03faeeade31c96b18c2e588"},
+    {file = "pytest-9.2.0.tar.gz", hash = "sha256:97c4f3b1f3c7414aa36465e09b8220f1d03627993bd51b1282e193753c80557b"},
+]
+
+[package.dependencies]
+colorama = {version = ">=0.4", markers = "sys_platform == \"win32\""}
+iniconfig = ">=2"
+packaging = ">=24"
+pluggy = ">=1.6,<2"
+pygments = ">=2.15"
+
+[package.extras]
+dev = ["argcomplete", "asynctest ; python_version < \"3.11\"", "attrs (>=23.1)", "coverage (>=7.5)", "hypothesis (>=6.75)", "mock", "numpy (>=1.26)", "pexpect (>=4.9)", "pytest-xdist (>=3.5)", "pyyaml", "requests", "setuptools", "xmlschema"]
+
 [[package]]
 name = "python-barcode"
 version = "0.16.1"
@@ -1882,5 +1943,5 @@ h11 = ">=0.16.0,<1"
 
 [metadata]
 lock-version = "2.1"
-python-versions = ">=3.14"
-content-hash = "18e1a5c8b085aa639b665279856f9e3c51a734a6a8d1d4dd135ca7e4f67e86ae"
+python-versions = ">=3.13"
+content-hash = "7f8ddfbcbf88df2634e01dd4daf62ad54d1b97c279e3c4b478822fb5d4485647"

pyproject.toml

@@ -43,6 +43,7 @@ dependencies = [
     "pep8 (>=1.7.1,<2.0.0)",
     "pylint (>=4.0.5,<5.0.0)",
     "brother-ql-inventree (>=1.3,<2.0)",
+    "pytest (>=9.2.0,<10.0.0)",
 ]
 
 [tool.poetry]

run.sh

@@ -0,0 +1,2 @@
+eval $(poetry env activate)
+export FLASK_DEBUG=True; export FLASK_APP=src/main.py && flask run  --cert=adhoc --debug --no-debugger --host 0.0.0.0 --without-threads

src/main.py

@@ -1,7 +1,8 @@
 """
 Welcome to the LittlePrynter's source code.
-This program expose a web interface, with user authentification,
+This program expose a web interface,
 that makes it possible to print messages from the web.
+
 It also exposes a API, making it possible to print and interface
 with much of the printer's abilities.
 
@@ -10,12 +11,14 @@ Then we build the API around Flask,
 Then we build the web interface, using the simple Jinja2 templating.
 
 We support two modes :
+
 The first is a simple mode, where a computer, connected to a thermal printer,
 runs this program and exposes a web interface that makes use of the client's camera
-The seconde is booth mode, where a Raspberry Pi is connected to a thermal printer,
-a button and a flash.
-The web interface exists but may not be used, as the press of the button with take
- a picture and activate the flash while simply informing the web page.
+
+The seconde is booth mode, where a Raspberry Pi is connected to
+a thermal printer, a button and a flash.
+The web interface exists but it's not needed, as the press of the button
+takes a picture and activates the flash while simply informing the web page.
 """
 
 # Following are the librairies we import,
@@ -36,11 +39,11 @@ import werkzeug.exceptions
 from flask_socketio import SocketIO
 from flask_limiter import Limiter
 from flask_limiter.util import get_remote_address
-from printer import Printer  # The wrapper for the printer class
 from raspberry import Raspberry  # The Raspberry pi control Class
 from web import Web  # Wrapper for the web routes and API
 from print_queue import PrintQueue
 from worker import PrintWorker
+from printers import Printers
 
 # We create the main Flask object
 app = Flask(__name__)
@@ -73,11 +76,7 @@ except OSError as e:
 
 app.logger.debug("Config file loaded !")
 
-# Define the USB connections here.
-vendor_id = configuration_file["printer"]["vendor_id"]
-device_id = configuration_file["printer"]["device_id"]
 UPLOAD_FOLDER = str(configuration_file["printer"]["upload_folder"])
-
 try:
     os.mkdir(UPLOAD_FOLDER)
     app.logger.debug("Directory %s created successfully.", UPLOAD_FOLDER)
@@ -88,49 +87,53 @@ except PermissionError:
     sys.exit(77)
 
 # Output the config file
-if os.getenv("FLASK_DEBUG"):
+if not os.getenv("FLASK_DEBUG") is None and os.getenv("FLASK_DEBUG") is True:
     pprint.pprint(configuration_file)
 
 # We define the app module used by Flask
 app.secret_key = configuration_file["secrets"]["flask_secret_key"]
 app.config["UPLOAD_FOLDER"] = UPLOAD_FOLDER
 app.config["ALLOWED_EXTENSIONS"] = ALLOWED_EXTENSIONS
-app.config["MAX_CONTENT_LENGTH"] = 10 * 1000 * 1000  # Maximum 3Mb for a file upload
+app.config["MAX_CONTENT_LENGTH"] = 10 * 1000 * 1000  # Maximum 10Mb for a file upload
 app.config["TEMPLATES_AUTO_RELOAD"] = True
 
-# Printer connection
-# Uses the class defined in the printer.py file
-printer = Printer(app, 0x04B8, 0x0E28)
-printer.init_printer()
-
-# Find out if we are running on a Raspberry Pi
-rpi = Raspberry(
-    printer,
-    app,
-    socketio,
-    configuration_file["rpi"]["button_gpio_port_number"],
-    configuration_file["rpi"]["indicator_gpio_port_number"],
-    configuration_file["rpi"]["flash_gpio_port_number"],
-    configuration_file["rpi"]["flash"],
-)
-
-RASPBERRY_PI_CONNECTED = rpi.is_raspberry_pi()
-
 # Queue creation
 print_queue = PrintQueue(app)
 
+# Find out if we are running on a Raspberry Pi
+rpi = Raspberry(print_queue, app, configuration_file)
+RASPBERRY_PI_CONNECTED = rpi.is_raspberry_pi()
+
+
 #  Web & API management
 web = Web(app, print_queue)
 
+# Create a pool of printers
+try:
+    # comment: Find all printers connected to the system
+    printers_pool = Printers(app, configuration_file)
+except Exception as e:
+    app.logger.error("Could not create a pool of printers because %s", str(e))
+    sys.exit(-1)
+# end try
+
 # Start worker thread
-worker = PrintWorker(app, print_queue, printer, socketio)
-worker.start()
+try:
+    worker = PrintWorker(app, print_queue, printers_pool=printers_pool)
+    worker.start()
+except Exception as e:
+    app.logger.error("Could not start the worker because %s ", str(e))
+    sys.exit(-1)
 
 # The rate limit
 limiter = Limiter(
     get_remote_address, app=app, default_limits=["1500 per day", "500 per hour"]
 )
 
+
+app.logger.info("🖶 Welcome to LittlePrynter !")
+
+
 # General routes
 @app.route("/")
 @limiter.limit("1/second", override_defaults=False)
@@ -170,9 +173,19 @@ def web_print_sms():
             "No signature found for this print, using default signature : %s ", str(e)
         )
         sign = configuration_file["defaults"]["signature"]
+    try:
+        do_cut = bool(request.form["cut"])
+    except werkzeug.exceptions.BadRequestKeyError:
+        do_cut = False
 
     try:
-        web.print_sms(txt, sign)
+        # Clamp value between 1 and
+        many = max(1, min(int(request.form["many"]), 20))
+    except werkzeug.exceptions.BadRequestKeyError:
+        many = 1
+
+    try:
+        web.print_sms(txt, sign, do_cut, many)
     except RuntimeError as e:
         app.logger.error("Whoops, we could not print an SMS because : %s ", str(e))
         flash("Whoops, we could not print an SMS because :" + str(e), "error")
@@ -197,6 +210,9 @@ def web_print_img():
             "No signature found for this print, using default signature : %s", str(e)
         )
         sign = configuration_file["defaults"]["signature"]
+    except werkzeug.exceptions.RequestEntityTooLarge as e:
+        flash("Whoops, image is too big: " + str(e), "error")
+        return redirect(url_for("index"))
 
     # check if the post request has the file part
     if "img" not in request.files:
@@ -213,9 +229,25 @@ def web_print_img():
         flash("Submitted file has no filename !", "error")
         return redirect(url_for("index"))
 
+    try:
+        do_cut = bool(request.form["cut"])
+    except werkzeug.exceptions.BadRequestKeyError:
+        do_cut = False
+
+    try:
+        process_image = bool(request.form["process"])
+    except werkzeug.exceptions.BadRequestKeyError:
+        process_image = False
+
+    try:
+        # Clamp value between 1 and
+        many = max(1, min(int(request.form["many"]), 20))
+    except werkzeug.exceptions.BadRequestKeyError:
+        many = 1
+
     try:
         app.logger.debug("Sending the image to the printer.")
-        web.print_image(file, sign)
+        web.print_image(file, sign, do_cut, process_image, many)
     except RuntimeError as e:
         app.logger.error("The image could not be printed because : %s ", str(e))
         flash("The image could not be printed because : " + str(e), "error")
@@ -260,9 +292,21 @@ def api_print_sms():
             "No signature found for this print, using default signature. : %s", str(e)
         )
         sign = configuration_file["defaults"]["signature"]
+
+    try:
+        do_cut = bool(request.form["cut"])
+    except werkzeug.exceptions.BadRequestKeyError:
+        do_cut = False
+
+    try:
+        # Clamp value between 1 and
+        many = max(1, min(int(request.form["many"]), 20))
+    except werkzeug.exceptions.BadRequestKeyError:
+        many = 1
+
     try:
         # comment: We try to print the SMS
-        web.print_sms(txt, sign)
+        web.print_sms(txt, sign, do_cut, many)
     except RuntimeError as e:
         return str(e), 500
     # end try
@@ -295,16 +339,34 @@ def api_print_image():
         app.logger.error("Submitted file has no filename !")
         return "Submitted file has no filename !", 400
 
+    try:
+        do_cut = bool(request.form["cut"])
+    except werkzeug.exceptions.BadRequestKeyError:
+        do_cut = False
+
+    try:
+        process_image = bool(request.form["process"])
+    except werkzeug.exceptions.BadRequestKeyError:
+        process_image = False
+
+    try:
+        # Clamp value between 1 and
+        many = max(1, min(int(request.form["many"]), 20))
+    except werkzeug.exceptions.BadRequestKeyError:
+        many = 1
+
     try:
         app.logger.debug("Sending the image to the printer.")
-        web.print_image(file, sign)
+        web.print_image(file, sign, do_cut, process_image, many)
     except RuntimeError as e:
         return str(e), 500
 
     return "OK", 200
 
 
+# TODO: This might not depend on the Raspberry Pi
 @app.route("/api/camera/picture", methods=["GET"])
+@limiter.limit("6/minute", override_defaults=False)
 def camera_picture():
     """Returns a picture taken by the camera on a raspberry pi"""
     if RASPBERRY_PI_CONNECTED:
@@ -317,18 +379,28 @@ def camera_picture():
 
 
 @app.route("/api/queue", methods=["GET"])
+@limiter.limit("6/minute", override_defaults=False)
 def api_queue_status():
     """API endpoint for entire queue"""
     return jsonify(web.get_queue_state())
 
 
+@app.route("/api/queue/completed", methods=["GET"])
+@limiter.limit("6/minute", override_defaults=False)
+def api_queue_completed():
+    """API endpoint that returns the finished tasks"""
+    return jsonify(web.get_queue_completed())
+
+
 @app.route("/api/worker", methods=["GET"])
+@limiter.limit("6/minute", override_defaults=False)
 def api_worker_state():
     """API endpoint to get the worker state"""
     return jsonify(worker.current_state())
 
 
 @app.route("/api/worker/start")
+@limiter.limit("6/minute", override_defaults=False)
 def api_worker_start():
     """
     Enable to worker. This starts to process the print queue.
@@ -338,6 +410,7 @@ def api_worker_start():
 
 
 @app.route("/api/worker/stop")
+@limiter.limit("6/minute", override_defaults=False)
 def api_worker_stop():
     """
     Stops the print queue. This stops the processing of the print queue.
@@ -346,6 +419,13 @@ def api_worker_stop():
     return jsonify(worker.current_state())
 
 
+@app.route("/api/printers")
+@limiter.limit("6/minute", override_defaults=False)
+def api_printers_info():
+    """Returns the current state of every printers"""
+    return jsonify(printers_pool.printers_info())
+
+
 ## Authentification
 
 
@@ -403,4 +483,4 @@ def camera_status():
 
 
 if __name__ == "__main__":
-    app.run(debug=True, use_reloader=False, host="0.0.0.0", ssl_context="adhoc")
+    app.run(use_reloader=False, host="0.0.0.0", ssl_context="adhoc")

src/print_queue.py

@@ -76,7 +76,21 @@ class PrintQueue:
         """Return current queue state"""
         with self._lock:
             self.app.logger.debug("Return current queue state")
-            return [{"task_id": t.task_id, "status": t.status} for t in self._queue]
+            return [
+                {
+                    "task_id": t.task_id,
+                    "status": t.status,
+                    "type": str(t.task_type),
+                    "content": str(t.get_print_data()),
+                }
+                for t in self._queue
+            ]
+
+    def get_queue_completed(self):
+        """Return completed queue elements"""
+        with self._lock:
+            self.app.logger.debug("Return completed queue elements")
+            return self._completed_tasks
 
     def get_status(self, task_id):
         """Get full status info for a task"""

src/printer.py

@@ -1,119 +1,163 @@
 """
 This class manages connexion to a Printer
 """
-# import brother_ql
-from time import sleep
-import os.path
 
-from PIL import Image, ImageEnhance
+import os.path
+import os
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+import time
+from enum import Enum
+import uuid
+import threading
+from pathlib import Path
+from uuid import uuid4
+import usb.core
+from PIL import Image, ImageEnhance, ImageDraw, ImageFont
 import numpy as np
 
-# Importing the module to manage the connection to the printer.
+# Importing the modules needed for each supported printer Type
 import escpos.printer
+from brother_ql.models import ModelsManager
+from brother_ql.backends import backend_factory, guess_backend
+from brother_ql.raster import BrotherQLRaster
+from brother_ql.conversion import convert
+from brother_ql.backends.helpers import send
+from brother_ql import create_label
 
 
-class Printer():
+class PrinterType(Enum):
     """
-    # The connection is based on the ESC/POS library
-
-    ## Connection to the USB printer
-
-    ## Making sure the printer is alive
-
-    ## Making sure it has paper
-
-    ## Define default print settings
-
-    ## Print starting message, log time of first print, cut.
-
-    ## Annonce readyness : return a positive pong message.
+    What are the capacities of a Printer ?
     """
 
-    # Is the printer ready to accept a new print ?
-    ready = False
+    EPSON = "epson"
+    BROTHER = "brother"
 
-    def __init__(self, app, device_id, vendor_id):
-        super().__init__()
+
+# For Brother-QL Printers
+@dataclass
+class PrinterInfo:
+    """
+    Brother-QL printer information
+    """
+
+    identifier: str
+    backend: str
+    protocol: str
+    vendor_id: str
+    product_id: str
+    serial_number: str
+    name: str = "Brother QL Printer"
+    model: str = "QL-570"
+    status: str = "unknown"
+    label_type: str = "unknown"
+    label_size: str = "unknown"
+    label_width: int = 0
+    label_height: int = 0
+
+    def __getitem__(self, item):
+        return getattr(self, item)
+
+    def __setitem__(self, key, value):
+        setattr(self, key, value)
+
+
+class Printer(ABC):
+    """
+    If it outputs printed paper and speaks like a printer, then it must be a printer.
+    """
+
+    def __init__(self, app, vendor_id, device_id, printer_type: PrinterType):
+        """
+        We initialize a Printer via it's USB connexion, and generate a unique ID
+        """
+        self.id = uuid.uuid4()
         self.app = app
-        self.ready = False
-        self.printer = None
-        self.device_id = device_id
         self.vendor_id = vendor_id
+        self.device_id = device_id
+        self.ready = False
+        self.printer_type = printer_type
+        self._lock = threading.Lock()
+        self.used = False
+
+    @abstractmethod
+    def _has_paper(self) -> bool:
+        """Check if the printer has papier"""
+
+    @abstractmethod
+    def _state(self) -> bool:
+        """Reports the state of the Printer"""
+
+    @abstractmethod
+    def print_task(self, task_type, data) -> None:
+        """Takes a PrintTask and executes it"""
+
+    def use_printer(self) -> None:
+        """Marks the printer as being used"""
+        self.used = True
+
+    def free_printer(self) -> None:
+        """Marks the printer as being not used, it's available."""
+        self.used = False
+
+
+class EscPosPrinter(Printer):
+    """
+    Create a new ESC/POS based printer.
+    """
+
+    def __init__(self, app, vendor_id, device_id, configuration_file):
+        """
+        Create a connexion to a ESC/POS Printer via USB,
+        Making sure the printer is alive,
+        Making sure it has paper,
+        Define default print settings
+        """
+        super().__init__(app, vendor_id, device_id, printer_type=PrinterType.EPSON)
+        self.printer = None
         self.usb_args = {}
-        self.usb_args["idVendor"] = self.device_id
-        self.usb_args["idProduct"] = self.vendor_id
+        self.usb_args["idVendor"] = self.vendor_id
+        self.usb_args["idProduct"] = self.device_id
+        self.configuration_file = configuration_file
 
-    def check_paper(self) -> bool:
-        """
-        On printers that support it, we check that the printer has paper
-        """
-        self.app.logger.debug("Checking paper status...")
-        self.printer.open(self.usb_args)
-        status = self.printer.paper_status()
-        match status:
-            case 0:
-                self.app.logger.error("Printer has no more paper, aborting...")
-                self.printer.close()
-                raise RuntimeError("No more paper in the printer")
-            case 1:
-                self.app.logger.warning(
-                    "Printer needs paper to be changed very soon ! "
-                )
-                self.printer.close()
-            case 2:
-                self.app.logger.debug("Printer has paper, good to go")
-                self.printer.close()
+        try:
+            # This also calls open(), which we need to close()
+            # or else the device will appear as busy.
+            p = escpos.printer.Usb(
+                self.vendor_id, self.device_id, 0, profile=configuration_file["profile"]
+            )
+        except escpos.exceptions.DeviceNotFoundError as e:
+            self.app.logger.error(
+                "The USB device is not plugged in : %s",
+                str(e),
+            )
+            raise e
+        except Exception as e:
+            self.app.logger.error("Printer could not be connected : %s ", str(e))
+            raise e
 
-    def init_printer(self):
-        """
-        Check if the printer online ? Is the communication with the printer successfull ?
-        """
+        try:
+            if p.is_online():
+                self.app.logger.debug("Printer online !")
+        except Exception as e:
+            raise e
 
-        # TODO: This could happen directly when creating a new Printer class
-        if os.getenv("FLASK_DEBUG"):
-            waiting_elapsed = 3
-        else:
-            waiting_elapsed = 10
-
-        self.app.logger.debug("Waiting for printer to get online...")
-
-        while not self.ready:
-            try:
-                # This also calls open(), which we need to close()
-                # or else the device will appear as busy.
-                p = escpos.printer.Usb(
-                    self.device_id, self.vendor_id, 0, profile="TM-P80"
-                )
-            except RuntimeError as e:
-                self.app.logger.error(
-                    "The USB device is not plugged in, trying again %s : %s",
-                    waiting_elapsed,
-                    str(e),
-                )
-
-            try:
-                if p.is_online():
-                    self.ready = True
-                    self.app.logger.debug("Printer online !")
-            except RuntimeError as e:
-                self.app.logger.error(
-                    "Error while getting the printer online %s : %s",
-                    waiting_elapsed,
-                    str(e),
-                )
-
-            sleep(1)
-            waiting_elapsed -= 1
-            if waiting_elapsed < 1:
-                self.app.logger.error(
-                    "Printer took more than 30 seconds to get online, aborting..."
-                )
-                waiting_elapsed = 1  # Reset the waiting time for the next print.
-                return False
+        self.printer_info = PrinterInfo(
+            identifier=configuration_file["profile"],
+            backend="pyusb",
+            model=configuration_file["profile"],
+            protocol="ESC/POS",
+            vendor_id=self.vendor_id,
+            product_id=self.device_id,
+            serial_number="",
+            label_type=self.configuration_file["label_type"],
+        )
 
         # Setting up the printing options.
+        # TODO : Expose this to the web interface
         p.set(
-            align="center",
+            align=self.configuration_file["align_text"],
             font="a",
             bold=False,
             underline=0,
@@ -130,15 +174,37 @@ class Printer():
         # Beware : if we print every time the printer becomes ready, it means
         # we are printing before and after every print !
         self.printer = p
+        self.printer.close()  # We close the connexion to the Printer
+
+        try:
+            self._has_paper()
+        except Exception as e:
+            raise e
+
         self.ready = True
-        self.printer.close()
 
-        self.check_paper()
-
-        return True
-
-    def _print_sms(self, msg, signature="", bold=False):
+    def _has_paper(self):
+        """Check if the printer has paper left"""
+        self.app.logger.debug("Checking paper status...")
+        self.printer.open(self.usb_args)
+        status = self.printer.paper_status()
+        match status:
+            case 0:
+                self.app.logger.error("Printer has no more paper, aborting...")
+                self.printer.close()
+                raise RuntimeError("No more paper in the printer")
+            case 1:
+                self.app.logger.warning(
+                    "Printer needs paper to be changed very soon ! "
+                )
+                self.printer.close()
+                return True
+            case 2:
+                self.app.logger.debug("Printer has paper, good to go")
+                self.printer.close()
+                return True
 
+    def _print_txt(self, msg, signature="", bold=False):
         if not isinstance(msg, str):
             self.app.logger.error(
                 "It is not possible to print a " + str(type(msg)) + ", only strings."
@@ -150,24 +216,25 @@ class Printer():
         clean_signature = str(signature)
 
         # Make checks on the size of the message being printed
-        if len(clean_msg) > 4096:
+        if len(clean_msg) > int(self.configuration_file["text_max_length"]):
             self.app.logger.warning(
                 "Could not print message of this length: " + str(len(clean_msg))
             )
             raise RuntimeError(
                 "Could not print message of this length :"
                 + str(len(clean_msg))
-                + ", needs to be below 4096 caracters long."
+                + ", needs to be below %s caracters long.",
+                str(self.configuration_file["text_max_length"]),
             )
-
-        if len(signature) > 256:
+        if len(signature) > int(self.configuration_file["signature_max_length"]):
             self.app.logger.warning(
                 "Could not print signature of this length: " + str(len(clean_signature))
             )
             raise RuntimeError(
                 "Could not print signature of this length :"
                 + str(len(clean_signature))
-                + ", needs to be below 256 caracters long."
+                + ", needs to be below %s caracters long.",
+                str(self.configuration_file["signature_max_length"]),
             )
 
         # Do the actual printing
@@ -178,6 +245,7 @@ class Printer():
             self.printer.textln(clean_msg)
             if clean_signature:
                 self.printer.textln(clean_signature)
+            self.printer.textln()
             self.printer.close()
         except Exception as e:
             self.app.logger.error("Unable to print because : " + str(e))
@@ -186,19 +254,20 @@ class Printer():
             ) from e
 
         self.app.logger.info("Printed text")
-        return True
+        self.ready = True
 
     def _print_img(self, path, signature="", center=True, process=False):
         clean_signature = str(signature)
 
-        if len(signature) > 256:
+        if len(signature) > int(self.configuration_file["signature_max_length"]):
             self.app.logger.warning(
                 "Could not print signature of this length: " + str(len(clean_signature))
             )
-            raise ValueError(
+            raise RuntimeError(
                 "Could not print signature of this length :"
                 + str(len(clean_signature))
-                + ", needs to be below 256 caracters long."
+                + ", needs to be below %s caracters long.",
+                str(self.configuration_file["signature_max_length"]),
             )
 
         if not os.path.isfile(str(path)):
@@ -214,55 +283,56 @@ class Printer():
         if process:
             try:
                 self.app.logger.debug("Proccessing the image")
-                path = _process_image(self, path)
+                processed_path = _process_image(self, path)
             except RuntimeError as e:
                 self.app.logger.error(
                     "Error while processing the image, aborting print : %s", str(e)
                 )
                 raise e
         else:
+            processed_path = path
             self.app.logger.warning("Not proccessing the image")
 
         try:
             self.printer.open(self.usb_args)
-            self.printer.image(path, center=center)
+            self.printer.image(processed_path, center=center)
             self.printer.textln(signature)
             self.printer.close()
-            self.app.logger.debug("Printed an image : " + str(path))
+            self.app.logger.debug("Printed an image : " + str(processed_path))
         except Exception as e:
             self.app.logger.error(str(e))
             raise RuntimeError("Could not print the picture") from e
-        finally:
-            try:
-                os.remove(path)
-            except OSError as e:
-                raise e
+        # finally:
+        #     try:
+        #         os.remove(path)
+        #         os.remove(processed_path)
+        #         self.app.logger.debug("Removed image : " + str(processed_path))
+        #         self.app.logger.debug("Removed image : " + str(path))
+        #     except OSError as e:
+        #         raise e
 
-            self.app.logger.debug("Removed image : " + str(path))
-
-            try:
-                self.printer.close()
-            except Exception as e:
-                self.app.logger.error(
-                    "Could not close the printer connexion %s", str(e)
-                )
-                raise RuntimeError("Could not close the printer connexion. ") from e
+        try:
+            self.printer.close()
+        except Exception as e:
+            self.app.logger.error("Could not close the printer connexion %s", str(e))
+            raise RuntimeError("Could not close the printer connexion. ") from e
 
         self.app.logger.info("Printed a picture")
-        return True
+        self.ready = True
 
     def _qr(self, content):
         try:
             self.printer.open(self.usb_args)
             self.printer.qr(content, center=True)
+            self.printer.textln(content)
             self.printer.close()
         except RuntimeError as e:
             self.printer.close()
             self.app.logger.error(str(e))
-            return False
+            raise e
 
         self.app.logger.info("Printed a QR")
-        return True
+        self.ready = True
 
     def _cut(self):
         try:
@@ -275,73 +345,443 @@ class Printer():
             raise e
 
         self.app.logger.info("Did a cut")
-        return True
+        self.ready = True
+
+    def _state(self) -> bool:
+        has_paper = self._has_paper()
+        is_ready = self.ready
+
+        self.app.logger.debug("Has paper : %s ", has_paper)
+        self.app.logger.debug("Ready : %s ", is_ready)
+
+        return is_ready and has_paper  # and is_online
 
     def print_task(self, task_type, data):
         """Execute actual print based on task type"""
-        match (task_type.value):
-            case "text":
-                self._print_sms(data["txt"], signature=data["sign"])
-            case "image":
-                self._print_img(
-                    data["img"], signature=data["sign"], process=data["process"]
+
+        with self._lock:
+            self.app.logger.debug("Acquired lock to start print")
+
+            i_m_ready = self._state()
+            while not i_m_ready:
+                self.app.logger.debug(
+                    "Waiting for the printer to become ready, current state %s ",
+                    str(i_m_ready),
                 )
-            case "cut":
-                self._cut()
-            case _:
-                raise RuntimeError("This task type is not supported")
+                i_m_ready = self._state()
+                time.sleep(0.3)
+
+            self.app.logger.debug("Checked state to start printing : %s", self._state())
+            self.ready = False
+            try:
+                self.app.logger.debug("Checking task type")
+                match (task_type.value):
+                    case "text":
+
+                        self._print_txt(data["txt"], signature=data["sign"])
+                        self.ready = True
+                    case "image":
+                        self._print_img(
+                            data["img"], signature=data["sign"], process=data["process"]
+                        )
+                        self.ready = True
+                    case "cut":
+                        self._cut()
+                        self.ready = True
+                    case "qr":
+                        self._qr(data["txt"])
+                        self.ready = True
+                    case _:
+                        raise RuntimeError("This task type is not supported")
+            except Exception as e:
+                self.app.logger.debug("Exception occured while printing %s", str(e))
+                self.ready = True
+                raise RuntimeError from e
 
 
-def _process_image(self, path):
-    brightness_factor = 1.5  # Used only if image is too dark
-    brightness_threshold = 100  # Brightness threshold (0–255)
-    contrast_factor = 0.6  # Less than 1.0 = lower contrast
-    max_width = 575
-    max_height = 1000
+class BrotherPrinter(Printer):
+    """
+    Manages connexion and capabilities of a BrotherQL Printer
+    """
 
-    with Image.open(path) as original_img:
-        # Convert to RGB if needed (JPEG doesn't support alpha)
-        if original_img.mode in ("RGBA", "P"):
-            self.app.logger.debug("Converting the image to RGB from RGBA")
-            original_img = original_img.convert("RGB")
+    def __init__(self, app, vendor_id, device_id, configuration_file):
 
-        # Resize while maintaining aspect ratio
-        original_img.thumbnail((max_width, max_height), Image.Resampling.LANCZOS)
-        self.app.logger.debug("Resized the image")
+        super().__init__(app, vendor_id, device_id, printer_type=PrinterType.BROTHER)
+        self.printer = None
+        self.usb_args = {}
+        self.usb_args["idVendor"] = self.vendor_id
+        self.usb_args["idProduct"] = self.device_id
+        self.model_manager = ModelsManager()
 
-        # # Convert to grayscale for dithering
-        # dithered_img = original_img.convert("L").convert("1")
-        # Dithering using default method (Floyd–Steinberg)
-        # self.app.logger.debug("Dithered the image")
+        # Code taken from https://github.com/5shekel/printit/blob/master/printer_utils.py
 
-        # Compute brightness of original image (grayscale average)
-        grayscale = original_img.convert("L")
-        avg_brightness = np.array(grayscale).mean()
-        self.app.logger.debug(
-            "Average brightness of the image : " + str(avg_brightness)
+        self.app.logger.debug("Creating backend for Brother")
+        backend = backend_factory("pyusb")
+
+        available_devices = backend["list_available_devices"]()
+
+        for printer in available_devices:
+            self.app.logger.debug(f"Found device: {printer}")
+            identifier = printer["identifier"]
+            parts = identifier.split("/")
+
+            if len(parts) < 4:
+                self.app.logger.warning(
+                    f"Skipping device with invalid identifier format: {identifier}"
+                )
+                continue
+
+            protocol = parts[0]
+            # device_info = parts[2]
+            serial_number = parts[3]
+
+        try:
+            for m in self.model_manager.iter_elements():
+                if m.product_id == self.device_id:
+                    model = m.identifier
+
+                    break
+
+            self.app.logger.debug(f"Matched printer model: {model}")
+        except ValueError as ve:
+            self.app.logger.warning("Invalid product ID format:" + str(ve))
+            raise ve
+        except Exception as e:
+            self.app.logger.error("Error while finding a model ? : " + str(e))
+            raise e
+
+        self.printer_info = PrinterInfo(
+            identifier=identifier,
+            backend="pyusb",
+            model=model,
+            protocol=protocol,
+            vendor_id=vendor_id,
+            product_id=self.device_id,
+            serial_number=serial_number,
+            label_type=configuration_file[
+                "label_type"
+            ],  # TODO: Implement automatic label type detection : https://framagit.org/stickoeur/diagnostickoeur/-/blob/no-masters/printit.py?ref_type=heads#L239
+        )
+        self.app.logger.debug("Created a Brother printer !")
+        self.ready = True
+
+    def _has_paper(self):
+        raise NotImplementedError("This printer model does not support this.")
+
+    def _state(self):
+        return self.ready
+
+    def _print_txt(self, msg, signature="", bold=False):
+        """Print text after converting it to an image"""
+        self._print_img(text_to_image(msg))
+        self._print_img(text_to_image(signature))
+
+    def _print_img(
+        self,
+        data,
+        signature="",
+        process=False,
+    ):
+        """
+        Print a raster image via a Brother QL printer
+        """
+        self.app.logger.debug("Printing an image %s via Brother printer", data)
+        if process:
+            try:
+                self.app.logger.debug("Proccessing the image")
+                processed_path = _process_image(self, data)
+            except RuntimeError as e:
+                self.app.logger.error(
+                    "Error while processing the image, aborting print : %s", str(e)
+                )
+                raise e
+        else:
+            processed_path = data
+            self.app.logger.warning("Not proccessing the image")
+
+        try:
+            selected_backend = guess_backend(self.printer_info.identifier)
+            BACKEND_CLASS = backend_factory(selected_backend)["backend_class"]
+            BACKEND_STRING_DESCR = self.printer_info.identifier
+        except Exception as e:
+            self.app.logger.error(
+                "Couldn't guess the backend to use from the printer string descriptor"
+            )
+            raise e
+
+        try:
+            im = Image.open(processed_path)
+            qlr = BrotherQLRaster(self.printer_info.model)
+            # create_label(qlr, im, self.printer_info.label_type, cut=False, dither=True)
+
+            # noinspection PyCallingNonCallable
+            # be = BACKEND_CLASS(BACKEND_STRING_DESCR)
+            # be.write(qlr.data)
+            # be.dispose()
+            # del be
+
+            instructions = convert(
+                qlr=qlr,
+                images=[im],
+                label=self.printer_info.label_type,
+                dither=True,
+                compress=False,
+                dpi_600=False,
+                cut=False,
+            )
+
+            success = send(
+                instructions=instructions,
+                printer_identifier=BACKEND_STRING_DESCR,
+                backend_identifier="pyusb",
+                blocking=False,
+            )
+
+            self.app.logger.debug(str(success))
+            self.app.logger.debug("Printed image")
+            time.sleep(2)
+
+        except usb.core.USBError as e:
+            if "timeout error" in str(e):
+                self.app.logger.error("USB Timeout Error %s", str(e))
+        except Exception as e:
+            raise e
+        # finally:
+        #     try:
+        #         os.remove(processed_path)
+        #         self.app.logger.debug("Removed image : " + str(processed_path))
+        #     except OSError as e:
+        #         raise e
+
+        if signature != "":
+            self.app.logger.debug("Printing signature for the image %s", data)
+            try:
+                signature_file = text_to_image(signature)
+                im = Image.open(signature_file)
+                qlr = BrotherQLRaster(self.printer_info.model)
+                # create_label(
+                #     qlr, im, self.printer_info.label_type, cut=False, dither=True
+                # )
+
+                # noinspection PyCallingNonCallable
+                # be = BACKEND_CLASS(BACKEND_STRING_DESCR)
+                # be.write(qlr.data)
+                # be.dispose()
+                # del be
+                instructions = convert(
+                    qlr=qlr,
+                    images=[signature_file],
+                    label=self.printer_info.label_type,
+                    dither=True,
+                    compress=False,
+                    dpi_600=False,
+                    cut=False,
+                )
+
+                success = send(
+                    instructions=instructions,
+                    printer_identifier=BACKEND_STRING_DESCR,
+                    backend_identifier="pyusb",
+                    blocking=False,
+                )
+                self.app.logger.debug(str(success))
+                self.app.logger.debug("Printed signature")
+                time.sleep(2)
+
+            except Exception as e:
+                raise e
+            finally:
+                try:
+                    # os.remove(signature_file)
+                    self.app.logger.debug("Removed image : " + str(signature_file))
+                except OSError as e:
+                    raise e
+
+    def _cut(self):
+        self.app.logger.debug("Cutting via Brother Printer")
+        try:
+            selected_backend = guess_backend(self.printer_info.identifier)
+            BACKEND_CLASS = backend_factory(selected_backend)["backend_class"]
+            BACKEND_STRING_DESCR = self.printer_info.identifier
+        except Exception as e:
+            self.app.logger.error(
+                "Couldn't guess the backend to use from the printer string descriptor"
+            )
+            raise e
+
+        data = "src/static/images/1x1.png"
+        try:
+            im = Image.open(data)
+            qlr = BrotherQLRaster(self.printer_info.model)
+            create_label(
+                qlr, im, self.printer_info.label_type, threshold=70, cut=True, rotate=0
+            )
+
+            # noinspection PyCallingNonCallable
+            be = BACKEND_CLASS(BACKEND_STRING_DESCR)
+            be.write(qlr.data)
+            be.dispose()
+            del be
+            self.app.logger.debug("Finished cutting via Brother Printer")
+        except Exception as e:
+            raise e
+
+    def _qr(self):
+        # This should not be reached by a print on a BrotherQL
+        raise NotImplementedError()
+
+    def print_task(self, task_type, data):
+        """Execute actual print based on task type"""
+        with self._lock:
+            self.app.logger.debug("Acquired lock to start print")
+            i_m_ready = self._state()
+            while not i_m_ready:
+                self.app.logger.debug(
+                    "Waiting for the printer to become ready, current state %s ",
+                    str(i_m_ready),
+                )
+                i_m_ready = self._state()
+                time.sleep(0.3)
+
+            self.app.logger.debug("Checked state to start printing : %s", self._state())
+            self.ready = False
+
+            try:
+                match (task_type.value):
+                    case "image":
+                        self._print_img(data["img"], signature=data["sign"])
+                        self.ready = True
+                    case "cut":
+                        self._cut()
+                        self.ready = True
+                    case "text":
+                        self._print_txt(data["txt"], signature=data["sign"])
+                        self.ready = True
+                    case _:
+                        raise RuntimeError("This task type is not supported")
+            except Exception as e:
+                raise e
+
+
+def _process_image(self, path, max_width=575, max_height=1000):
+    brightness_threshold = 100
+    contrast_factor = 2.0
+
+    with Image.open(path) as img:
+        # Preserve aspect ratio while fitting within the maximum dimensions.
+        img.thumbnail(
+            (max_width, max_height),
+            Image.Resampling.LANCZOS,
         )
 
-        # Dynamically compute brightness factor if too dark
+        grayscale = img.convert("L")
+
+        avg_brightness = np.asarray(grayscale, dtype=np.float32).mean()
+        self.app.logger.debug("Average brightness of the image: %.2f", avg_brightness)
+
         if avg_brightness < brightness_threshold:
-            brightness_factor = (
-                1 + (brightness_threshold - avg_brightness) / brightness_threshold
-            )
             brightness_factor = min(
-                max(brightness_factor, 1.1), 2.5
-            )  # Clamp between 1.1 and 2.5
-            self.app.logger.debug(
-                f"Image too dark, increasing brightness by a factor of {brightness_factor:.2f}"
+                max(
+                    1 + (brightness_threshold - avg_brightness) / brightness_threshold,
+                    1.1,
+                ),
+                2.5,
             )
-            enhancer = ImageEnhance.Brightness(original_img)
-            original_img = enhancer.enhance(brightness_factor)
+            self.app.logger.debug(
+                "Image is dark; increasing brightness by %.2f",
+                brightness_factor,
+            )
+            grayscale = ImageEnhance.Brightness(grayscale).enhance(brightness_factor)
 
-        # # Reduce contrast
-        # contrast_enhancer = ImageEnhance.Contrast(original_img)
-        # original_img = contrast_enhancer.enhance(contrast_factor)
+        contrast = float(np.asarray(grayscale, dtype=np.float32).std())
+        self.app.logger.debug("Grayscale standard deviation: %.2f", contrast)
+
+        # Save the enhanced result.
+        processed = ImageEnhance.Contrast(grayscale).enhance(contrast_factor)
 
-        # Convert to JPEG and save
         jpeg_path = os.path.splitext(path)[0] + "_processed.jpg"
-        original_img.save(jpeg_path, format="JPEG", quality=95, optimize=True)
-        self.app.logger.debug("Processed and saved image.")
+        processed.save(jpeg_path, format="JPEG", quality=95, optimize=True)
 
+    self.app.logger.debug("Processed and saved image: %s", jpeg_path)
     return jpeg_path
+
+
+def text_to_image(
+    text,
+    width=400,
+    font_path="src/static/font/MonospaceTypewriter.ttf",
+    font_size=24,
+    padding=10,
+    line_spacing=4,
+    background="white",
+    fill="black",
+    output_dir="src/static/uploads",
+):
+    """Converts a string to an image"""
+
+    font = ImageFont.truetype(font_path, font_size)
+
+    # Measure and wrap text by pixel width.
+    measure_img = Image.new("RGB", (1, 1))
+    draw = ImageDraw.Draw(measure_img)
+    max_text_width = width - 2 * padding
+    if max_text_width <= 0:
+        raise ValueError("width must be greater than twice the padding")
+
+    lines = []
+    for paragraph in text.splitlines() or [""]:
+        words = paragraph.split()
+        if not words:
+            lines.append("")
+            continue
+
+        line = ""
+        for word in words:
+            candidate = f"{line} {word}".strip()
+            if draw.textbbox((0, 0), candidate, font=font)[2] <= max_text_width:
+                line = candidate
+                continue
+
+            if line:
+                lines.append(line)
+
+            # Split a word that is wider than the available width.
+            line = ""
+            piece = ""
+            for char in word:
+                if (
+                    piece
+                    and draw.textbbox((0, 0), piece + char, font=font)[2]
+                    > max_text_width
+                ):
+                    lines.append(piece)
+                    piece = char
+                else:
+                    piece += char
+            line = piece
+
+        if line:
+            lines.append(line)
+
+    if not lines:
+        lines = [""]
+
+    ascent, descent = font.getmetrics()
+    line_height = ascent + descent
+    height = 2 * padding + len(lines) * line_height + (len(lines) - 1) * line_spacing
+
+    image = Image.new("RGB", (width, height), background)
+    draw = ImageDraw.Draw(image)
+
+    y = padding
+    for line in lines:
+        draw.text((padding, y), line, font=font, fill=fill)
+        y += line_height + line_spacing
+
+    upload_dir = Path(output_dir)
+    upload_dir.mkdir(parents=True, exist_ok=True)
+
+    image_path = upload_dir / f"{uuid4().hex}.png"
+    image.save(image_path, format="PNG")
+
+    return str(image_path)

src/printers.py

@@ -0,0 +1,215 @@
+"""
+A collection of Printers.
+
+It has methods to discover printers, and provides an interface for
+the methods expected from printers.
+"""
+
+from collections.abc import Set
+import time
+import threading
+import usb.core
+import usb.util
+from printer import Printer, EscPosPrinter, BrotherPrinter
+
+
+class Printers:
+    """
+    Finds and creates a set of Printer that can be used by the Workers to print.
+    """
+
+    def __init__(self, app, configuration_file):
+        """
+        Discovers printers connected to the computer
+        """
+        self.app = app
+        self.configuration_file = configuration_file
+        self.printers = list(self._discover_printers())
+        self._lock = threading.Lock()
+
+    def _discover_printers(self) -> Set[Printer]:
+        """
+        Gets connected USB printer devices using the pyusb library.
+
+        We analyse the USB devices, get the ones that match
+        the printer class ( 7 ) and for Brother and EPSON printers,
+        try to create a Printer object that can be used by the Worker class
+        to execute prints.
+
+        Returns a set of Printer
+        """
+
+        self.app.logger.debug("Discovering USB Devices connected to this system")
+
+        printers = set()
+
+        waiting_time_for_printer = self.configuration_file["printer"]["waiting_time"]
+
+        while True:
+            # Find all connected USB devices
+            # the find() fnc returns a generator
+            devices = list(
+                usb.core.find(find_all=True, custom_match=_FindClass(self.app, 7))
+            )
+
+            if devices:
+                break
+
+            if waiting_time_for_printer <= 0:
+                self.app.logger.warning(
+                    "No USB devices of class 7 ( printers ) found or pyusb could not access the bus."
+                )
+                raise RuntimeError(
+                    "No USB devices of class 7 ( printers ) found or pyusb could not access the bus."
+                )
+
+            self.app.logger.warning(
+                "No printers found; waiting for a printer to connect..."
+            )
+
+            time.sleep(1)
+            waiting_time_for_printer -= 1
+
+        for dev in devices:
+            # Attempt to get the manufacturer and product strings
+            try:
+                manufacturer = usb.util.get_string(dev, dev.iManufacturer)
+            except Exception:
+                manufacturer = "Unknown"
+
+            try:
+                product = usb.util.get_string(dev, dev.iProduct)
+            except Exception:
+                product = "Unknown"
+
+            self.app.logger.debug(
+                "Looking at %s %s (%s:%s)",
+                manufacturer,
+                product,
+                hex(dev.idVendor),
+                hex(dev.idProduct),
+            )
+
+            match (manufacturer):
+                case "EPSON":
+                    try:
+                        # We create a new EscPosPrinter()
+                        self.app.logger.debug("Trying to create a new EPSON printer")
+                        prid = dev.idProduct
+                        vendir = dev.idVendor
+                        escpos_printer = EscPosPrinter(
+                            self.app,
+                            vendir,
+                            prid,
+                            self.configuration_file["printer"]["epson"],
+                        )
+                    except Exception as e:
+                        raise e
+
+                    # If the object creation is successfull, we add it to the list of Printers
+                    printers.add(escpos_printer)
+                    self.app.logger.debug("Found a %s printer", manufacturer)
+                case "Brother":
+                    try:
+                        # We create a new BrotherPrinter()
+                        self.app.logger.debug("Trying to create a new BROTHER printer")
+
+                        brother_printer = BrotherPrinter(
+                            self.app,
+                            dev.idVendor,
+                            dev.idProduct,
+                            self.configuration_file["printer"]["brother"],
+                        )
+                    except Exception as e:
+                        self.app.logger.error(
+                            "Could not create a %s printer class with %s:%s",
+                            product,
+                            dev.idVendor,
+                            dev.idProduct,
+                        )
+                        raise e
+
+                    # If the object creation is successfull, we add it to the list of Printers
+                    printers.add(brother_printer)
+                    self.app.logger.debug("Found a %s printer", manufacturer)
+                case _:
+                    self.app.logger.debug(
+                        "Found a printer of unknown manufacturer : %s", manufacturer
+                    )
+            # end match
+
+        self.app.logger.debug("Found %s printers", len(printers))
+
+        if len(printers) < 1:
+            self.app.logger.warning(
+                "Not printers found ! Please plug in a Printer and restart the program."
+            )
+            raise RuntimeError("No printers found")
+
+        return printers
+
+    def acquire_available_printer(self, start_index=0):
+        """Atomically acquire and return an available printer, or None."""
+        printers = self.printers
+        if not printers:
+            self.app.logger.error("No printers available for acquisition")
+            return None
+
+        with self._lock:
+            # So don't always look at the first printer available if need be
+            # this allows for a round-robin lookup
+            for offset in range(len(printers)):
+                index = (start_index + offset) % len(printers)
+                printer = printers[index]
+
+                if not printer.used:
+                    printer.use_printer()
+                    return index, printer
+
+        return None
+
+    def printers_info(self):
+        """Return the current list of printers"""
+        printers_info_list = []
+        for i in self.printers:
+            printers_info_list.append(
+                [
+                    i.printer_type.name,
+                    "Used: " + str(i.used),
+                    "Ready: " + str(i.ready),
+                    i.printer_info,
+                ]
+            )
+
+        return printers_info_list
+
+
+class _FindClass:
+    """
+    Use by usb.core to modify the way USB devices are found
+    Taken from pyUSB documentation on Github
+    """
+
+    def __init__(self, app, class_):
+        self._class = class_
+        self.app = app
+
+    def __call__(self, device):
+        # first, let's check the device
+        self.app.logger.debug(
+            "Found a USB device of class %s", str(device.bDeviceClass)
+        )
+        if device.bDeviceClass == self._class:
+            return True
+        # ok, transverse all devices to find an
+        # interface that matches our class
+        for configuration in device:
+            # Every device can have one or more configuration,
+            interface = usb.util.find_descriptor(
+                configuration, bInterfaceClass=self._class
+            )
+            # each config can have several interfaces
+            if interface is not None:
+                return True
+
+        return False

src/raspberry.py

@@ -10,12 +10,12 @@ import io  # To check if we are on a Raspberry Pi
 import subprocess
 import os
 from time import sleep, gmtime, strftime
-from flask_socketio import SocketIO
 from gpiozero import Button, LED, DigitalOutputDevice
 from PIL import Image
 from task import TextTask, ImageTask, CutTask
 
-class Raspberry():
+
+class Raspberry:
     """
     This class will manage three things :
     - Connecting to a USB webcam
@@ -23,29 +23,17 @@ class Raspberry():
     - Activating a flash ( or light )
     - Flash an indicator light
 
+    # pylint: disable=too-many-instance-attributes
+    # dede
     """
 
-    def __init__(
-        self,
-        print_queue,
-        app,
-        socketio,
-        button_gpio_port_number,
-        indicator_gpio_port_number,
-        flash_gpio_port_number,
-        is_flash_present,
-    ):
+    def __init__(self, print_queue, app, configuration_file):
         self.print_queue = print_queue
-        self.socketio = socketio
         self.app = app
-
-        self.flash_gpio = flash_gpio_port_number
-        self.is_flash_present = is_flash_present
-        self.button_gpio = button_gpio_port_number
-        self.led_gpio = indicator_gpio_port_number
+        self.configuration_file = configuration_file
         self.image_path = self.app.config["UPLOAD_FOLDER"] + "/image.jpg"
 
-    def is_raspberry_pi(self, raise_on_errors=False):
+    def is_raspberry_pi(self):
         """
         Checking if we are on a Raspberry Pi by checking
         information on the /proc/cpuinfo file
@@ -72,8 +60,11 @@ class Raspberry():
                             return False
 
                 if not found:
-                    self.app.logger.error(
-                        "Couldn't get sufficient hardware information from /proc/cpuinfo, Unable to determine if we are on a Raspberry Pi."
+                    self.app.logger.warning(
+                        "Couldn't get sufficient hardware information from /proc/cpuinfo"
+                    )
+                    self.app.logger.warning(
+                        "Unable to determine if we are on a Raspberry Pi."
                     )
                     return False
         except IOError:
@@ -83,28 +74,41 @@ class Raspberry():
         self.app.logger.debug("It seems we are on a Raspberry Pi")
 
         try:
-            self.initialise_gpio()
+            self._initialise_gpio()
         except Exception as e:
             self.app.logger.debug("Could not init GPIO : " + str(e))
             raise e
         return True
 
-    def initialise_gpio(self):
+    def _initialise_gpio(self):
+        """
+        Set GPIO ports from configuration and activate them
+        to show the user it's working.
+        """
         self.app.logger.debug("Initializing GPIO")
 
-        self.led = LED(self.led_gpio)
+        self.led = LED(self.configuration_file["rpi"]["indicator_gpio_port_number"])
         self.app.logger.debug("Activated indicator LED")
         self.indicator_countdown(iters=3)
-        self.button = Button(self.button_gpio, pull_up=True, bounce_time=0.1)
+        self.button = Button(
+            self.configuration_file["rpi"]["button_gpio_port_number"],
+            pull_up=True,
+            bounce_time=0.1,
+        )
         self.button.when_pressed = self.on_button_pressed
         self.app.logger.debug("Activated button")
 
         # The "flash" is a relay-controlled device ( light bulb for example )
-        self.flash = DigitalOutputDevice(self.flash_gpio)
+        self.flash = DigitalOutputDevice(
+            self.configuration_file["rpi"]["flash_gpio_port_number"]
+        )
         self.flash_toggle()
         self.app.logger.debug("Activated flash")
 
     def indicator_countdown(self, iters=10, multi=10):
+        """
+        Activates the LED faster and faster to show a countdown
+        """
         for i in range(iters, 0, -1):
             self.led.on()
             sleep(i / multi)
@@ -112,7 +116,10 @@ class Raspberry():
             sleep(i / multi)
 
     def indicator_led(self, timing=0.2, l=5):
-        for i in range(l):
+        """
+        Turns on the indicator LED for a certain period of time
+        """
+        for _ in range(l):
             self.app.logger.debug("LED turned on")
             self.led.on()
             sleep(timing)
@@ -121,6 +128,9 @@ class Raspberry():
             sleep(timing)
 
     def flash_toggle(self):
+        """
+        Flashes the flash
+        """
         self.app.logger.debug("Flash turned on")
         self.flash.on()
         sleep(0.3)
@@ -128,6 +138,9 @@ class Raspberry():
         self.app.logger.debug("Flash turned off")
 
     def take_picture(self):
+        """
+        Takes a picture via the USB webcam
+        """
         # Validate if the image path is valid
         if not os.path.isdir(os.path.dirname(self.image_path)):
             self.app.logger.error(
@@ -173,6 +186,9 @@ class Raspberry():
         position="bottom_right",
         margin=10,
     ):
+        """
+        Takes an image and overlays it with a another picture.
+        """
         try:
             image = Image.open(image_path).convert("RGBA")
             logo = Image.open(logo_path).convert("RGBA")
@@ -199,7 +215,9 @@ class Raspberry():
                 y = image.height - logo.height - margin
             else:
                 raise ValueError(
-                    "Invalid position. Choose from 'bottom_right', 'top_left', 'top_right', or 'bottom_left'."
+                    "Invalid position."
+                    + "Choose from 'bottom_right', 'top_left', "
+                    + " 'top_right', or 'bottom_left'."
                 )
 
             # Composite the logo onto the image
@@ -217,6 +235,9 @@ class Raspberry():
         return True
 
     def crop_to_square(self, image_path, output_path=None):
+        """
+        Crop an image so that it becomes a square
+        """
         try:
             image = Image.open(image_path)
             width, height = image.size
@@ -244,6 +265,10 @@ class Raspberry():
         return True
 
     def on_button_pressed(self):
+        """
+        When a button press is detected, a picture is taken from the webcam
+        and added to the print queue.
+        """
         self.app.logger.debug("Button has been pressed")
         self.led.on()
         self.app.logger.debug("Counting down")
@@ -263,8 +288,10 @@ class Raspberry():
         self.app.logger.debug("Printing picture")
         self.led.on()
         self.crop_to_square(self.image_path)
-        self.print_queue.enqueue(ImageTask(self.image_path,signature="",process=True))
-        self.print_queue.enqueue(TextTask(content="Imprimé par LittlePrynter", signature=""))
+        self.print_queue.enqueue(ImageTask(self.image_path, signature="", process=True))
+        self.print_queue.enqueue(
+            TextTask(content="Imprimé par LittlePrynter", signature="")
+        )
         time = strftime("%Y-%m-%d %H:%M", gmtime())
         self.print_queue.enqueue(TextTask(content=time, signature=""))
         self.print_queue.enqueue(CutTask())

src/task.py

@@ -14,6 +14,7 @@ to print at the same time.
 We can also delay and store printing tasks until a printer becomes
 available if none is online.
 """
+
 from abc import ABC, abstractmethod
 
 ## See https://docs.python.org/3/library/abc.html to learn more about this
@@ -27,9 +28,11 @@ class TaskType(Enum):
     """
     The different tasks supported by the printers
     """
+
     TEXT = "text"
     IMAGE = "image"
     CUT = "cut"
+    QR = "qr"
 
 
 class PrintTask(ABC):
@@ -37,18 +40,15 @@ class PrintTask(ABC):
     A print task holds information about what we are looking to print.
     """
 
-    def __init__(self, task_type):
+    def __init__(self, task_type: TaskType):
         self.task_id = self._generate_id()
         self.task_type = task_type
         self.status = "pending"  # pending, processing, completed, failed
 
-        print("Created a new " + str(self.task_type) + " with ID " + self.task_id)
-
     @abstractmethod
     def get_print_data(self):
         """Return data formatted for printer"""
 
-
     def _generate_id(self):
         # Generate unique task ID
         return str(uuid.uuid4())
@@ -68,6 +68,18 @@ class TextTask(PrintTask):
         return {"txt": self.content, "sign": self.signature}
 
 
+class QRTask(TextTask):
+    """This task prints a QR-Code, the signature is ignore and is always the content itself"""
+
+    def __init__(self, content):
+        super().__init__(content, signature="")
+        self.content = content
+        self.signature = content
+
+    def get_print_data(self):
+        return {"txt": self.content, "sign": self.signature}
+
+
 class ImageTask(PrintTask):
     """
     This tasks represents a image content ( in the form of it's path ), and it's signature.

src/templates/api.html

@@ -5,6 +5,6 @@
     <title>LittlePrynter API</title>
   </head>
   <body>
-    "Welcome to the printing software's API. Please see the index page to get started.
+    Welcome to the printing software's API. Please see the index page to get started.
   </body>
 </html>

src/templates/base.html

@@ -53,7 +53,7 @@
         <hr>
 
         <footer class="row">
-        <p class=" text-center">Little Prynter is built by <a href="https://n07070.xyz/about-me/">n07070</a> because it's fun :) | <a href="https://git.n07070.xyz/n07070/littleprynter">Source code - AGPLv3</a></p>
+        <p class=" text-center">Little Prynter is built by <a href="https://n07070.xyz/about-me/">n07070</a> because it's fun :) | <a href="/api">API interface</a> | <a href="https://git.n07070.xyz/n07070/littleprynter">Source code - AGPLv3</a></p>
         </footer>
     </body>
             <script src="https://cdn.socket.io/4.0.0/socket.io.min.js"></script>

src/templates/footer.html

@@ -1,5 +0,0 @@
-<hr>
-<footer>Little Prynter is built by <a href="https://n07070.xyz/about-me/">n07070</a> because it's fun :) | <a href="https://git.n07070.xyz/n07070/littleprynter/src/branch/epson-tm-t20iii">Source code - AGPLv3</a></footer>
-</div>
-</body>
-</html>

src/templates/index.html

@@ -6,9 +6,23 @@
       <h3 class="card-header">Print a short message</h3>
       <div class="card-body">
         <form class="form-group" action="/web/print/sms" method="post">
-          <input class="form-control" type="text" name="txt" placeholder="200 chars or less " maxlength="200" required><br>
-          <input class="form-control" type="text" name="signature" placeholder="Signature or pseudo" maxlength="200"><br>
-          <input class="btn btn-primary float-right" type="submit" value="Imprimer" name="imprimer">
+          <textarea class="form-control" type="text" name="txt" placeholder="4096 caractères maximum " maxlength="4096"></textarea>
+          <br>
+          <input class="form-control" type="text" name="signature" placeholder="Signature ou pseudo" maxlength="200"><br>
+          <div class="input-group">
+            <span class="input-group-text">Combien ?</span>
+            <input type="number" aria-label="how-many" class="form-control" name="many" max="20" min="1" value="1">
+            <input class="btn btn-primary float-right" type="submit" value="Imprimer" name="imprimer">
+          </div>
+          <br>
+          <div class="form-check">
+            <input class="form-check-input" type="checkbox" value="True" id="flexCheckDefault" name="cut" checked>
+            <label class="form-check-label" for="flexCheckDefault">
+              Couper après impression ?
+            </label>
+          </div>
+
+
         </form>
       </div>
     </div>
@@ -20,8 +34,26 @@
       <div class="card-body">
         <form enctype="multipart/form-data" class="form-group" action="/web/print/img" method="post">
           <input class="form-control" type="file" name="img" required><br>
-          <input class="form-control" type="text" name="signature" placeholder="Signature or pseudo" maxlength="200"><br>
-          <input class="btn btn-primary float-right" type="submit" value="Imprimer" name="imprimer">
+          <input class="form-control" type="text" name="signature" placeholder="Signature ou pseudo" maxlength="200"><br>
+          <div class="input-group">
+            <span class="input-group-text">Combien ?</span>
+            <input type="number" aria-label="how-many" class="form-control" name="many" max="20" min="1" value="1">
+            <input class="btn btn-primary float-right" type="submit" value="Imprimer" name="imprimer">
+          </div>
+          <br>
+          <div class="form-check .form-check-inline">
+            <input class="form-check-input" type="checkbox" value="True" id="flexCheckDefault" name="cut" checked>
+            <label class="form-check-label" for="flexCheckDefault">
+              Couper après impression ?
+            </label>
+          </div>
+          <div class="form-check .form-check-inline">
+            <input class="form-check-input" type="checkbox" value="True" id="flexCheckDefault" name="process">
+            <label class="form-check-label" for="flexCheckDefault">
+              Traiter l'image ?
+            </label>
+          </div>
+
         </form>
       </div>
     </div>

src/templates/password.html

@@ -1,30 +0,0 @@
-<!DOCTYPE html>
-<html>
-    <head>
-        <meta charset="utf-8">
-        <title>Log in</title>
-        <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
-        <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous">
-        <link rel="stylesheet" href="{{ url_for('static',filename='css/style.css') }}">
-    </head>
-    <body class="container">
-        <div class="col-md-6 offset-md-3">
-            <h1>Login</h1>
-            {% with messages = get_flashed_messages(with_categories=true) %}
-              {% if messages %}
-                {% for category, message in messages %}
-                  <div class="alert alert-{{ category }}" role="alert">{{ message }}</div>
-                {% endfor %}
-              {% endif %}
-            {% endwith %}
-
-            <form action="/login" method="post">
-                <div class="form-group">
-                <input type="text" name="username" class="form-control" placeholder="Pseudo">
-                <input type="password" name="password" class="form-control" placeholder="Password">
-                <button type="submit" class="btn btn-primary">Submit</button>
-                </div>
-            </form>
-        </div>
-    </body>
-</html>

src/web.py

@@ -1,20 +1,22 @@
-from flask import flash
-from werkzeug.utils import secure_filename
-import time
+"""
+Manage all of the inputs from a web source
+"""
+
 import os
+from werkzeug.utils import secure_filename
 from task import TextTask, ImageTask, CutTask
 
 
-class Web(object):
+class Web:
     """Web is the class that gets all of the information from web calls
-     ( API and Web page ) and provides checks before sending stuff to printing"""
+    ( API and Web page ) and provides checks before sending stuff to printing"""
 
     def __init__(self, app, print_queue):
         super(Web).__init__()
         self.print_queue = print_queue
         self.app = app
 
-    def print_sms(self, texte, sign: str) -> bool:
+    def print_sms(self, texte, sign: str, do_cut: bool, many: int = 1) -> bool:
         """
         Get text and a signature, prints the text and cuts after that.
         """
@@ -26,15 +28,22 @@ class Web(object):
             # !! there is no garantee !! that both the SMS task and the Cut task
             # are added back to back, another task could be
             # inserted between the two.
-            sms = self.print_queue.enqueue(TextTask(content=texte, signature=sign))
-            cut = self.print_queue.enqueue(CutTask())
+            for i in range(many):
+                sms = self.print_queue.enqueue(TextTask(content=texte, signature=sign))
+                self.app.logger.info("Added a SMS task at position %s", sms)
+                if do_cut:
+                    cut = self.print_queue.enqueue(CutTask())
+                    self.app.logger.info("Added a CUT task at position %s", cut)
+
         except Exception as e:
             self.app.logger.error(e)
             raise RuntimeError("Could not add SMS to queue, " + str(e)) from e
-        self.app.logger.info("Added two new tasks at position %s and %s", sms, cut)
+
         return True
 
-    def print_image(self, image, sign: str) -> bool:
+    def print_image(
+        self, image, sign: str, do_cut: bool, process_image: bool, many: int = 1
+    ) -> bool:
         """
         Get an image and a signature, prints the image and cuts after that.
         """
@@ -42,40 +51,45 @@ class Web(object):
             file_uploaded = self.upload_file(image)
         except Exception as e:
             self.app.logger.error(e)
-            raise RuntimeError("Could not upload file") from e
+            raise RuntimeError("Could not upload file : " + str(e)) from e
 
         if file_uploaded:
             self.app.logger.debug("File has been uploaded, printing...")
             try:
-                img = self.print_queue.enqueue(
-                    ImageTask(
-                        os.path.join(
-                            self.app.config["UPLOAD_FOLDER"],
-                            secure_filename(image.filename),
-                        ),
-                        signature=sign,
-                        process=True,
+                for i in range(many):
+                    img = self.print_queue.enqueue(
+                        ImageTask(
+                            os.path.join(
+                                self.app.config["UPLOAD_FOLDER"],
+                                secure_filename(image.filename),
+                            ),
+                            signature=sign,
+                            process=process_image,
+                        )
                     )
-                )
+                    self.app.logger.info("Added a IMG task at position %s", img)
 
-                cut = self.print_queue.enqueue(CutTask())
+                    if do_cut:
+                        cut = self.print_queue.enqueue(CutTask())
+                        self.app.logger.info("Added a CUT task at position %s", cut)
             except Exception as e:
                 raise RuntimeError("Could not add IMG to queue" + str(e)) from e
 
-            self.app.logger.info("Added two new tasks at position %s and %s", img, cut)
-
         return True
 
-    def login(self, username: str, password: str) -> bool:
-        """Not implemented"""
-        return
+    # def login(self, username: str, password: str) -> bool:
+    #     """Not implemented"""
+    #     return
 
-    def logout(self, username: str, password: str) -> bool:
-        """Not implemented"""
-        return
+    # def logout(self, username: str, password: str) -> bool:
+    #     """Not implemented"""
+    #     return
 
     def allowed_file(self, filename) -> bool:
-        self.app.logger.debug("Is the filename allowed ?")
+        """
+        Check if the file extension is allowed
+        """
+        self.app.logger.debug("Checking if the file extension is allowed")
         return (
             "." in filename
             and filename.rsplit(".", 1)[1].lower()
@@ -83,8 +97,11 @@ class Web(object):
         )
 
     def upload_file(self, image) -> bool:
+        """
+        Save the file after executing checks on it
+        """
         self.app.logger.debug("Validating file")
-        if image:
+        if not image is None or not image == "":
             if self.allowed_file(image.filename):
                 filename = secure_filename(image.filename)
                 self.app.logger.debug("File valid")
@@ -92,24 +109,23 @@ class Web(object):
                     image.save(os.path.join(self.app.config["UPLOAD_FOLDER"], filename))
                 except OSError as e:
                     self.app.logger.error("Could not save file %s", e)
-                    return False
+                    raise RuntimeError(
+                        "An OS error occured while uploading this file : " + str(e)
+                    ) from e
 
                 self.app.logger.debug(
                     "File saved to "
                     + str(os.path.join(self.app.config["UPLOAD_FOLDER"], filename))
                 )
                 return True
-            else:
-                self.app.logger.error(
-                    "Could not save file because the filename is forbidden"
-                )
-                return False
-        else:
-            self.app.logger.error(
-                "Could not save file, it seems to be null ? : " + str(filename)
-            )
-            return False
+
+        self.app.logger.error("Could not save file because the filename is forbidden")
+        raise RuntimeError("This file type is forbidden.")
 
     def get_queue_state(self):
         """Return current queue state"""
         return self.print_queue.get_queue_state()
+
+    def get_queue_completed(self):
+        """Return completed queue elements"""
+        return self.print_queue.get_queue_completed()

src/worker.py

@@ -1,84 +1,158 @@
-# This is the main printing thread
-# As explained in the task file, this is where we command
-# printing to happen.
+"""
+This is the main printing thread. A worker thread consums Tasks from
+ a PrintQueue, while trying to find available printers.
+"""
 
 import threading
 import time
+import traceback
 
 
 class PrintWorker(threading.Thread):
-    def __init__(self, app, print_queue, printer, socketio=None):
+    """
+    A thread used to consume Tasks added to a Print Queue.
+
+    On initialisation, the worker will try to find Printers,
+    and on each print, if the choosen Printer becomes unavailable, it
+    will choose an available Printer from a list of Printers.
+
+    If a print fails, it's not retried, but will be added to a list of completed
+    tasks. TODO : Change that
+    """
+
+    def __init__(self, app, print_queue, printers_pool, printer_index=0):
         super().__init__(daemon=True)
         self.app = app
         self.print_queue = print_queue
-        self.printer = printer
-        self.socketio = socketio  # Optional
+        self.printer = None
+        self._lock = threading.Lock()
         self.running = True
         self.state = "idle"  # idle, printing, dead, drinking-a-beer
 
+        # All workers share the same pool of printers.
+        self.printers = printers_pool
+        self.printers_obj = self.printers.printers
+        # If we create several workers, we can assign an index
+        # so that we lookup the nth printer for the nth worker
+        self._printer_index = printer_index
+
+        self.app.logger.debug("Worker initialized.")
+        self.app.logger.debug("Printers connected:")
+        for printer in self.printers_obj:
+            self.app.logger.debug("Printer type: %s", printer.printer_type)
+            self.app.logger.debug("Printer state: %s", printer.ready)
+
         self.app.logger.debug("Ho great, I'm alive... I'm ready to work another day...")
 
+    def _acquire_available_printer(self):
+        result = self.printers.acquire_available_printer(
+            start_index=self._printer_index
+        )
+        if result is None:
+            return None
+
+        index, printer = result
+        # In case we need to lookup another printer, we don't
+        # look at the same printer in the printer list
+        self._printer_index = (index + 1) % len(self.printers_obj)
+        return printer
+
     def run(self):
         """Background thread that processes queue items"""
-        self.app.logger.info("Worker started working.")
+        self.app.logger.debug("Worker %s started working.", threading.get_ident())
+        self.app.logger.debug("Current threads : %s", threading.active_count())
+        self.app.logger.debug("Threads actives : %s ", threading.enumerate())
+
         while True:
-            if not self.running or not self.printer.ready:
+
+            # If the printer is dead or asleep, it can't work.
+            if not self.running:
                 time.sleep(0.2)
                 continue
 
-            try:
-                task = self.print_queue.dequeue()
-            except Exception as e:
-                self.app.logger.error("Could not get a new task ! %s ", str(e))
-                raise RuntimeError(
-                    "We could not get a new task because " + str(e)
-                ) from e
+            # If we have no available printer, we look at the list printers
+            # we know about, and try to find one that is available.
+            # When we find a printer, we acquire it
+            # When we are finished with a printer, we release it to the world.
 
-            if task:
+            # If we do not have a printer, we try to find one
+
+            while self.running and self.printer is None:
+                self.app.logger.debug(
+                    "Trying to find a available printer for the worker."
+                )
+                self.printer = self._acquire_available_printer()
+                self.app.logger.debug(
+                    "The worker got a %s printer and it's %s",
+                    self.printer.printer_type,
+                    "Ready" if self.printer.ready else "Not ready",
+                )
+
+                if self.printer is None:
+                    time.sleep(1)
+
+            self.printer.use_printer()
+
+            # If the printer is not ready, we wait for it to become ready.
+            while not self.printer.ready:
+                self.app.debug("Waiting for our printer to become ready...")
+                time.sleep(1)
+
+            if self.state != "idle":
+                self.app.logger("We are not idle, waiting...")
+                time.sleep(1)
+                continue
+
+            self.state = "printing"
+
+            with self._lock:
                 try:
-                    self.app.logger.info("Got a new task")
-                    self.app.logger.debug("Got task %s", task.task_id)
-                    self.state = "printing"
-                    task.status = "processing"
-                    self._emit_status(task.task_id, "processing")
+                    task = self.print_queue.dequeue()
+                except Exception as e:
+                    self.app.logger.error("Could not get a new task ! %s ", str(e))
+                    self.state = "idle"
+                    self.printer.free_printer()
+                    raise RuntimeError(
+                        "We could not get a new task because " + str(e)
+                    ) from e
 
-                    print_data = task.get_print_data()
+                if task:
                     try:
-                        self.printer.print_task(task.task_type, print_data)
+                        self.app.logger.info("Got a new task")
+                        self.app.logger.debug(
+                            "Got task %s %s", task.task_type, task.task_id
+                        )
+                        task.status = "processing"
+
+                        print_data = task.get_print_data()
+
+                        try:
+                            self.printer.print_task(task.task_type, print_data)
+                        except RuntimeError as e:
+                            self.state = "idle"
+                            self.app.logger.error("Could not print : %s", str(e))
+                            self.app.logger.error(traceback.format_exc())
+                            self.printer.free_printer()
+
+                        task.status = "completed"
+                        self.print_queue.mark_completed(task.task_id, "completed")
+                        self.app.logger.debug(
+                            "Finished printing task %s ", task.task_id
+                        )
+                        self.state = "idle"
+
                     except RuntimeError as e:
-                        self.app.logger.error("Could not print : %s", str(e))
-                        raise e
+                        task.status = "failed"
+                        self.state = "idle"
+                        self.print_queue.mark_completed(task.task_id, "failed")
+                        self.app.logger.error(
+                            "Could not print task %s because %s ", task.task_id, str(e)
+                        )
 
-                    task.status = "completed"
-                    self.print_queue.mark_completed(task.task_id, "completed")
-                    self._emit_status(task.task_id, "completed")
-
-                except RuntimeError as e:
-                    task.status = "failed"
-                    self.print_queue.mark_completed(task.task_id, "failed")
-                    self._emit_status(task.task_id, "failed", error=str(e))
-                    print(f"Print task {task.task_id} failed: {e}")
-            else:
-                # When they are no new tasks to handle, we put the thread to sleep.
-                self.state = "idle"
-                time.sleep(0.1)
-
-    def _emit_status(self, task_id, status, error=None):
-        """Emit status update via Socket.IO if available"""
-        if not self.socketio:
-            return
-
-        room = f"task_{task_id}"
-        data = {
-            "task_id": task_id,
-            "status": status,
-            "position": None,  # Task no longer in queue
-        }
-
-        if error:
-            data["error"] = error
-
-        self.socketio.emit("task_status", data, room=room)
+                else:
+                    # When they are no new tasks to handle, we put the thread to sleep.
+                    self.state = "idle"
+                    time.sleep(0.1)
 
     def stop_worker(self):
         """
@@ -86,6 +160,10 @@ class PrintWorker(threading.Thread):
         """
         self.app.logger.debug("Giving the worker a break")
         self.state = "drinking-a-beer"
+        # Free the printer during the worker break
+        # so it can be used by someone else
+        self.printer.free_printer()
+        self.printer = None
         self.running = False
 
     def start_worker(self):
@@ -104,4 +182,5 @@ class PrintWorker(threading.Thread):
             "is_running": self.running,
             "queue_size": len(self.print_queue),
             "state": self.state,
+            "printers": len(self.printers_obj),
         }