machine_access_control 0.2.3__tar.gz → 0.4.0__tar.gz

{machine_access_control-0.2.3 → machine_access_control-0.4.0}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: machine_access_control
-Version: 0.2.3
+Version: 0.4.0
 Summary: Decatur Makers Machine Access Control package
-Home-page: https://github.com/jantman/machine_access_control
 License: MIT
+License-File: LICENSE
 Author: Jason Antman
 Author-email: jason@jasonantman.com
 Requires-Python: >=3.12,<4.0
@@ -12,18 +12,20 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: aiohttp (>=3.11.4,<4.0.0)
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: aiohttp (>=3.12.14,<4.0.0)
 Requires-Dist: asyncio (>=3.4.3,<4.0.0)
-Requires-Dist: filelock (>=3.15.4,<4.0.0)
+Requires-Dist: filelock (>=3.16.1,<4.0.0)
 Requires-Dist: humanize (>=4.11.0,<5.0.0)
 Requires-Dist: jsonschema (>=4.23.0,<5.0.0)
 Requires-Dist: prometheus-client (>=0.20.0,<0.21.0)
 Requires-Dist: quart (>=0.19.8,<0.20.0)
-Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: requests (>=2.32.4,<3.0.0)
 Requires-Dist: slack-bolt (>=1.21.3,<2.0.0)
 Requires-Dist: slack-sdk (>=3.33.5,<4.0.0)
 Project-URL: Changelog, https://github.com/jantman/machine_access_control/releases
 Project-URL: Documentation, https://github.com/jantman/machine_access_control
+Project-URL: Homepage, https://github.com/jantman/machine_access_control
 Project-URL: Repository, https://github.com/jantman/machine_access_control
 Description-Content-Type: text/x-rst
 

{machine_access_control-0.2.3 → machine_access_control-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "machine_access_control"
-version = "0.2.3"
+version = "0.4.0"
 description = "Decatur Makers Machine Access Control package"
 authors = ["Jason Antman <jason@jasonantman.com>"]
 license = "MIT"
@@ -25,13 +25,13 @@ Changelog = "https://github.com/jantman/machine_access_control/releases"
 [tool.poetry.dependencies]
 python = "^3.12"
 jsonschema = "^4.23.0"
-requests = "^2.32.3"
-filelock = "^3.15.4"
+requests = "^2.32.4"
+filelock = "^3.16.1"
 prometheus-client = "^0.20.0"
 quart = "^0.19.8"
 asyncio = "^3.4.3"
 slack-bolt = "^1.21.3"
-aiohttp = "^3.11.4"
+aiohttp = "^3.12.14"
 slack-sdk = "^3.33.5"
 humanize = "^4.11.0"
 
@@ -40,7 +40,7 @@ Pygments = ">=2.10.0"
 black = ">=21.10b0"
 coverage = {extras = ["toml"], version = ">=6.2"}
 darglint = ">=1.8.1"
-flake8 = ">=4.0.1"
+flake8 = ">=7.1.1"
 flake8-bandit = ">=2.1.2"
 flake8-bugbear = ">=21.9.2"
 flake8-docstrings = ">=1.6.0"
@@ -49,7 +49,7 @@ furo = ">=2021.11.12"
 isort = ">=5.10.1"
 mypy = ">=0.930"
 nox = ">=2024.4.15"
-nox-poetry = ">= 1.0.3"
+nox-poetry = ">= 1.2.0"
 pep8-naming = ">=0.12.1"
 pre-commit = ">=2.16.0"
 pre-commit-hooks = ">=4.1.0"
@@ -65,7 +65,7 @@ responses = "^0.25.3"
 types-requests = "^2.32.0.20240712"
 faker = "^26.3.0"
 pytest-html = "^4.1.1"
-poetry-plugin-export = "^1.8.0"
+poetry-plugin-export = "^1.9.0"
 freezegun = "^1.5.1"
 
 [tool.isort]

{machine_access_control-0.2.3 → machine_access_control-0.4.0}/src/dm_mac/models/machine.py

@@ -53,6 +53,18 @@ CONFIG_SCHEMA: Dict[str, Any] = {
                     "but log and display a warning if the "
                     "operator is not authorized.",
                 },
+                "always_enabled": {
+                    "type": "boolean",
+                    "description": "If set, machine is always enabled and "
+                    "does not require RFID authentication. "
+                    "Displays 'Always On' and relay is always "
+                    "on unless Oopsed or Locked.",
+                },
+                "alias": {
+                    "type": "string",
+                    "description": "Optional human-friendly alias for the machine. "
+                    "Used in Slack messages and logs instead of the machine name.",
+                },
             },
             "additionalProperties": False,
             "description": "Unique machine name, alphanumeric _ and - only.",
