dsf-python 3.4.5.post2__py3-none-any.whl → 3.4.6.post2__py3-none-any.whl

dsf/__init__.py

@@ -1,10 +1,10 @@
-# path to unix socket file
-SOCKET_FILE = "/run/dsf/dcs.sock"
-
-# allowed connection per unix server
-DEFAULT_BACKLOG = 4
-
-# DSF protocol version
-PROTOCOL_VERSION = 12
-
-from . import commands, connections, http, object_model
+# path to unix socket file
+SOCKET_FILE = "/run/dsf/dcs.sock"
+
+# allowed connection per unix server
+DEFAULT_BACKLOG = 4
+
+# DSF protocol version
+PROTOCOL_VERSION = 12
+
+from . import commands, connections, http, object_model

dsf/commands/__init__.py

@@ -1,2 +1,2 @@
-from . import base_command, code, code_interception, code_channel, code_parameter, files, generic,\
-    http_endpoints, model_subscription, object_model, packages, plugins, responses, result, user_sessions
+from . import base_command, code, code_interception, code_channel, code_parameter, files, generic,\
+    http_endpoints, model_subscription, object_model, packages, plugins, responses, user_sessions

dsf/commands/base_command.py

@@ -1,12 +1,12 @@
-class BaseCommand:
-    """Base class of a command."""
-
-    @classmethod
-    def from_json(cls, data):
-        """Deserialize an instance of this class from a JSON deserialized dictionary"""
-        return cls(**data)
-
-    def __init__(self, command: str, **kwargs):
-        self.command = command
-        for key, value in kwargs.items():
-            self.__dict__[key] = value
+class BaseCommand:
+    """Base class of a command."""
+
+    @classmethod
+    def from_json(cls, data):
+        """Deserialize an instance of this class from a JSON deserialized dictionary"""
+        return cls(**data)
+
+    def __init__(self, command: str, **kwargs):
+        self.command = command
+        for key, value in kwargs.items():
+            self.__dict__[key] = value

dsf/commands/code.py

