odoo-driver 0.9.6__py3-none-any.whl

odoo_driver/__init__.py

@@ -0,0 +1,5 @@
+from pathlib import Path
+
+from single_source import get_version
+
+__version__ = get_version(__name__, Path(__file__).parent.parent)

odoo_driver/app.py

@@ -0,0 +1,29 @@
+from flask import Flask, request
+from flask_babel import Babel
+from flask_cors import CORS
+
+# Initialize Flask Application
+app = Flask(__name__)
+
+# Include extra route files
+from . import flask_app  # noqa: F401,E402
+
+# Handle CORS call
+CORS(app, resources={r"/*": {"origins": "*"}})
+
+# Handle translation via babel
+app.config["BABEL_DEFAULT_LOCALE"] = "en"
+babel = Babel(app)
+
+
+def get_locale():
+    # Use the browser's language preferences to select an available translation
+    available_translations = [
+        str(translation) for translation in babel.list_translations()
+    ]
+    for lang in request.accept_languages.values():
+        if lang[:2] in available_translations:
+            return lang[:2]
+
+
+babel.init_app(app, locale_selector=get_locale)

odoo_driver/cli.py

@@ -0,0 +1,121 @@
+import logging
+import os
+import sys
+from pathlib import Path
+
+import click
+import importlib_resources
+import simplejson
+from click_loglevel import LogLevel
+from gevent import pywsgi
+from geventwebsocket.handler import WebSocketHandler
+from loguru import logger
+
+import odoo_driver
+
+from .app import app
+from .interface import interface
+
+# Define loguru specific level for logging
+# to make click_loglevel working
+logging.addLevelName(5, "TRACE")
+logging.addLevelName(25, "SUCCESS")
+
+
+@click.command()
+@click.option(
+    "-a",
+    "--address",
+    type=click.STRING,
+    default="0.0.0.0",
+    show_default=True,
+    help="Address on which the web service will be exposed",
+)
+@click.option(
+    "-p",
+    "--port",
+    type=click.INT,
+    default=8069,
+    show_default=True,
+    help="Port on which the web service will be exposed",
+)
+@click.option(
+    "--secure/--unsecure",
+    default=True,
+    show_default=True,
+    help="Option 'secure' exposes web service on https."
+    " Option 'unsecure' exposes web service on http.",
+)
+@click.option(
+    "-r",
+    "--refresh-devices-delay",
+    type=click.INT,
+    default=1,
+    show_default=True,
+    help="Interval in seconds between two device refreshes",
+)
+@click.option(
+    "--options",
+    type=click.STRING,
+    default="{}",
+    show_default=True,
+    help="""Extra JSON options to pass to devices. Exemple:"
+    " --options '{"scale": {"polynomial": "123456"}}'
+    """,
+)
+@click.option(
+    "-l",
+    "--log-level",
+    type=LogLevel(extra=["TRACE", "SUCCESS"]),
+    default="INFO",
+    show_default=True,
+)
+@click.option(
+    "-f",
+    "--log-folder",
+    type=click.Path(
+        exists=True, file_okay=False, writable=True, resolve_path=True, path_type=Path
+    ),
+    show_default=True,
+)
+@click.version_option(version=odoo_driver.__version__)
+def main(log_level, address, port, refresh_devices_delay, secure, log_folder, options):
+    logger.success("Lauching odoo-driver ...")
+
+    logger.info(f"Application Path: {os.path.abspath(__file__)}")
+
+    # Log Configuration
+    # remove first default sink that is defined to 'INFO'
+    logger.remove()
+
+    # Add stdout logger
+    logger.add(sys.stderr, level=log_level)
+
+    # Add file logger
+    if log_folder:
+        log_path = log_folder / "odoo-driver_{time}.log"
+        logger.info(f"Log Path: {log_path}")
+        logger.add(log_path, level=log_level, rotation="1 week", enqueue=True)
+
+    # Initialize Interface
+    interface.initialize(
+        refresh_devices_delay=refresh_devices_delay,
+        options=simplejson.loads(options),
+        log_folder=log_folder,
+    )
+
+    kwargs = {"handler_class": WebSocketHandler}
+
+    # Handle HTTPS, if required
+    if secure:
+        cert_folder = importlib_resources.files("odoo_driver") / "default_cert"
+        server_key_path = cert_folder / "server.key"
+        server_cert_path = cert_folder / "server.crt"
+        kwargs.update({"keyfile": server_key_path, "certfile": server_cert_path})
+    http_server = pywsgi.WSGIServer((address, port), app, **kwargs)
+    prefix = secure and "https" or "http"
+    logger.success(
+        f"Serving odoo-driver (version: {odoo_driver.__version__})"
+        f" on {prefix}://{address}:{port} ..."
+    )
+    http_server.serve_forever()