@@ -69,6 +81,8 @@ class Machine:
         name: str,
         authorizations_or: List[str],
         unauthorized_warn_only: bool = False,
+        always_enabled: bool = False,
+        alias: Optional[str] = None,
     ):
         """Initialize a new MachineState instance."""
         #: The name of the machine
@@ -78,6 +92,10 @@ class Machine:
         #: Whether to allow anyone to operate machine regardless of
         #: authorization, just logging/displaying a warning if unauthorized
         self.unauthorized_warn_only: bool = unauthorized_warn_only
+        #: Whether machine is always enabled without RFID authentication
+        self.always_enabled: bool = always_enabled
+        #: Optional human-friendly alias for the machine
+        self.alias: Optional[str] = alias
         #: state of the machine
         self.state: "MachineState" = MachineState(self)
 
@@ -135,6 +153,11 @@ class Machine:
             return
         await slack.log_unoops(self, source)
 
+    @property
+    def display_name(self) -> str:
+        """Return the display name for this machine (alias if present, else name)."""
+        return self.alias if self.alias else self.name
+
     @property
     def as_dict(self) -> Dict[str, Any]:
         """Return a dict representation of this machine."""
@@ -142,6 +165,8 @@ class Machine:
             "name": self.name,
             "authorizations_or": self.authorizations_or,
             "unauthorized_warn_only": self.unauthorized_warn_only,
+            "always_enabled": self.always_enabled,
+            "alias": self.alias,
         }
 
 
@@ -152,6 +177,7 @@ class MachinesConfig:
         """Initialize MachinesConfig."""
         logger.debug("Initializing MachinesConfig")
         self.machines_by_name: Dict[str, Machine] = {}
+        self.machines_by_alias: Dict[str, Machine] = {}
         self.machines: List[Machine] = []
         mdict: Dict[str, Any]
         mname: str
@@ -159,8 +185,16 @@ class MachinesConfig:
             mach: Machine = Machine(name=mname, **mdict)
             self.machines.append(mach)
             self.machines_by_name[mach.name] = mach
+            if mach.alias:
+                self.machines_by_alias[mach.alias] = mach
         self.load_time: float = time()
 
