dsf-python 3.6.0rc3__py3-none-any.whl → 3.7.0b1__py3-none-any.whl

dsf/__init__.py

@@ -1,10 +1,10 @@
-__version__ = "3.6.0-rc.3"
+__version__ = "3.7.0-beta.1"
 
 import json
 import os
 
 # Default socket file path
-SOCKET_FILE = "/run/dsf/dcs.sock"
+SOCKET_FILE: str = "/run/dsf/dcs.sock"
 
 # Try to read socket file path from config
 config_path = "/opt/dsf/conf/config.json"

dsf/commands/base_command.py

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

dsf/commands/code.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import Callable, Optional, cast
 
 from .base_command import BaseCommand
 from .code_channel import CodeChannel
@@ -13,15 +13,24 @@ class Code(BaseCommand):
     """A parsed representation of a generic G/M/T-code"""
 
     @classmethod
-    def from_json(cls, data):
+    def from_json(cls, data: dict[str, object]) -> "Code":
         """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"]))
+        # TODO refactor the types here to use JSONObj
+        message_from_json = cast(Callable[[dict[str, object]], Message], getattr(Message, "from_json"))
+        parameter_from_json = cast(Callable[[dict[str, object]], CodeParameter], getattr(CodeParameter, "from_json"))
+
+        result_raw = cast(list[dict[str, object]] | None, data["result"])
+        data["result"] = None if result_raw is None else [message_from_json(item) for item in result_raw]
+
+        parameters_raw = cast(list[dict[str, object]], data["parameters"])
+        data["parameters"] = [parameter_from_json(item) for item in parameters_raw]
         if "channel" in data:
             data["channel"] = CodeChannel(data["channel"])
         return cls(**data)
 
-    def __init__(self, **kwargs):
+    def __init__(self, **kwargs: object) -> None:
+        kwargs_copy = dict(kwargs)
+        command = cast(str, kwargs_copy.pop("command"))
         # 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
@@ -29,31 +38,31 @@ class Code(BaseCommand):
 
         # 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
+        self.result: Optional[list[Message]] = None
 
         # Type of the code
-        self.type = CodeType.CodeNone
+        self.type: CodeType = CodeType.CodeNone
 
         # Code channel to send this code to
-        self.channel = CodeChannel.DEFAULT_CHANNEL
+        self.channel: CodeChannel = CodeChannel.DEFAULT_CHANNEL
 
         # Line number of this code
-        self.lineNumber = None
+        self.lineNumber: Optional[int] = None
 
         # Number of whitespaces prefixing the command content
-        self.indent = 0
+        self.indent: int = 0
 
         # Type of conditional G-code (if any)
         self.keyword = KeywordType.KeywordNone
 
         # Argument of the conditional G-code (if any)
-        self.keywordArgument = None
+        self.keywordArgument: Optional[str] = None
 
         # Major code number (e.g. 28 in G28)
-        self.majorNumber = None
+        self.majorNumber: Optional[int] = None
 
         # Minor code number (e.g. 3 in G54.3)
-        self.minorNumber = None
+        self.minorNumber: Optional[int] = None
 
         # Flags of this code
         self.flags = CodeFlags.CodeFlagsNone
@@ -71,16 +80,16 @@ class Code(BaseCommand):
         self.length = None
 
         # List of parsed code parameters
-        self.parameters: List[CodeParameter] = []
+        self.parameters: list[CodeParameter] = []
 
-        super().__init__(**kwargs)
+        super().__init__(command=command, **kwargs_copy)
 
     @property
     def is_from_file_channel(self) -> bool:
         """Check if this code is from a file channel"""
         return self.channel is CodeChannel.File or self.channel is CodeChannel.File2
 
-    def parameter(self, letter: str, default=None):
+    def parameter(self, letter: str, default: Optional[object] = None) -> Optional[CodeParameter]:
         """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]
@@ -90,12 +99,12 @@ class Code(BaseCommand):
             return CodeParameter.simple_param(letter, default)
         return None
 
-    def get_unprecedented_string(self, quote: bool = False):
+    def get_unprecedented_string(self, quote: bool = False) -> str:
         """
         Reconstruct an unprecedented string from the parameter list or
         retrieve the parameter which does not have a letter assigned.
         """