odoo_driver/default_cert/server.crt

@@ -0,0 +1,22 @@
+-----BEGIN CERTIFICATE-----
+MIIDmTCCAoGgAwIBAgIUSJxXt4mpzmWmDHxjeN9/0l4TBJAwDQYJKoZIhvcNAQEL
+BQAwXDELMAkGA1UEBhMCRlIxHTAbBgNVBAgMFEF1dmVyZ25lIFJob25lLUFscGVz
+MQ0wCwYDVQQHDARMeW9uMQ0wCwYDVQQKDARHUkFQMRAwDgYDVQQLDAdJVCBUZWFt
+MB4XDTI0MDgxMjE0Mzc0OVoXDTI1MDgxMjE0Mzc0OVowXDELMAkGA1UEBhMCRlIx
+HTAbBgNVBAgMFEF1dmVyZ25lIFJob25lLUFscGVzMQ0wCwYDVQQHDARMeW9uMQ0w
+CwYDVQQKDARHUkFQMRAwDgYDVQQLDAdJVCBUZWFtMIIBIjANBgkqhkiG9w0BAQEF
+AAOCAQ8AMIIBCgKCAQEA1vrN9ArLWLgsySqqGuGLiU7sWG3MWpC1YHtiCf9LEOlq
+gsmWQpkeUGb0qni6VsoT9M3sSNFS7TX0kmjEu5pE84IHmuWIvQoferl/PQWIqr7p
+A3YTH9RxHQuII59LxfKzehfuZ+85CPYBOlSuLdovkd1+nm9ZcbyLotSeZ/G1JuTC
+Gjg6JhbvHHh6oC8o1rqY2V+T5HgXTBqjHAogD14CMJVkQ7HbeNEQ3JfhyWgfBT6U
+QYJkXcfZ4vI7TCZ8PiHMheoA4O3kIPzxogBwAxnNSs/T6LjkvXfNHVMLsfFrVY+h
+wBbQz2QNbkSKLVrc+JRFBRqZWkvILqBcDsqKlvD+bwIDAQABo1MwUTAdBgNVHQ4E
+FgQUtjczAx17jhbwMAPDpbGa1dQ8Im8wHwYDVR0jBBgwFoAUtjczAx17jhbwMAPD
+pbGa1dQ8Im8wDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAQz3v
+7Y1gOkYTcogihzczC5yXUCDOUDnQluUweTnFiNy4bSlD2DuOMvC8eC2eCZesRUwp
+RPcwFQ9RwhNtVI0j+K1Ta5+R43J1ynjFWNed1UFo3oYv0WqeHon+W82mBQZ+x2Hn
+fD98vRBxh0Kch9L00T2mpL2059uSM/CF2C/gXrFGLin9WXYdwjlvtuX2uTr20XzO
+Xl9Tgumvqxvq3SqA68TBYtvpVRXAIgAkCOJLfH7GBKbqUg0dasrGB6MrOePUCyZn
+xDTosZI9fyf0hNB6SdsbSYCd1c+zfh6/WwjMiUqQpNGecBB2i14nHFgQKg6qy8Fk
+mnOKX0WobzE+IsJmbw==
+-----END CERTIFICATE-----

