dsf-python 3.4.6.post3__py3-none-any.whl → 3.5.0__py3-none-any.whl

dsf/commands/code.py

@@ -1,4 +1,3 @@
-from __future__ import annotations
 from typing import List, Optional
 
 from .base_command import BaseCommand
@@ -79,7 +78,7 @@ class Code(BaseCommand):
     @property
     def is_from_file_channel(self) -> bool:
         """Check if this code is from a file channel"""
-        return self.channel is CodeChannel.File
+        return self.channel is CodeChannel.File or self.channel is CodeChannel.File2
 
     def parameter(self, letter: str, default=None):
         """Retrieve the parameter whose letter equals c or generate a default parameter"""

dsf/commands/code_channel.py

@@ -40,6 +40,12 @@ class CodeChannel(str, Enum):
     # Code channel that executes macros on power fail, heater faults and filament out
     Autopause = "Autopause"
 
+    # Code channel for secondary file prints
+    File2 = "File2"
+
+    # Code channel for the code queue that executes a couple of codes in-sync with moves of the primary print file
+    Queue2 = "Queue2"
+
     # Unknown code channel
     Unknown = "Unknown"
 

dsf/commands/code_interception.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from typing import Optional
 
 from .base_command import BaseCommand
 from ..object_model.messages import MessageType
@@ -17,7 +17,7 @@ def ignore():
     return BaseCommand("Ignore")
 
 
-def resolve_code(rtype: MessageType, content: str | None = None):
+def resolve_code(rtype: MessageType, content: Optional[str]):
     """
     Resolve the code to intercept and return the given message details for its completion.
     This command is only permitted in ConnectionMode.Intercept mode.

dsf/commands/code_parameter.py

@@ -1,7 +1,6 @@
 """
 codeparameter contains all classes and methods dealing with deserialized code parameters.
 """
-from __future__ import annotations
 import json
 
 from ..exceptions import CodeParserException

dsf/commands/generic.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from typing import Optional
 
 from .base_command import BaseCommand
 from .code_channel import CodeChannel
@@ -10,7 +10,9 @@ def check_password(password: str):
     """
     Check if the given password is correct and matches the previously set value from M551.
     If no password was configured before or if it was set to "reprap", this will always return true
+
     :param password: Password to check
+
     :returns: true if the password matches or is not set
     """
     if not isinstance(password, str) or not password:
@@ -23,6 +25,7 @@ def evaluate_expression(channel: CodeChannel, expression: str):
     Evaluate an arbitrary expression on the given channel in RepRapFirmware.
     Do not use this call to evaluate file-based and network-related fields because the
     DSF and RRF models diverge in this regard.
+
     :param channel: Code channel where the expression is evaluated
     :param expression: Expression to evaluate
     """
@@ -33,22 +36,36 @@ def evaluate_expression(channel: CodeChannel, expression: str):
     return BaseCommand("EvaluateExpression", **{"Channel": channel, "Expression": expression})
 
 
-def flush(channel: CodeChannel):
+def flush(channel: CodeChannel, sync_file_streams: bool = False, if_executing: bool = True):
     """
     Wait for all pending (macro) codes on the given channel to finish.
     This effectively guarantees that all buffered codes are processed by RRF before this command finishes.
+
     :param channel: Code channel to flush
+    :param sync_file_streams: Whether the File and File2 streams are supposed to synchronize if a code is being
+    intercepted. This option should be used with care, under certain circumstances this can lead to a deadlock!
+    :param if_executing: Check if the corresponding channel is actually executing codes (i.e. if it is active).
+    If the input channel is not active, this command returns false.
+    This option is ignored if SyncFileStreams is true.
+
     :returns: true if the flush request is successful
     """
     if not isinstance(channel, CodeChannel):
         raise TypeError("channel must be a CodeChannel")
-    return BaseCommand("Flush", **{"Channel": channel})
+    if not isinstance(sync_file_streams, bool):
+        raise TypeError("sync_file_streams must be a boolean")
+    if not isinstance(if_executing, bool):
+        raise TypeError("if_executing must be a boolean")
+    return BaseCommand("Flush",
+                       **{"Channel": channel, "SyncFileStreams": sync_file_streams, "IfExecuting": if_executing})
 
 
 def invalidate_channel(channel: CodeChannel):
     """
     Invalidate all pending codes and files on a given channel (including buffered codes from DSF in RepRapFirmware)
+
     :param channel: Code channel to invalidate
+
     :returns: true if the invalidate request is successful
     """
     if not isinstance(channel, CodeChannel):