+    def get_machine(self, name_or_alias: str) -> Optional[Machine]:
+        """Get a machine by name or alias."""
+        return self.machines_by_name.get(name_or_alias) or self.machines_by_alias.get(
+            name_or_alias
+        )
+
     def _load_and_validate_config(self) -> Dict[str, Dict[str, Any]]:
         """Load and validate the config file."""
         config: Dict[str, Dict[str, Any]] = cast(
@@ -187,6 +221,8 @@ class MachineState:
 
     LOCKOUT_DISPLAY_TEXT: str = "Down for\nmaintenance"
 
+    ALWAYS_ON_DISPLAY_TEXT: str = "Always On"
+
     STATUS_LED_BRIGHTNESS: float = 0.5
 
     def __init__(self, machine: Machine, load_state: bool = True):
@@ -290,29 +326,37 @@ class MachineState:
     async def _handle_reboot(self) -> None:
         """Handle when the ESP32 (MCU) has rebooted since last checkin.
 
-        This logs out the current user if logged in and turns off the relay if
-        turned on.
+        This logs out the current user if logged in and resets the machine state.
+        For always-enabled machines, restores the always-on state.
         """
         logging.getLogger("AUTH").warning(
-            "Machine %s rebooted; resetting relay and RFID state", self.machine.name
+            "Machine %s rebooted; resetting relay and RFID state",
+            self.machine.display_name,
         )
         # locking handled in update()
-        self.relay_desired_state = False
         self.current_user = None
-        self.display_text = self.DEFAULT_DISPLAY_TEXT
-        self.status_led_rgb = (0.0, 0.0, 0.0)
-        self.status_led_brightness = 0.0
+        # Restore always-enabled state if applicable
+        if self.machine.always_enabled:
+            self.relay_desired_state = True
+            self.display_text = self.ALWAYS_ON_DISPLAY_TEXT
+            self.status_led_rgb = (0.0, 1.0, 0.0)
+            self.status_led_brightness = self.STATUS_LED_BRIGHTNESS
+        else:
+            self.relay_desired_state = False
+            self.display_text = self.DEFAULT_DISPLAY_TEXT
+            self.status_led_rgb = (0.0, 0.0, 0.0)
+            self.status_led_brightness = 0.0
         # log to Slack, if enabled
         slack: Optional["SlackHandler"] = current_app.config.get("SLACK_HANDLER")
         if not slack:
             # Slack integration is not enabled
             return
-        await slack.admin_log(f"Machine {self.machine.name} has rebooted.")
+        await slack.admin_log(f"Machine {self.machine.display_name} has rebooted.")
 
     def lockout(self) -> None:
         """Lock-out the machine."""
         logging.getLogger("OOPS").warning(
-            "Machine %s was locked out for maintenance.", self.machine.name
+            "Machine %s was locked out for maintenance.", self.machine.display_name
         )
         with self._lock:
             self.is_locked_out = True
@@ -325,19 +369,29 @@ class MachineState:
     def unlock(self) -> None:
         """Un-lock-out the machine."""
         logging.getLogger("OOPS").warning(
-            "Machine %s was removed from maintenance lock-out.", self.machine.name
+            "Machine %s was removed from maintenance lock-out.",
+            self.machine.display_name,
         )
         with self._lock:
             self.is_locked_out = False
-            self.relay_desired_state = False
             self.current_user = None
-            self.display_text = self.DEFAULT_DISPLAY_TEXT
-            self.status_led_rgb = (0.0, 0.0, 0.0)
-            self.status_led_brightness = 0.0
+            # Restore always-enabled state if applicable
+            if self.machine.always_enabled:
+                self.relay_desired_state = True
+                self.display_text = self.ALWAYS_ON_DISPLAY_TEXT
+                self.status_led_rgb = (0.0, 1.0, 0.0)
+                self.status_led_brightness = self.STATUS_LED_BRIGHTNESS
+            else:
+                self.relay_desired_state = False
+                self.display_text = self.DEFAULT_DISPLAY_TEXT
+                self.status_led_rgb = (0.0, 0.0, 0.0)
+                self.status_led_brightness = 0.0
 
     def oops(self, do_locking: bool = True) -> None:
         """Oops the machine."""
-        logging.getLogger("OOPS").warning("Machine %s was Oopsed.", self.machine.name)
+        logging.getLogger("OOPS").warning(
+            "Machine %s was Oopsed.", self.machine.display_name
+        )
         locker = self._lock if do_locking else nullcontext()
         with locker:
             self.is_oopsed = True
@@ -350,16 +404,23 @@ class MachineState:
     def unoops(self, do_locking: bool = True) -> None:
         """Un-oops the machine."""
         logging.getLogger("OOPS").warning(
-            "Machine %s was un-Oopsed.", self.machine.name
+            "Machine %s was un-Oopsed.", self.machine.display_name
         )
         locker = self._lock if do_locking else nullcontext()
         with locker:
             self.is_oopsed = False
-            self.relay_desired_state = False
             self.current_user = None
-            self.display_text = self.DEFAULT_DISPLAY_TEXT
-            self.status_led_rgb = (0.0, 0.0, 0.0)
-            self.status_led_brightness = 0
+            # Restore always-enabled state if applicable
+            if self.machine.always_enabled:
+                self.relay_desired_state = True
+                self.display_text = self.ALWAYS_ON_DISPLAY_TEXT
+                self.status_led_rgb = (0.0, 1.0, 0.0)
+                self.status_led_brightness = self.STATUS_LED_BRIGHTNESS
+            else:
+                self.relay_desired_state = False
+                self.display_text = self.DEFAULT_DISPLAY_TEXT
+                self.status_led_rgb = (0.0, 0.0, 0.0)
+                self.status_led_brightness = 0
 
     async def update(
         self,
@@ -398,7 +459,21 @@ class MachineState:
             if oops:
                 await self._handle_oops(users)
                 self.last_update = time()
-            if rfid_value != self.rfid_value:
+            # Handle always-enabled machines - track RFID but maintain always-on state
+            if (
+                self.machine.always_enabled
+                and not self.is_oopsed
+                and not self.is_locked_out
+            ):
+                self.relay_desired_state = True
+                self.display_text = self.ALWAYS_ON_DISPLAY_TEXT
+                self.status_led_rgb = (0.0, 1.0, 0.0)
+                self.status_led_brightness = self.STATUS_LED_BRIGHTNESS
+                self.last_update = time()
+                # Track RFID changes for logging/auditing purposes
+                if rfid_value != self.rfid_value:
+                    await self._handle_rfid_tracking_always_enabled(users, rfid_value)
+            elif rfid_value != self.rfid_value:
                 if rfid_value is None:
                     await self._handle_rfid_remove()
                 else:
@@ -417,7 +492,7 @@ class MachineState:
                 ustr = f" Current user is: {user.full_name}."
                 uname = user.full_name
         logging.getLogger("OOPS").warning(
-            "Machine %s was Oopsed.%s", self.machine.name, ustr
+            "Machine %s was Oopsed.%s", self.machine.display_name, ustr
         )
         # locking handled in update()
         self.oops(do_locking=False)
@@ -437,12 +512,12 @@ class MachineState:
         """Handle RFID card removed."""
         logging.getLogger("AUTH").info(
             "RFID logout on %s by %s; session duration %d seconds",
-            self.machine.name,
+            self.machine.display_name,
             self.current_user.full_name if self.current_user else self.rfid_value,
             time() - cast(float, self.rfid_present_since),
         )
         log_str: str = (
-            f"RFID logout on {self.machine.name} by "
+            f"RFID logout on {self.machine.display_name} by "
             + (self.current_user.full_name if self.current_user else "unknown")
             + "; session duration "
             + naturaldelta(time() - cast(float, self.rfid_present_since))
@@ -473,13 +548,13 @@ class MachineState:
         if not user:
             logging.getLogger("AUTH").warning(
                 "RFID login attempt on %s by unknown fob %s",
-                self.machine.name,
+                self.machine.display_name,
                 rfid_value,
             )
             if self.is_oopsed or self.is_locked_out:
                 if slack:
                     await slack.admin_log(
-                        f"RFID login attempt on {self.machine.name} "
+                        f"RFID login attempt on {self.machine.display_name} "
                         "by unknown fob when oopsed or locked out."
                     )
                 return
@@ -488,7 +563,7 @@ class MachineState:
             self.status_led_brightness = self.STATUS_LED_BRIGHTNESS
             if slack:
                 await slack.admin_log(
-                    f"RFID login attempt on {self.machine.name} by unknown fob"
+                    f"RFID login attempt on {self.machine.display_name} by unknown fob"
                 )
             return
         # ok, we have a known user
@@ -496,26 +571,26 @@ class MachineState:
         if self.is_oopsed:
             logging.getLogger("AUTH").warning(
                 "RFID login attempt while oopsed on %s by %s",
-                self.machine.name,
+                self.machine.display_name,
                 logname,
             )
             # don't change anything
             if slack:
                 await slack.admin_log(
-                    f"RFID login attempt on {self.machine.name} by "
+                    f"RFID login attempt on {self.machine.display_name} by "
                     f"{user.full_name} when oopsed."
                 )
             return
         if self.is_locked_out:
             logging.getLogger("AUTH").warning(
                 "RFID login attempt while locked out on %s by %s",
-                self.machine.name,
+                self.machine.display_name,
                 logname,
             )
             # don't change anything
             if slack:
                 await slack.admin_log(
-                    f"RFID login attempt on {self.machine.name} by "
+                    f"RFID login attempt on {self.machine.display_name} by "
                     f"{user.full_name} when machine locked-out."
                 )
             return
@@ -524,7 +599,7 @@ class MachineState:
                 "User %s (%s) authorized for %s; session start",
                 user.full_name,
                 user.account_id,
-                self.machine.name,
+                self.machine.display_name,
             )
             self.current_user = user
             self.relay_desired_state = True
@@ -533,7 +608,7 @@ class MachineState:
             self.status_led_brightness = self.STATUS_LED_BRIGHTNESS
             if slack:
                 await slack.admin_log(
-                    f"RFID login on {self.machine.name} by authorized user "
+                    f"RFID login on {self.machine.display_name} by authorized user "
                     f"{user.full_name}"
                 )
         else:
@@ -541,7 +616,7 @@ class MachineState:
                 "User %s (%s) UNAUTHORIZED for %s",
                 user.full_name,
                 user.account_id,
-                self.machine.name,
+                self.machine.display_name,
             )
             self.relay_desired_state = False
             self.display_text = "Unauthorized"
@@ -549,10 +624,56 @@ class MachineState:
             self.status_led_brightness = self.STATUS_LED_BRIGHTNESS
             if slack:
                 await slack.admin_log(
-                    f"rejected RFID login on {self.machine.name} by "
+                    f"rejected RFID login on {self.machine.display_name} by "
                     f"UNAUTHORIZED user {user.full_name}"
                 )
 
+    async def _handle_rfid_tracking_always_enabled(
+        self, users: UsersConfig, rfid_value: Optional[str]
+    ) -> None:
+        """Track RFID changes for always-enabled machines without changing state.
+
+        This method logs RFID insertions and removals for auditing purposes while
+        maintaining the always-on state of the machine.
+        """
+        # locking handled in update()
+        if rfid_value is None:
+            # RFID removed
+            logging.getLogger("AUTH").info(
+                "RFID removed on always-enabled machine %s (was %s); session duration %d seconds",
+                self.machine.display_name,
+                self.current_user.full_name if self.current_user else self.rfid_value,
+                (
+                    time() - cast(float, self.rfid_present_since)
+                    if self.rfid_present_since
+                    else 0
+                ),
+            )
+            self.rfid_value = None
+            self.rfid_present_since = None
+            self.current_user = None
+            # State remains always-on (relay/display/LED not changed)
+        else:
+            # RFID inserted
+            self.rfid_present_since = time()
+            self.rfid_value = rfid_value
+            user: Optional[User] = users.users_by_fob.get(rfid_value)
+            if user:
+                self.current_user = user
+                logging.getLogger("AUTH").info(
+                    "RFID inserted on always-enabled machine %s by %s (%s)",
+                    self.machine.display_name,
+                    user.full_name,
+                    rfid_value,
+                )
+            else:
+                logging.getLogger("AUTH").warning(
+                    "RFID inserted on always-enabled machine %s by unknown fob %s",
+                    self.machine.display_name,
+                    rfid_value,
+                )
+            # State remains always-on (relay/display/LED not changed)
+
     async def _user_is_authorized(
         self, user: User, slack: Optional["SlackHandler"] = None
     ) -> bool:
@@ -563,7 +684,7 @@ class MachineState:
                     "User %s (%s) authorized for %s based on %s",
                     user.full_name,
                     user.account_id,
-                    self.machine.name,
+                    self.machine.display_name,
                     auth,
                 )
                 return True
