Machine integration

InvenTree/InvenTree/settings.py

@@ -196,6 +196,7 @@
     'stock.apps.StockConfig',
     'users.apps.UsersConfig',
     'plugin.apps.PluginAppConfig',
+    'machine.apps.MachineConfig',
     'InvenTree.apps.InvenTreeConfig',       # InvenTree app runs last
 
     # Core django modules

InvenTree/common/models.py

@@ -381,6 +381,12 @@ def get_setting_object(cls, key, **kwargs):
             filters['plugin'] = plugin
             kwargs['plugin'] = plugin
 
+        # Filter by machine
+        machine = kwargs.get('machine', None)
+
+        if machine is not None:
+            filters['machine'] = machine
+
         # Filter by method
         method = kwargs.get('method', None)
 
@@ -497,6 +503,7 @@ def set_setting(cls, key, value, change_user, create=True, **kwargs):
 
         user = kwargs.get('user', None)
         plugin = kwargs.get('plugin', None)
+        machine = kwargs.get('machine', None)
 
         if user is not None:
             filters['user'] = user
@@ -509,6 +516,9 @@ def set_setting(cls, key, value, change_user, create=True, **kwargs):
             else:
                 filters['plugin'] = plugin
 
+        if machine is not None:
+            filters['machine'] = machine
+
         try:
             setting = cls.objects.get(**filters)
         except cls.DoesNotExist:
@@ -629,13 +639,17 @@ def validate_unique(self, exclude=None, **kwargs):
 
         user = getattr(self, 'user', None)
         plugin = getattr(self, 'plugin', None)
+        machine = getattr(self, 'machine', None)
 
         if user is not None:
             filters['user'] = user
 
         if plugin is not None:
             filters['plugin'] = plugin
 
+        if machine is not None:
+            filters['machine'] = machine
+
         try:
             # Check if a duplicate setting already exists
             setting = self.__class__.objects.filter(**filters).exclude(id=self.id)

InvenTree/machine/admin.py

@@ -0,0 +1,44 @@
+from django import forms
+from django.contrib import admin
+from django.utils.translation import gettext_lazy as _
+
+from machine import models
+from machine.registry import registry
+
+
+class MachineAdminForm(forms.ModelForm):
+    def get_machine_type_choices():
+        return [(machine_type.SLUG, machine_type.NAME) for machine_type in registry.machine_types.values()]
+
+    def get_driver_choices():
+        return [(driver.SLUG, driver.NAME) for driver in registry.drivers.values()]
+
+    # TODO: add conditional choices like shown here
+    # Ref: https://www.reddit.com/r/django/comments/18cj55/conditional_choices_for_model_field_based_on/
+    # Ref: https://gist.github.com/blackrobot/4956070
+    driver_key = forms.ChoiceField(label=_("Driver"), choices=get_driver_choices)
+    machine_type_key = forms.ChoiceField(label=_("Machine Type"), choices=get_machine_type_choices)
+
+
+class MachineSettingInline(admin.TabularInline):
+    """Inline admin class for MachineSetting."""
+
+    model = models.MachineSetting
+
+    read_only_fields = [
+        'key',
+    ]
+
+    def has_add_permission(self, request, obj):
+        """The machine settings should not be meddled with manually."""
+        return False
+
+
+@admin.register(models.Machine)
+class MachineAdmin(admin.ModelAdmin):
+    """Custom admin with restricted id fields."""
+
+    form = MachineAdminForm
+    list_filter = ["active"]
+    list_display = ["name", "machine_type_key", "driver_key", "active", "is_driver_available", "no_errors"]
+    inlines = [MachineSettingInline]

InvenTree/machine/apps.py

@@ -0,0 +1,23 @@
+import logging
+
+from django.apps import AppConfig
+
+from InvenTree.ready import canAppAccessDatabase
+from plugin import registry as plg_registry
+
+logger = logging.getLogger('inventree')
+
+
+class MachineConfig(AppConfig):
+    name = 'machine'
+
+    def ready(self) -> None:
+        """Initialization method for the Machine app."""
+        if not canAppAccessDatabase(allow_test=True) or plg_registry.is_loading:
+            logger.info("Skipping machine loading sequence")
+            return
+
+        from machine.registry import registry
+
+        logger.info("Loading InvenTree machines")
+        registry.initialize()