-        str_list = []
+        str_list: list[str] = []
         for param in self.parameters:
             if quote and param.is_string:
                 str_list.append(f'{param.letter}"{param.string_value}"')
@@ -103,13 +112,14 @@ class Code(BaseCommand):
                 str_list.append(f"{param.letter}{param.string_value}")
         return " ".join(str_list)
 
-    def __str__(self):
+    def __str__(self) -> str:
         """Convert the parsed code back to a text-based G/M/T-code"""
         if self.keyword != KeywordType.KeywordNone:
+            keyword = cast(str, self.keyword_to_str())
             if self.keywordArgument is not None:
-                return f"{self.keyword_to_str()} {self.keywordArgument}"
+                return f"{keyword} {self.keywordArgument}"
             else:
-                return self.keyword_to_str()
+                return keyword
 
         if self.type == CodeType.Comment:
             return f";{self.comment}"
@@ -129,7 +139,7 @@ class Code(BaseCommand):
 
         return "".join(str_list)
 
-    def short_str(self):
+    def short_str(self) -> str:
         """Convert only the command portion to a text-based G/M/T-code (e.g. G28)"""
         if self.type == CodeType.Comment:
             return "(comment)"
@@ -143,7 +153,7 @@ class Code(BaseCommand):
 
         return f"{prefix}{self.type}"
 
-    def keyword_to_str(self):
+    def keyword_to_str(self) -> Optional[str]:
         """Convert the keyword to a string"""
         return {
             KeywordType.If: "if",
@@ -159,5 +169,5 @@ class Code(BaseCommand):
             KeywordType.Global: "global",
         }.get(self.keyword)
 
-    def is_flag_set(self, flag: CodeFlags):
+    def is_flag_set(self, flag: CodeFlags) -> bool:
         return self.flags & flag != 0

dsf/commands/code_channel.py

@@ -16,6 +16,8 @@ class CodeChannel(str, Enum):
     # Code channel for USB requests
     USB = "USB"
 
+    USB2 = "USB2"
+
     # Code channel for serial devices (e.g. PanelDue)
     Aux = "Aux"
 
@@ -53,4 +55,8 @@ class CodeChannel(str, Enum):
 
     @staticmethod
     def list():
-        return list(map(lambda cc: cc.value, CodeChannel))
+        return list(map(lambda cc: cc, CodeChannel))
+        
+    def get_input_index(self) -> int:
+        """Get the index of this code channel for use in client init messages"""
+        return self.list().index(self)

dsf/commands/code_interception.py

@@ -24,8 +24,4 @@ def resolve_code(rtype: MessageType, content: Optional[str]):
     :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})

dsf/commands/code_parameter.py

@@ -2,17 +2,40 @@
 codeparameter contains all classes and methods dealing with deserialized code parameters.
 """
 import json
+from typing import Self, TypeAlias, TypedDict, cast, Optional
 
 from ..exceptions import CodeParserException
 from ..object_model.move.driver_id import DriverId
 
 
+CodeParameterScalar: TypeAlias = str | int | float | DriverId
+CodeParameterArray: TypeAlias = list[int] | list[float] | list[DriverId]
+CodeParameterValue: TypeAlias = CodeParameterScalar | CodeParameterArray
+
+
+class CodeParameterJSON(TypedDict):
+    letter: str
+    value: object
+    isString: Optional[bool]
+    isDriverId: Optional[bool]
+
+
 class CodeParameter(json.JSONEncoder):
     """Represents a parsed parameter of a G/M/T-code"""
 
     LETTER_FOR_UNPRECEDENTED_STRING = "@"
-
-    def default(self, o):
+    letter: str
+    string_value: str
+    is_string: Optional[bool]
+    is_expression: bool
+    is_driver_id: bool
+    __parsed_value: object
+
+    @property
+    def value(self) -> object:
+        return self.__parsed_value
+
+    def default(self, o: Self) -> dict[str, object]:
         return {
             "letter": o.letter,
             "value": o.value,
@@ -21,16 +44,22 @@ class CodeParameter(json.JSONEncoder):
         }
 
     @classmethod
-    def from_json(cls, data):
+    def from_json(cls, data: CodeParameterJSON) -> Self:
         """Instantiate a new instance of this class from JSON deserialized dictionary"""
         return cls(**data)
 
     @classmethod
-    def simple_param(cls, letter: str, value, isDriverId: bool = False):
+    def simple_param(cls, letter: str, value: object, isDriverId: bool = False) -> Self:
         """Create a new simple parameter without parsing the value"""
         return cls(letter, value, isDriverId=isDriverId)
 
-    def __init__(self, letter: str, value, isString: bool = None, isDriverId: bool = None):
+    def __init__(
+        self,
+        letter: str,
+        value: object,
+        isString: Optional[bool] = None,
+        isDriverId: Optional[bool] = None,
+    ) -> None:
         """
         Creates a new CodeParameter instance and parses value to a native data type
         if applicable