odoo_driver/default_cert/server.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQDW+s30CstYuCzJ
+Kqoa4YuJTuxYbcxakLVge2IJ/0sQ6WqCyZZCmR5QZvSqeLpWyhP0zexI0VLtNfSS
+aMS7mkTzggea5Yi9Ch96uX89BYiqvukDdhMf1HEdC4gjn0vF8rN6F+5n7zkI9gE6
+VK4t2i+R3X6eb1lxvIui1J5n8bUm5MIaODomFu8ceHqgLyjWupjZX5PkeBdMGqMc
+CiAPXgIwlWRDsdt40RDcl+HJaB8FPpRBgmRdx9ni8jtMJnw+IcyF6gDg7eQg/PGi
+AHADGc1Kz9PouOS9d80dUwux8WtVj6HAFtDPZA1uRIotWtz4lEUFGplaS8guoFwO
+yoqW8P5vAgMBAAECggEAbUQgte9el4NU0BJtTyhgIbQJkJCOE2IFrjpIBEjLwJbC
+2iLXypXEwJzzskmWfFJNflnDxOcPvR11Z4z0oV2xugrXDrWnoF2qzlfGAh/z7MUH
+7ghvg/gYXejkkyZ9/uhyrJXJSO5gENvol9s+hHOnRf5MQv7ZeWOZnXNv5+kEZ/Vi
+lAszy/oxj6kJOcjbeE3E2vNS1Yn9RC1GrGLl/UYTPli6lFZvKylbFQ3i4HePXej7
+smreMu1BVHn6sr871dFqAyG9tW0hrYIUha+FYdgqU/lDhZLIzuxlKhwdxuuoBVDJ
+dmPBhzeENoHXjHJpNQ3PMmlaajfUDQWWC4Nr17aWEQKBgQD35yBKpitbvX81LZfq
+uU+djjDTiekdFfDjLO7wvhwihH1wJAaPFSmxzyinYie8Yhb0WHLhwfvmek06jlyM
+zcQxt09cIsy+hi1vxWdMt/JI5suJle98tN3rPvp9ZmstY0Ua/q2Q8/PL1y5QMJR/
+tH5b9xMmgPOrXX/5L47/thmkqwKBgQDeAGMVnC/m+ULEdxvxsqx/jbS1jo0sPfuN
+1+JfIm//VTAAcV9PJMx5dM+OpdKQACE7wlZZaqE7xr/odyFEei2OmTU8dV+LL2bN
+KjRvkXLFZH8TaaAWO4+w2OkC1/DM2zahcgrjlDutXqkMLilS7PDhWjPNYtVxlIHM
+QscZO8llTQKBgGqi6joSNq502iZm4WVfp0av5oLoXPVc/czLBFFchb+3XDoD1Spx
+QQkygltWFp+rVhJvhaNlDVV8IIJiwJ702ENGhgWtFoOSNjNRJ/lRWxBO7xjU/TqY
+lqld4uRUTSAuBojxKnoi5ik1+78U1pwEaSJoKr2yVJ7PToBDG/EVRPyXAoGAAVu9
+P3eaL26dAvi7mgn+1jT2wxmhMYEble2ZO/3I86YAyi/nZmOSQLf/QR8wn6LwkR4K
+SzfEzsnTiMeZ04Jv3ux/D+Sj9gUPOvgkI/6e1ihcQrElwp0QrwNUwaiyl35L4kcB
+XA0fJFts618o75H1k1tq77nIFo7TEH3kG/pqrA0CgYAofu2NLjwqyTwWlmv46eyb
+nLV1OXBIxGTRFeP1fqJN4b4iy/PsTt4cclRoO+oAFhVJp2/DyxO7hGToR2foA5w4
+sU/I9zFuaddmG9y3hey8i1gBRdeGRT0F/fEyEv6hZMXr7w4OVTVMsi3VW0m7NalK
+wqDKXF//CF6whZKdmOFmcQ==
+-----END PRIVATE KEY-----

odoo_driver/devices/__init__.py

@@ -0,0 +1,4 @@
+from .device_display import DeviceDisplay  # noqa: F401
+from .device_payment import DevicePayment  # noqa: F401
+from .device_printer import DevicePrinter  # noqa: F401
+from .device_scale import DeviceScale  # noqa: F401

odoo_driver/devices/device_display.py

