dsf-python 3.4.6.post4__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,9 +1,8 @@
-from __future__ import annotations
 import json
 import socket
+from typing import Optional
 
-from .exceptions import (IncompatibleVersionException, InternalServerException, IPCSocketBrokenException,
-                         TaskCanceledException)
+from .exceptions import IncompatibleVersionException, InternalServerException, TaskCanceledException
 from .init_messages import client_init_messages, server_init_message
 from ..commands import responses
 
@@ -12,16 +11,12 @@ class BaseConnection:
     """
     Base class for connections that access the control server via the Duet API
     using a UNIX socket
-
-    Constructor arguments:
-    :param debug: Whether to print debug information or not
-    :param timeout: Set a timeout value on blocking socket operations or None to set the socket in non-blocking mode
     """
 
-    def __init__(self, debug: bool = False, timeout: int = None):
+    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 = ""
 
@@ -30,7 +25,7 @@ class BaseConnection:
 
         self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
         self.socket.connect(socket_file)
-        self.socket.settimeout(self.timeout)
+        self.socket.setblocking(True)
         server_init_msg = server_init_message.ServerInitMessage.from_json(
             json.loads(self.socket.recv(50).decode("utf8"))
         )
@@ -117,9 +112,7 @@ class BaseConnection:
                     except Exception as e:
                         raise e
                     # either 0 or end of data
-                    if part == b"":
-                        raise IPCSocketBrokenException()
-                    elif len(part) < BUFF_SIZE:
+                    if len(part) < BUFF_SIZE:
                         break
 
                 json_string += data.decode("utf8")

dsf/connections/exceptions.py

@@ -14,10 +14,3 @@ class InternalServerException(Exception):
 
 class TaskCanceledException(Exception):
     """Exception returned by the server if the task has been cancelled remotely"""
-
-
-class IPCSocketBrokenException(Exception):
-    """Exception raised if the IPC connection has been closed on the remote server"""
-
-    def __init__(self):
-        super().__init__("IPC socket connection broken")

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