@@ -45,7 +74,7 @@ class CodeParameter(json.JSONEncoder):
             return
 
         self.letter = letter
-        self.string_value = value
+        self.string_value = str(value)
         self.is_string = isString
         self.is_expression = False
         self.is_driver_id = isDriverId if isDriverId is not None else False
@@ -53,10 +82,10 @@ class CodeParameter(json.JSONEncoder):
             self.__parsed_value = value
             return
         elif self.is_driver_id:
-            drivers = [DriverId(as_str=value) for value in self.string_value.split(":")]
+            drivers = [DriverId(as_str=driver_value) for driver_value in self.string_value.split(":")]
             self.__parsed_value = drivers[0] if len(drivers) == 1 else drivers
 
-        value = value.strip()
+        value = self.string_value.strip()
         # Empty parameters are represented as integers with the value 0 (e.g. G92 XY => G92 X0 Y0)
         if not value:
             self.__parsed_value = 0
@@ -81,7 +110,7 @@ class CodeParameter(json.JSONEncoder):
                 except:  # noqa
                     self.__parsed_value = value
 
-    def convert_driver_ids(self):
+    def convert_driver_ids(self) -> None:
         """Convert this parameter to driver id(s)"""
         if self.is_expression:
             return
@@ -95,23 +124,9 @@ class CodeParameter(json.JSONEncoder):
         else:
             self.__parsed_value = drivers
 
-        drivers = []
-        parameters = self.string_value.split(":")
-        for value in parameters:
-            segments = value.split(".")
-            segment_count = len(segments)
-            if segment_count == 1:
-                drivers.append(int(segments[0]))
-            elif segment_count == 2:
-                driver = (int(segments[0]) << 16) & 0xFFFF
-                driver |= int(segments[1] & 0xFFFF)
-            else:
-                raise CodeParserException(f"Driver value from {self.letter} parameter is invalid")
-
-        self.__parsed_value = drivers[0] if len(drivers) == 1 else drivers
         self.is_driver_id = True
 
-    def as_float(self):
+    def as_float(self) -> float:
         """Conversion to float"""
         if isinstance(self.__parsed_value, float):
             return self.__parsed_value
@@ -120,16 +135,16 @@ class CodeParameter(json.JSONEncoder):
 
         raise Exception(f"Cannot convert {self.letter} parameter to float (value {self.string_value})")
 
-    def as_int(self):
+    def as_int(self) -> int:
         """Conversion to int"""
         if isinstance(self.__parsed_value, int):
             return self.__parsed_value
         if isinstance(self.__parsed_value, DriverId):
-            return self.__parsed_value.as_int()
+            return int(self.__parsed_value.as_int())
 
         raise Exception(f"Cannot convert {self.letter} parameter to int (value {self.string_value})")
 
-    def as_driver_id(self):
+    def as_driver_id(self) -> DriverId:
         if isinstance(self.__parsed_value, DriverId):
             return self.__parsed_value
         if isinstance(self.__parsed_value, int):
@@ -139,67 +154,96 @@ class CodeParameter(json.JSONEncoder):
                 pass
         raise Exception(f"Cannot convert {self.letter} parameter to DriverId (value {self.string_value})")
 