InvenTree/machine/base_drivers/BaseLabelPrintingDriver.py

@@ -0,0 +1,23 @@
+from django.utils.translation import gettext_lazy as _
+
+from machine.driver import BaseDriver, BaseMachineType
+
+
+class BaseLabelPrintingDriver(BaseDriver):
+    """Base label printing driver."""
+
+    def print_label():
+        """This function must be overriden."""
+        raise NotImplementedError("The `print_label` function must be overriden!")
+
+    def print_labels():
+        """This function must be overriden."""
+        raise NotImplementedError("The `print_labels` function must be overriden!")
+
+
+class LabelPrintingMachineType(BaseMachineType):
+    SLUG = "label_printer"
+    NAME = _("Label Printer")
+    DESCRIPTION = _("Label printer used to print labels")
+
+    base_driver = BaseLabelPrintingDriver

InvenTree/machine/base_drivers/__init__.py

@@ -0,0 +1,6 @@
+from machine.base_drivers.BaseLabelPrintingDriver import \
+    BaseLabelPrintingDriver
+
+__all__ = [
+    "BaseLabelPrintingDriver",
+]

InvenTree/machine/driver.py

@@ -0,0 +1,52 @@
+from typing import Dict
+
+
+class BaseDriver:
+    """Base class for machine drivers
+
+    Attributes:
+        SLUG: Slug string for identifying a machine
+        NAME: User friendly name for displaying
+        DESCRIPTION: Description of what this driver does (default: "")
+    """
+
+    SLUG: str
+    NAME: str
+    DESCRIPTION: str = ""
+
+    # Import only for typechecking
+    from typing import TYPE_CHECKING
+    if TYPE_CHECKING:
+        from machine.models import Machine
+    else:  # pragma: no cover
+        class Machine:
+            pass
+
+    # TODO: add better typing
+    MACHINE_SETTINGS: Dict[str, dict]
+
+    def init_machine(self, machine: Machine):
+        """This method get called for each active machine using that driver while initialization
+
+        Arguments:
+            machine: Machine instance
+        """
+        pass
+
+
+class BaseMachineType:
+    """Base class for machine types
+
+    Attributes:
+        SLUG: Slug string for identifying a machine type
+        NAME: User friendly name for displaying
+        DESCRIPTION: Description of what this machine type can do (default: "")
+
+        base_driver: Reference to the base driver for this machine type
+    """
+
+    SLUG: str
+    NAME: str
+    DESCRIPTION: str = ""
+
+    base_driver: BaseDriver

InvenTree/machine/migrations/0001_initial.py

@@ -0,0 +1,37 @@
+# Generated by Django 3.2.19 on 2023-05-14 18:39
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Machine',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(help_text='Name of machine', max_length=255, unique=True, verbose_name='Name')),
+                ('machine_type_key', models.CharField(help_text='Type of machine', max_length=255, verbose_name='Machine Type')),
+                ('driver_key', models.CharField(help_text='Driver used for the machine', max_length=255, verbose_name='Driver')),
+                ('active', models.BooleanField(default=True, help_text='Machines can be disabled', verbose_name='Active')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='MachineSetting',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('key', models.CharField(help_text='Settings key (must be unique - case insensitive)', max_length=50)),
+                ('value', models.CharField(blank=True, help_text='Settings value', max_length=200)),
+                ('machine', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='settings', to='machine.machine', verbose_name='Machine')),
+            ],
+            options={
+                'unique_together': {('machine', 'key')},
+            },
+        ),
+    ]

InvenTree/machine/models.py