@@ -59,6 +76,7 @@ def invalidate_channel(channel: CodeChannel):
 def set_update_status(updating: bool):
     """
     Override the current status as reported by the object model when performing a software update.
+
     :param updating: Whether an update is now in progress
     """
     if not isinstance(updating, bool):
@@ -73,6 +91,7 @@ def simple_code(code: str, channel: CodeChannel = CodeChannel.DEFAULT_CHANNEL, a
     its Code.Result is transformed back into a basic string. This is useful for minimal
     extensions that do not require granular control of the code details. Except for certain cases, it
     is NOT recommended for usage in InterceptionMode because it renders the internal code buffer useless.
+
     :param code: Code to parse and execute
     :param channel: Destination channel
     :param async_exec: Whether this code may be executed asynchronously.
@@ -89,10 +108,11 @@ def write_message(
     message_type: MessageType,
     content: str,
     output_message: bool = True,
-    log_level: LogLevel | None = None,
+    log_level: Optional[LogLevel] = None,
 ):
     """
     Write an arbitrary generic message
+
     :param message_type: Type of the message to write
     :param content: Content of the message to write
     :param output_message: Output the message on the console and via the object model

dsf/commands/http_endpoints.py

@@ -1,5 +1,5 @@
 from .base_command import BaseCommand
-from ..object_model.http_endpoints import HttpEndpointType
+from ..object_model import HttpEndpointType
 
 
 def add_http_endpoint(endpoint_type: HttpEndpointType, namespace: str, path: str, is_upload_request: bool):

dsf/commands/user_sessions.py

@@ -1,21 +1,5 @@
-from enum import Enum
-
 from .base_command import BaseCommand
-
-
-class AccessLevel(str, Enum):
-    """Defines what a user is allowed to do"""
-
-    ReadOnly = "ReadOnly"
-    ReadWrite = "ReadWrite"
-
-
-class SessionType(str, Enum):
-    """Types of user sessions"""
-
-    Local = "Local"
-    HTTP = "HTTP"
-    Telnet = "Telnet"
+from ..object_model import AccessLevel, SessionType
 
 
 def add_user_session(access_level: AccessLevel, session_type: SessionType, origin: str):

dsf/connections/__init__.py

@@ -24,8 +24,8 @@ class InterceptionMode(str, Enum):
     # Intercept codes before they are internally processed by the control server
     PRE = "Pre"
 
-    # Intercept codes after the initial processing of the control server but before they are forwarded to
-    # the RepRapFirmware controller
+    # Intercept codes after the initial processing of the control server, but before they are forwarded
+    # to the RepRapFirmware controller
     POST = "Post"
 
     # Receive a notification for executed codes. In this state the final result can be still changed

dsf/connections/base_command_connection.py

@@ -5,8 +5,7 @@ from .. import commands, DEFAULT_BACKLOG
 from ..commands import code
 from ..commands.code_channel import CodeChannel
 from ..http import HttpEndpointUnixSocket
-from ..object_model import ObjectModel
-from ..object_model.http_endpoints import HttpEndpointType
+from ..object_model import HttpEndpointType, ObjectModel
 from ..object_model.job import GCodeFileInfo
 from ..object_model.messages import Message, MessageType
 from ..object_model.state import LogLevel

dsf/connections/base_connection.py

@@ -1,6 +1,6 @@
-from __future__ import annotations
 import json
 import socket
+from typing import Optional
 
 from .exceptions import IncompatibleVersionException, InternalServerException, TaskCanceledException
 from .init_messages import client_init_messages, server_init_message
@@ -16,7 +16,7 @@ class BaseConnection:
     def __init__(self, debug: bool = False, timeout: int = 3):
         self.debug = debug
         self.timeout = timeout
-        self.socket: socket.socket | None = None
+        self.socket: Optional[socket.socket] = None
         self.id = None
         self.input = ""
 

dsf/connections/init_messages/client_init_messages.py

@@ -17,7 +17,7 @@ clientinitmessages holds all messages a client can send to the server to initiat
     You should have received a copy of the GNU Lesser General Public License
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
-from __future__ import annotations
+from typing import List
 from .server_init_message import ServerInitMessage
 from .. import ConnectionMode, InterceptionMode, SubscriptionMode
 from ...commands.code_channel import CodeChannel
@@ -38,10 +38,11 @@ class ClientInitMessage:
 
 def intercept_init_message(
         intercept_mode: InterceptionMode,
-        channels: list[CodeChannel],
-        filters: list[str],
+        channels: List[CodeChannel],
+        filters: List[str],
         priority_codes: bool,
-        auto_flush: bool = True):
+        auto_flush: bool = True,
+        auto_evaluate_expression: bool = True):
     """
     Enter interception mode
     Whenever a code is received, the connection must respond with one of
@@ -62,6 +63,9 @@ def intercept_init_message(
     is specified.
     This option makes extra Flush calls in the interceptor implementation obsolete.
     It is highly recommended to enable this in order to avoid potential deadlocks when dealing with macros!
+    :param auto_evaluate_expression: Automatically evaluate expression parameters to their final values
+    before sending it over to the client.
+    This requires auto_flush to be True and happens when the remaining codes have been processed.
     """
     return ClientInitMessage(
         ConnectionMode.INTERCEPT,
@@ -69,8 +73,9 @@ def intercept_init_message(
             "InterceptionMode": intercept_mode,
             "Channels": channels,
             "AutoFlush": auto_flush,
+            "AutoEvaluateExpressions": auto_evaluate_expression,
             "Filters": filters,
-            "PriortyCodes": priority_codes,
+            "PriorityCodes": priority_codes,
         },
     )
 

dsf/connections/intercept_connection.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from typing import List, Optional
 
 from .base_command_connection import BaseCommandConnection
 from .init_messages import client_init_messages
@@ -21,6 +21,9 @@ class InterceptConnection(BaseCommandConnection):
     in case a code filter is specified.
     This option makes extra Flush calls in the interceptor implementation obsolete.
     It is highly recommended to enable this in order to avoid potential deadlocks when dealing with macros!
+    :param auto_evaluate_expression: Automatically evaluate expression parameters to their final values
+    before sending it over to the client.
+    This requires auto_flush to be True and happens when the remaining codes have been processed.
     :param priority_codes: Defines if priority codes may be intercepted (e.g. M122 or M999)
     :param debug: Whether debugging output is turned on for this connection
     """
@@ -28,9 +31,10 @@ class InterceptConnection(BaseCommandConnection):
     def __init__(
         self,
         interception_mode: client_init_messages.InterceptionMode,
-        channels: list[CodeChannel] = None,
-        filters: list[str] = None,
+        channels: List[CodeChannel] = None,
+        filters: List[str] = None,
         auto_flush: bool = True,
+        auto_evaluate_expression: bool = True,
         priority_codes: bool = False,
         debug: bool = False,
     ):
@@ -39,12 +43,18 @@ class InterceptConnection(BaseCommandConnection):
         self.channels = channels if channels is not None else CodeChannel.list()
         self.filters = filters
         self.auto_flush = auto_flush
+        self.auto_evaluate_expression = auto_evaluate_expression
         self.priority_codes = priority_codes
 
     def connect(self, socket_file: str = SOCKET_FILE):  # noqa
         """Establishes a connection to the given UNIX socket file"""
         iim = client_init_messages.intercept_init_message(
-            self.interception_mode, self.channels, self.filters, self.priority_codes, self.auto_flush
+            self.interception_mode,
+            self.channels,
+            self.filters,
+            self.priority_codes,
+            self.auto_flush,
+            self.auto_evaluate_expression
         )
         return super().connect(iim, socket_file)
 
@@ -60,7 +70,7 @@ class InterceptConnection(BaseCommandConnection):
         """Instruct the control server to ignore the last received code (in intercepting mode)"""
         self.send(commands.code_interception.ignore())
 
-    def resolve_code(self, rtype: MessageType = MessageType.Success, content: str | None = None):
+    def resolve_code(self, rtype: MessageType = MessageType.Success, content: Optional[str] = None):
         """
         Instruct the control server to resolve the last received code with the given
         message details (in intercepting mode)

dsf/http.py

@@ -5,7 +5,7 @@ from concurrent.futures import ThreadPoolExecutor
 from enum import Enum
 
 from . import DEFAULT_BACKLOG
-from .object_model.http_endpoints import HttpEndpointType
+from .object_model import HttpEndpointType
 
 
 class HttpResponseType(str, Enum):

dsf/object_model/__init__.py

@@ -2,19 +2,19 @@ from .boards import Board, BoardState
 from .directories import Directories
 from .fans import Fan
 from .heat import Heat, Heater, HeaterState
-from .http_endpoints import HttpEndpoint, HttpEndpointType
 from .inputs import InputChannel
 from .job import Job
+from .led_strips import LedStrip, LedStripType
 from .limits import Limits
 from .messages import Message, MessageType
 from .move import DriverId, Move
 from .network import Network, NetworkInterface, NetworkInterfaceType, NetworkProtocol, NetworkState
 from .object_model import ObjectModel
 from .plugins import Plugin, PluginManifest, SbcPermissions
-from .scanner import Scanner, ScannerStatus
+from .sbc import CPU, Memory, SBC
+from .sbc.dsf import AccessLevel, HttpEndpoint, HttpEndpointType, SessionType, UserSession
 from .sensors import AnalogSensor, AnalogSensorType, Endstop, EndstopType, GpInputPort, Probe, ProbeType, Sensors
 from .spindles import Spindle, SpindleState
 from .state import LogLevel, MachineStatus, MessageBox, MessageBoxMode, State
 from .tools import Tool, ToolState
-from .user_sessions import AccessLevel, SessionType, UserSession
 from .volumes import Volume

dsf/object_model/boards/__init__.py

@@ -1,10 +1,10 @@
 from .accelerometer import Accelerometer
 from .boards import Board, BoardState
-from .closed_loop import ClosedLoop
+from .board_closed_loop import BoardClosedLoop
 from .direct_display import DirectDisplay
-from .driver import Driver, DriverSettings
+from .driver import Driver
+from .driver_closed_loop import DriverClosedLoop, ClosedLoopCurrentFraction, ClosedLoopPositionError
 from .min_max_current import MinMaxCurrent
-from .stall_detect_settings import StallDetectSettings
 
-__all__ = ['Accelerometer', 'Board', 'BoardState', 'ClosedLoop', 'DirectDisplay', 'Driver', 'DriverSettings',
-           'MinMaxCurrent', 'StallDetectSettings']
+__all__ = ['Accelerometer', 'Board', 'BoardState', 'BoardClosedLoop', 'DirectDisplay', 'Driver', 'DriverClosedLoop',
+           'ClosedLoopCurrentFraction', 'ClosedLoopPositionError', 'MinMaxCurrent']

dsf/object_model/boards/accelerometer.py

@@ -5,11 +5,24 @@ class Accelerometer(ModelObject):
     """This represents an accelerometer"""
     def __init__(self):
         super(Accelerometer, self).__init__()
+        # Orientation of the accelerometer
+        # See https://docs.duet3d.com/en/Duet3D_hardware/Accessories/Duet3D_Accelerometer#orientation for a list of orientations
+        self._orientation = 20
         # Number of collected data points in the last run or 0 if it failed
         self._points = 0
         # Number of completed sampling runs
         self._runs = 0
 
+    @property
+    def orientation(self) -> int:
+        """Orientation of the accelerometer
+        See https://docs.duet3d.com/en/Duet3D_hardware/Accessories/Duet3D_Accelerometer#orientation for a list of orientations"""
+        return self._orientation
+
+    @orientation.setter
+    def orientation(self, value):
+        self._orientation = int(value)
+
     @property
     def points(self) -> int:
         """Number of collected data points in the last run or 0 if it failed"""

dsf/object_model/boards/{closed_loop.py → board_closed_loop.py}

@@ -1,10 +1,10 @@
 from ..model_object import ModelObject
 
 
-class ClosedLoop(ModelObject):
+class BoardClosedLoop(ModelObject):
     """This represents information about closed-loop tuning"""
     def __init__(self):
-        super(ClosedLoop, self).__init__()
+        super(BoardClosedLoop, self).__init__()
         # Number of collected data points in the last run or 0 if it failed
         self._points = 0
         # Number of completed sampling runs

dsf/object_model/boards/boards.py

@@ -1,12 +1,16 @@
-from __future__ import annotations
 from enum import Enum
+from typing import List, Optional
 
 from .accelerometer import Accelerometer
-from .closed_loop import ClosedLoop
+from .board_closed_loop import BoardClosedLoop
 from .direct_display import DirectDisplay
+from .driver import Driver
+from .inductive_sensor import InductiveSensor
 from .min_max_current import MinMaxCurrent
+from ..model_collection import ModelCollection
 from ..model_object import ModelObject
 from ..utils import wrap_model_property
+from ...utils import deprecated
 
 
 class BoardState(str, Enum):
@@ -36,9 +40,11 @@ class Board(ModelObject):
     # Accelerometer of this board or None if unknown
     accelerometer = wrap_model_property('accelerometer', Accelerometer)
     # Closed loop data of this board or None if unknown
-    closed_loop = wrap_model_property('closed_loop', ClosedLoop)
+    closed_loop = wrap_model_property('closed_loop', BoardClosedLoop)
     # Details about a connected display or None if none is connected
     direct_display = wrap_model_property('direct_display', DirectDisplay)
+    # Information about an inductive sensor or None if not present
+    inductive_sensor = wrap_model_property('inductive_sensor', InductiveSensor)
     # Minimum, maximum, and current temperatures of the MCU or None if unknown
     mcu_temp = wrap_model_property('mcu_temp', MinMaxCurrent)
     # Minimum, maximum, and current voltages on the 12V rail or None if unknown
@@ -59,6 +65,8 @@ class Board(ModelObject):
         self._closed_loop = None
         # Details about a connected display or None if none is connected
         self._direct_display = None
+        # Drivers of this board
+        self._drivers = None
         # Date of the firmware build
         self._firmware_date = ""
         # Filename of the firmware binary
@@ -67,11 +75,15 @@ class Board(ModelObject):
         self._firmware_name = ""
         # Version of the firmware build
         self._firmware_version = ""
+        # Amount of free RAM on this board (in bytes or null if unknown)
+        self._free_ram = None
         # Filename of the IAP binary that is used for updates from the SBC or None if unsupported
         self._iap_file_name_SBC = None
         # Filename of the IAP binary that is used for updates from the SD card or None if unsupported
         # This is only available for the mainboard (first board item)
         self._iap_file_name_SD = None
+        # Information about an inductive sensor or None if not present
+        self._inductive_sensor = None
         # Maximum number of heaters this board can control
         self._max_heaters = 0
         # Maximum number of motors this board can drive
@@ -95,32 +107,43 @@ class Board(ModelObject):
         self._v_12 = None
         # Minimum, maximum, and current voltages on the input rail or None if unknown
         self._v_in = None
+        # Filename of the on-board WiFi chip or None if not present
+        self._wifi_firmware_file_name = None
 
     @property
-    def bootloader_file_name(self) -> str | None:
+    def bootloader_file_name(self) -> Optional[str]:
         """Filename of the bootloader binary or None if unknown"""
         return self._bootloader_file_name
 
     @bootloader_file_name.setter
-    def bootloader_file_name(self, value: str | None = None):
+    def bootloader_file_name(self, value):
         self._bootloader_file_name = str(value) if value is not None else None
 
     @property
-    def can_address(self) -> int | None:
+    def can_address(self) -> Optional[int]:
         """CAN address of this board or None if not applicable"""
         return self._can_address
 
     @can_address.setter
-    def can_address(self, value: int | None = None):
+    def can_address(self, value):
         self._can_address = int(value) if value is not None else None
 
+    @property
+    def drivers(self) -> Optional[List[Driver]]:
+        """Drivers of this board"""
+        return self._drivers
+
+    @drivers.setter
+    def drivers(self, value):
+        self._drivers = None if value is None else ModelCollection(Driver, value)
+
     @property
     def firmware_date(self) -> str:
         """Date of the firmware build"""
         return self._firmware_date
 
     @firmware_date.setter
-    def firmware_date(self, value: str):
+    def firmware_date(self, value):
         self._firmware_date = str(value)
 
     @property
@@ -129,7 +152,7 @@ class Board(ModelObject):
         return self._firmware_file_name
 
     @firmware_file_name.setter
-    def firmware_file_name(self, value: str):
+    def firmware_file_name(self, value):
         self._firmware_file_name = str(value)
 
     @property
@@ -138,7 +161,7 @@ class Board(ModelObject):
         return self._firmware_name
 
     @firmware_name.setter
-    def firmware_name(self, value: str):
+    def firmware_name(self, value):
         self._firmware_name = str(value)
 
     @property
@@ -147,26 +170,35 @@ class Board(ModelObject):
         return self._firmware_version
 
     @firmware_version.setter
-    def firmware_version(self, value: str):
+    def firmware_version(self, value):
         self._firmware_version = str(value)
 
     @property
-    def iap_file_name_SBC(self) -> str | None:
+    def free_ram(self) -> Optional[int]:
+        """Amount of free RAM on this board (in bytes or null if unknown)"""
+        return self._free_ram
+
+    @free_ram.setter
+    def free_ram(self, value):
+        self._free_ram = None if value is None else int(value)
+
+    @property
+    def iap_file_name_SBC(self) -> Optional[str]:
         """Filename of the IAP binary that is used for updates from the SBC or None if unsupported"""
         return self._iap_file_name_SBC
 
     @iap_file_name_SBC.setter
-    def iap_file_name_SBC(self, value: str | None = None):
+    def iap_file_name_SBC(self, value):
         self._iap_file_name_SBC = str(value) if value is not None else None
 
     @property
-    def iap_file_name_SD(self) -> str | None:
+    def iap_file_name_SD(self) -> Optional[str]:
         """Filename of the IAP binary that is used for updates from the SD card or None if unsupported
         This is only available for the mainboard (first board item)"""
         return self._iap_file_name_SD
 
     @iap_file_name_SD.setter
-    def iap_file_name_SD(self, value: str | None = None):
+    def iap_file_name_SD(self, value):
         self._iap_file_name_SD = str(value) if value is not None else None
 
     @property
@@ -175,7 +207,7 @@ class Board(ModelObject):
         return self._max_heaters
 
     @max_heaters.setter
-    def max_heaters(self, value: int):
+    def max_heaters(self, value):
         self._max_heaters = int(value)
 
     @property
@@ -184,7 +216,7 @@ class Board(ModelObject):
         return self._max_motors
 
     @max_motors.setter
-    def max_motors(self, value: int):
+    def max_motors(self, value):
         self._max_motors = int(value)
 
     @property
@@ -193,7 +225,7 @@ class Board(ModelObject):
         return self._name
 
     @name.setter
-    def name(self, value: str):
+    def name(self, value):
         self._name = str(value)
 
     @property
@@ -202,7 +234,7 @@ class Board(ModelObject):
         return self._short_name
 
     @short_name.setter
-    def short_name(self, value: str):
+    def short_name(self, value):
         self._short_name = str(value)
 
     @property
@@ -211,23 +243,23 @@ class Board(ModelObject):
         return self._state
 
     @state.setter
-    def state(self, value: BoardState):
-        if isinstance(value, BoardState):
+    def state(self, value):
+        if value is None or isinstance(value, BoardState):
             self._state = value
         elif isinstance(value, str):
             self._state = BoardState(value)
         else:
-            raise TypeError(f"{__name__}.state must be of type BoardState."
-                            f" Got {type(value)}: {value}")
+            raise TypeError(f"{__name__}.state must be of type BoardState or None. Got {type(value)}: {value}")
 
     @property
+    @deprecated(f"Use {__name__}.supports_direct_display instead")
     def supports_12864(self) -> bool:
         """Indicates if this board supports external 12864 displays
-        Obsolete: Replaced with SupportsDirectDisplay"""
+        Deprecated: Use supports_direct_display instead"""
         return self._supports_12864
 
     @supports_12864.setter
-    def supports_12864(self, value: bool):
+    def supports_12864(self, value):
         self._supports_12864 = bool(value)
 
     @property
@@ -236,14 +268,23 @@ class Board(ModelObject):
         return self._supports_direct_display
 
     @supports_direct_display.setter
-    def supports_direct_display(self, value: bool):
+    def supports_direct_display(self, value):
         self._supports_direct_display = bool(value)
 
     @property
-    def unique_id(self) -> str | None:
+    def unique_id(self) -> Optional[str]:
         """Unique identifier of the board or None if unknown"""
         return self._unique_id
 
     @unique_id.setter
-    def unique_id(self, value: str | None = None):
+    def unique_id(self, value):
         self._unique_id = str(value) if value is not None else None
+
+    @property
+    def wifi_firmware_file_name(self):
+        """Filename of the on-board WiFi chip or None if not present"""
+        return self._wifi_firmware_file_name
+
+    @wifi_firmware_file_name.setter
+    def wifi_firmware_file_name(self, value):
+        self._wifi_firmware_file_name = str(value) if value is not None else None