Merge pull request 'Restructure the code and implement a printing queue' (#29) from restructure-printing-queue into master

Reviewed-on: #29

.gitignore

@@ -2,6 +2,7 @@
 __pycache__/
 *.py[cod]
 *$py.class
+CACHEDIR.TAG
 
 # C extensions
 *.so

README.md

@@ -19,44 +19,56 @@ To make this project work, you will need :
 - Some electric wires.
 - Some knowledge of the command line,
 - Some knowledge of Python.
+    - You will need to install [Poetry](https://python-poetry.org/) to manage the depedencies of the projet.
 - 3h of your time, 5h if things need debugging.
-- `git`, `virtualenv`,`pip` and `python` >= 3.8.6.
+- You will need to following packages: `fswebcam`, `libjpeg-dev` ,`zlib1g-dev`,`libffi-dev`,`git`, `virtualenv`,`pip` and `python` >= 3.8.6.
 - A webcam for the webcam page to work. Will work on a smartphone. Not required.
 
 ## Context
 
+### Testing your printer
 For the EPSON TM-T20III, you can get the CUPS driver from [here](https://download.epson-biz.com/modules/pos/index.php?page=soft&scat=32). It's not specific to the printer I've been using, so you can try with other printers.
 
-With that, you can try out your printer and print normal text, images or pdf documents for example. LittlePrynter itself does not require any other software than the ones installed with it, i.e the ones listed in the `requirements.txt` file.
+With that, you can try out your printer and print normal text, images or pdf documents for example. For the Adafruit printer, start by following the guide [here](https://learn.adafruit.com/networked-thermal-printer-using-cups-and-raspberry-pi) to install the CUPS software needed to print images. If you want, you can install it via the command line, [following this guide](https://help.ubuntu.com/lts/serverguide/cups.html).
-
-For the Adafruit printer, start by following the guide [here](https://learn.adafruit.com/networked-thermal-printer-using-cups-and-raspberry-pi) to install the CUPS software needed to print images. If you want, you can install it via the command line, [following this guide](https://help.ubuntu.com/lts/serverguide/cups.html).
 
 You can also get some information from [here](https://learn.adafruit.com/mini-thermal-receipt-printer) and [here](https://learn.adafruit.com/instant-camera-using-raspberry-pi-and-thermal-printer) if you're stuck.
 
+### How LittlePrynter works
+
+LittlePrynter itself does not require any other software than the ones installed with it, i.e the ones listed in the `pyproject.toml` file.
+
 The version for the EPSON TM-T20III uses a library called `python-escpos`, which doesn't need a CUPS driver or anything else. It's included in the Python dependencies.
 
-The project only supports the EPSON printer, but you can try to adapt it for other printers using the `adafruit-thermal` branch, but I won't offer support for it.
+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 :
+
+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.
+
 ```
 $ git clone https://git.n07070.xyz/n07070/LittlePrynter
-$ virtualenv LittlePrynter
 $ cd LittlePrynter
-$ source bin/activate
+$ eval "$(poetry env activate)"
-$ pip install -r requirements.txt
+$ poetry install
 ```
 
-> tip : when you're done, you can get out of the virtualenv either by closing your terminal, or by running `deactivate`.
+> tip : when you're done, you can get out of the poetry environnement either by closing your terminal, or by running `deactivate`.
+
+### Configure LittlePrynter
 
 You should see a folder named `configuration`. Enter it, and duplicate the file named `config.toml.sample`, and rename the copy to `config.toml`. Now, edit this file by following the comments in the file itself.
 
+You should also setup the proper `udev` permissions to access the printers via USB, following the configuration found [here](https://python-escpos.readthedocs.io/en/latest/user/installation.html#setup-udev-for-usb-printers).
+
 You can now start the web server with
 
 ```
 $ export FLASK_APP=src/main.py
-$ flask run
+$ 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.
+
 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à !
@@ -67,6 +79,34 @@ 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 about the Flask framework. You can start by looking at the code in the `src/` folder, in the `main.py` file. There, you will see that a few classes are initialized. In general, they are two parts to the program :
+
+The Web pages and the API, which are the user-facing parts. This is with what the users will interact, and define how the program is going to be used. The web pages are renderer from the `include/` folder where Jinj2 templates are defined.
+
+The Worker and Printer Queue are the internal parts. When a new thing needs to be printed, usually sent from the Web or API interfaces, a new Task in the type of the document is created, and added to a print queue. Then, a Worker thread looks up the state of the queue every so often and picks jobs to execute on the printers connected to the system.
+
+The 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.
+
+To do so, you can run the following command, which will modify your files to be in a certain coding style ;
+
+```
+black src/
+```
+
+Beware that this command *will* re-write files, so doing `git add <file>` and then `black src/` and then `git diff` to see what the linter has done is a good idea.
+
+Then, you can run another command, called Pylint ( [documentation](https://www.pylint.org/) ) which will rate your code. Try to get 10/10 : an excellent code works better and make you a better programmer !
+
+```
+pylint src/
+```
+
 ## Screenshots
 
 ![](src/static/images/homepage.png)
@@ -89,6 +129,7 @@ If you liked this project, feel free to support my work !
 - [Github repo with CUPS drivers for the Adafruit Thermal Printer ( zj-58 )](https://github.com/klirichek/zj-58)
 - [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.
 
 
 ## Licence

configuration/config.toml

@@ -1,11 +1,21 @@
 # Configuration file the LittlePrynter
 
+[defaults]
+signature = "Anonymous"
+
 # Printer settings
 [printer]
 vendor_id = 0x04b8
 device_id = 0x0e28
 upload_folder = "src/static/uploads"
 
+# Raspberry Pi Configuration
+[rpi]
+button_gpio_port_number = 2
+indicator_gpio_port_number = 22
+flash_gpio_port_number = 16
+flash = true
+
 # Users = Password
 [users]
 admin = "admin"

configuration/config.toml.sample

@@ -1,10 +1,19 @@
 # Configuration file the LittlePrynter
 
+[defaults]
+signature = "Anonymous"
+
 # Printer settings
 [printer]
 vendor_id = "0x04b8"
 device_id = "0x0e28"
 
+# Raspberry Pi Configuration
+[rpi]
+button_gpio_port_number = 17
+indicator_gpio_port_number = 18
+flash = true
+
 # Users = Password
 [users]
 admin = "admin"

littleprynter.service

@@ -0,0 +1,12 @@
+[Unit]
+Description=LittlePrynter
+After=network.target
+
+[Service]
+Type=simple
+WorkingDirectory=/home/pi/littleprynter/
+Environment=FLASK_APP=src/main.py
+ExecStart=/home/pi/littleprynter/bin/flask run --host 0.0.0.0 --no-reload
+
+[Install]
+WantedBy=multi-user.target

pip-selfcheck.json

@@ -1 +0,0 @@
-{"last_check":"2018-10-10T18:33:22Z","pypi_version":"18.1"}

pyproject.toml

@@ -0,0 +1,56 @@
+[project]
+name = "littleprynter"
+version = "0.1.0"
+description = "A web interface and API to print on thermal printers"
+authors = [
+    {name = "n07070",email = "contact@n07070.xyz"}
+]
+license = "AGPLv3"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "flask (>=3.1.3,<4.0.0)",
+    "numpy (>=2.3.4)",
+    "toml (>=0.10.2,<0.11.0)",
+    "flask-socketio (>=5.6.1,<6.0.0)",
+    "flask-limiter (>=4.1.1,<5.0.0)",
+    "gpiozero (>=2.0.1)",
+    "cryptography (>=48.0.0,<49.0.0)",
+    "pyusb (>=1.3.1,<2.0.0)",
+    "pyserial (>=3.5,<4.0)",
+    "qrcode (<9.0)",
+    "python-barcode (>=0.16.1)",
+    "setuptools (==81)",
+    "cffi (>=2.0.0,<3.0.0)",
+    "configobj (>=5.0.9,<6.0.0)",
+    "future (>=1.0.0,<2.0.0)",
+    "h11 (>=0.16.0,<0.17.0)",
+    "idna (>=3.15,<4.0)",
+    "itsdangerous (>=2.2.0,<3.0.0)",
+    "jinja2 (>=3.1.6,<4.0.0)",
+    "jsonpointer (>=3.1.1,<4.0.0)",
+    "jsonschema (>=4.26.0,<5.0.0)",
+    "limits (>=5.8.0,<6.0.0)",
+    "markupsafe (>=3.0.3,<4.0.0)",
+    "pillow (>=12.2.0,<13.0.0)",
+    "pycryptodomex (>=3.23.0,<4.0.0)",
+    "python-dateutil (>=2.9.0.post0,<3.0.0)",
+    "python-engineio (>=4.13.1,<5.0.0)",
+    "python-socketio (>=5.16.1,<6.0.0)",
+    "pyyaml (>=6.0.3,<7.0.0)",
+    "requests (>=2.34.2,<3.0.0)",
+    "python-escpos (>=3.1,<4.0)",
+    "pep8 (>=1.7.1,<2.0.0)",
+    "pylint (>=4.0.5,<5.0.0)",
+    "brother-ql-inventree (>=1.3,<2.0)",
+]
+
+[tool.poetry]
+package-mode = false
+
+
+[tool.poetry.dependencies]
+python-escpos = {allow-prereleases = true}
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

requirements.txt

@@ -1,36 +0,0 @@
-Adafruit_Thermal==1.1.0
-appdirs==1.4.4
-argcomplete==2.0.6
-cffi==1.17.1
-click==8.1.8
-commonmark==0.9.1
-cryptography==45.0.4
-Deprecated==1.2.18
-escpos==2.0.0
-Flask==2.1.3
-Flask-Limiter==2.4.5.1
-future==0.18.3
-itsdangerous==2.1.2
-Jinja2==3.1.6
-limits==2.6.3
-MarkupSafe==2.1.5
-numpy==2.3.0
-packaging==21.3
-pillow==11.2.1
-pycparser==2.22
-Pygments==2.12.0
-pyparsing==3.0.9
-pyserial==3.5
-python-barcode==0.13.1
-pyusb==1.2.1
-PyYAML==6.0.2
-qrcode==7.3.1
-rich==12.4.4
-setuptools==80.9.0
-six==1.16.0
-toml==0.10.2
-typing_extensions==4.2.0
-Unidecode==1.3.8
-viivakoodi==0.8.0
-Werkzeug==2.1.2
-wrapt==1.14.1

run.sh

@@ -1,7 +0,0 @@
-virtualenv .
-
-pip install -r requirements.txt
-
-export FLASK_APP=src/main.py
-export FLASK_ENV=development
-flask run --host 192.168.0.42 --debugger --eager-loading

src/main.py

@@ -1,40 +1,78 @@
-# Welcome to the LittlePrynter's source code.
+"""
-# This program expose a web interface, with user authentification, that makes it possible to print messages from the web.
+Welcome to the LittlePrynter's source code.
-# It also exposes a API, making it possible to print and interface with much of the printer's abilities.
+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.
 
-# We first define the connection to the printer itself,
+We first define the connection to the printer itself,
-# Then we build the API around Flask,
+Then we build the API around Flask,
-# Then we build the web interface, using the simple Jinja2 templating.
+Then we build the web interface, using the simple Jinja2 templating.
+
+We support two modes :
+The first is a simple mode, where a computer, connected to a thermal printer,
+runs this program and exposes a web interface that makes use of the client's camera
+The seconde is booth mode, where a Raspberry Pi is connected to a thermal printer,
+a button and a flash.
+The web interface exists but may not be used, as the press of the button with take
+ a picture and activate the flash while simply informing the web page.
+"""
 
 # Following are the librairies we import,
-from flask import Flask, request, render_template, flash, abort, redirect, url_for, make_response, jsonify       # Used for the web framework
+import sys
+import os  # For VARS from the shell.
+import pprint  # To pretty print JSON
+import toml  # Used for the config file parsing
+from flask import (
+    Flask,
+    request,
+    render_template,
+    flash,
+    redirect,
+    url_for,
+    jsonify,
+)  # Used for the web framework
+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
-import toml                             # Used for the config file parsing
+from print_queue import PrintQueue
-import pprint                           # To pretty print JSON
+from worker import PrintWorker
-import time                             # To sleep
-import os                               # For VARS from the shell.
-# Variables
 
+# We create the main Flask object
 app = Flask(__name__)
+socketio = SocketIO(app, cors_allowed_origins="*")
+
+# Global variables
+ALLOWED_EXTENSIONS = {"png", "jpg", "jpeg", "gif", "webp"}
 
 # Load the configuration file
 try:
     app.logger.debug("Loading config file...")
-    configuration_file = toml.load("configuration/config.toml")
+    with open("configuration/config.toml", "r", encoding="utf-8") as f:
-except TypeError :
+        configuration_file = toml.load(f)
-    app.logger.error("Unable to load the config file: invalid type or is a list containing invalid types")
+except TypeError:
-    exit(-1)
+    app.logger.error(
-except toml.TomlDecodeError:
+        "Unable to load the config file: invalid type or is a list containing invalid types"
-    app.logger.error("An error occured while decoding the file")
+    )
-    exit(-1)
+    sys.exit(-1)
-except Exception as e:
+except toml.TomlDecodeError as e:
-    app.logger.error("Error while loading file : " + str(e))
+    app.logger.error(
-    exit(-1)
+        "An error occured while decoding the file %s ,  error at %s:%s",
+        str(e.doc),
+        str(e.colno),
+        str(e.lineno),
+    )
+    sys.exit(-1)
+except OSError as e:
+    app.logger.error("Error while loading file %s ", str(e))
+    sys.exit(-1)
 
 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"]
@@ -42,56 +80,150 @@ UPLOAD_FOLDER = str(configuration_file["printer"]["upload_folder"])
 
 try:
     os.mkdir(UPLOAD_FOLDER)
-    app.logger.debug(f"Directory '{UPLOAD_FOLDER}' created successfully.")
+    app.logger.debug("Directory %s created successfully.", UPLOAD_FOLDER)
 except FileExistsError:
-    app.logger.error(f"Directory '{UPLOAD_FOLDER}' already exists.")
+    app.logger.debug("Directory %s already exists.", UPLOAD_FOLDER)
 except PermissionError:
-    app.logger.error(f"Permission denied: Unable to create '{UPLOAD_FOLDER}'.")
+    app.logger.error("Permission denied: Unable to create %s", UPLOAD_FOLDER)
-except Exception as e:
+    sys.exit(77)
-    app.logger.error(f"An error occurred: {e}")
-
-ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif'}
 
 # Output the config file
-if os.getenv('LIPY_DEBUG') == 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["UPLOAD_FOLDER"] = UPLOAD_FOLDER
-app.config['ALLOWED_EXTENSIONS'] = ALLOWED_EXTENSIONS
+app.config["ALLOWED_EXTENSIONS"] = ALLOWED_EXTENSIONS
-app.config['MAX_CONTENT_LENGTH'] = 10 * 1000 * 1000 # Maximum 3Mb for a file upload
+app.config["MAX_CONTENT_LENGTH"] = 10 * 1000 * 1000  # Maximum 3Mb for a file upload
-app.config['TEMPLATES_AUTO_RELOAD'] = True
+app.config["TEMPLATES_AUTO_RELOAD"] = True
 
 # Printer connection
 # Uses the class defined in the printer.py file
-printer = Printer(app,0x04b8, 0x0e28)
+printer = Printer(app, 0x04B8, 0x0E28)
 printer.init_printer()
 
-# Web routes
+# Find out if we are running on a Raspberry Pi
-web = Web(app, printer)
+rpi = Raspberry(
-
+    printer,
-if __name__ == "__main__":
-    app.run(ssl_context='adhoc')
-
-
-limiter = Limiter(
     app,
-    key_func=get_remote_address,
+    socketio,
-    default_limits=["1500 per day", "500 per hour"]
+    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"],
 )
 
-@app.route('/')
+RASPBERRY_PI_CONNECTED = rpi.is_raspberry_pi()
+
+# Queue creation
+print_queue = PrintQueue(app)
+
+#  Web & API management
+web = Web(app, print_queue)
+
+# Start worker thread
+worker = PrintWorker(app, print_queue, printer, socketio)
+worker.start()
+
+# The rate limit
+limiter = Limiter(
+    get_remote_address, app=app, default_limits=["1500 per day", "500 per hour"]
+)
+
+# General routes
+@app.route("/")
 @limiter.limit("1/second", override_defaults=False)
 def index():
+    """Return the web interface index"""
     app.logger.debug("Loading index")
-    return render_template('index.html')
+    return render_template("index.html")
 
-@app.route('/webcam')
+
+@app.route("/webcam")
 @limiter.limit("1/second", override_defaults=False)
 def webcam():
+    """Returns the webcam web interface"""
     app.logger.debug("Loading webcam interface")
-    return render_template('webcam.html')
+    return render_template("webcam.html")
+
+
+# Form treatement
+@app.route("/web/print/sms", methods=["POST"])
+@limiter.limit("6/minute", override_defaults=False)
+def web_print_sms():
+    """Prints a short message on a printer"""
+    app.logger.debug("Printing an sms via web method")
+
+    try:
+        txt = request.form["txt"]
+    except werkzeug.exceptions.BadRequestKeyError as e:
+        app.logger.error("Whoops, we are missing the txt input field. : %s ", str(e))
+        flash("Whoops, no forms submitted or missing signature : " + str(e), "error")
+        return redirect(url_for("index"))
+
+    try:
+        # comment: We try to get a signature
+        sign = request.form["signature"]
+    except werkzeug.exceptions.BadRequestKeyError as e:
+        app.logger.warning(
+            "No signature found for this print, using default signature : %s ", str(e)
+        )
+        sign = configuration_file["defaults"]["signature"]
+
+    try:
+        web.print_sms(txt, sign)
+    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")
+    return redirect(url_for("index"))
+
+
+@app.route("/web/print/img", methods=["POST"])
+@limiter.limit("1/second", override_defaults=False)
+def web_print_img():
+    """Prints an image on a printer"""
+    app.logger.debug("Printing an image with web method")
+
+    try:
+        # comment: We try to get a signature
+        sign = request.form["signature"]
+    except werkzeug.exceptions.BadRequestKeyError as e:
+        app.logger.warning(
+            "No signature found for this print, using default signature : %s", str(e)
+        )
+        sign = configuration_file["defaults"]["signature"]
+
+    # check if the post request has the file part
+    if "img" not in request.files:
+        app.logger.error("Whoops, no images submitted  : %s ", str(e))
+        app.logger.error("Error getting the files : %s", str(e))
+        flash("Whoops, no images submitted  : " + str(e), "error")
+        return redirect(url_for("index"))
+
+    file = request.files["img"]
+    # 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 !")
+        flash("Submitted file has no filename !", "error")
+        return redirect(url_for("index"))
+
+    try:
+        app.logger.debug("Sending the image to the printer.")
+        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")
+    return redirect(url_for("index"))
+
 
 # API routes
 # The api has the following methods
@@ -99,99 +231,176 @@ def webcam():
 # api/auth/{login,logout}
 # api/status/{paper,ping,stats}
 
+
 # If you just call the api route, you get a help back.
-@app.route('/api')
+@app.route("/api")
-@app.route('/api/print')
+@app.route("/api/print")
 @limiter.limit("1/second", override_defaults=False)
 def api_index():
+    """Returns a how-to for the API"""
     app.logger.debug("Loading API")
     return render_template("api.html")
 
 
-@app.route('/api/print/sms', methods=['POST'])
+@app.route("/api/print/sms", methods=["POST"])
 @limiter.limit("6/minute", override_defaults=False)
 def api_print_sms():
-    app.logger.debug("Printing an sms")
+    """Prints a short message on a printer"""
+    app.logger.debug("Printing an sms via API")
     try:
         txt = request.form["txt"]
-        sign = request.form["signature"]
+    except werkzeug.exceptions.BadRequestKeyError as e:
-    except Exception as e:
+        app.logger.error("Whoops, we are missing the txt input field. : %s ", str(e))
-        app.logger.error(str(e) + " - Whoops, no forms submitted or missing signature.")
+        return str(e), 400
-        return jsonify({'message': 'Error getting the information from the form :' + e}), 500
-
     try:
-        web.print_sms(txt,sign)
+        # comment: We try to get a signature
-    except Exception as e:
+        sign = request.form["signature"]
-        return jsonify({'message': 'Error printing the SMS:' + e}), 500
+    except werkzeug.exceptions.BadRequestKeyError as e:
+        app.logger.warning(
+            "No signature found for this print, using default signature. : %s", str(e)
+        )
+        sign = configuration_file["defaults"]["signature"]
+    try:
+        # comment: We try to print the SMS
+        web.print_sms(txt, sign)
+    except RuntimeError as e:
+        return str(e), 500
+    # end try
+    return "OK", 200
 
 
-    return jsonify({'message': 'Message printed'}), 200
+@app.route("/api/print/img", methods=["POST"])
-
-@app.route('/api/print/img', methods=['POST'])
 @limiter.limit("6/minute", override_defaults=False)
 def api_print_image():
-    app.logger.debug("Printing an image")
+    """Prints an image on a printer"""
+    app.logger.debug("Printing an image via API")
 
     try:
+        # comment: We try to get a signature
         sign = request.form["signature"]
-    except Exception as e:
+    except werkzeug.exceptions.BadRequestKeyError as e:
-        app.logger.error(str(e) + " - Whoops, no forms submitted or missing signature.")
+        app.logger.warning(
-        return jsonify({'message': 'Error getting the information from the form :' + e}), 500
+            "No signature found for this print, using default signature. %s", str(e)
+        )
+        sign = configuration_file["defaults"]["signature"]
 
-
-    if request.method == 'POST':
     # check if the post request has the file part
-        try:
+    if "img" not in request.files:
-            if 'img' not in request.files:
+        app.logger.error("Whoops, no images submitted.")
-                app.logger.error("No file found. Did you use the good form ?")
+        return "No image submitted", 400
-                return jsonify({'message': 'No file found. Did you use the good form ?'}), 500
-            else:
-                file = request.files['img']
-        except Exception as e:
-            app.logger.error('Error getting the files :' + e)
-            return jsonify({'message': 'Error getting the files :' + e}), 500
 
-        # If the user does not select a file, the browser submits an
+    file = request.files["img"]
-        # empty file without a filename.
+    # If the user submits an empty file without a filename.
-        if file.filename == '':
+    if file.filename == "":
         app.logger.error("Submitted file has no filename !")
-            return jsonify({'message': "Submitted file has no filename !" + e}), 500
+        return "Submitted file has no filename !", 400
 
     try:
         app.logger.debug("Sending the image to the printer.")
         web.print_image(file, sign)
-        except Exception as e:
+    except RuntimeError as e:
-            app.logger.error("The image could not be printed : " + e )
+        return str(e), 500
-            return jsonify({'message': "The image could not be printed :" + e}), 500
 
+    return "OK", 200
+
+
+@app.route("/api/camera/picture", methods=["GET"])
+def camera_picture():
+    """Returns a picture taken by the camera on a raspberry pi"""
+    if RASPBERRY_PI_CONNECTED:
+        try:
+            return rpi.camera_picture()
+        except RuntimeError as e:
+            return jsonify({"message": "Error getting the stream : " + e}), 500
     else:
-        return jsonify({'message': "Method Not Allowed, please POST"}), 403
+        return jsonify({"message": "No camera present"}), 500
-        app.logger.debug('Bad access type to this API, please POST')
-
-    return jsonify({'message': 'Message printed'}), 200
 
 
-@app.route('/login')
+@app.route("/api/queue", methods=["GET"])
+def api_queue_status():
+    """API endpoint for entire queue"""
+    return jsonify(web.get_queue_state())
+
+
+@app.route("/api/worker", methods=["GET"])
+def api_worker_state():
+    """API endpoint to get the worker state"""
+    return jsonify(worker.current_state())
+
+
+@app.route("/api/worker/start")
+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")
+def api_worker_stop():
+    """
+    Stops the print queue. This stops the processing of the print queue.
+    """
+    worker.stop_worker()
+    return jsonify(worker.current_state())
+
+
+## Authentification
+
+
+@app.route("/login")
 @limiter.limit("1/second", override_defaults=False)
 def login_page():
+    """Unsued, logins"""
     # web.login(username,password)
-    return redirect(url_for("index"))
+    return redirect(url_for("index")), 501
 
-@app.route('/logout')
+
+@app.route("/logout")
 @limiter.limit("1/second", override_defaults=False)
 def logout_page():
+    """Unused, logout"""
     # web.logout(username, password)
-    return redirect(url_for("index"))
+    return redirect(url_for("index")), 501
+
 
 @app.errorhandler(429)
 def ratelimit_handler(e):
-    flash("Rate limit reached, please slow down :) ( Currently at "+ e.description + ")", 'error')
+    """Handle rate limits"""
-    app.logger.debug('Rate limit reached ' + e)
+    flash(
+        "Rate limit reached, please slow down :) ( Currently at " + e.description + ")",
+        "error",
+    )
+    app.logger.debug("Rate limit reached %s ", str(e.description))
     return redirect(url_for("index"))
 
+
 @app.route("/ping")
 @limiter.exempt
 def ping():
-    flash("🏓 Pong !",'info')
+    """Returns a pong"""
-    app.logger.debug('🏓 Pong !')
+    flash("🏓 Pong !", "info")
+    app.logger.debug("🏓 Pong !")
     return redirect(url_for("index"))
+
+
+@socketio.on("ping")
+def handle_message(data):
+    """Handle sockets pings"""
+    app.logger.debug("Received : %s ", str(data))
+    socketio.emit("pong", "Pong !")
+
+
+@socketio.on("get_camera_status")
+def camera_status():
+    """Returns camera status to a socket"""
+    app.logger.debug("Client asked if we had a camera")
+    if RASPBERRY_PI_CONNECTED:
+        socketio.emit("camera_status", True)
+    else:
+        socketio.emit("camera_status", False)
+
+
+if __name__ == "__main__":
+    app.run(debug=True, use_reloader=False, host="0.0.0.0", ssl_context="adhoc")

src/print_queue.py

@@ -0,0 +1,135 @@
+"""
+This class has the method by which we manage the Tasks
+It's a printing queue, so we need to add, remove and get information on where
+the queue is
+"""
+
+from collections import deque
+
+# Because actually printing and adding new print job requests happen at
+# diffrent times, the print queue is managed by it's own thread.
+import threading
+
+from datetime import datetime
+from task import TaskType
+
+
+class PrintQueue:
+    """
+    A Double-ended Queue to manage the printing Tasks
+    """
+
+    def __init__(self, app):
+        self.app = app
+        self._queue = deque()
+        self._lock = threading.Lock()
+        self._completed_tasks = {}  # Store completed task info
+        self._task_counter = 0
+        self.app.logger.debug("Created a new PrintQueue")
+
+    def __len__(self) -> int:
+        return len(self._queue)
+
+    def enqueue(self, task):
+        """Add task to right of the queue and return position"""
+        with self._lock:
+            try:
+                self.app.logger.info("Add task %s to queue ", task.task_id)
+                self._queue.append(task)
+                position = self._queue.index(task)
+                # We return the current position of the task if it was added
+                self.app.logger.debug(
+                    "Added a new task %s to the queue at position %s",
+                    task.task_id,
+                    position,
+                )
+                return position
+            except Exception as e:
+                self.app.logger.error("Could not add a task to the queue : %s ", e)
+                raise e
+
+    def dequeue(self):
+        """Remove and return next task ( from the left of the queue ) (thread-safe)"""
+        with self._lock:
+            return self._queue.popleft() if len(self._queue) > 0 else None
+
+    def get_position(self, task):
+        """Get current position of task in queue (1-indexed)"""
+        with self._lock:
+            if task.task_id in self._completed_tasks:
+                return None  # Task already completed
+
+        try:
+            # Try to get the position of a Task
+            return self._queue.index(task)
+        except ValueError as e:
+            raise e
+        # end try
+
+    def is_empty(self):
+        """Check if queue is empty"""
+        with self._lock:
+            self.app.logger.debug("Checking if queue is empty")
+            return len(self._queue) == 0
+
+    def get_queue_state(self):
+        """Return current queue state"""
+        with self._lock:
+            self.app.logger.debug("Return current queue state")
+            return [{"task_id": t.task_id, "status": t.status} for t in self._queue]
+
+    def get_status(self, task_id):
+        """Get full status info for a task"""
+        with self._lock:
+
+            if task_id in self._completed_tasks:
+                return self._completed_tasks[task_id]
+
+            # Check in queue if it exists
+            for index, task in enumerate(self._queue):
+                if task.task_id == task_id:
+                    # Depending on it's type, we return more info
+                    if task.task_type == TaskType.IMAGE:
+                        return {
+                            "task_id": task_id,
+                            "status": task.status,
+                            "type": task.task_type,
+                            "position": index,
+                            "in_queue": True,
+                            "content": task.content,
+                            "signature": task.signature,
+                        }
+
+                    if task.task_type == TaskType.TEXT:
+                        return {
+                            "task_id": task_id,
+                            "status": task.status,
+                            "type": task.task_type,
+                            "position": index,
+                            "in_queue": True,
+                            "image_path": str(task.image_path),
+                            "signature": task.signature,
+                            "process": str(task.process),
+                        }
+
+                    if task.task_type == TaskType.CUT:
+                        return {
+                            "task_id": task_id,
+                            "status": task.status,
+                            "type": task.task_type,
+                            "position": index,
+                            "in_queue": True,
+                        }
+
+            return None
+
+    def mark_completed(self, task_id, task_status):
+        """Mark task as completed and remove from queue"""
+        with self._lock:
+            self._completed_tasks[task_id] = {
+                "task_id": task_id,
+                "status": task_status,
+                "position": None,
+                "in_queue": False,
+                "completed_at": datetime.now().isoformat(),
+            }

src/printer.py

@@ -1,13 +1,18 @@
-# Importing the module to mage the connection to the printer.
+"""
-from flask import flash
+This class manages connexion to a Printer
-from escpos.printer import Usb, USBNotFoundError
+"""
-from time import sleep, gmtime, strftime
+# import brother_ql
+from time import sleep
 import os.path
-from PIL import Image, ImageEnhance, ImageOps
+
+from PIL import Image, ImageEnhance
 import numpy as np
 
+# Importing the module to manage the connection to the printer.
+import escpos.printer
 
-class Printer(object):
+
+class Printer():
     """
     # The connection is based on the ESC/POS library
 
@@ -28,156 +33,269 @@ class Printer(object):
     ready = False
 
     def __init__(self, app, device_id, vendor_id):
-        super(Printer, self).__init__()
+        super().__init__()
         self.app = app
         self.ready = False
         self.printer = None
         self.device_id = device_id
         self.vendor_id = vendor_id
         self.usb_args = {}
-        self.usb_args['idVendor'] = self.device_id
+        self.usb_args["idVendor"] = self.device_id
-        self.usb_args['idProduct'] = self.vendor_id
+        self.usb_args["idProduct"] = self.vendor_id
 
     def check_paper(self) -> bool:
-        # Let's check paper status
+        """
-        self.app.logger.debug('Checking paper status...')
+        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.app.logger.error("Printer has no more paper, aborting...")
-                flash("No more paper on the printer. Sorry.",category='error')
                 self.printer.close()
-                return False
+                raise RuntimeError("No more paper in the printer")
             case 1:
-                self.app.logger.warning('Printer needs paper to be changed very soon ! ')
+                self.app.logger.warning(
-                flash('Printer needs paper to be changed very soon ! ', category='info')
+                    "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.app.logger.debug("Printer has paper, good to go")
                 self.printer.close()
-                return True
 
     def init_printer(self):
+        """
+        Check if the printer online ? Is the communication with the printer successfull ?
+        """
 
-        # Is the printer online ? Is the communication with the printer successfull ?
+        # TODO: This could happen directly when creating a new Printer class
-        waiting_elapsed = 30
+        if os.getenv("FLASK_DEBUG"):
-        self.app.logger.debug('Waiting for printer to get online...')
+            waiting_elapsed = 3
+        else:
+            waiting_elapsed = 10
+
+        self.app.logger.debug("Waiting for printer to get online...")
 
         while not self.ready:
             try:
                 # This also calls open(), which we need to close()
                 # or else the device will appear as busy.
-                p = Usb(self.device_id, self.vendor_id, 0, profile="TM-P80")
+                p = escpos.printer.Usb(
-            except USBNotFoundError as e:
+                    self.device_id, self.vendor_id, 0, profile="TM-P80"
-                self.app.logger.error("The USB device is not plugged in, trying again : " + str(e))
+                )
-                pass
+            except RuntimeError as e:
+                self.app.logger.error(
+                    "The USB device is not plugged in, trying again %s : %s",
+                    waiting_elapsed,
+                    str(e),
+                )
 
             try:
                 if p.is_online():
                     self.ready = True
-                    self.app.logger.debug('Printer online !')
+                    self.app.logger.debug("Printer online !")
-            except Exception as e:
+            except RuntimeError as e:
-                pass
+                self.app.logger.error(
+                    "Error while getting the printer online %s : %s",
+                    waiting_elapsed,
+                    str(e),
+                )
 
             sleep(1)
             waiting_elapsed -= 1
             if waiting_elapsed < 1:
-                self.app.logger.error('Printer took more than 30 seconds to get online, aborting...')
+                self.app.logger.error(
-                waiting_elapsed = 30 # Reset the waiting time for the next print.
+                    "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.
-        p.set(align='center', font='a', bold=False, underline=0, width=1, height=1, density=9, invert=False, smooth=False, flip=False, double_width=False, double_height=False, custom_size=False)
+        p.set(
+            align="center",
+            font="a",
+            bold=False,
+            underline=0,
+            width=1,
+            height=1,
+            density=9,
+            invert=False,
+            smooth=False,
+            flip=False,
+            double_width=False,
+            double_height=False,
+            custom_size=False,
+        )
         # Beware : if we print every time the printer becomes ready, it means
         # we are printing before and after every print !
         self.printer = p
-        self.ready = True;
+        self.ready = True
-        self.printer.close();
+        self.printer.close()
 
-        if not self.check_paper():
+        self.check_paper()
-            return False
 
         return True
 
-    def print_sms(self, msg, signature) -> bool:
+    def _print_sms(self, msg, signature="", bold=False):
-        clean_msg = str(msg)
+
+        if not isinstance(msg, str):
+            self.app.logger.error(
+                "It is not possible to print a " + str(type(msg)) + ", only strings."
+            )
+            raise ValueError
+
+        # We make sure that the signature is not something too goofy
+        clean_msg = str(msg) + "\n"
         clean_signature = str(signature)
 
-        if not self.check_paper():
+        # Make checks on the size of the message being printed
-            return False
+        if len(clean_msg) > 4096:
+            self.app.logger.warning(
+                "Could not print message of this length: " + str(len(clean_msg))
+            )
+            raise RuntimeError(
+                "Could not print message of this length :"
+                + str(len(clean_msg))
+                + ", needs to be below 4096 caracters long."
+            )
 
-        if len(clean_msg) > 256 or len(clean_msg) < 3 :
+        if len(signature) > 256:
-            self.app.logger.warning("Could not print message of this length: " + str(len(clean_msg)))
+            self.app.logger.warning(
-            flash("Could not print message of this length :" + str(len(clean_msg)) + ", needs to between 3 and 256 caracters long.",category='error')
+                "Could not print signature of this length: " + str(len(clean_signature))
-            return False
+            )
+            raise RuntimeError(
+                "Could not print signature of this length :"
+                + str(len(clean_signature))
+                + ", needs to be below 256 caracters long."
+            )
 
-        if len(signature) > 256 or len(signature) < 3:
+        # Do the actual printing
-            self.app.logger.warning("Could not print message without a signature.")
+        # We would pop the next element in the queue here, if it's a sms type
-            flash("Could not print message without a signature.",category='error')
-            return False
-
-        if not os.getenv('LIPY_DEBUG') == True:
         try:
-                self.printer.open(self.usb_args);
+            self.printer.open(self.usb_args)
-                self.printer.set(align='left', font='a', bold=False, underline=0, width=1, height=1, density=8, invert=False, smooth=True, flip=False, double_width=False, double_height=False, custom_size=False)
+            self.printer.set(align="center", font="a", bold=bold)
             self.printer.textln(clean_msg)
-                self.printer.set(align='left', font='b', bold=False, underline=1, width=1, height=1, density=9, invert=False, smooth=True, flip=False, double_width=False, double_height=False, custom_size=False)
+            if clean_signature:
-                self.printer.textln("> " + clean_signature + " @ " + strftime("%Y-%m-%d %H:%M:%S", gmtime()))
+                self.printer.textln(clean_signature)
-                self.printer.cut()
+            self.printer.close()
-                self.printer.close
         except Exception as e:
-                flash("Unable to print because : " + e)
+            self.app.logger.error("Unable to print because : " + str(e))
+            raise RuntimeError(
+                "Unable to print a SMS, the printer couldn't do it."
+            ) from e
 
-        flash("Message printed : " + clean_msg ,category='info')
+        self.app.logger.info("Printed text")
         return True
 
-    def print_img(self, path, sign):
+    def _print_img(self, path, signature="", center=True, process=False):
-        clean_signature = str(sign)
+        clean_signature = str(signature)
-
-        if len(clean_signature) > 256 or len(clean_signature) < 3:
-            self.app.logger.warning("Could not print message without a signature.")
-            flash("Could not print message without a signature.",category='error')
-            return False
 
+        if len(signature) > 256:
+            self.app.logger.warning(
+                "Could not print signature of this length: " + str(len(clean_signature))
+            )
+            raise ValueError(
+                "Could not print signature of this length :"
+                + str(len(clean_signature))
+                + ", needs to be below 256 caracters long."
+            )
 
         if not os.path.isfile(str(path)):
             self.app.logger.warning("File does not exist : " + str(path))
-            flash('The file path for this image :' + str(path) + " wasn't found. Please try again.", 'error')
+            raise OSError(
-            return False
+                "The file path for this image :"
-        else:
+                + str(path)
+                + " wasn't found. Please try again."
+            )
+
         self.app.logger.debug("Printing file from " + str(path))
 
+        if process:
             try:
                 self.app.logger.debug("Proccessing the image")
-            path = process_image(self, path)
+                path = _process_image(self, path)
-        except Exception as e:
+            except RuntimeError as e:
-            flash(str(e))
+                self.app.logger.error(
-            self.app.logger.error(str(e))
+                    "Error while processing the image, aborting print : %s", str(e)
+                )
+                raise e
+        else:
+            self.app.logger.warning("Not proccessing the image")
 
         try:
             self.printer.open(self.usb_args)
-            self.printer.textln("> " + clean_signature + " @ " + strftime("%Y-%m-%d %H:%M:%S", gmtime()))
+            self.printer.image(path, center=center)
-            self.printer.image(path)
+            self.printer.textln(signature)
-            self.printer.cut()
             self.printer.close()
             self.app.logger.debug("Printed an image : " + str(path))
-            os.remove(path)
-            self.app.logger.debug("Removed image.")
-            return True
         except Exception as e:
+            self.app.logger.error(str(e))
+            raise RuntimeError("Could not print the picture") from e
+        finally:
+            try:
+                os.remove(path)
+            except OSError as e:
+                raise e
+
+            self.app.logger.debug("Removed image : " + str(path))
+
+            try:
                 self.printer.close()
-            flash(str(e),'error')
+            except Exception as e:
+                self.app.logger.error(
+                    "Could not close the printer connexion %s", str(e)
+                )
+                raise RuntimeError("Could not close the printer connexion. ") from e
+
+        self.app.logger.info("Printed a picture")
+        return True
+
+    def _qr(self, content):
+        try:
+            self.printer.open(self.usb_args)
+            self.printer.qr(content, center=True)
+            self.printer.close()
+        except RuntimeError as e:
+            self.printer.close()
+            self.app.logger.error(str(e))
             return False
 
-def process_image(self, path):
+        self.app.logger.info("Printed a QR")
+        return True
+
+    def _cut(self):
+        try:
+            self.printer.open(self.usb_args)
+            self.printer.cut()
+            self.printer.close()
+        except Exception as e:
+            self.printer.close()
+            self.app.logger.error(str(e))
+            raise e
+
+        self.app.logger.info("Did a cut")
+        return True
+
+    def print_task(self, task_type, data):
+        """Execute actual print based on task type"""
+        match (task_type.value):
+            case "text":
+                self._print_sms(data["txt"], signature=data["sign"])
+            case "image":
+                self._print_img(
+                    data["img"], signature=data["sign"], process=data["process"]
+                )
+            case "cut":
+                self._cut()
+            case _:
+                raise RuntimeError("This task type is not supported")
+
+
+def _process_image(self, path):
     brightness_factor = 1.5  # Used only if image is too dark
-    brightness_threshold = 150  # Brightness threshold (0–255)
+    brightness_threshold = 100  # Brightness threshold (0–255)
-    contrast_factor = 1.2         # Less than 1.0 = lower contrast
+    contrast_factor = 0.6  # Less than 1.0 = lower contrast
     max_width = 575
     max_height = 1000
 
@@ -188,38 +306,42 @@ def process_image(self, path):
             original_img = original_img.convert("RGB")
 
         # Resize while maintaining aspect ratio
-        original_img.thumbnail((max_width, max_height), Image.LANCZOS)
+        original_img.thumbnail((max_width, max_height), Image.Resampling.LANCZOS)
         self.app.logger.debug("Resized the image")
 
-        # Convert to grayscale for dithering
+        # # Convert to grayscale for dithering
-        dithered_img = original_img.convert("L").convert("1")  # Dithering using default method (Floyd–Steinberg)
+        # dithered_img = original_img.convert("L").convert("1")
-        self.app.logger.debug("Dithered the image")
+        # 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) )
+        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 = (
-            brightness_factor = min(max(brightness_factor, 1.1), 2.5)  # Clamp between 1.1 and 2.5
+                1 + (brightness_threshold - avg_brightness) / brightness_threshold
-            self.app.logger.debug(f"Image too dark, increasing brightness by a factor of {brightness_factor:.2f}")
+            )
+            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
+        # # Reduce contrast
-        contrast_enhancer = ImageEnhance.Contrast(original_img)
+        # contrast_enhancer = ImageEnhance.Contrast(original_img)
-        original_img = contrast_enhancer.enhance(contrast_factor)
+        # original_img = contrast_enhancer.enhance(contrast_factor)
-
-        # Final resize check
-        if original_img.height > max_height:
-            flash("Image is too long, sorry! Keep it below 575×1000 pixels.", 'error')
-            self.app.logger.error("Image is too long, sorry! Keep it below 575×1000 pixels.")
-            return False
 
         # 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)
+        original_img.save(jpeg_path, format="JPEG", quality=95, optimize=True)
+        self.app.logger.debug("Processed and saved image.")
 
     return jpeg_path

src/raspberry.py

@@ -0,0 +1,273 @@
+"""
+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():
+    """
+    This class will manage three things :
+    - Connecting to a USB webcam
+    - Managing a push button
+    - Activating a flash ( or light )
+    - Flash an indicator light
+
+    """
+
+    def __init__(
+        self,
+        print_queue,
+        app,
+        socketio,
+        button_gpio_port_number,
+        indicator_gpio_port_number,
+        flash_gpio_port_number,
+        is_flash_present,
+    ):
+        self.print_queue = print_queue
+        self.socketio = socketio
+        self.app = app
+
+        self.flash_gpio = flash_gpio_port_number
+        self.is_flash_present = is_flash_present
+        self.button_gpio = button_gpio_port_number
+        self.led_gpio = indicator_gpio_port_number
+        self.image_path = self.app.config["UPLOAD_FOLDER"] + "/image.jpg"
+
+    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:
+                found = False
+                for line in cpuinfo:
+                    if line.startswith("Hardware"):
+                        found = True
+                        label, value = line.strip().split(":", 1)
+                        value = value.strip()
+                        if value not in (
+                            "BCM2708",
+                            "BCM2709",
+                            "BCM2711",
+                            "BCM2835",
+                            "BCM2836",
+                        ):
+                            self.app.logger.debug(
+                                "This system does not appear to be a Raspberry Pi."
+                            )
+                            return False
+
+                if not found:
+                    self.app.logger.error(
+                        "Couldn't get sufficient hardware information from /proc/cpuinfo, Unable to determine if we are on a Raspberry Pi."
+                    )
+                    return False
+        except IOError:
+            self.app.logger.error("Unable to open `/proc/cpuinfo`.")
+            return False
+
+        self.app.logger.debug("It seems we are on a Raspberry Pi")
+
+        try:
+            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):
+        self.app.logger.debug("Initializing GPIO")
+
+        self.led = LED(self.led_gpio)
+        self.app.logger.debug("Activated indicator LED")
+        self.indicator_countdown(iters=3)
+        self.button = Button(self.button_gpio, pull_up=True, bounce_time=0.1)
+        self.button.when_pressed = self.on_button_pressed
+        self.app.logger.debug("Activated button")
+
+        # The "flash" is a relay-controlled device ( light bulb for example )
+        self.flash = DigitalOutputDevice(self.flash_gpio)
+        self.flash_toggle()
+        self.app.logger.debug("Activated flash")
+
+    def indicator_countdown(self, iters=10, multi=10):
+        for i in range(iters, 0, -1):
+            self.led.on()
+            sleep(i / multi)
+            self.led.off()
+            sleep(i / multi)
+
+    def indicator_led(self, timing=0.2, l=5):
+        for i in range(l):
+            self.app.logger.debug("LED turned on")
+            self.led.on()
+            sleep(timing)
+            self.led.off()
+            self.app.logger.debug("LED turned off")
+            sleep(timing)
+
+    def flash_toggle(self):
+        self.app.logger.debug("Flash turned on")
+        self.flash.on()
+        sleep(0.3)
+        self.flash.off()
+        self.app.logger.debug("Flash turned off")
+
+    def take_picture(self):
+        # Validate if the image path is valid
+        if not os.path.isdir(os.path.dirname(self.image_path)):
+            self.app.logger.error(
+                f"Invalid directory for image path: {self.image_path}"
+            )
+            return False
+
+        try:
+            result = subprocess.run(
+                ["fswebcam", "--no-banner", "-r", "1920x1080", self.image_path],
+                check=True,  # Will raise CalledProcessError if the command fails
+                stdout=subprocess.PIPE,  # Capture standard output
+                stderr=subprocess.PIPE,  # Capture error output
+            )
+
+            # Optionally log the command output
+            self.app.logger.debug(
+                f"Image captured successfully: {result.stdout.decode()}"
+            )
+        except subprocess.CalledProcessError as e:
+            # Log error output if available
+            self.app.logger.error(
+                f"Unable to take a picture. Error: {e.stderr.decode()}"
+            )
+            return False
+        except RuntimeError as e:
+            # Catch any unexpected errors
+            self.app.logger.error(f"Unexpected error while taking picture: {str(e)}")
+            return False
+
+        #   # Overlay logo
+        # logo_path = 'src/static/images/requin.png'  # Update path as needed
+        # if not self.overlay_logo(self.image_path, logo_path):
+        #     self.app.logger.warning("Picture taken but failed to overlay logo.")
+
+        return True
+
+    def overlay_logo(
+        self,
+        image_path,
+        logo_path,
+        output_path=None,
+        position="bottom_right",
+        margin=10,
+    ):
+        try:
+            image = Image.open(image_path).convert("RGBA")
+            logo = Image.open(logo_path).convert("RGBA")
+
+            # Resize logo if it's too big (logo will be 30% the width of the image)
+            logo_ratio = (
+                0.30  # You can change the ratio if you want the logo bigger or smaller
+            )
+            logo_width = int(image.width * logo_ratio)
+            logo_height = int(logo.height * (logo_width / logo.width))
+            logo = logo.resize((logo_width, logo_height), Image.Resampling.LANCZOS)
+
+            # Calculate position based on the chosen location
+            if position == "bottom_right":
+                x = image.width - logo.width - margin
+                y = image.height - logo.height - margin
+            elif position == "top_left":
+                x, y = margin, margin
+            elif position == "top_right":
+                x = image.width - logo.width - margin
+                y = margin
+            elif position == "bottom_left":
+                x = margin
+                y = image.height - logo.height - margin
+            else:
+                raise ValueError(
+                    "Invalid position. Choose from 'bottom_right', 'top_left', 'top_right', or 'bottom_left'."
+                )
+
+            # Composite the logo onto the image
+            image.paste(logo, (x, y), logo)  # Use logo as its own alpha mask
+
+            # Save the result
+            if not output_path:
+                output_path = image_path  # Overwrite the original image if no output path is given
+            image.save(output_path)
+
+        except RuntimeError 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):
+        try:
+            image = Image.open(image_path)
+            width, height = image.size
+
+            # Determine shorter side
+            new_edge = min(width, height)
+
+            # Calculate cropping box (centered)
+            left = (width - new_edge) // 2
+            top = (height - new_edge) // 2
+            right = left + new_edge
+            bottom = top + new_edge
+
+            image = image.crop((left, top, right, bottom))
+
+            if not output_path:
+                output_path = image_path  # Overwrite original
+
+            image.save(output_path)
+
+        except RuntimeError as e:
+            self.app.logger.error(f"Error cropping image to square: {e}")
+            return False
+
+        return True
+
+    def on_button_pressed(self):
+        self.app.logger.debug("Button has been pressed")
+        self.led.on()
+        self.app.logger.debug("Counting down")
+        self.indicator_countdown(
+            iters=4, multi=20
+        )  # The indicator will flash a countdown LED
+        self.app.logger.debug("Taking picture")
+        try:
+            self.flash.on()
+            self.take_picture()
+        except RuntimeError as e:
+            self.app.logger.error(
+                "Could not take a picture after the button press : " + str(e)
+            )
+        finally:
+            self.flash.off()
+        self.app.logger.debug("Printing picture")
+        self.led.on()
+        self.crop_to_square(self.image_path)
+        self.print_queue.enqueue(ImageTask(self.image_path,signature="",process=True))
+        self.print_queue.enqueue(TextTask(content="Imprimé par LittlePrynter", signature=""))
+        time = strftime("%Y-%m-%d %H:%M", gmtime())
+        self.print_queue.enqueue(TextTask(content=time, signature=""))
+        self.print_queue.enqueue(CutTask())
+        self.led.off()
+        self.app.logger.debug("Added a photomaton picture to the print queue")
+        return True

src/static/css/style.css

@@ -3,6 +3,36 @@
     margin-right: 20%;
 } */
 
+html, body {
+    height: 100%;
+    width: 100%;
+}
+
+.fullscreen-countdown {
+    position: fixed;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
+    z-index: 100;
+    height: 100%;
+    width: 100%;
+    /* backdrop-filter: blur(10px); */
+    color: black;
+    box-sizing: initial;
+
+}
+
+#countdown-number {
+    font-weight: bolder;
+    font-size: 10em;
+    text-shadow:   0px 0px 3em white, 1px 1px 1px rgba(255, 255, 255, 1);
+    position: fixed;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+}
+
 /*// Small devices (landscape phones, 576px and up)*/
 @media (min-width: 576px) {
 

src/static/js/webcam.js

@@ -1,39 +1,159 @@
 let streaming;
 var current_stream;
 var current_camera_is;
+var supports_facing_mode;
+var camera_options;
 
 var width = document.getElementById("video").parentNode.parentElement.clientWidth;
 var height = width / (4 / 3);
+var socket = io();
 
-function startup(){
+socket.on('connect', function() {
+    socket.emit('ping', {data: 'I\'m connected!'});
+    console.log("Sent a ping to the server :)");
+});
+
+
+socket.on('pong', () => {
+  console.log('Received pong back ! ');
+});
+
+socket.on('new_image', () => {
+    console.log("Received new image event");
+    const img = document.getElementById('snapshot');
+    img.src = '/image?' + new Date().getTime();  // Bust cache
+});
+
+
+async function startup(){
   video = document.getElementById('video');
   canvas = document.getElementById('canvas');
   photo = document.getElementById('photo');
   switch_cameras = document.getElementById('flip')
   printButton = document.getElementById('print_button');
 
-  if (check_webcam() === true ){
+  console.log("Checking for client webcam capabilities");
+  // We have a camera_options dictionnary in return, or false if the device does not support webcams.
+  let client_webcam_capabilities = await check_webcam_capabilies();
+
+
+  if ( client_webcam_capabilities != false ){
+    get_webcam(client_webcam_capabilities);
     setup_events();
     clear_canvas();
   } else {
+    console.log("Checking for server webcam capabilities");
+    let server_webcam_capabilities = await check_server_camera();
+    if (server_webcam_capabilities === true ){
+      console.log("The server has a camera, using it.");
+      console.log("TODO");
+    }
+    else {
       no_webcam_error();
-    console.log("Seems like it's impossible to get a webcam.");
+      console.log("Seems like it's impossible to get a webcam from the client nor the server.");
+    }
   }
 }
 
-function check_webcam(){
+async function check_webcam_capabilies(){
-  console.log("Cheking for a camera...");
+  console.log("Checking for a the capabilities of the client's media devices");
-  if (get_front_webcam()) {
+
-    console.log("Got front camera !");
+  // We try to start with the front facing camera,
-    return true;
+  // if we have no support, we switch back to a normal camera.
+  try {
+    // We first check if the navigator has a media device
+    if (!navigator.mediaDevices?.enumerateDevices) {
+      console.log("enumerateDevices() not supported.");
+      return false;
+    } else {
+      // List cameras and microphones.
+      console.log("The device has the following media devices : ")
+      await navigator.mediaDevices
+        .enumerateDevices()
+        .then((devices) => {
+          devices.forEach((device) => {
+            console.log(`${device.kind}: ${device.label} id = ${device.deviceId}`);
+          });
+        })
+        .catch((err) => {
+          console.error(`${err.name}: ${err.message}`);
+          return false;
+        });
+    }
+  } catch (e) {
+    console.log("The device does not seem to support webcams " + e);
+    return false;
   }
 
-  if (get_any_webcam()) {
+  console.log("Checking for the supported constraints of the media devices ");
-    console.log("Got a webcam !");
+  try {
-    return true;
+    const supports = navigator.mediaDevices.getSupportedConstraints();
+    if (!supports['facingMode']) {
+      throw new Error("This browser does not support facingMode!");
+    } else {
+      console.log("The device supports facing mode, selecting the front camera by default");
+      supports_facing_mode = true;
+      camera_options = {
+        video: {
+           facingMode: 'user', // Or 'environment' if we want a camera facing away
+        },
+        audio: false
+      };
+      return camera_options;
     }
-  console.log("Nope");
+  } catch (e) {
+    console.log("Resetting to default camera : " + e);
+    supports_facing_mode = false;
+    camera_options = {
+      video: true,
+      audio: false
+    };
+    return camera_options
+  }
+}
+
+async function get_webcam(options){
+  stop_video_streams();
+
+  try {
+    navigator.mediaDevices.getUserMedia(options)
+    .then(function(stream) {
+      // on success, stream it in video tag
+      // the video tag is hidden, as is the canvas.
+      console.log("Got the webcam stream");
+
+      printButton.removeAttribute("disabled","");
+      current_stream = stream;
+      video.srcObject = stream;
+      video.setAttribute('autoplay', '');
+      video.setAttribute('muted', '');
+      video.setAttribute('playsinline', '')
+      video.play();
+      return true;
+    })
+    .catch(function(err) {
+        console.log("Didn't manage to get a camera :" + err);
         return false;
+    });
+  } catch (err) {
+    console.log("Didn't manage to get a camera :" + err);
+    return false;
+  }
+}
+
+async function check_server_camera(){
+  console.log("Checking for a camera on the server");
+
+  await socket.emit('get_camera_status', (response) => {
+    if (response){
+      console.log("Server has a camera !");
+      return true;
+    } else {
+      console.log("The server doesn't seem to have a camera");
+      return false;
+    }
+  });
+
 }
 
 function setup_events(){
@@ -69,15 +189,15 @@ function setup_events(){
     flip_cameras();
   }, false );
 
-  printButton.addEventListener('click', function(ev){
+  printButton.addEventListener('click', async function(ev) {
-    data = take_picture();
+    ev.preventDefault();
     try {
+      await countDownToPicture();         // wait for countdown to finish
+      var data = await take_picture();  // take_picture can be async
       print_picture(data);
     } catch (e) {
       alert("Failed to print a picture because : " + e);
     }
-
-    ev.preventDefault();
   }, false);
 
 }
@@ -92,6 +212,10 @@ function clear_canvas() {
 }
 
 function dataURLtoFile(dataurl, filename) {
+  if(dataurl === "") {
+    console.log("We didn't receive data");
+  }
+
   var arr = dataurl.split(','), mime = arr[0].match(/:(.*?);/)[1],
       bstr = atob(arr[1]), n = bstr.length, u8arr = new Uint8Array(n);
   while(n--){
@@ -100,19 +224,18 @@ function dataURLtoFile(dataurl, filename) {
   return new File([u8arr], filename, {type:mime});
 }
 
-function take_picture(){
+async function take_picture() {
-  var context = canvas.getContext('2d');
+  const context = canvas.getContext('2d');
+  let data = null;
   if (width && height) {
     canvas.width = width;
     canvas.height = height;
     context.drawImage(video, 0, 0, width, height);
-
+    data = canvas.toDataURL('image/png');
-      var data = canvas.toDataURL('image/png');
     photo.setAttribute('src', data);
   } else {
     clear_canvas();
   }
-
   return data;
 }
 
@@ -124,7 +247,7 @@ function print_picture(data){
   let time = currentDate.getHours() + ":" + currentDate.getMinutes() + ":" + currentDate.getSeconds();
 
   formData.set("img", picture, "picture.png");
-  formData.set("signature", "Printed via the webcam @ " + time)
+  formData.set("signature", "Webcam")
 
   fetch(url, {
     method: 'POST', // or 'PUT'
@@ -132,32 +255,28 @@ function print_picture(data){
     // headers:{
     //   'Content-Type': 'multipart/form-data'
     // }
-  }).then(function(response) { console.log('Success:', response); } , true)
+  }).then(function(response) {
+    console.log('Reponse:', response);
+    if(response.status != 200 ){
+      alert("The picture could not be printed be : " + response.statusText)
+    }
+  } , true)
   .catch(error => console.error('Error:', error), false);
 
 }
 
 function flip_cameras(){
-  switch (current_camera_is) {
+  console.log("Current facing mode : " + camera_options.video.facingMode)
-    case "front":
+  if ( supports_facing_mode ) {
-      try {
+    console.log("Support facing mode, trying to switch !");
-        get_any_webcam();
+    if (camera_options.video.facingMode == 'user'){
-      } catch (e) {
+      camera_options = { audio: false, video: { facingMode: "environment" },};
-        console.log("Could not get another camera");
+    } else {
-        get_front_webcam();
+      camera_options = { audio: false, video: { facingMode: "user" },};
     }
-      break;
-    case "any":
-      try {
-        get_front_webcam();
-      } catch (e) {
-        console.log("Could not get another camera");
-        get_any_webcam();
-      }
-      break;
-    default:
-      console.log("Impossible to switch cameras : none is selected.");
   }
+  console.log("Switching to " + camera_options.video.facingMode );
+  get_webcam(camera_options);
 }
 
 function stop_video_streams(){
@@ -177,84 +296,6 @@ function stop_video_streams(){
   }
 }
 
-async function get_webcam(options){
-  stop_video_streams();
-
-  try {
-    await navigator.mediaDevices.getUserMedia(options)
-    .then(function(stream) {
-      // on success, stream it in video tag
-      // the video tag is hidden, as is the canvas.
-      console.log("Got a camera ( generic )");
-
-      printButton.removeAttribute("disabled","");
-      current_stream = stream;
-      video.srcObject = stream;
-      video.setAttribute('autoplay', '');
-      video.setAttribute('muted', '');
-      video.setAttribute('playsinline', '')
-      video.play();
-      return true;
-    })
-    .catch(function(err) {
-        console.log("Didn't manage to get a camera :" + err);
-        return false;
-    });
-  } catch (err) {
-    console.log("Didn't manage to get a camera :" + err);
-    return false;
-  }
-}
-
-function get_any_webcam(){
-  var camera_options = {
-    video: {
-       facingMode: 'environment', // Or 'environment' if we want a camera facing away
-    },
-    audio: false
-  };
-
-  if(get_webcam(camera_options)){
-    console.log("Got any camera, or environment camera.");
-    current_camera_is = "any";
-    return true;
-  } else {
-    return false;
-  }
-}
-
-function get_front_webcam(){
-  // We try to start with the front facing camera,
-  // if we have no support, we switch back to a normal camera.
-  try {
-    const supports = navigator.mediaDevices.getSupportedConstraints();
-    if (!supports['facingMode']) {
-      throw new Error("This browser does not support facingMode!");
-    } else {
-      var camera_options = {
-        video: {
-           facingMode: 'user', // Or 'environment' if we want a camera facing away
-        },
-        audio: false
-      };
-    }
-  } catch (e) {
-    console.log("Resetting to default camera : " + e);
-    var camera_options = {
-      video: true,
-      audio: false
-    };
-  }
-
-  if(get_webcam(camera_options)){
-    console.log("Got the front camera");
-    current_camera_is = "front";
-    return true;
-  } else {
-    return false;
-  }
-}
-
 function no_webcam_error(){
   console.log("Seems like they is no webcam available.")
 
@@ -275,4 +316,33 @@ function no_webcam_error(){
   throw new Error("Unable to get a video device, stopping the photobooth.");
 }
 
+async function countDownToPicture(){
+  return new Promise((resolve) => {
+    console.log("Starting countdown");
+    // We create full-page overlay that displays a number to countdown until the picture is taken.
+    const countdown_div = document.getElementById("countdown");
+    countdown_div.style.display = "block";
+
+    // Set the different styling attributes of the element
+    countdown_div.setAttribute("class", "fullscreen-countdown");
+
+    // The loop must run for 3 seconds
+    interval = 1000;
+    var loops = 3;
+
+    var x = setInterval(() => {
+      console.log(loops);
+      // Update the content of the div
+      document.getElementById("countdown-number").innerHTML = loops;
+      if (loops == 0) {
+        countdown_div.style.display = "none";
+        // The timer has finished
+        clearInterval(x);
+        resolve();
+      }
+      loops--;
+    }, interval);
+  });
+}
+
 window.addEventListener('load', startup, false);

src/task.py

@@ -0,0 +1,98 @@
+"""
+Here we define the types of tasks
+We are using Abstract Base Classes,
+like this we can define types of tasks ( text, images, ... )
+that all work with the same basic options
+
+The tasks are going to be injected into a Queue.
+It's a usefull way of storing information in our
+program, while making sure that things are indeed printed.
+It's also a way to prevent two concurrent connexions creating
+a access conflict on a single printer, like two people wanting
+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 enum import Enum
+import uuid
+
+
+## You can expand this if you want to take other types of tasks into account
+class TaskType(Enum):
+    """
+    The different tasks supported by the printers
+    """
+    TEXT = "text"
+    IMAGE = "image"
+    CUT = "cut"
+
+
+class PrintTask(ABC):
+    """
+    A print task holds information about what we are looking to print.
+    """
+
+    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())
+
+
+class TextTask(PrintTask):
+    """
+    This tasks represents a texte content, and it's signature.
+    """
+
+    def __init__(self, content, signature):
+        super().__init__(TaskType.TEXT)
+        self.content = content
+        self.signature = signature
+
+    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.
+    """
+
+    def __init__(self, image_path, signature, process):
+        super().__init__(TaskType.IMAGE)
+        self.image_path = image_path
+        self.signature = signature
+        self.process = process
+
+    def get_print_data(self):
+        # Return image data in printer-compatible format
+        return {"img": self.image_path, "sign": self.signature, "process": self.process}
+
+
+class CutTask(PrintTask):
+    """
+    This class activates the cutter on the printer if it exists
+    """
+
+    def __init__(self):
+        super().__init__(TaskType.CUT)
+
+    # There is no print data,
+    # the task existence in itself is indication of what to do
+    def get_print_data(self):
+        return None

src/templates/base.html

@@ -56,4 +56,6 @@
         <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>
+
 </html>

src/templates/index.html

@@ -5,9 +5,9 @@
     <div class="card">
       <h3 class="card-header">Print a short message</h3>
       <div class="card-body">
-        <form class="form-group" action="/api/print/sms" method="post">
+        <form class="form-group" action="/web/print/sms" method="post">
           <input class="form-control" type="text" name="txt" placeholder="200 chars or less " maxlength="200" required><br>
-          <input class="form-control" type="text" name="signature" placeholder="Signature or pseudo" maxlength="200" required><br>
+          <input class="form-control" type="text" name="signature" placeholder="Signature or pseudo" maxlength="200"><br>
           <input class="btn btn-primary float-right" type="submit" value="Imprimer" name="imprimer">
         </form>
       </div>
@@ -18,9 +18,9 @@
     <div class="card">
       <h3 class="card-header">Print an image</h3>
       <div class="card-body">
-        <form enctype="multipart/form-data" class="form-group" action="/api/print/img" method="post">
+        <form enctype="multipart/form-data" class="form-group" action="/web/print/img" method="post">
           <input class="form-control" type="file" name="img" required><br>
-          <input class="form-control" type="text" name="signature" placeholder="Signature or pseudo" maxlength="200" required><br>
+          <input class="form-control" type="text" name="signature" placeholder="Signature or pseudo" maxlength="200"><br>
           <input class="btn btn-primary float-right" type="submit" value="Imprimer" name="imprimer">
         </form>
       </div>

src/templates/webcam.html

@@ -54,6 +54,10 @@
 
 	</div>
 
+	<div id="countdown">
+		<div id="countdown-number"></div>
+	</div>
+
 <style media="screen">
   canvas {
     display: none;
@@ -99,6 +103,7 @@
 
 </style>
 
+<script src="https://cdn.socket.io/4.0.0/socket.io.min.js"></script>
 <script type="text/javascript" src="{{ url_for('static',filename='js/webcam.js') }}"></script>
 
 <br>

src/user.py

@@ -1,39 +1,41 @@
-class User(object):
+# class User(object):
-    """docstring for User."""
+#     """docstring for User."""
 
-    def __init__(self, arg):
+#     def __init__(self, arg):
-        super(User, self).__init__()
+#         super(User, self).__init__()
-        self.arg = arg
+#         self.arg = arg
 
-#         @app.route('/login', methods=['POST','GET'])
-# @limiter.limit("100 per minute", error_message=error_handler_limiter)
-def login():
-    if request.method == 'POST':
-        if not session.get('logged_in'):
-            if request.form['username'] and request.form['password']:
-                # Get the json
-                with open('users.json') as f:
-                    users_file = json.load(f)
-                for user in users_file["users"]:
-                    if users_file["users"][user] == request.form['password']:
-                        session['logged_in'] = True
-                        session['user'] = request.form['username']
 
-                if not session.get('logged_in'):
+# #         @app.route('/login', methods=['POST','GET'])
-                    flash('Mot de passe ou pseudo invalide.','danger')
+# # @limiter.limit("100 per minute", error_message=error_handler_limiter)
-                    return redirect(url_for('login'))
+# def login():
-                else:
+#     if request.method == "POST":
-                    return redirect(url_for('display_index_page'))
+#         if not session.get("logged_in"):
-            else:
+#             if request.form["username"] and request.form["password"]:
-                flash('Incorrect logins')
+#                 # Get the json
-                return render_template('password.html')
+#                 with open("users.json") as f:
-        else:
+#                     users_file = json.load(f)
-            return render_template('password.html')
+#                 for user in users_file["users"]:
-    else:
+#                     if users_file["users"][user] == request.form["password"]:
-        return render_template('password.html')
+#                         session["logged_in"] = True
+#                         session["user"] = request.form["username"]
 
-@app.route("/logout")
+#                 if not session.get("logged_in"):
-def logout():
+#                     flash("Mot de passe ou pseudo invalide.", "danger")
-    session['logged_in'] = False
+#                     return redirect(url_for("login"))
-    flash('Tu est déconnecté', 'info')
+#                 else:
-    return redirect(url_for('login'))
+#                     return redirect(url_for("display_index_page"))
+#             else:
+#                 flash("Incorrect logins")
+#                 return render_template("password.html")
+#         else:
+#             return render_template("password.html")
+#     else:
+#         return render_template("password.html")
+
+
+# @app.route("/logout")
+# def logout():
+#     session["logged_in"] = False
+#     flash("Tu est déconnecté", "info")
+#     return redirect(url_for("login"))

src/web.py

@@ -1,68 +1,115 @@
-from flask import Flask, request
+from flask import flash
 from werkzeug.utils import secure_filename
-from printer import Printer
 import time
 import os
+from task import TextTask, ImageTask, CutTask
+
 
 class Web(object):
-    """docstring for web."""
+    """Web is the class that gets all of the information from web calls
+     ( API and Web page ) and provides checks before sending stuff to printing"""
 
-    def __init__(self, app, printer ):
+    def __init__(self, app, print_queue):
         super(Web).__init__()
-        self.printer = printer
+        self.print_queue = print_queue
         self.app = app
 
-    def print_sms(self, texte, sign: str):
+    def print_sms(self, texte, sign: str) -> bool:
-        # TODO: verify the texte before printing it here ?
+        """
+        Get text and a signature, prints the text and cuts after that.
+        """
         self.app.logger.debug("Printing : " + str(texte) + " from " + str(sign))
-        if not os.getenv('LIPY_DEBUG'):
-            time.sleep(1)
 
-        return self.printer.print_sms(texte, sign)
-
-    def print_image(self, image, sign: str) -> bool:
-        self.app.logger.debug("Uploading file")
         try:
-            self.app.logger.debug("Uploading file from " + str(sign))
+            # We create two new tasks and add them directly to the queue
-            if self.upload_file(image):
+            # TODO: this might need to be improved because
-                self.app.logger.debug("File has been uploaded, printing...")
+            # !! there is no garantee !! that both the SMS task and the Cut task
-                self.printer.print_img(os.path.join(self.app.config['UPLOAD_FOLDER'], secure_filename(image.filename)), sign)
+            # are added back to back, another task could be
-                return True
+            # inserted between the two.
-            else:
+            sms = self.print_queue.enqueue(TextTask(content=texte, signature=sign))
-                return False
+            cut = self.print_queue.enqueue(CutTask())
         except Exception as e:
             self.app.logger.error(e)
-            raise Exception
+            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
 
-        else:
+    def print_image(self, image, sign: str) -> bool:
-            flash("Could not upload file.",'error')
+        """
-            return False
+        Get an image and a signature, prints the image and cuts after that.
+        """
+        try:
+            file_uploaded = self.upload_file(image)
+        except Exception as e:
+            self.app.logger.error(e)
+            raise RuntimeError("Could not upload file") from e
 
-    def login(username: str,password: str) -> bool:
+        if file_uploaded:
-        pass
+            self.app.logger.debug("File has been uploaded, printing...")
+            try:
+                img = self.print_queue.enqueue(
+                    ImageTask(
+                        os.path.join(
+                            self.app.config["UPLOAD_FOLDER"],
+                            secure_filename(image.filename),
+                        ),
+                        signature=sign,
+                        process=True,
+                    )
+                )
 
-    def logout(username: str, password: str) -> bool:
+                cut = self.print_queue.enqueue(CutTask())
-        pass
+            except Exception as e:
+                raise RuntimeError("Could not add IMG to queue" + str(e)) from e
+
+            self.app.logger.info("Added two new tasks at position %s and %s", img, cut)
+
+        return True
+
+    def login(self, username: str, password: str) -> bool:
+        """Not implemented"""
+        return
+
+    def logout(self, username: str, password: str) -> bool:
+        """Not implemented"""
+        return
 
     def allowed_file(self, filename) -> bool:
         self.app.logger.debug("Is the filename allowed ?")
-        return '.' in filename and filename.rsplit('.', 1)[1].lower() in self.app.config['ALLOWED_EXTENSIONS']
+        return (
+            "." in filename
+            and filename.rsplit(".", 1)[1].lower()
+            in self.app.config["ALLOWED_EXTENSIONS"]
+        )
 
-    def upload_file(self, image)-> bool:
+    def upload_file(self, image) -> bool:
         self.app.logger.debug("Validating file")
-        if image and self.allowed_file(image.filename):
+        if image:
+            if self.allowed_file(image.filename):
                 filename = secure_filename(image.filename)
                 self.app.logger.debug("File valid")
                 try:
-                image.save(os.path.join(self.app.config['UPLOAD_FOLDER'], filename))
+                    image.save(os.path.join(self.app.config["UPLOAD_FOLDER"], filename))
-                self.app.logger.debug("File saved")
+                except OSError as e:
-            except Exception as e:
+                    self.app.logger.error("Could not save file %s", e)
-                self.app.logger.error("Could not save file")
-                flash(e,'error')
                     return False
 
-            self.app.logger.debug("File saved to " + str(os.path.join(self.app.config['UPLOAD_FOLDER'], filename)))
+                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 " + str(filename))
+                self.app.logger.error(
+                    "Could not save file because the filename is forbidden"
+                )
                 return False
+        else:
+            self.app.logger.error(
+                "Could not save file, it seems to be null ? : " + str(filename)
+            )
+            return False
+
+    def get_queue_state(self):
+        """Return current queue state"""
+        return self.print_queue.get_queue_state()

src/worker.py

@@ -0,0 +1,107 @@
+# This is the main printing thread
+# As explained in the task file, this is where we command
+# printing to happen.
+
+import threading
+import time
+
+
+class PrintWorker(threading.Thread):
+    def __init__(self, app, print_queue, printer, socketio=None):
+        super().__init__(daemon=True)
+        self.app = app
+        self.print_queue = print_queue
+        self.printer = printer
+        self.socketio = socketio  # Optional
+        self.running = True
+        self.state = "idle"  # idle, printing, dead, drinking-a-beer
+
+        self.app.logger.debug("Ho great, I'm alive... I'm ready to work another day...")
+
+    def run(self):
+        """Background thread that processes queue items"""
+        self.app.logger.info("Worker started working.")
+        while True:
+            if not self.running or not self.printer.ready:
+                time.sleep(0.2)
+                continue
+
+            try:
+                task = self.print_queue.dequeue()
+            except Exception as e:
+                self.app.logger.error("Could not get a new task ! %s ", str(e))
+                raise RuntimeError(
+                    "We could not get a new task because " + str(e)
+                ) from e
+
+            if task:
+                try:
+                    self.app.logger.info("Got a new task")
+                    self.app.logger.debug("Got task %s", task.task_id)
+                    self.state = "printing"
+                    task.status = "processing"
+                    self._emit_status(task.task_id, "processing")
+
+                    print_data = task.get_print_data()
+                    try:
+                        self.printer.print_task(task.task_type, print_data)
+                    except RuntimeError as e:
+                        self.app.logger.error("Could not print : %s", str(e))
+                        raise e
+
+                    task.status = "completed"
+                    self.print_queue.mark_completed(task.task_id, "completed")
+                    self._emit_status(task.task_id, "completed")
+
+                except RuntimeError as e:
+                    task.status = "failed"
+                    self.print_queue.mark_completed(task.task_id, "failed")
+                    self._emit_status(task.task_id, "failed", error=str(e))
+                    print(f"Print task {task.task_id} failed: {e}")
+            else:
+                # When they are no new tasks to handle, we put the thread to sleep.
+                self.state = "idle"
+                time.sleep(0.1)
+
+    def _emit_status(self, task_id, status, error=None):
+        """Emit status update via Socket.IO if available"""
+        if not self.socketio:
+            return
+
+        room = f"task_{task_id}"
+        data = {
+            "task_id": task_id,
+            "status": status,
+            "position": None,  # Task no longer in queue
+        }
+
+        if error:
+            data["error"] = error
+
+        self.socketio.emit("task_status", data, room=room)
+
+    def stop_worker(self):
+        """
+        Give the worker a break
+        """
+        self.app.logger.debug("Giving the worker a break")
+        self.state = "drinking-a-beer"
+        self.running = False
+
+    def start_worker(self):
+        """
+        Get the worker back to it
+        """
+        self.app.logger.debug("Time to work !")
+        self.state = "idle"
+        self.running = True
+
+    def current_state(self):
+        """
+        Return the worker state
+        """
+        return {
+            "is_running": self.running,
+            "queue_size": len(self.print_queue),
+            "state": self.state,
+        }