-    def as_float_array(self):
-        """Conversion to float array"""
+    def _parse_expression_array(self) -> list[float]:
+        """Parse expression-based arrays like {0, 255, 128} into a list of floats."""
+        if not self.is_expression:
+            raise Exception(
+                f"Cannot parse expression array: {self.letter} is not an expression (value {self.string_value})"
+            )
+        # Strip braces and split by comma
+        content = self.string_value[1:-1].strip()  # Remove { }
+        if not content:
+            return []
+        elements = [elem.strip() for elem in content.split(",")]
         try:
-            if isinstance(self.__parsed_value, list):
-                return list(map(float, self.__parsed_value))
-            if isinstance(self.__parsed_value, float):
-                return [self.__parsed_value]
-            if isinstance(self.__parsed_value, int):
-                return [float(self.__parsed_value)]
+            # Try to parse as floats first, then convert to ints if needed
+            return [float(elem) for elem in elements if elem]
+        except ValueError as e:
+            raise Exception(
+                f"Cannot parse expression array: failed to convert elements to numbers in {self.letter} (value {self.string_value})"
+            ) from e
+
+    def as_float_array(self) -> list[float]:
+        """Conversion to float array. Supports colon-separated (C0.5:1.0) and expression formats (C{0.5, 1.0})."""
+        try:
+            parsed_value: object = self.__parsed_value
+            if isinstance(parsed_value, list):
+                values = cast(list[int | float], parsed_value)
+                return [float(value) for value in values]
+            if isinstance(parsed_value, float):
+                return [parsed_value]
+            if isinstance(parsed_value, int):
+                return [float(parsed_value)]
+            if self.is_expression:
+                return self._parse_expression_array()
         except:  # noqa
             pass
         raise Exception(f"Cannot convert {self.letter} parameter to float array (value {self.string_value})")
 
-    def as_int_array(self):
-        """Conversion to int array"""
+    def as_int_array(self) -> list[int]:
+        """Conversion to int array. Supports colon-separated (C0:255:128) and expression formats (C{0, 255, 128})."""
         try:
-            if isinstance(self.__parsed_value, list):
-                if isinstance(self.__parsed_value[0], DriverId):
-                    return [d.as_int() for d in self.__parsed_value]
-                return list(map(int, self.__parsed_value))
-            if isinstance(self.__parsed_value, int):
-                return [self.__parsed_value]
-            if isinstance(self.__parsed_value, DriverId):
-                return [self.__parsed_value.as_int()]
+            parsed_value: object = self.__parsed_value
+            if isinstance(parsed_value, list):
+                if isinstance(parsed_value[0], DriverId):
+                    values = cast(list[DriverId], parsed_value)
+                    return [int(value.as_int()) for value in values]
+                values = cast(list[int] | list[float], parsed_value)
+                return [int(value) for value in values]
+            if isinstance(parsed_value, int):
+                return [parsed_value]
+            if isinstance(parsed_value, DriverId):
+                return [int(parsed_value.as_int())]
+            if self.is_expression:
+                float_array = self._parse_expression_array()
+                return [int(value) for value in float_array]
         except:  # noqa
             pass
-        raise Exception(f"Cannot convert {self.letter} parameter to float array (value {self.string_value})")
+        raise Exception(f"Cannot convert {self.letter} parameter to int array (value {self.string_value})")
 
-    def as_driver_id_array(self):
+    def as_driver_id_array(self) -> list[DriverId]:
         try:
-            if isinstance(self.__parsed_value, list):
-                if isinstance(self.__parsed_value[0], DriverId):
-                    return self.__parsed_value
-                if isinstance(self.__parsed_value[0], int):
-                    return list(map(DriverId, self.__parsed_value))
-            if isinstance(self.__parsed_value, DriverId):
-                return [self.__parsed_value]
-            if isinstance(self.__parsed_value, int):
-                return [DriverId(as_int=self.__parsed_value)]
+            parsed_value: object = self.__parsed_value
+            if isinstance(parsed_value, list):
+                if isinstance(parsed_value[0], DriverId):
+                    return cast(list[DriverId], parsed_value)
+                if isinstance(parsed_value[0], int):
+                    values = cast(list[int], parsed_value)
+                    return [DriverId(as_int=value) for value in values]
+            if isinstance(parsed_value, DriverId):
+                return [parsed_value]
+            if isinstance(parsed_value, int):
+                return [DriverId(as_int=parsed_value)]
         except:  # noqa
             pass
         raise Exception(f"Cannot convert {self.letter} parameter to DriverId array (value {self.string_value})")
 