@@ -573,12 +694,12 @@ class MachineState:
                 "unauthorized_warn_only==True",
                 user.full_name,
                 user.account_id,
-                self.machine.name,
+                self.machine.display_name,
             )
             if slack:
                 await slack.admin_log(
                     f"WARNING - Authorizing user {user.full_name} for "
-                    f"{self.machine.name} based on unauthorized_warn_only "
+                    f"{self.machine.display_name} based on unauthorized_warn_only "
                     "setting for machine. User is NOT authorized for this "
                     "machine."
                 )

{machine_access_control-0.2.3 → machine_access_control-0.4.0}/src/dm_mac/slack_handler.py

@@ -160,11 +160,11 @@ class SlackHandler:
                 msg.channel_id,
             )
             return None
-        if msg.command[0] == "oops" and len(msg.command) == 2:
+        if msg.command[0] == "oops" and len(msg.command) >= 2:
             return await self.oops(msg, say)
-        elif msg.command[0] == "lock" and len(msg.command) == 2:
+        elif msg.command[0] == "lock" and len(msg.command) >= 2:
             return await self.lock(msg, say)
-        elif msg.command[0] == "clear" and len(msg.command) == 2:
+        elif msg.command[0] == "clear" and len(msg.command) >= 2:
             return await self.clear(msg, say)
         await say(self.HELP_RESPONSE)
 