@@ -0,0 +1,147 @@
+from flask_babel import gettext as _
+from loguru import logger
+
+from .models.device_abstract_with_queue import DeviceAbstractWithQueue
+from .tools.serial_code import FF, US
+
+
+class DeviceDisplay(DeviceAbstractWithQueue):
+    use_serial = True
+    device_type = "display"
+
+    @logger.catch
+    def _process_task_serial(self, serial, task):
+        lines_ascii = self._convert_task_to_ascii_lines(task)
+
+        self._clear_screen(serial)
+
+        for row, text in enumerate(lines_ascii, 1):
+            self._position_cursor(serial, 1, row)
+            self._send_message(serial, [text])
+
+    def _convert_task_to_ascii_lines(self, task):
+        lines_ascii = []
+
+        action = task.data["action"]
+
+        if action == "display_lines":
+            for line in task.data["text_lines"]:
+                lines_ascii.append(line)
+
+        elif action in [
+            "add_line",
+            "update_quantity",
+            "update_unit_price",
+            "update_discount",
+        ]:
+            # First Line
+            left_part = task.data.get("product_name")
+            right_part = self._prepare_percent(task.data.get("discount"))
+            line_1 = self._prepare_line(left_part, right_part)
+
+            # Second Line Line
+            left_part = (
+                self._prepare_qty(task.data.get("quantity"))
+                + "×"
+                + self._prepare_price(task.data.get("unit_price"))
+            )
+            right_part = self._prepare_price(task.data.get("total"))
+            line_2 = self._prepare_line(left_part, right_part)
+
+            lines_ascii = [line_1, line_2]
+
+        elif action == "remove_line":
+            lines_ascii = [
+                _("Deleting Line ..."),
+                self._prepare_line(task.data.get("product_name")),
+            ]
+
+        elif action == "payment_balance":
+            total = task.data.get("total")
+            total_paid = task.data.get("total_paid")
+            total_due = task.data.get("total_due")
+            total_to_pay = total - total_paid
+            line_1 = self._prepare_line(_("Total:"), self._prepare_price(total))
+            line_2 = ""
+            if total_paid != 0.0:
+                if total_to_pay > 0:
+                    line_2 = self._prepare_line(
+                        _("To Pay:"), self._prepare_price(total_to_pay)
+                    )
+                elif total_due < 0:
+                    line_2 = self._prepare_line(
+                        _("Change:"), self._prepare_price(-total_due)
+                    )
+            lines_ascii = [line_1, line_2]
+
+        else:
+            raise NotImplementedError(
+                f"{action} is not a valid action for the Display device."
+            )
+
+        return lines_ascii
+
+    def _clear_screen(self, serial):
+        self._send_message(serial, [FF], "Clear Screen")
+
+    def _position_cursor(self, serial, col=1, row=1):
+        self._send_message(
+            serial, [US, chr(36), chr(col), chr(row)], f"Move to col {col} / row {row}"
+        )
+
+    def _send_message(self, serial, message_list, action_description=""):
+        message_list = [x for x in message_list if x]
+        if not message_list:
+            return
+        message = b"".join([x.encode("cp858", errors="ignore") for x in message_list])
+        if action_description:
+            logger.debug(
+                f"Display: {action_description} with the message {message} ..."
+            )
+
+        serial.write(message)
+
+    def _display_float(self, float_repr, reduce_txt=True, suffix=""):
+        if reduce_txt:
+            while float_repr:
+                if float_repr[-1:] == "0":
+                    float_repr = float_repr[:-1]
+                else:
+                    break
+            if float_repr[-1:] == ".":
+                float_repr = float_repr[:-1]
+        return float_repr.replace(".", ",") + suffix
+
+    def _prepare_percent(self, percent):
+        try:
+            percent = float(percent)
+        except ValueError:
+            return ""
+        except TypeError:
+            return ""
+        if not percent:
+            return ""
+        return self._display_float("-{:.1f}".format(percent), suffix="%")
+
+    def _prepare_qty(self, quantity):
+        try:
+            quantity = float(quantity)
+        except ValueError:
+            quantity = 0.0
+        return self._display_float("{:.3f}".format(quantity))
+
+    def _prepare_price(self, price):
+        try:
+            price = float(price)
+        except ValueError:
+            price = 0.0
+        return self._display_float("{:.2f}".format(price), reduce_txt=False, suffix="€")
+
+    def _prepare_line(self, left_part, right_part=""):
+        result = left_part[:20].ljust(20, " ")
+        if right_part:
+            right_part = right_part[-20:]
+            result = result[0 : (20 - 1 - len(right_part))]
+            result += " " + right_part
+
+        return result

odoo_driver/devices/device_payment.py

@@ -0,0 +1,20 @@
+from telium import Telium, TeliumAsk
+
+from .models.device_abstract import DeviceAbstract
+
+
+class DevicePayment(DeviceAbstract):
+    device_type = "payment"
+
+    def push_amount(self, amount, currency_iso):
+        if not self.terminal_file:
+            return False
+        telium = Telium(self.terminal_file)
+        payment = TeliumAsk.new_payment(
+            amount,
+            payment_mode="debit",
+            target_currency=currency_iso,
+        )
+        result = telium.ask(payment)
+        telium.close()
+        return result