-    def as_bool(self):
+    def as_bool(self) -> bool:
         """Conversion to bool"""
         try:
             return float(self.string_value) > 0
         except:  # noqa
             return False
 
-    def __eq__(self, other):
-        if self is None:
-            return other is None
+    def __eq__(self, other: object) -> bool:
         if isinstance(other, CodeParameter):
             return self.letter == other.letter and self.__parsed_value == other.__parsed_value
         return self.__parsed_value == other
 
-    def __ne__(self, other):
+    def __ne__(self, other: object) -> bool:
         return not self == other
 
-    def __str__(self):
+    def __str__(self) -> str:
         letter = self.letter if not self.letter == CodeParameter.LETTER_FOR_UNPRECEDENTED_STRING else ""
         if self.is_string and not self.is_expression:
             double_quoted = self.string_value.replace('"', '""')

dsf/commands/files.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from .base_command import BaseCommand
 
 
@@ -7,18 +9,18 @@ def get_file_info(file_name: str, read_thumbnail_content: bool = False):
     :param file_name: The filename to extract information from
     :param read_thumbnail_content: Whether thumbnail content shall be returned
     """
-    if not isinstance(file_name, str) or not file_name:
-        raise TypeError("file_name must be a string")
+    if not file_name:
+        raise ValueError("file_name must not be empty")
     return BaseCommand("GetFileInfo", **{"fileName": file_name, "readThumbnailContent": read_thumbnail_content})
 
 
-def resolve_path(path: str, base_directory: str = None):
+def resolve_path(path: str, base_directory: Optional[str] = None):
     """
     Resolve a RepRapFirmware-style path to an actual file path
     :param path: Path that is RepRapFirmware-compatible
     :param base_directory: Optional base directory to resolve the path relative to
     :returns: The resolved path
     """
-    if not isinstance(path, str) or not path:
-        raise TypeError("path must be a string")
+    if not path:
+        raise ValueError("path must not be empty")
     return BaseCommand("ResolvePath", **{"path": path, "baseDirectory": base_directory})

dsf/commands/generic.py

@@ -15,8 +15,8 @@ def check_password(password: str):
 
     :returns: true if the password matches or is not set
     """
-    if not isinstance(password, str) or not password:
-        raise TypeError("password must be a string")
+    if not password:
+        raise ValueError("password must not be empty")
     return BaseCommand("CheckPassword", **{"password": password})
 
 
@@ -29,10 +29,8 @@ def evaluate_expression(channel: CodeChannel, expression: str):
     :param channel: Code channel where the expression is evaluated
     :param expression: Expression to evaluate
     """
-    if not isinstance(channel, CodeChannel):
-        raise TypeError("channel must be a CodeChannel")
-    if not isinstance(expression, str) or not expression:
-        raise TypeError("expression must be a string")
+    if not expression:
+        raise ValueError("expression must not be empty")
     return BaseCommand("EvaluateExpression", **{"channel": channel, "expression": expression})
 
 
@@ -50,12 +48,6 @@ def flush(channel: CodeChannel, sync_file_streams: bool = False, if_executing: b
 
     :returns: true if the flush request is successful
     """
-    if not isinstance(channel, CodeChannel):
-        raise TypeError("channel must be a CodeChannel")
-    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})
 
@@ -68,8 +60,6 @@ def invalidate_channel(channel: CodeChannel):
 
     :returns: true if the invalidate request is successful
     """
-    if not isinstance(channel, CodeChannel):
-        raise TypeError("channel must be a CodeChannel")
     return BaseCommand("InvalidateChannel", **{"channel": channel})
 
 
@@ -79,8 +69,6 @@ def set_update_status(updating: bool):
 
     :param updating: Whether an update is now in progress
     """
-    if not isinstance(updating, bool):
-        raise TypeError("updating must be a boolean")
     return BaseCommand("SetUpdateStatus", **{"updating": updating})
 
 