@@ -175,7 +175,7 @@ class SlackHandler:
         mname: str
         mach: Machine
         for mname, mach in sorted(mconf.machines_by_name.items()):
-            resp += mname + ": "
+            resp += mach.display_name + ": "
             if mach.state.is_oopsed or mach.state.is_locked_out:
                 if mach.state.is_oopsed:
                     resp += "Oopsed "
@@ -199,44 +199,44 @@ class SlackHandler:
 
     async def oops(self, msg: Message, say: AsyncSay) -> None:
         """Set oops status on a machine."""
-        mname: str = msg.command[1]
+        mname: str = " ".join(msg.command[1:])
         mconf: MachinesConfig = self.quart.config["MACHINES"]
-        mach: Optional[Machine] = mconf.machines_by_name.get(mname)
+        mach: Optional[Machine] = mconf.get_machine(mname)
         if not mach:
             await say(
-                f"Invalid machine name '{mname}'. Use status command to "
+                f"Invalid machine name or alias '{mname}'. Use status command to "
                 f"list all machines."
             )
             return
         if mach.state.is_oopsed:
-            await say(f"Machine {mname} is already oopsed.")
+            await say(f"Machine {mach.display_name} is already oopsed.")
             return
         await mach.oops(slack=self)
 
     async def lock(self, msg: Message, say: AsyncSay) -> None:
         """Set lock status on a machine."""