odoo_driver/devices/device_printer.py

@@ -0,0 +1,25 @@
+import base64
+from io import BytesIO
+
+from escpos.printer import Usb
+from PIL import Image
+
+from .models.device_abstract_with_queue import DeviceAbstractWithQueue
+
+
+class DevicePrinter(DeviceAbstractWithQueue):
+    device_type = "printer"
+
+    def _process_task(self, task):
+        printer = Usb(self._usb_device.idVendor, self._usb_device.idProduct, 0)
+        (action, value) = task.data
+
+        if action == "print":
+            im = Image.open(BytesIO(base64.b64decode(value)))
+            printer.image(im)
+            printer.cut()
+
+        elif action == "open_cashbox":
+            printer.cashdraw(2)
+
+        printer.close()

odoo_driver/devices/device_scale.py

@@ -0,0 +1,34 @@
+from .models.device_abstract import DeviceAbstract
+from .scale_dialog06 import state_machine
+
+
+class DeviceScale(DeviceAbstract):
+    device_type = "scale"
+
+    def __init__(self, interface, options):
+        DeviceAbstract.__init__(self, interface, options)
+        self.last_weight = 0.0
+
+    def read_weight(self, unit_price, tare):
+        with self._get_serial() as serial:
+            sm = state_machine.Dialog06Machine(
+                serial,
+                self.get_option("polynomial", int, required=True),
+                unit_price,
+                tare,
+            )
+
+            while not sm.current_state.final:
+                sm.continue_communication()
+
+        # In a dialog06 context, if the scale return 21 (no change since the last weight)
+        # The scale doesn't provide the weight.
+        # in that 'valid use case', we return the last weight
+        if sm.last_scale_answer.error_number != "21":
+            self.last_weight = sm.last_scale_answer.weight
+
+        return {
+            "weight": self.last_weight,
+            "error_number": sm.last_scale_answer.error_number,
+            "error_description": sm.last_scale_answer.error_description,
+        }

odoo_driver/devices/models/device_abstract.py

@@ -0,0 +1,115 @@
+import serial.tools.list_ports
+from flask_babel import gettext as _
+from loguru import logger
+from serial import Serial
+
+from ...usb_device import usb_device_tools
+
+
+class DeviceAbstract:
+    has_queue = False
+    use_serial = False
+    device_type = False
+
+    def __init__(self, interface, options):
+        self._interface = interface
+        self._usb_device = False
+        self.usb_device_name = False
+        self.terminal_file = False
+        self._usb_image_name = False
+        self._options = options
+
+    def get_option(self, option_name, option_type, required=False):
+        option = self._options.get(option_name, False)
+        if required and not option:
+            raise Exception(
+                f"{option_name} is required for the device {self.device_type}."
+            )
+        return option_type(option)
+
+    @property
+    def name(self):
+        if self.device_type == "display":
+            return _("Display")
+        elif self.device_type == "printer":
+            return _("Printer")
+        elif self.device_type == "payment":
+            return _("Payment Terminal")
+        elif self.device_type == "scale":
+            return _("Scale")
+        return "N/C"
+
+    @property
+    def usb_vendor_product_code(self):
+        return usb_device_tools.get_device_id_vendor_id_product(self._usb_device)
+
+    @property
+    def usb_serial_number(self):
+        return usb_device_tools.get_device_serial_number(self._usb_device)
+
+    @property
+    def usb_manufacturer(self):
+        return usb_device_tools.get_device_manufacturer(self._usb_device)
+
+    @property
+    def usb_product_name(self):
+        return usb_device_tools.get_device_product(self._usb_device)
+
+    @property
+    def is_connected(self):
+        return bool(self._usb_device)
+
+    @property
+    def disconnections(self):
+        return self._interface.disconnections.get(self.usb_vendor_product_code, [])
+
+    @property
+    def disconnections_qty(self):
+        return len(self.disconnections)
+
+    @property
+    def usb_image_name(self):
+        return self._usb_image_name or f"{self.device_type}.png"
+
+    # ###########################
+    # Device Section
+    # ###########################
+    def set_usb_device(self, usb_device, extra_info):
+        self._usb_device = usb_device
+        self.usb_device_name = extra_info.get("name", False)
+        self._usb_image_name = extra_info.get("image")
+        connected_comports = [x for x in serial.tools.list_ports.comports()]
+        for port in connected_comports:
+            if (port.vid, port.pid) == (
+                usb_device.idVendor,
+                usb_device.idProduct,
+            ):
+                self.terminal_file = port.device
+                self._logger("DEBUG", f"Terminal File found: {self.terminal_file}.")
+                break
+        if not self.terminal_file:
+            self._logger("DEBUG", "Terminal File not found.")
+
+    def remove_usb_device(self):
+        self._usb_device = False
+        self.usb_device_name = False
+        self._usb_image_name = False
+        self.terminal_file = False
+
+    def _get_serial(self):
+        if not self.terminal_file:
+            raise Exception(
+                "Unable to open a Serial connexion,"
+                " because terminal_file is not defined."
+            )
+        return Serial(self.terminal_file, 9600, timeout=0.05)
+
+    # ###########################
+    # Loggging Section
+    # ###########################
+    def _logger(self, level, message):
+        if self._usb_device:
+            extra_info = f" ({self.usb_device_name} - {self.usb_vendor_product_code})"
+        else:
+            extra_info = ""
+        logger.log(level, f"Device '{self.device_type}'{extra_info}: {message}")