@@ -97,10 +85,6 @@ def simple_code(code: str, channel: CodeChannel = CodeChannel.DEFAULT_CHANNEL, a
     :param async_exec: Whether this code may be executed asynchronously.
                        If set, the code reply is output as a generic message
     """
-    if not isinstance(code, str) or not code:
-        raise TypeError("code must be a string")
-    if not isinstance(channel, CodeChannel):
-        raise TypeError("channel must be a CodeChannel")
     return BaseCommand("SimpleCode", **{"code": code, "channel": channel, "executeAsynchronously": async_exec})
 
 
@@ -118,14 +102,6 @@ def write_message(
     :param output_message: Output the message on the console and via the object model
     :param log_level: Log level of this message
     """
-    if not isinstance(message_type, MessageType):
-        raise TypeError("rtype must be a MessageType")
-    if not isinstance(content, str):
-        raise TypeError("content must be a string")
-    if not isinstance(output_message, bool):
-        raise TypeError("output_message must be a boolean")
-    if log_level is not None and not isinstance(log_level, LogLevel):
-        raise TypeError("log_message must be a LogLevel")
     return BaseCommand(
         "WriteMessage",
         **{

dsf/commands/http_endpoints.py

@@ -14,14 +14,6 @@ def add_http_endpoint(endpoint_type: HttpEndpointType, namespace: str, path: str
     to whenever a matching HTTP request is received.
     A plugin using this command has to open a new UNIX socket with the given path that DuetWebServer can connect to
     """
-    if not isinstance(endpoint_type, HttpEndpointType):
-        raise TypeError("endpoint_type must be a HttpEndpointType")
-    if not isinstance(namespace, str) or not namespace:
-        raise TypeError("namespace must be a string")
-    if not isinstance(path, str) or not path:
-        raise TypeError("path must be a string")
-    if not isinstance(is_upload_request, bool):
-        raise TypeError("is_upload_request must be a boolean")
     return BaseCommand(
         "AddHttpEndpoint",
         **{
@@ -41,12 +33,6 @@ def remove_http_endpoint(endpoint_type: HttpEndpointType, namespace: str, path:
     :param path: Path to the endpoint to unregister
     :returns: true if the endpoint could be successfully removed
     """
-    if not isinstance(endpoint_type, HttpEndpointType):
-        raise TypeError("endpoint_type must be a HttpEndpointType")
-    if not isinstance(namespace, str) or not namespace:
-        raise TypeError("namespace must be a string")
-    if not isinstance(path, str) or not path:
-        raise TypeError("path must be a string")
     return BaseCommand(
         "RemoveHttpEndpoint",
         **{"endpointType": endpoint_type, "namespace": namespace, "path": path},

dsf/commands/object_model.py

@@ -20,10 +20,6 @@ def patch_object_model(key: str, patch: str):
     :param key: Key to update
     :param patch: JSON patch to apply
     """
-    if not isinstance(key, str) or not key:
-        raise TypeError("key must be a string")
-    if not isinstance(patch, str) or not patch:
-        raise TypeError("patch must be a string")
     return BaseCommand("PatchObjectModel", **{"key": key, "patch": patch})
 
 
@@ -34,10 +30,6 @@ def set_network_protocol(protocol: str, enabled: bool):
     :param enabled: Whether the protocol is enabled or not
     :returns: true if the protocol could be flagged
     """
-    if not isinstance(protocol, str) or not protocol:
-        raise TypeError("protocol must be a string")
-    if not isinstance(enabled, bool):
-        raise TypeError("enabled must be a boolean")
     return BaseCommand("SetNetworkProtocol", **{"networkProtocol": protocol, "enabled": enabled})
 
 
@@ -49,10 +41,6 @@ def set_object_model(property_path: str, value: str):
     :param value: String representation of the value to set
     :returns: true if the field could be updated
     """
-    if not isinstance(property_path, str) or not property_path:
-        raise TypeError("property_path must be a string")
-    if not isinstance(value, str):
-        raise TypeError("value must be a string")
     return BaseCommand("SetObjectModel", **{"propertyPath": property_path, "value": value})