-        mname: str = msg.command[1]
+        mname: str = " ".join(msg.command[1:])
         mconf: MachinesConfig = self.quart.config["MACHINES"]
-        mach: Optional[Machine] = mconf.machines_by_name.get(mname)
+        mach: Optional[Machine] = mconf.get_machine(mname)
         if not mach:
             await say(
-                f"Invalid machine name '{mname}'. Use status command to "
+                f"Invalid machine name or alias '{mname}'. Use status command to "
                 f"list all machines."
             )
             return
         if mach.state.is_locked_out:
-            await say(f"Machine {mname} is already locked-out.")
+            await say(f"Machine {mach.display_name} is already locked-out.")
             return
         await mach.lockout(slack=self)
 
     async def clear(self, msg: Message, say: AsyncSay) -> None:
         """Clear oops and lock status on a machine."""
-        mname: str = msg.command[1]
+        mname: str = " ".join(msg.command[1:])
         mconf: MachinesConfig = self.quart.config["MACHINES"]
-        mach: Optional[Machine] = mconf.machines_by_name.get(mname)
+        mach: Optional[Machine] = mconf.get_machine(mname)
         if not mach:
             await say(
-                f"Invalid machine name '{mname}'. Use status command to "
+                f"Invalid machine name or alias '{mname}'. Use status command to "
                 f"list all machines."
             )
             return
@@ -248,7 +248,7 @@ class SlackHandler:
             await mach.unlock(slack=self)
             acted = True
         if not acted:
-            await say(f"Machine {mname} is not oopsed or locked-out.")
+            await say(f"Machine {mach.display_name} is not oopsed or locked-out.")
 
     async def log_unoops(self, machine: Machine, source: str) -> None:
         """
@@ -262,13 +262,13 @@ class SlackHandler:
         create_task(
             self.app.client.chat_postMessage(
                 channel=self.control_channel_id,
-                text=f"Machine {machine.name} un-oopsed via {source}.",
+                text=f"Machine {machine.display_name} un-oopsed via {source}.",
             )
         )
         create_task(
             self.app.client.chat_postMessage(
                 channel=self.oops_channel_id,
-                text=f"Machine {machine.name} oops has been cleared.",
+                text=f"Machine {machine.display_name} oops has been cleared.",
             )
         )
 
@@ -286,13 +286,13 @@ class SlackHandler:
         create_task(
             self.app.client.chat_postMessage(
                 channel=self.control_channel_id,
-                text=f"Machine {machine.name} oopsed via {source} by {user_name}.",
+                text=f"Machine {machine.display_name} oopsed via {source} by {user_name}.",
             )
         )
         create_task(
             self.app.client.chat_postMessage(
                 channel=self.oops_channel_id,
-                text=f"Machine {machine.name} has been Oops'ed!",
+                text=f"Machine {machine.display_name} has been Oops'ed!",
             )
         )
 
@@ -308,13 +308,13 @@ class SlackHandler:
         create_task(
             self.app.client.chat_postMessage(
                 channel=self.control_channel_id,
-                text=f"Machine {machine.name} locked-out cleared via {source}.",
+                text=f"Machine {machine.display_name} locked-out cleared via {source}.",
             )
         )
         create_task(
             self.app.client.chat_postMessage(
                 channel=self.oops_channel_id,
-                text=f"Machine {machine.name} is no longer locked-out for "
+                text=f"Machine {machine.display_name} is no longer locked-out for "
                 f"maintenance.",
             )
         )
@@ -331,13 +331,13 @@ class SlackHandler:
         create_task(
             self.app.client.chat_postMessage(
                 channel=self.control_channel_id,
-                text=f"Machine {machine.name} locked-out via {source}.",
+                text=f"Machine {machine.display_name} locked-out via {source}.",
             )
         )
         create_task(
             self.app.client.chat_postMessage(
                 channel=self.oops_channel_id,
-                text=f"Machine {machine.name} is locked-out for maintenance.",
+                text=f"Machine {machine.display_name} is locked-out for maintenance.",
             )
         )
 

{machine_access_control-0.2.3 → machine_access_control-0.4.0}/src/dm_mac/views/prometheus.py

@@ -134,52 +134,35 @@ class PromCustomCollector:
         )
         m: Machine
         for m in mconf.machines:
-            relay_state.add_metric(
-                {"machine_name": m.name}, 1 if m.state.relay_desired_state else 0
-            )
-            oops_state.add_metric(
-                {"machine_name": m.name}, 1 if m.state.is_oopsed else 0
-            )
-            lockout_state.add_metric(
-                {"machine_name": m.name}, 1 if m.state.is_locked_out else 0
-            )
-            unauth_state.add_metric(
-                {"machine_name": m.name}, 1 if m.unauthorized_warn_only else 0
-            )
-            m_checkin.add_metric({"machine_name": m.name}, m.state.last_checkin or 0)
-            m_update.add_metric({"machine_name": m.name}, m.state.last_update or 0)
-            m_rfid_present.add_metric(
-                {"machine_name": m.name}, 1 if m.state.rfid_value else 0
-            )
-            m_rfid_present_since.add_metric(
-                {"machine_name": m.name}, m.state.rfid_present_since or 0
-            )
-            current_amps.add_metric({"machine_name": m.name}, m.state.current_amps)
-            m_user.add_metric(
-                {"machine_name": m.name}, 1 if m.state.current_user else 0
-            )
-            uptime.add_metric({"machine_name": m.name}, m.state.uptime)
-            wifi_db.add_metric({"machine_name": m.name}, m.state.wifi_signal_db or 0)
-            wifi_percent.add_metric(
-                {"machine_name": m.name}, m.state.wifi_signal_percent or 0
-            )
-            temp_c.add_metric(
-                {"machine_name": m.name}, m.state.internal_temperature_c or 0
-            )
+            labels = {"machine_name": m.name, "display_name": m.display_name}
+            relay_state.add_metric(labels, 1 if m.state.relay_desired_state else 0)
+            oops_state.add_metric(labels, 1 if m.state.is_oopsed else 0)
+            lockout_state.add_metric(labels, 1 if m.state.is_locked_out else 0)
+            unauth_state.add_metric(labels, 1 if m.unauthorized_warn_only else 0)
+            m_checkin.add_metric(labels, m.state.last_checkin or 0)
+            m_update.add_metric(labels, m.state.last_update or 0)
+            m_rfid_present.add_metric(labels, 1 if m.state.rfid_value else 0)
+            m_rfid_present_since.add_metric(labels, m.state.rfid_present_since or 0)
+            current_amps.add_metric(labels, m.state.current_amps)
+            m_user.add_metric(labels, 1 if m.state.current_user else 0)
+            uptime.add_metric(labels, m.state.uptime)
+            wifi_db.add_metric(labels, m.state.wifi_signal_db or 0)
+            wifi_percent.add_metric(labels, m.state.wifi_signal_percent or 0)
+            temp_c.add_metric(labels, m.state.internal_temperature_c or 0)
             led.add_metric(
-                {"machine_name": m.name, "led_attribute": "red"},
+                {**labels, "led_attribute": "red"},
                 m.state.status_led_rgb[0],
             )
             led.add_metric(
-                {"machine_name": m.name, "led_attribute": "green"},
+                {**labels, "led_attribute": "green"},
                 m.state.status_led_rgb[1],
             )
             led.add_metric(
-                {"machine_name": m.name, "led_attribute": "blue"},
+                {**labels, "led_attribute": "blue"},
                 m.state.status_led_rgb[2],
             )
             led.add_metric(
-                {"machine_name": m.name, "led_attribute": "brightness"},
+                {**labels, "led_attribute": "brightness"},
                 m.state.status_led_brightness,
             )
         yield mconf_load