@@ -1,170 +1,161 @@
-"""
-Module code contains relevant classes and enums being received
-as well as sent back to the server.
-
-    Python interface to DuetSoftwareFramework
-    Copyright (C) 2020 Duet3D
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    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 enum import Enum, IntEnum
-from typing import List
-
-from .base_command import BaseCommand
-from .code_channel import CodeChannel
-from .code_parameter import CodeParameter
-from ..object_model.messages import Message
-
-
-class CodeType(str, Enum):
-    """Type of generic G/M/T-code. If none is applicable, it is treated as a comment"""
-
-    Comment = "Q"
-    GCode = "G"
-    MCode = "M"
-    TCode = "T"
-
-
-class KeywordType(IntEnum):
-    """Enumeration of conditional G-code keywords"""
-
-    KeywordNone = 0
-    If = 1
-    ElseIf = 2
-    Else = 3
-    While = 4
-    Break = 5
-    Return = 6  # Deprecated: Was never supported in RRF
-    Abort = 7
-    Var = 8
-    Set = 9
-    Echo = 10
-    Continue = 11
-    Global = 12
-
-
-keyword_type_names = {
-    KeywordType.Abort: "abort",
-    KeywordType.Break: "break",
-    KeywordType.Echo: "echo",
-    KeywordType.Else: "else",
-    KeywordType.ElseIf: "elif",
-    KeywordType.If: "if",
-    KeywordType.Return: "return",
-    KeywordType.Set: "set",
-    KeywordType.Var: "var",
-    KeywordType.While: "while",
-    KeywordType.Continue: "continue",
-}
-
-
-class CodeFlags(IntEnum):
-    """Code bits to classify G/M/T-codes"""
-
-    CodeFlagsNone = 0
-    Asynchronous = 1
-    IsPreProcessed = 2
-    IsPostProcessed = 4
-    IsFromMacro = 8
-    IsNestedMacro = 16
-    IsFromConfig = 32
-    IsFromConfigOverride = 64
-    EnforceAbsolutePosition = 128
-    IsPrioritized = 256
-    Unbuffered = 512
-    IsFromFirmware = 1024
-    IsLastCode = 2048
-
-
-class Code(BaseCommand):
-    """A parsed representation of a generic G/M/T-code"""
-
-    parameters: List
-    result: List
-
-    @classmethod
-    def from_json(cls, data):
-        """Deserialize an instance of this class from JSON deserialized dictionary"""
-        data["result"] = [] if data["result"] is None else list(map(Message.from_json, data["result"]))
-        data["parameters"] = list(map(CodeParameter.from_json, data["parameters"]))
-        if "channel" in data:
-            data["channel"] = CodeChannel(data["channel"])
-        return cls(**data)
-
-    def parameter(self, letter: str, default=None):
-        """Retrieve the parameter whose letter equals c or generate a default parameter"""
-        letter = letter.upper()
-        param = [param for param in self.parameters if param.letter.upper() == letter]
-        if len(param) > 0:
-            return param[0]
-        if default is not None:
-            return CodeParameter.simple_param(letter, default)
-        return None
-
-    def get_unprecedented_string(self, quote: bool = False):
-        """
-        Reconstruct an unprecedented string from the parameter list or
-        retrieve the parameter which does not have a letter assigned.
-        """
-        str_list = []
-        for param in self.parameters:
-            if quote and param.is_string:
-                str_list.append(f'{param.letter}"{param.string_value}"')
-            else:
-                str_list.append(f"{param.letter}{param.string_value}")
-        return " ".join(str_list)
-
-    def __str__(self):
-        """Convert the parsed code back to a text-based G/M/T-code"""
-        if self.keyword != KeywordType.KeywordNone:
-            if self.keywordArgument is not None:
-                return f"{self.keyword_to_str()} {self.keywordArgument}"
-            else:
-                return self.keyword_to_str()
-
-        if self.type == CodeType.Comment:
-            return f";{self.comment}"
-
-        str_list = [self.short_str()]
-
-        for param in self.parameters:
-            str_list.append(f" {param}")
-
-        if self.comment:
-            if len(str_list) > 0:
-                str_list.append(" ")
-            str_list.append(f";{self.comment}")
-
-        if len(self.result) > 0:
-            str_list.append(f" => {self.result}")
-
-        return "".join(str_list)
-
-    def short_str(self):
-        """Convert only the command portion to a text-based G/M/T-code (e.g. G28)"""
-        if self.type == CodeType.Comment:
-            return "(comment)"
-
-        prefix = "G53 " if self.flags & CodeFlags.EnforceAbsolutePosition != 0 else ""
-        if self.majorNumber is not None:
-            if self.minorNumber is not None:
-                return f"{prefix}{self.type}{self.majorNumber}.{self.minorNumber}"
-
-            return f"{prefix}{self.type}{self.majorNumber}"
-
-        return f"{prefix}{self.type}"
-
-    def keyword_to_str(self):
-        """Convert the keyword to a str"""
-        return keyword_type_names.get(self.keyword)
+from __future__ import annotations
+from typing import List, Optional
+
+from .base_command import BaseCommand
+from .code_channel import CodeChannel
+from .code_flags import CodeFlags
+from .code_parameter import CodeParameter
+from .code_type import CodeType
+from .condition_type import KeywordType
+from ..object_model.messages import Message
+
+
+class Code(BaseCommand):
+    """A parsed representation of a generic G/M/T-code"""
+
+    @classmethod
+    def from_json(cls, data):
+        """Deserialize an instance of this class from JSON deserialized dictionary"""
+        data["result"] = None if data["result"] is None else list(map(Message.from_json, data["result"]))
+        data["parameters"] = list(map(CodeParameter.from_json, data["parameters"]))
+        if "channel" in data:
+            data["channel"] = CodeChannel(data["channel"])
+        return cls(**data)
+
+    def __init__(self, **kwargs):
+        # The connection ID this code was received from. If this is 0, the code originates from an internal DCS task
+        # Usually there is no need to populate this property.
+        # It is internally overwritten by the control server on receipt
+        self.sourceConnection = 0
+
+        # Result of this code. This property is only set when the code has finished its execution.
+        # It remains None if the code has been cancelled
+        self.result: Optional[List[Message]] = None
+
+        # Type of the code
+        self.type = CodeType.CodeNone
+
+        # Code channel to send this code to
+        self.channel = CodeChannel.DEFAULT_CHANNEL
+
+        # Line number of this code
+        self.lineNumber = None
+
+        # Number of whitespaces prefixing the command content
+        self.indent = 0
+
+        # Type of conditional G-code (if any)
+        self.keyword = KeywordType.KeywordNone
+
+        # Argument of the conditional G-code (if any)
+        self.keywordArgument = None
+
+        # Major code number (e.g. 28 in G28)
+        self.majorNumber = None
+
+        # Minor code number (e.g. 3 in G54.3)
+        self.minorNumber = None
+
+        # Flags of this code
+        self.flags = CodeFlags.CodeFlagsNone
+
+        # Comment of the G/M/T-code. May be null if no comment is present
+        # The parser combines different comment segments and concatenates them as a single value.
+        # So for example a code like 'G28 (Do homing) ; via G28'
+        # causes the Comment field to be filled with 'Do homing via G28'
+        self.comment = None
+
+        # File position of this code in bytes (optional)
+        self.filePosition = None
+
+        # Length of the original code in bytes (optional)
+        self.length = None
+
+        # List of parsed code parameters
+        self.parameters: List[CodeParameter] = []
+
+        super().__init__(**kwargs)
+
+    @property
+    def is_from_file_channel(self) -> bool:
+        """Check if this code is from a file channel"""
+        return self.channel is CodeChannel.File
+
+    def parameter(self, letter: str, default=None):
+        """Retrieve the parameter whose letter equals c or generate a default parameter"""
+        letter = letter.upper()
+        param = [param for param in self.parameters if param.letter.upper() == letter]
+        if len(param) > 0:
+            return param[0]
+        if default is not None:
+            return CodeParameter.simple_param(letter, default)
+        return None
+
+    def get_unprecedented_string(self, quote: bool = False):
+        """
+        Reconstruct an unprecedented string from the parameter list or
+        retrieve the parameter which does not have a letter assigned.
+        """
+        str_list = []
+        for param in self.parameters:
+            if quote and param.is_string:
+                str_list.append(f'{param.letter}"{param.string_value}"')
+            else:
+                str_list.append(f"{param.letter}{param.string_value}")
+        return " ".join(str_list)
+
+    def __str__(self):
+        """Convert the parsed code back to a text-based G/M/T-code"""
+        if self.keyword != KeywordType.KeywordNone:
+            if self.keywordArgument is not None:
+                return f"{self.keyword_to_str()} {self.keywordArgument}"
+            else:
+                return self.keyword_to_str()
+
+        if self.type == CodeType.Comment:
+            return f";{self.comment}"
+
+        str_list = [self.short_str()]
+
+        for param in self.parameters:
+            str_list.append(f" {param}")
+
+        if self.comment:
+            if len(str_list) > 0:
+                str_list.append(" ")
+            str_list.append(f";{self.comment}")
+
+        if self.result and len(self.result) > 0:
+            str_list.append(f" => {self.result}")
+
+        return "".join(str_list)
+
+    def short_str(self):
+        """Convert only the command portion to a text-based G/M/T-code (e.g. G28)"""
+        if self.type == CodeType.Comment:
+            return "(comment)"
+
+        prefix = "G53 " if self.flags & CodeFlags.EnforceAbsolutePosition != 0 else ""
+        if self.majorNumber is not None:
+            if self.minorNumber is not None:
+                return f"{prefix}{self.type}{self.majorNumber}.{self.minorNumber}"
+
+            return f"{prefix}{self.type}{self.majorNumber}"
+
+        return f"{prefix}{self.type}"
+
+    def keyword_to_str(self):
+        """Convert the keyword to a string"""
+        return {
+            KeywordType.If: "if",
+            KeywordType.ElseIf: "elif",
+            KeywordType.Else: "else",
+            KeywordType.While: "while",
+            KeywordType.Break: "break",
+            KeywordType.Continue: "continue",
+            KeywordType.Abort: "abort",
+            KeywordType.Var: "var",
+            KeywordType.Set: "set",
+            KeywordType.Echo: "echo",
+            KeywordType.Global: "global",
+        }.get(self.keyword)

dsf/commands/code_channel.py

@@ -1,50 +1,50 @@
-from enum import Enum
-
-
-class CodeChannel(str, Enum):
-    """Enumeration of every available code channel"""
-
-    # Code channel for HTTP requests
-    HTTP = "HTTP"
-
-    # Code channel for Telnet requests
-    Telnet = "Telnet"
-
-    # Code channel for primary file prints
-    File = "File"
-
-    # Code channel for USB requests
-    USB = "USB"
-
-    # Code channel for serial devices (e.g. PanelDue)
-    Aux = "Aux"
-
-    # Code channel for running triggers or config.g
-    Trigger = "Trigger"
-
-    # Code channel for the code queue that executes a couple of codes in-sync with moves of the primary print file
-    Queue = "Queue"
-
-    # Code channel for auxiliary LCD devices (e.g. PanelOne)
-    LCD = "LCD"
-
-    # Default code channel for requests over SPI
-    SBC = "SBC"
-
-    # Code channel that executes the daemon process
-    Daemon = "Daemon"
-
-    # Code channel for the second UART port
-    Aux2 = "Aux2"
-
-    # Code channel that executes macros on power fail, heater faults and filament out
-    Autopause = "Autopause"
-
-    # Unknown code channel
-    Unknown = "Unknown"
-
-    DEFAULT_CHANNEL = SBC
-
-    @staticmethod
-    def list():
-        return list(map(lambda cc: cc.value, CodeChannel))
+from enum import Enum
+
+
+class CodeChannel(str, Enum):
+    """Enumeration of every available code channel"""
+
+    # Code channel for HTTP requests
+    HTTP = "HTTP"
+
+    # Code channel for Telnet requests
+    Telnet = "Telnet"
+
+    # Code channel for primary file prints
+    File = "File"
+
+    # Code channel for USB requests
+    USB = "USB"
+
+    # Code channel for serial devices (e.g. PanelDue)
+    Aux = "Aux"
+
+    # Code channel for running triggers or config.g
+    Trigger = "Trigger"
+
+    # Code channel for the code queue that executes a couple of codes in-sync with moves of the primary print file
+    Queue = "Queue"
+
+    # Code channel for auxiliary LCD devices (e.g. PanelOne)
+    LCD = "LCD"
+
+    # Default code channel for requests over SPI
+    SBC = "SBC"
+
+    # Code channel that executes the daemon process
+    Daemon = "Daemon"
+
+    # Code channel for the second UART port
+    Aux2 = "Aux2"
+
+    # Code channel that executes macros on power fail, heater faults and filament out
+    Autopause = "Autopause"
+
+    # Unknown code channel
+    Unknown = "Unknown"
+
+    DEFAULT_CHANNEL = SBC
+
+    @staticmethod
+    def list():
+        return list(map(lambda cc: cc.value, CodeChannel))

dsf/commands/code_flags.py

@@ -0,0 +1,55 @@
+from enum import IntEnum
+
+
+class CodeFlags(IntEnum):
+    """Code bits to classify G/M/T-codes"""
+
+    # Placeholder to indicate that no flags are set
+    CodeFlagsNone = 0
+
+    # Code execution finishes as soon as it is enqueued in the code queue
+    # If codes are started asynchronously, code replies are normally reported via the object model.
+    # In order to keep track of code replies, an <see cref="Connection.ConnectionMode.Intercept"/> connection
+    # in <see cref="Connection.InterceptionMode.Executed"/> mode can be used
+    Asynchronous = 1
+
+    # Code has been preprocessed (i.e. it has been processed by the DCS pre-side code interceptors)
+    IsPreProcessed = 2
+
+    # Code has been postprocessed (i.e. it has been processed by the internal DCS code processor)
+    IsPostProcessed = 4
+
+    # Code originates from a macro file
+    IsFromMacro = 8
+
+    # Code originates from a system macro file (i.e. RRF requested it)
+    IsNestedMacro = 16
+
+    # Code comes from config.g or config.g.bak
+    IsFromConfig = 32
+
+    # Code comes from config-override.g
+    IsFromConfigOverride = 64
+
+    # Enforce absolute positioning via prefixed G53 code
+    EnforceAbsolutePosition = 128
+
+    # Execute this code as quickly as possible and skip codes that have the <see cref="Unbuffered"/> flag set
+    # In order to execute this code as quickly as possible, DCS attempts to change
+    # the <see cref="Code.Channel"/> property to a code channel that is completely idle.
+    # If this fails, a warning is logged. This flag should be only used for diagnostics and time-critical codes
+    # like M112/M122/M999
+    IsPrioritized = 256
+
+    # Do NOT process another code on the same channel before this code has been fully executed.
+    # Note that priority codes may still override codes that have this flag set
+    Unbuffered = 512
+
+    # Indicates if this code was requested from the firmware
+    IsFromFirmware = 1024
+
+    # Indicates if this is the last code on the line
+    IsLastCode = 2048
+
+    # Code has been processed internally (if this is set the internal execution of a code is skipped)
+    IsInternallyProcessed = 4096

dsf/commands/code_interception.py

@@ -1,31 +1,31 @@
-from typing import Optional
-
-from .base_command import BaseCommand
-from ..object_model.messages import MessageType
-
-
-def cancel():
-    """Cancel a code in Connection.InterceptionMode."""
-    return BaseCommand("Cancel")
-
-
-def ignore():
-    """
-    Ignore the code to intercept and allow it to be processed without any modifications.
-    This command is only permitted in ConnectionMode.Intercept mode.
-    """
-    return BaseCommand("Ignore")
-
-
-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.
-    :param rtype: Type of the resolving message
-    :param content: Content of the resolving message
-    """
-    if not isinstance(rtype, MessageType):
-        raise TypeError("rtype must be a MessageType")
-    if content is not None and not isinstance(content, str):
-        raise TypeError("content must be None or a string")
-    return BaseCommand("Resolve", **{"Type": rtype, "Content": content})
+from __future__ import annotations
+
+from .base_command import BaseCommand
+from ..object_model.messages import MessageType
+
+
+def cancel():
+    """Cancel a code in Connection.InterceptionMode."""
+    return BaseCommand("Cancel")
+
+
+def ignore():
+    """
+    Ignore the code to intercept and allow it to be processed without any modifications.
+    This command is only permitted in ConnectionMode.Intercept mode.
+    """
+    return BaseCommand("Ignore")
+
+
+def resolve_code(rtype: MessageType, content: str | None = None):
+    """
+    Resolve the code to intercept and return the given message details for its completion.
+    This command is only permitted in ConnectionMode.Intercept mode.
+    :param rtype: Type of the resolving message
+    :param content: Content of the resolving message
+    """
+    if not isinstance(rtype, MessageType):
+        raise TypeError("rtype must be a MessageType")
+    if content is not None and not isinstance(content, str):
+        raise TypeError("content must be None or a string")
+    return BaseCommand("Resolve", **{"Type": rtype, "Content": content})