@@ -0,0 +1,146 @@
+from typing import Any
+
+from django.contrib import admin
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+
+import common.models
+from machine.registry import registry
+
+
+class Machine(models.Model):
+    """A Machine objects represents a physical machine."""
+
+    name = models.CharField(
+        unique=True,
+        max_length=255,
+        verbose_name=_("Name"),
+        help_text=_("Name of machine")
+    )
+
+    machine_type_key = models.CharField(
+        max_length=255,
+        verbose_name=_("Machine Type"),
+        help_text=_("Type of machine"),
+    )
+
+    driver_key = models.CharField(
+        max_length=255,
+        verbose_name=_("Driver"),
+        help_text=_("Driver used for the machine")
+    )
+
+    active = models.BooleanField(
+        default=True,
+        verbose_name=_("Active"),
+        help_text=_("Machines can be disabled")
+    )
+
+    def __str__(self) -> str:
+        """String representation of a machine."""
+        return f"{self.name}"
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Override to set origignal state of the machine instance."""
+        super().__init__(*args, **kwargs)
+
+        self.errors = []
+
+        self.driver = registry.get_driver_instance(self.driver_key)
+        self.machine_type = registry.machine_types.get(self.machine_type_key, None)
+
+        if not self.driver:
+            self.errors.append(f"Driver '{self.driver_key}' not found")
+        if not self.machine_type:
+            self.errors.append(f"Machine type '{self.machine_type_key}' not found")
+        if self.machine_type and not isinstance(self.driver, self.machine_type.base_driver):
+            self.errors.append(f"'{self.driver.NAME}' is incompatibe with machine type '{self.machine_type.NAME}'")
+
+        if len(self.errors) > 0:
+            return
+
+        # TODO: add other init stuff here
+
+    @admin.display(boolean=True, description=_("Driver available"))
+    def is_driver_available(self) -> bool:
+        """Status if driver for machine is available"""
+        return self.driver is not None
+
+    @admin.display(boolean=True, description=_("Machine has no errors"))
+    def no_errors(self) -> bool:
+        """Status if machine has errors"""
+        return len(self.errors) == 0
+
+    def initialize(self):
+        """Machine initialitation function, gets called after all machines are loaded"""
+        if self.driver is None:
+            return
+
+        self.driver.init_machine(self)
+
+    def get_setting(self, key, cache=False):
+        """Return the 'value' of the setting associated with this machine.
+
+        Arguments:
+            key: The 'name' of the setting value to be retrieved
+            cache: Whether to use RAM cached value (default = False)
+        """
+        from machine.models import MachineSetting
+
+        return MachineSetting.get_setting(key, machine=self, cache=cache)
+
+    def set_setting(self, key, value, user=None):
+        """Set plugin setting value by key.
+
+        Arguments:
+            key: The 'name' of the setting to set
+            value: The 'value' of the setting
+            user: TODO: what is this doing?
+        """
+        from machine.models import MachineSetting
+
+        MachineSetting.set_setting(key, value, user, machine=self)
+
+
+class MachineSetting(common.models.BaseInvenTreeSetting):
+    """This models represents settings for individial machines."""
+
+    typ = "machine"
+
+    class Meta:
+        """Meta for MachineSetting."""
+        unique_together = [
+            ("machine", "key")
+        ]
+
+    machine = models.ForeignKey(
+        Machine,
+        related_name="settings",
+        verbose_name=_("Machine"),
+        on_delete=models.CASCADE
+    )
+
+    @classmethod
+    def get_setting_definition(cls, key, **kwargs):
+        """In the BaseInvenTreeSetting class, we have a class attribute named 'SETTINGS', which
+        is a dict object that fully defines all the setting parameters.
+
+        Here, unlike the BaseInvenTreeSetting, we do not know the definitions of all settings
+        'ahead of time' (as they are defined externally in the machine).
+
+        Settings can be provided by the caller, as kwargs['settings'].
+
+        If not provided, we'll look at the machine registry to see what settings this machine requires
+        """
+        if 'settings' not in kwargs:
+            machine: Machine = kwargs.pop('machine', None)
+            if machine:
+                kwargs['settings'] = getattr(machine.driver, "MACHINE_SETTINGS", {})
+
+        return super().get_setting_definition(key, **kwargs)
+
+    def get_kwargs(self):
+        """Explicit kwargs required to uniquely identify a particular setting object, in addition to the 'key' parameter."""
+        return {
+            'machine': self.machine,
+        }