odoo_driver/devices/models/device_abstract_with_queue.py

@@ -0,0 +1,84 @@
+import time
+from queue import Queue
+from threading import Thread
+
+from .device_abstract import DeviceAbstract
+from .device_task import DeviceTask
+
+
+class DeviceAbstractWithQueue(DeviceAbstract, Thread):
+    has_queue = True
+
+    def __init__(self, interface, options, delay=0, max_queue_size=0):
+        """Initialize a new Device.
+        delay: time between processing two messages, in seconds.
+        """
+        DeviceAbstract.__init__(self, interface, options)
+        Thread.__init__(self)
+        self.errored_tasks = []
+        self._queue = Queue(max_queue_size)
+        self.delay = delay
+
+    @property
+    def queue_size(self):
+        return self._queue.qsize()
+
+    @property
+    def max_queue_size(self):
+        return self._queue.maxsize
+
+    @property
+    def errored_tasks_qty(self):
+        return len(self.errored_tasks)
+
+    # ###########################
+    # Thread / Task Section
+    # ###########################
+    def run(self):
+        while True:
+            if self._usb_device:
+                current_size = self._queue.qsize()
+                if current_size:
+                    self._logger("INFO", f"Process one of the {current_size} task(s).")
+                else:
+                    self._logger("INFO", "Waiting for message ...")
+                task = self._queue.get(True)
+                self._process_task_abstract(task)
+                time.sleep(self.delay)
+            else:
+                time.sleep(1)
+
+    def _process_task_abstract(self, task):
+        self._logger("DEBUG", f"Processing task {task.uuid} ...")
+        try:
+            if self.use_serial:
+                with self._get_serial() as serial:
+                    self._process_task_serial(serial, task)
+            else:
+                self._process_task(task)
+            if task in self.errored_tasks:
+                self.errored_tasks.remove(task)
+            self._logger("SUCCESS", f"Task processed. UUID: {task.uuid}.")
+
+        except Exception as e:
+            self._logger("ERROR", f"Task {task.uuid}. Error{e}")
+            task.error = e
+            if task not in self.errored_tasks:
+                self._logger("INFO", f"Reenqueing task. UUID: {task.uuid} ...")
+                self.errored_tasks.append(task)
+                self._queue.put(task)
+            if self._usb_device:
+                self._interface._hook_usb_device_removed(self._usb_device, e)
+
+    def add_task(self, data):
+        if self.max_queue_size:
+            while self._queue.qsize() >= self._queue.maxsize:
+                self._logger("WARNING", "Removing obsolete task in queue.")
+                self._queue.get_nowait()
+        task = DeviceTask(data)
+        self._queue.put(task)
+        self._logger(
+            "INFO",
+            f"Task Enqueued ({self._queue.qsize()}/{self._queue.maxsize})."
+            f" UUID: {task.uuid}",
+        )

odoo_driver/devices/models/device_task.py

@@ -0,0 +1,10 @@
+import uuid
+from datetime import datetime
+
+
+class DeviceTask:
+    def __init__(self, data):
+        self.create_date = datetime.now()
+        self.uuid = uuid.uuid4()
+        self.data = data
+        self.error = False