Apply linting

update Printer

README.md

@@ -15,7 +15,6 @@ 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,
@@ -38,15 +37,13 @@ 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 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 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.
 
-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.
+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`.
 
 ### Install & setup the project :
 
-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.
+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.
-
-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
@@ -72,8 +69,6 @@ $ 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à !
@@ -84,16 +79,6 @@ Your contributions are very much welcome ! You can either request an account on
 
 Please also say if you had a printer to test your code, and which printer you've been using.
 
-### Code structure
-
-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 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.
-
 ### Linting
 
 If you want to contribute code, please make sure to lint the project before commiting. This helps the code keep a general structure, and avoids some commons erros and mistakes.
@@ -135,7 +120,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,28 +1,13 @@
 # Configuration file the LittlePrynter
 
 [defaults]
-signature = ""
+signature = "Anonymous"
-
 
 # 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,25 +5,8 @@ signature = "Anonymous"
 
 # Printer settings
 [printer]
-# Where do we upload the pictures and such
+vendor_id = "0x04b8"
-upload_folder = "src/static/uploads"
+device_id = "0x0e28"
-
-# 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,18 +651,6 @@ 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"
@@ -1149,18 +1137,6 @@ 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"
@@ -1225,21 +1201,6 @@ 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"
@@ -1292,28 +1253,6 @@ 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"
@@ -1943,5 +1882,5 @@ h11 = ">=0.16.0,<1"
 
 [metadata]
 lock-version = "2.1"
-python-versions = ">=3.13"
+python-versions = ">=3.14"
-content-hash = "7f8ddfbcbf88df2634e01dd4daf62ad54d1b97c279e3c4b478822fb5d4485647"
+content-hash = "18e1a5c8b085aa639b665279856f9e3c51a734a6a8d1d4dd135ca7e4f67e86ae"

pyproject.toml

@@ -7,7 +7,7 @@ authors = [
 ]
 license = "AGPLv3"
 readme = "README.md"
-requires-python = ">=3.13"
+requires-python = ">=3.14"
 dependencies = [
     "flask (>=3.1.3,<4.0.0)",
     "numpy (>=2.3.4)",
@@ -43,7 +43,6 @@ 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

@@ -1,2 +0,0 @@
-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,8 +1,7 @@
 """
 Welcome to the LittlePrynter's source code.
-This program expose a web interface,
+This program expose a web interface, with user authentification,
 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.
 
@@ -11,14 +10,12 @@ 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,
-The seconde is booth mode, where a Raspberry Pi is connected to
+a button and a flash.
-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
-The web interface exists but it's not needed, as the press of the button
+ a picture and activate the flash while simply informing the web page.
-takes a picture and activates the flash while simply informing the web page.
 """
 
 # Following are the librairies we import,
@@ -39,11 +36,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__)
@@ -76,7 +73,11 @@ 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)
@@ -87,54 +88,54 @@ except PermissionError:
     sys.exit(77)
 
 # Output the config file
-if not os.getenv("FLASK_DEBUG") is None and os.getenv("FLASK_DEBUG") is True:
+if os.getenv("FLASK_DEBUG"):
     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 10Mb for a file upload
+app.config["MAX_CONTENT_LENGTH"] = 10 * 1000 * 1000  # Maximum 3Mb 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)
+# printers = Printer(app)
+# printers.discover_printers()
+# printers.init()
+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
+#  Web & API  routes
-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
-try:
+worker = PrintWorker(app, print_queue, printer, socketio)
-    worker = PrintWorker(app, print_queue, printers_pool=printers_pool)
+worker.start()
-    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)
 def index():
@@ -152,6 +153,8 @@ def webcam():
 
 
 # Form treatement
+
+
 @app.route("/web/print/sms", methods=["POST"])
 @limiter.limit("6/minute", override_defaults=False)
 def web_print_sms():
@@ -173,26 +176,16 @@ 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:
-        # Clamp value between 1 and
+        web.print_sms(txt, sign)
-        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")
         return redirect(url_for("index"))
 
     # end try
-    flash("The SMS has been added to the print queue !", "info")
+    flash("The SMS has been printed !", "info")
     return redirect(url_for("index"))
 
 
@@ -210,9 +203,6 @@ 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:
@@ -229,31 +219,15 @@ 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, do_cut, process_image, many)
+        web.print_image(file, sign)
     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")
         return redirect(url_for("index"))
 
-    flash("Picture added to the print queue !", "info")
+    flash("Picture printed !", "info")
     return redirect(url_for("index"))
 
 
@@ -292,21 +266,9 @@ 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, do_cut, many)
+        web.print_sms(txt, sign)
     except RuntimeError as e:
         return str(e), 500
     # end try
@@ -334,39 +296,22 @@ def api_print_image():
         return "No image submitted", 400
 
     file = request.files["img"]
-    # If the user submits an empty file without a filename.
+    # If the user does not select a file, the browser submits an
+    # empty file without a filename.
     if file.filename == "":
         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, do_cut, process_image, many)
+        web.print_image(file, sign)
     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:
@@ -379,53 +324,29 @@ 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.
-    """
     worker.start_worker()
     return jsonify(worker.current_state())
 
 
 @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.
-    """
     worker.stop_worker()
     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
 
 
@@ -483,4 +404,4 @@ def camera_status():
 
 
 if __name__ == "__main__":
-    app.run(use_reloader=False, host="0.0.0.0", ssl_context="adhoc")
+    app.run(debug=True, use_reloader=False, host="0.0.0.0", ssl_context="adhoc")

src/print_queue.py

@@ -76,21 +76,7 @@ class PrintQueue:
         """Return current queue state"""
         with self._lock:
             self.app.logger.debug("Return current queue state")
-            return [
+            return [{"task_id": t.task_id, "status": t.status} for t in self._queue]
-                {
-                    "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,163 +1,119 @@
-"""
-This class manages connexion to a Printer
-"""
 
+# import brother_ql
+from time import sleep
 import os.path
-import os
+
-from abc import ABC, abstractmethod
+from PIL import Image, ImageEnhance
-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 modules needed for each supported printer Type
+# Importing the module to manage the connection to the printer.
 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 PrinterType(Enum):
+class Printer(object):
     """
-    What are the capacities of a Printer ?
+    # 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.
     """
 
-    EPSON = "epson"
+    # Is the printer ready to accept a new print ?
-    BROTHER = "brother"
+    ready = False
 
-
+    def __init__(self, app, device_id, vendor_id):
-# For Brother-QL Printers
+        super(Printer, self).__init__()
-@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.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.device_id = device_id
+        self.vendor_id = vendor_id
         self.usb_args = {}
-        self.usb_args["idVendor"] = self.vendor_id
+        self.usb_args["idVendor"] = self.device_id
-        self.usb_args["idProduct"] = self.device_id
+        self.usb_args["idProduct"] = self.vendor_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()
+
+    def init_printer(self):
+        """
+        Check if the printer online ? Is the communication with the printer successfull ?
+        """
+
+        # TODO: This could happen directly when creating a new Printer class
+        if os.getenv("FLASK_DEBUG"):
+            waiting_elapsed = 15
+        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.vendor_id, self.device_id, 0, profile=configuration_file["profile"]
+                    self.device_id, self.vendor_id, 0, profile="TM-P80"
                 )
-        except escpos.exceptions.DeviceNotFoundError as e:
+            except Exception as e:
                 self.app.logger.error(
-                "The USB device is not plugged in : %s",
+                    "The USB device is not plugged in, trying again %s : %s",
+                    waiting_elapsed,
                     str(e),
                 )
-            raise e
+                pass
-        except Exception as e:
-            self.app.logger.error("Printer could not be connected : %s ", str(e))
-            raise e
 
             try:
                 if p.is_online():
+                    self.ready = True
                     self.app.logger.debug("Printer online !")
             except Exception as e:
-            raise e
+                self.app.logger.error(
-
+                    "Error while getting the printer online %s : %s",
-        self.printer_info = PrinterInfo(
+                    waiting_elapsed,
-            identifier=configuration_file["profile"],
+                    str(e),
-            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"],
                 )
+                pass
+
+            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
 
         # Setting up the printing options.
-        # TODO : Expose this to the web interface
         p.set(
-            align=self.configuration_file["align_text"],
+            align="center",
             font="a",
             bold=False,
             underline=0,
@@ -174,37 +130,15 @@ class EscPosPrinter(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()
 
-    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):
+    def _print_sms(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."
@@ -216,25 +150,24 @@ class EscPosPrinter(Printer):
         clean_signature = str(signature)
 
         # Make checks on the size of the message being printed
-        if len(clean_msg) > int(self.configuration_file["text_max_length"]):
+        if len(clean_msg) > 4096:
             self.app.logger.warning(
                 "Could not print message of this length: " + str(len(clean_msg))
             )
-            raise RuntimeError(
+            raise Exception(
                 "Could not print message of this length :"
                 + str(len(clean_msg))
-                + ", needs to be below %s caracters long.",
+                + ", needs to be below 4096 caracters long."
-                str(self.configuration_file["text_max_length"]),
             )
-        if len(signature) > int(self.configuration_file["signature_max_length"]):
+
+        if len(signature) > 256:
             self.app.logger.warning(
                 "Could not print signature of this length: " + str(len(clean_signature))
             )
-            raise RuntimeError(
+            raise Exception(
                 "Could not print signature of this length :"
                 + str(len(clean_signature))
-                + ", needs to be below %s caracters long.",
+                + ", needs to be below 256 caracters long."
-                str(self.configuration_file["signature_max_length"]),
             )
 
         # Do the actual printing
@@ -245,7 +178,6 @@ class EscPosPrinter(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))
@@ -254,20 +186,19 @@ class EscPosPrinter(Printer):
             ) from e
 
         self.app.logger.info("Printed text")
-        self.ready = True
+        return True
 
     def _print_img(self, path, signature="", center=True, process=False):
         clean_signature = str(signature)
 
-        if len(signature) > int(self.configuration_file["signature_max_length"]):
+        if len(signature) > 256:
             self.app.logger.warning(
                 "Could not print signature of this length: " + str(len(clean_signature))
             )
-            raise RuntimeError(
+            raise ValueError(
                 "Could not print signature of this length :"
                 + str(len(clean_signature))
-                + ", needs to be below %s caracters long.",
+                + ", needs to be below 256 caracters long."
-                str(self.configuration_file["signature_max_length"]),
             )
 
         if not os.path.isfile(str(path)):
@@ -277,62 +208,61 @@ class EscPosPrinter(Printer):
                 + str(path)
                 + " wasn't found. Please try again."
             )
-
+        else:
             self.app.logger.debug("Printing file from " + str(path))
 
         if process:
             try:
                 self.app.logger.debug("Proccessing the image")
-                processed_path = _process_image(self, path)
+                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(processed_path, center=center)
+            self.printer.image(path, center=center)
             self.printer.textln(signature)
             self.printer.close()
-            self.app.logger.debug("Printed an image : " + str(processed_path))
+            self.app.logger.debug("Printed an image : " + str(path))
         except Exception as e:
             self.app.logger.error(str(e))
             raise RuntimeError("Could not print the picture") from e
-        # finally:
+        finally:
-        #     try:
+            try:
-        #         os.remove(path)
+                os.remove(path)
-        #         os.remove(processed_path)
+            except OSError as e:
-        #         self.app.logger.debug("Removed image : " + str(processed_path))
+                raise e
-        #         self.app.logger.debug("Removed image : " + str(path))
+
-        #     except OSError as e:
+            self.app.logger.debug("Removed image : " + str(path))
-        #         raise e
 
             try:
                 self.printer.close()
             except Exception as e:
-            self.app.logger.error("Could not close the printer connexion %s", str(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")
-        self.ready = True
+        return 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:
+        except Exception as e:
             self.printer.close()
             self.app.logger.error(str(e))
-            raise e
+            return False
 
         self.app.logger.info("Printed a QR")
-        self.ready = True
+        return True
 
     def _cut(self):
         try:
@@ -345,443 +275,163 @@ class EscPosPrinter(Printer):
             raise e
 
         self.app.logger.info("Did a cut")
-        self.ready = True
+        return 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"""
-
-        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:
-                self.app.logger.debug("Checking task type")
         match (task_type.value):
             case "text":
-
+                self._print_sms(data["txt"], signature=data["sign"])
-                        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
 
 
-class BrotherPrinter(Printer):
+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
+
+    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")
+
+        # Resize while maintaining aspect ratio
+        original_img.thumbnail((max_width, max_height), Image.Resampling.LANCZOS)
+        self.app.logger.debug("Resized the image")
+
+        # # 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")
+
+        # 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)
+        )
+
+        # Dynamically compute brightness factor if too dark
+        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}"
+            )
+            enhancer = ImageEnhance.Brightness(original_img)
+            original_img = enhancer.enhance(brightness_factor)
+
+        # # Reduce contrast
+        # contrast_enhancer = ImageEnhance.Contrast(original_img)
+        # original_img = contrast_enhancer.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.")
+
+    return jpeg_path
+
+
+def discover_printers():
     """
-    Manages connexion and capabilities of a BrotherQL Printer
+    We try to find all the connected printers ( 0 or n ) to this system.
+
+    For every type of supported printer, we try to autodiscover them.
+
+    http://www.linux-usb.org/usb.ids A list of USB vendor IDs
+
+    04b8  Seiko Epson Corp.
+    04f9  Brother Industries, Ltd
     """
 
-    def __init__(self, app, vendor_id, device_id, configuration_file):
 
-        super().__init__(app, vendor_id, device_id, printer_type=PrinterType.BROTHER)
+def find_and_parse_borther_ql_printer():
-        self.printer = None
-        self.usb_args = {}
-        self.usb_args["idVendor"] = self.vendor_id
-        self.usb_args["idProduct"] = self.device_id
-        self.model_manager = ModelsManager()
 
-        # Code taken from https://github.com/5shekel/printit/blob/master/printer_utils.py
+    ## We might be able to no use this because there is a `discover` command in https://github.com/pklaus/brother_ql#usage
 
-        self.app.logger.debug("Creating backend for Brother")
+    ## Code stolen from https://framagit.org/stickoeur/diagnostickoeur/-/blob/no-masters/printit.py?ref_type=heads
-        backend = backend_factory("pyusb")
 
+    """Find and parse Brother QL printer information."""
+
+    model_manager = ModelsManager()
+
+    # Debug print to show we're searching
+    # print("Searching for Brother QL printer...")
+
+    for backend_name in ["pyusb", "linux_kernel"]:
+        try:
+            # print(f"Trying backend: {backend_name}")
+            backend = backend_factory(backend_name)
             available_devices = backend["list_available_devices"]()
+            # print(f"Found {len(available_devices)} devices with {backend_name} backend")
 
             for printer in available_devices:
-            self.app.logger.debug(f"Found device: {printer}")
+                # print(f"Found device: {printer}")
                 identifier = printer["identifier"]
                 parts = identifier.split("/")
 
                 if len(parts) < 4:
-                self.app.logger.warning(
+                    # print(f"Skipping device with invalid identifier format: {identifier}")
-                    f"Skipping device with invalid identifier format: {identifier}"
-                )
                     continue
 
                 protocol = parts[0]
-            # device_info = parts[2]
+                device_info = parts[2]
                 serial_number = parts[3]
 
                 try:
-            for m in self.model_manager.iter_elements():
+                    vendor_id, product_id = device_info.split(":")
-                if m.product_id == self.device_id:
+                except ValueError:
+                    # print(f"Invalid device info format: {device_info}")
+                    continue
+
+                # Default model
+                model = "QL-570"
+
+                # Try to match product ID to determine actual model
+                try:
+                    product_id_int = int(product_id, 16)
+                    for m in model_manager.iter_elements():
+                        if m.product_id == product_id_int:
                             model = m.identifier
-
                             break
-
+                    # print(f"Matched printer model: {model}")
-            self.app.logger.debug(f"Matched printer model: {model}")
+                except ValueError:
-        except ValueError as ve:
+                    # print(f"Invalid product ID format: {product_id}")
-            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,
-        )
-
-        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 = min(
-                max(
-                    1 + (brightness_threshold - avg_brightness) / brightness_threshold,
-                    1.1,
-                ),
-                2.5,
-            )
-            self.app.logger.debug(
-                "Image is dark; increasing brightness by %.2f",
-                brightness_factor,
-            )
-            grayscale = ImageEnhance.Brightness(grayscale).enhance(brightness_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)
-
-        jpeg_path = os.path.splitext(path)[0] + "_processed.jpg"
-        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 = ""
+                printer_info = {
-        for word in words:
+                    "identifier": identifier,
-            candidate = f"{line} {word}".strip()
+                    "backend": backend_name,
-            if draw.textbbox((0, 0), candidate, font=font)[2] <= max_text_width:
+                    "model": model,
-                line = candidate
+                    "protocol": protocol,
+                    "vendor_id": vendor_id,
+                    "product_id": product_id,
+                    "serial_number": serial_number,
+                }
+                # print(f"Found printer: {printer_info}")
+                return printer_info
+
+        except Exception as e:
+            # print(f"Error with backend {backend_name}: {str(e)}")
             continue
 
-            if line:
+    print("No Brother QL printer found")
-                lines.append(line)
+    return None
 
-            # 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:
+def fint_and_parse_epson_printer():
-            lines.append(line)
+    pass
-
-    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

@@ -1,215 +0,0 @@
-"""
-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

@@ -1,21 +1,12 @@
-"""
-This class executes when we are on a raspberry Pi.
-
-It handles the press of a button via GPIO,
-activates a flash and prints out the picture
-that was taken via a USB Webcam.
-"""
-
 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,24 +14,32 @@ class Raspberry:
     - Activating a flash ( or light )
     - Flash an indicator light
 
-    # pylint: disable=too-many-instance-attributes
-    # dede
     """
 
-    def __init__(self, print_queue, app, configuration_file):
+    def __init__(
-        self.print_queue = print_queue
+        self,
+        printer,
+        app,
+        socketio,
+        button_gpio_port_number,
+        indicator_gpio_port_number,
+        flash_gpio_port_number,
+        is_flash_present,
+    ):
+        self.printer = printer
+        self.socketio = socketio
         self.app = app
-        self.configuration_file = configuration_file
+
+        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.image_path = self.app.config["UPLOAD_FOLDER"] + "/image.jpg"
 
-    def is_raspberry_pi(self):
+    def is_raspberry_pi(self, raise_on_errors=False):
-        """
-        Checking if we are on a Raspberry Pi by checking
-        information on the /proc/cpuinfo file
-        """
         # Check if we are running on a raspberry pi
         try:
-            with io.open("/proc/cpuinfo", "r", encoding="utf-8") as cpuinfo:
+            with io.open("/proc/cpuinfo", "r") as cpuinfo:
                 found = False
                 for line in cpuinfo:
                     if line.startswith("Hardware"):
@@ -60,11 +59,8 @@ class Raspberry:
                             return False
 
                 if not found:
-                    self.app.logger.warning(
+                    self.app.logger.error(
-                        "Couldn't get sufficient hardware information from /proc/cpuinfo"
+                        "Couldn't get sufficient hardware information from /proc/cpuinfo, Unable to determine if we are on a Raspberry Pi."
-                    )
-                    self.app.logger.warning(
-                        "Unable to determine if we are on a Raspberry Pi."
                     )
                     return False
         except IOError:
@@ -74,41 +70,28 @@ 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.configuration_file["rpi"]["indicator_gpio_port_number"])
+        self.led = LED(self.led_gpio)
         self.app.logger.debug("Activated indicator LED")
         self.indicator_countdown(iters=3)
-        self.button = Button(
+        self.button = Button(self.button_gpio, pull_up=True, bounce_time=0.1)
-            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 = DigitalOutputDevice(self.flash_gpio)
-            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)
@@ -116,10 +99,7 @@ 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)
@@ -128,9 +108,6 @@ class Raspberry:
             sleep(timing)
 
     def flash_toggle(self):
-        """
-        Flashes the flash
-        """
         self.app.logger.debug("Flash turned on")
         self.flash.on()
         sleep(0.3)
@@ -138,9 +115,6 @@ 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(
@@ -166,7 +140,7 @@ class Raspberry:
                 f"Unable to take a picture. Error: {e.stderr.decode()}"
             )
             return False
-        except RuntimeError as e:
+        except Exception as e:
             # Catch any unexpected errors
             self.app.logger.error(f"Unexpected error while taking picture: {str(e)}")
             return False
@@ -186,9 +160,6 @@ 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")
@@ -215,9 +186,7 @@ class Raspberry:
                 y = image.height - logo.height - margin
             else:
                 raise ValueError(
-                    "Invalid position."
+                    "Invalid position. Choose from 'bottom_right', 'top_left', 'top_right', or 'bottom_left'."
-                    + "Choose from 'bottom_right', 'top_left', "
-                    + " 'top_right', or 'bottom_left'."
                 )
 
             # Composite the logo onto the image
@@ -228,16 +197,13 @@ class Raspberry:
                 output_path = image_path  # Overwrite the original image if no output path is given
             image.save(output_path)
 
-        except RuntimeError as e:
+        except Exception as e:
             self.app.logger.error(f"Error overlaying logo: {e}")
             return False
 
         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
@@ -258,17 +224,13 @@ class Raspberry:
 
             image.save(output_path)
 
-        except RuntimeError as e:
+        except Exception as e:
             self.app.logger.error(f"Error cropping image to square: {e}")
             return False
 
         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")
@@ -279,7 +241,7 @@ class Raspberry:
         try:
             self.flash.on()
             self.take_picture()
-        except RuntimeError as e:
+        except Exception as e:
             self.app.logger.error(
                 "Could not take a picture after the button press : " + str(e)
             )
@@ -288,13 +250,15 @@ 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.printer.print_img("src/static/images/extase-club.png", process=True)
-        self.print_queue.enqueue(
+        self.printer.print_img(self.image_path, process=True)
-            TextTask(content="Imprimé par LittlePrynter", signature="")
+        self.printer.print_sms("")
-        )
+        self.printer.print_sms("With Love From Société.Vide", signature="", bold=True)
-        time = strftime("%Y-%m-%d %H:%M", gmtime())
+        self.printer.print_sms("Printed by LittlePrynter", signature="")
-        self.print_queue.enqueue(TextTask(content=time, signature=""))
+        self.printer.print_sms("n07070.xyz", signature="")
-        self.print_queue.enqueue(CutTask())
+        self.printer.print_sms(strftime("%Y-%m-%d %H:%M", gmtime()), signature="")
+        self.printer.qr("https://n07070.xyz/articles/littleprynter")
+        self.printer.cut()
         self.led.off()
-        self.app.logger.debug("Added a photomaton picture to the print queue")
+        self.app.logger.debug("Done printing picture")
         return True

src/task.py

@@ -14,11 +14,11 @@ 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
 
+# from dataclasses import dataclass
 from enum import Enum
 import uuid
 
@@ -28,11 +28,9 @@ class TaskType(Enum):
     """
     The different tasks supported by the printers
     """
-
     TEXT = "text"
     IMAGE = "image"
     CUT = "cut"
-    QR = "qr"
 
 
 class PrintTask(ABC):
@@ -40,15 +38,18 @@ class PrintTask(ABC):
     A print task holds information about what we are looking to print.
     """
 
-    def __init__(self, task_type: TaskType):
+    def __init__(self, task_type):
         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,18 +69,6 @@ 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="/api">API interface</a> | <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="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

@@ -0,0 +1,5 @@
+<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,23 +6,9 @@
       <h3 class="card-header">Print a short message</h3>
       <div class="card-body">
         <form class="form-group" action="/web/print/sms" method="post">
-          <textarea class="form-control" type="text" name="txt" placeholder="4096 caractères maximum " maxlength="4096"></textarea>
+          <input class="form-control" type="text" name="txt" placeholder="200 chars or less " maxlength="200" required><br>
-          <br>
+          <input class="form-control" type="text" name="signature" placeholder="Signature or pseudo" maxlength="200"><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>
@@ -34,26 +20,8 @@
       <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 ou pseudo" maxlength="200"><br>
+          <input class="form-control" type="text" name="signature" placeholder="Signature or 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

@@ -0,0 +1,30 @@
+<!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,22 +1,19 @@
-"""
+from flask import flash
-Manage all of the inputs from a web source
-"""
-
-import os
 from werkzeug.utils import secure_filename
+import time
+import os
 from task import TextTask, ImageTask, CutTask
 
 
-class Web:
+class Web(object):
-    """Web is the class that gets all of the information from web calls
+    """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, do_cut: bool, many: int = 1) -> bool:
+    def print_sms(self, texte, sign: str) -> bool:
         """
         Get text and a signature, prints the text and cuts after that.
         """
@@ -28,22 +25,15 @@ class Web:
             # !! 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.
-            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(
+    def print_image(self, image, sign: str) -> bool:
-        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.
         """
@@ -51,12 +41,11 @@ class Web:
             file_uploaded = self.upload_file(image)
         except Exception as e:
             self.app.logger.error(e)
-            raise RuntimeError("Could not upload file : " + str(e)) from e
+            raise RuntimeError("Could not upload file") from e
 
         if file_uploaded:
             self.app.logger.debug("File has been uploaded, printing...")
             try:
-                for i in range(many):
                 img = self.print_queue.enqueue(
                     ImageTask(
                         os.path.join(
@@ -64,32 +53,28 @@ class Web:
                             secure_filename(image.filename),
                         ),
                         signature=sign,
-                            process=process_image,
+                        process=True,
                     )
                 )
-                    self.app.logger.info("Added a IMG task at position %s", img)
 
-                    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:
+    def login(self, username: str, password: str) -> bool:
-    #     """Not implemented"""
+        """Not implemented"""
-    #     return
+        return
 
-    # def logout(self, username: str, password: str) -> bool:
+    def logout(self, username: str, password: str) -> bool:
-    #     """Not implemented"""
+        """Not implemented"""
-    #     return
+        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()
@@ -97,11 +82,8 @@ class Web:
         )
 
     def upload_file(self, image) -> bool:
-        """
-        Save the file after executing checks on it
-        """
         self.app.logger.debug("Validating file")
-        if not image is None or not image == "":
+        if image:
             if self.allowed_file(image.filename):
                 filename = secure_filename(image.filename)
                 self.app.logger.debug("File valid")
@@ -109,23 +91,24 @@ class Web:
                     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)
-                    raise RuntimeError(
+                    return False
-                        "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")
+                self.app.logger.error(
-        raise RuntimeError("This file type is forbidden.")
+                    "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
 
     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,117 +1,35 @@
-"""
+# This is the main printing thread
-This is the main printing thread. A worker thread consums Tasks from
+# As explained in the task file, this is where we command
- a PrintQueue, while trying to find available printers.
+# printing to happen.
-"""
 
 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 = None
+        self.printer = printer
-        self._lock = threading.Lock()
+        self.socketio = socketio  # Optional
         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.debug("Worker %s started working.", threading.get_ident())
+        self.app.logger.info("Worker started working.")
-        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
 
-            # 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 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:
                 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
@@ -119,51 +37,55 @@ class PrintWorker(threading.Thread):
             if task:
                 try:
                     self.app.logger.info("Got a new task")
-                        self.app.logger.debug(
+                    self.app.logger.debug("Got task %s", task.task_id)
-                            "Got task %s %s", task.task_type, task.task_id
+                    self.state = "printing"
-                        )
                     task.status = "processing"
+                    self._emit_status(task.task_id, "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())
+                        raise e
-                            self.printer.free_printer()
 
                     task.status = "completed"
                     self.print_queue.mark_completed(task.task_id, "completed")
-                        self.app.logger.debug(
+                    self._emit_status(task.task_id, "completed")
-                            "Finished printing task %s ", task.task_id
-                        )
-                        self.state = "idle"
 
                 except RuntimeError as e:
                     task.status = "failed"
-                        self.state = "idle"
                     self.print_queue.mark_completed(task.task_id, "failed")
-                        self.app.logger.error(
+                    self._emit_status(task.task_id, "failed", error=str(e))
-                            "Could not print task %s because %s ", task.task_id, 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)
+
     def stop_worker(self):
         """
         Give the worker a break
         """
         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):
@@ -182,5 +104,4 @@ class PrintWorker(threading.Thread):
             "is_running": self.running,
             "queue_size": len(self.print_queue),
             "state": self.state,
-            "printers": len(self.printers_obj),
         }