mx-remote 6.2.0__tar.gz → 7.0.0__tar.gz

{mx_remote-6.2.0 → mx_remote-7.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mx_remote
-Version: 6.2.0
+Version: 7.0.0
 Summary: Python 3 library for interfacing with MX Remote compatible devices
 Project-URL: Homepage, https://github.com/opdenkamp/mx-remote/
 Project-URL: Documentation, https://opdenkamp.github.io/mx-remote/

{mx_remote-6.2.0 → mx_remote-7.0.0}/docs/api.md

@@ -94,6 +94,52 @@ bit, and the range of the infrared profiles.
 .. autodata:: mx_remote.proto.Constants.ONEIP_VLAN_ID_MAX
 ```
 
+## OneIP PTP
+
+A device's PTP settings, which it reports and a controller writes, and the PTP
+state only the device reports.
+
+```{eval-rst}
+.. autoclass:: mx_remote.OneIPPtpState
+   :members:
+
+.. autoclass:: mx_remote.proto.Constants.OneIPPtpMode
+   :members:
+
+.. autoclass:: mx_remote.proto.Constants.OneIPPtpFlag
+   :members:
+
+.. autoclass:: mx_remote.proto.Constants.OneIPPtpLock
+   :members:
+
+.. autodata:: mx_remote.proto.Constants.ONEIP_DEVICE_SETTINGS_PTP
+
+.. autodata:: mx_remote.proto.Constants.ONEIP_PTP_DOMAIN_MAX
+```
+
+## Unit status and commands
+
+A unit's health and IP configuration, and the commands sent to one unit.
+
+```{eval-rst}
+.. autoclass:: mx_remote.UnitStatus
+   :members:
+
+.. autoclass:: mx_remote.UnitNetConfig
+   :members:
+
+.. autoclass:: mx_remote.proto.Constants.UnitFlag
+   :members:
+
+.. autoclass:: mx_remote.proto.Constants.UnitCommandKind
+   :members:
+
+.. autoclass:: mx_remote.proto.Constants.UnitCommandFlag
+   :members:
+
+.. autodata:: mx_remote.proto.Constants.UNIT_MAX_TEMPERATURES
+```
+
 ## OneIP test card
 
 A sink's test pattern, tone and lip-sync flash, and the ranges it accepts.

{mx_remote-6.2.0 → mx_remote-7.0.0}/docs/oneip.md

@@ -222,6 +222,35 @@ goes out at 176 bytes: a receiver with the schedule ignores the settings of a
 shorter frame, and one whose settings end at the idle minutes takes it all the
 same.
 
+### PTP
+
+A device's PTP mode, domain and grandmaster priority1 are settings like the
+others, each behind its own bit.
+
+```python
+from mx_remote import OneIPPtpMode
+
+print(settings.ptp_mode, settings.ptp_domain, settings.ptp_priority1)
+
+await device.set_oneip_ptp_mode(OneIPPtpMode.AUTO)   # follow, or lead when no one does
+await device.set_oneip_ptp_domain(0)                 # up to ONEIP_PTP_DOMAIN_MAX
+await device.set_oneip_ptp_priority1(128)            # lower wins
+```
+
+A mode this library does not name and a domain above `ONEIP_PTP_DOMAIN_MAX` are
+refused before they are sent, and not cached from another controller's write.
+
+What the device's clock is actually doing is its PTP state, which only the
+device reports about itself and nothing writes:
+
+```python
+ptp = device.oneip_ptp        # None: no report yet, no PTP, or in power save
+if ptp is not None:
+    print(ptp.mode, ptp.domain, ptp.lock, ptp.port_state)   # port_state per IEEE 1588
+    print(ptp.followed)       # locked to a master since PTP started
+    print(ptp.grandmaster)    # its clock identity, None while there is none
+```
+
 ### VLAN
 
 A device that announces `DeviceFeature.VLAN` tags its uplink by a VLAN
@@ -300,7 +329,44 @@ await mx.set_all_oneip_device_settings(OneIPDeviceSettings(
 Nothing is cached from it: each device that applies a change reports its
 settings, and its `oneip_settings` reads that. What every device would ignore is
 refused rather than sent - no setting at all, one only a device reports about
-itself, a profile out of range, or a schedule time that is not a time of day.
+itself, a profile, PTP mode or PTP domain out of range, or a schedule time that
+is not a time of day.
+
+## Unit status and commands
+
+A unit on protocol 0x2C reports its health and IP configuration with its
+periodic broadcast, and within a few seconds of a change to its flags, status
+or addresses.
+
+```python
+from mx_remote import UnitFlag
+
+status = device.unit_status     # None until the unit has reported
+print(status.uptime, status.boot_count, status.reboot_count)
+print(status.network)           # address, netmask, gateway, two DNS servers
+print(status.fan_rpm, status.temperatures, status.status_message)
+print(UnitFlag.DHCP in status.flags, status.network_pending)
+```
+
+A unit takes a command only from its mesh controller or a management
+application, which this client announces itself as:
+
+```python
+from mx_remote import UnitNetConfig
+
+await device.clear_unit_status()
+await device.upgrade_unit_video_processor(force=False)
+await device.set_unit_network(UnitNetConfig(
+    ip='10.1.2.3', netmask='255.255.255.0', gateway='10.1.2.254', dns1='10.1.2.254'))
+await device.confirm_unit_network()    # keep it, once the unit reports it
+await device.set_unit_dhcp()
+```
+
+A changed IP configuration applies at once and reverts unless the mesh
+controller confirms it in time; `status.network_pending` says whether it still
+waits. Each command returns False without sending for a device that is not a
+OneIP unit, one below 0x2C, or an address and netmask a unit cannot hold.
+Nothing acknowledges a command: `unit_status` reads what the unit reports next.
 
 ## Mesh and firmware
 

{mx_remote-6.2.0 → mx_remote-7.0.0}/mx_remote/Interface.py

@@ -42,7 +42,7 @@ def mxr_valid_addresses() -> list[str]:
     Get the list of valid local_ip addresses that can be used
 
     Returns:
-        addresses (list[str]): list of IP addressses that can be used for the local_ip parameter
+        list[str]: the IP addresses that can be used for the local_ip parameter
     """
     addresses:list[str] = []
     for iface in netifaces.interfaces():
@@ -1946,6 +1946,133 @@ def _vlan_port_index(wire:int) -> int|None:
     '''A port index from its 1-based wire form.'''
     return (wire - 1) if (1 <= wire <= ONEIP_VLAN_PORTS) else None
 
+@dataclass(frozen=True)
+class UnitNetConfig:
+    """An IP configuration: the addresses a unit uses, or is told to use."""
+    ip: str = '0.0.0.0'
+    """The address."""
+    netmask: str = '0.0.0.0'
+    """The netmask."""
+    gateway: str = '0.0.0.0'
+    """The gateway."""
+    dns1: str = '0.0.0.0'
+    """The primary DNS server."""
+    dns2: str = '0.0.0.0'
+    """The secondary DNS server."""
+
+    @property
+    def addresses(self) -> tuple[str, str, str, str, str]:
+        """The five addresses, in the order the wire carries them."""
+        return (self.ip, self.netmask, self.gateway, self.dns1, self.dns2)
+
+    def is_valid(self) -> bool:
+        """Whether every address parses, the address is one a unit can hold,
+        and the netmask is a run of ones from the top."""
+        try:
+            for address in self.addresses:
+                ipaddress.IPv4Address(address)
+            ip = ipaddress.IPv4Address(self.ip)
+            mask = int(ipaddress.IPv4Address(self.netmask))
+        except ValueError:
+            return False
+        host = ~mask & 0xFFFFFFFF   # all ones from the bottom for a valid netmask
+        return not (ip.is_unspecified or ip.is_multicast or (int(ip) == 0xFFFFFFFF)) \
+            and (mask != 0) and ((host & (host + 1)) == 0)
+
+    def __str__(self) -> str:
+        return f"{self.ip}/{self.netmask} gw {self.gateway} dns {self.dns1} {self.dns2}"
+
+@dataclass(frozen=True)
+class UnitStatus:
+    """
+    A unit's health and IP configuration, as it last reported them.
+
+    A unit reports this about itself with its periodic broadcast, and within a
+    few seconds of a change to its flags, its status or its addresses.
+    """
+    flags: UnitFlag = UnitFlag(0)
+    """The report's flags."""
+    uptime: int = 0
+    """Seconds since the unit booted."""
+    boot_count: int|None = None
+    """How often the unit has booted, None while it does not report it."""
+    reboot_count: int = 0
+    """How often the unit has rebooted."""
+    encoder_health: int = 0
+    """The encoder's health, a mask of the unit's encoder status bits."""
+    decoder_health: int = 0
+    """The decoder's health, a mask of the unit's decoder status and state bits."""
+    network: UnitNetConfig = UnitNetConfig()
+    """The IP configuration in use."""
+    fan_rpm: int|None = None
+    """The fan speed in RPM, None while the unit does not report it."""
+    fan_duty: int = 0
+    """The fan duty cycle, in percent."""
+    status: int = 0
+    """The unit's system status."""
+    net_revert_s: int = 0
+    """Seconds before a pending IP configuration is reverted."""
+    temperatures: tuple[int, ...] = ()
+    """Temperatures in degrees Celsius, at most UNIT_MAX_TEMPERATURES of them."""
+    status_message: str = ''
+    """The message of the current system status."""
+
+    @property
+    def network_pending(self) -> bool:
+        """Whether an IP configuration changed through the mesh waits for the
+        mesh controller to confirm it."""
+        return UnitFlag.NET_PENDING in self.flags
+
+    def __str__(self) -> str:
+        return (f"up {self.uptime}s boots {self.boot_count} reboots {self.reboot_count} "
+                f"encoder {self.encoder_health:#x} decoder {self.decoder_health:#x} net [{self.network}] "
+                f"fan {self.fan_rpm} rpm {self.fan_duty}% status {self.status} '{self.status_message}' "
+                f"temperatures {list(self.temperatures)} flags {self.flags!r}")
+
+@dataclass(frozen=True)
+class OneIPPtpState:
+    """
+    A OneIP device's PTP state, as it reports it about itself.
+
+    Only the device can read its own video processor, so this is never written
+    to a device, and a controller's frame about one carries none.
+    """
+    flags: OneIPPtpFlag = OneIPPtpFlag(0)
+    """The block's flags."""
+    mode: OneIPPtpMode|int = OneIPPtpMode.OFF
+    """The mode the video processor runs; a raw int for one this library does
+    not name."""
+    domain: int = 0
+    """The domain the video processor runs in."""
+    port_state: int = 0
+    """The IEEE 1588 portState."""
+    lock: OneIPPtpLock|int = OneIPPtpLock.UNLOCKED
+    """How far the clock has locked; a raw int for a value this library does
+    not name."""
+    clock_identity: bytes = bytes(8)
+    """The device's own clock identity."""
+    grandmaster_identity: bytes = bytes(8)
+    """The clock identity of the grandmaster the device runs on, all zero
+    while it runs on none."""
+
+    @property
+    def followed(self) -> bool:
+        """Whether the device locked to a master since its PTP started, so its
+        mesh holds a time."""
+        return OneIPPtpFlag.FOLLOWED in self.flags
+
+    @property
+    def grandmaster(self) -> bytes|None:
+        """The grandmaster the device runs on, None while it runs on none."""
+        return self.grandmaster_identity if any(self.grandmaster_identity) else None
+
+    def __str__(self) -> str:
+        mode = self.mode.name.lower() if isinstance(self.mode, OneIPPtpMode) else self.mode
+        lock = self.lock.name.lower() if isinstance(self.lock, OneIPPtpLock) else self.lock
+        gm = self.grandmaster.hex(':') if (self.grandmaster is not None) else 'none'
+        return (f"{mode} domain {self.domain} port state {self.port_state} {lock}"
+                f"{' followed' if self.followed else ''} clock {self.clock_identity.hex(':')} grandmaster {gm}")
+
 @dataclass(frozen=True)
 class OneIPVlan:
     """
@@ -2117,7 +2244,8 @@ class OneIPDeviceSettings:
     def __init__(self, valid:OneIPDeviceSetting=OneIPDeviceSetting(0),
                  flags:OneIPDeviceSetting=OneIPDeviceSetting(0), ir_profiles:int=0,
                  ir_profile:int=0, ir_profile_sink:int=0, auto_power_save:int=0,
-                 power_save:OneIPPowerSaveSchedule|None=None) -> None:
+                 power_save:OneIPPowerSaveSchedule|None=None, ptp_mode:OneIPPtpMode|int=OneIPPtpMode.OFF,
+                 ptp_domain:int=0, ptp_priority1:int=0) -> None:
         self._valid = OneIPDeviceSetting(valid)
         self._flags = OneIPDeviceSetting(flags)
         self._ir_profiles = ir_profiles
@@ -2125,6 +2253,9 @@ class OneIPDeviceSettings:
         self._ir_profile_sink = ir_profile_sink
         self._auto_power_save = auto_power_save
         self._power_save = power_save if (power_save is not None) else OneIPPowerSaveSchedule()
+        self._ptp_mode = int(ptp_mode)
+        self._ptp_domain = ptp_domain
+        self._ptp_priority1 = ptp_priority1
 
     @property
     def valid(self) -> OneIPDeviceSetting:
@@ -2180,6 +2311,29 @@ class OneIPDeviceSettings:
             return None
         return self._power_save
 
+    @property
+    def ptp_mode(self) -> OneIPPtpMode|int|None:
+        """The PTP mode, a raw int for one this library does not name, None
+        while it is not reported."""
+        if (OneIPDeviceSetting.PTP_MODE not in self._valid):
+            return None
+        return _wire_enum(OneIPPtpMode, self._ptp_mode)
+
+    @property
+    def ptp_domain(self) -> int|None:
+        """The PTP domain, up to ONEIP_PTP_DOMAIN_MAX, None while it is not reported."""
+        if (OneIPDeviceSetting.PTP_DOMAIN not in self._valid):
+            return None
+        return self._ptp_domain
+
+    @property
+    def ptp_priority1(self) -> int|None:
+        """The priority1 the device announces as a PTP grandmaster, lower
+        winning, None while it is not reported."""
+        if (OneIPDeviceSetting.PTP_PRIORITY1 not in self._valid):
+            return None
+        return self._ptp_priority1
+
     def merge(self, previous:'OneIPDeviceSettings|None') -> 'OneIPDeviceSettings':
         """
         Fold this received block onto the cached one.
@@ -2203,31 +2357,46 @@ class OneIPDeviceSettings:
             auto_power_save=(self._auto_power_save if (OneIPDeviceSetting.AUTO_POWER_SAVE in valid)
                              else previous._auto_power_save),
             power_save=(self._power_save if (OneIPDeviceSetting.POWER_SAVE_SCHEDULE in valid)
-                        else previous._power_save))
+                        else previous._power_save),
+            ptp_mode=(self._ptp_mode if (OneIPDeviceSetting.PTP_MODE in valid)
+                      else previous._ptp_mode),
+            ptp_domain=(self._ptp_domain if (OneIPDeviceSetting.PTP_DOMAIN in valid)
+                        else previous._ptp_domain),
+            ptp_priority1=(self._ptp_priority1 if (OneIPDeviceSetting.PTP_PRIORITY1 in valid)
+                           else previous._ptp_priority1))
 
     def as_applied_to(self, reported:OneIPDeviceSetting) -> 'OneIPDeviceSettings':
         """
         This block limited to what a device takes from a write about it.
 
-        A device applies a setting only if it has it, a profile only within its
-        range, and never what only it can report about itself.
+        A device applies a setting only if it has it, a profile, PTP mode or PTP
+        domain only within its range, and never what only it can report about
+        itself.
         """
         valid = (self._valid & reported) & ~ONEIP_DEVICE_SETTINGS_REPORTED_ONLY
         if not (0 <= self._ir_profile < ONEIP_IR_PROFILE_MAX):
             valid &= ~OneIPDeviceSetting.IR_PROFILE
         if not (ONEIP_IR_PROFILE_NOT_SET <= self._ir_profile_sink < ONEIP_IR_PROFILE_MAX):
             valid &= ~OneIPDeviceSetting.IR_PROFILE_SINK
+        if (self._ptp_mode > OneIPPtpMode.AUTO):
+            valid &= ~OneIPDeviceSetting.PTP_MODE
+        if (self._ptp_domain > ONEIP_PTP_DOMAIN_MAX):
+            valid &= ~OneIPDeviceSetting.PTP_DOMAIN
         return OneIPDeviceSettings(valid=valid, flags=self._flags, ir_profiles=self._ir_profiles,
                                   ir_profile=self._ir_profile, ir_profile_sink=self._ir_profile_sink,
-                                  auto_power_save=self._auto_power_save, power_save=self._power_save)
+                                  auto_power_save=self._auto_power_save, power_save=self._power_save,
+                                  ptp_mode=self._ptp_mode, ptp_domain=self._ptp_domain,
+                                  ptp_priority1=self._ptp_priority1)
 
     def __eq__(self, other:Any) -> bool:
         if not isinstance(other, OneIPDeviceSettings):
             return NotImplemented
         return ((self._valid, self._flags, self._ir_profiles, self._ir_profile, self._ir_profile_sink,
-                 self._auto_power_save, self._power_save)
+                 self._auto_power_save, self._power_save, self._ptp_mode, self._ptp_domain,
+                 self._ptp_priority1)
                 == (other._valid, other._flags, other._ir_profiles, other._ir_profile, other._ir_profile_sink,
-                    other._auto_power_save, other._power_save))
+                    other._auto_power_save, other._power_save, other._ptp_mode, other._ptp_domain,
+                    other._ptp_priority1))
 
     def __ne__(self, other:Any) -> bool:
         result = self.__eq__(other)
@@ -2249,6 +2418,12 @@ class OneIPDeviceSettings:
             parts.append(f"auto_power_save={self.auto_power_save}")
         if (self.power_save_schedule is not None):
             parts.append(f"power_save=[{self.power_save_schedule}]")
+        if ((mode := self.ptp_mode) is not None):
+            parts.append(f"ptp_mode={mode.name.lower() if isinstance(mode, OneIPPtpMode) else mode}")
+        if (self.ptp_domain is not None):
+            parts.append(f"ptp_domain={self.ptp_domain}")
+        if (self.ptp_priority1 is not None):
+            parts.append(f"ptp_priority1={self.ptp_priority1}")
         return " ".join(parts)
 
     def __repr__(self) -> str:
@@ -2575,6 +2750,39 @@ class DeviceBase(ABC):
         '''The VLAN configuration this OneIP device last reported about itself,
         None until it has reported one.'''
 
+    @property
+    @abstractmethod
+    def unit_status(self) -> UnitStatus|None:
+        '''The health and IP configuration this unit last reported, None until
+        it has reported them.'''
+
+    @abstractmethod
+    async def clear_unit_status(self) -> bool:
+        '''clear the unit's current system status'''
+
+    @abstractmethod
+    async def upgrade_unit_video_processor(self, force:bool=False) -> bool:
+        '''upgrade the unit's video processor to the latest image it holds'''
+
+    @abstractmethod
+    async def set_unit_dhcp(self) -> bool:
+        '''switch the unit to an IP configuration from DHCP'''
+
+    @abstractmethod
+    async def set_unit_network(self, network:UnitNetConfig) -> bool:
+        '''give the unit a static IP configuration'''
+
+    @abstractmethod
+    async def confirm_unit_network(self) -> bool:
+        '''keep the unit's pending IP configuration'''
+
+    @property
+    @abstractmethod
+    def oneip_ptp(self) -> OneIPPtpState|None:
+        '''The PTP state this OneIP device last reported about itself, None
+        until it has reported one, and while it has no PTP to report: none on
+        its video processor, or in power save.'''
+
     @property
     @abstractmethod
     def oneip_testcard(self) -> OneIPTestcard|None:
@@ -2848,6 +3056,18 @@ class DeviceBase(ABC):
     async def set_oneip_power_save_schedule(self, schedule:OneIPPowerSaveSchedule) -> bool:
         '''set the device's daily power save windows'''
 
+    @abstractmethod
+    async def set_oneip_ptp_mode(self, mode:OneIPPtpMode) -> bool:
+        '''set the PTP mode the device runs'''
+
+    @abstractmethod
+    async def set_oneip_ptp_domain(self, domain:int) -> bool:
+        '''set the PTP domain the device runs in'''
+
+    @abstractmethod
+    async def set_oneip_ptp_priority1(self, priority1:int) -> bool:
+        '''set the priority1 the device announces as a PTP grandmaster'''
+
     @abstractmethod
     async def set_oneip_vlan(self, vlan:OneIPVlan) -> bool:
         '''change the device's VLAN configuration'''

{mx_remote-6.2.0 → mx_remote-7.0.0}/mx_remote/Interface.pyi

@@ -696,6 +696,49 @@ class OneIPPowerSaveSchedule:
     def __eq__(self, other: Any) -> bool: ...
     def __hash__(self) -> int: ...
 
+@dataclass(frozen=True)
+class UnitNetConfig:
+    ip: str = ...
+    netmask: str = ...
+    gateway: str = ...
+    dns1: str = ...
+    dns2: str = ...
+    @property
+    def addresses(self) -> tuple[str, str, str, str, str]: ...
+    def is_valid(self) -> bool: ...
+
+@dataclass(frozen=True)
+class UnitStatus:
+    flags: UnitFlag = ...
+    uptime: int = ...
+    boot_count: int | None = ...
+    reboot_count: int = ...
+    encoder_health: int = ...
+    decoder_health: int = ...
+    network: UnitNetConfig = ...
+    fan_rpm: int | None = ...
+    fan_duty: int = ...
+    status: int = ...
+    net_revert_s: int = ...
+    temperatures: tuple[int, ...] = ...
+    status_message: str = ...
+    @property
+    def network_pending(self) -> bool: ...
+
+@dataclass(frozen=True)
+class OneIPPtpState:
+    flags: OneIPPtpFlag = ...
+    mode: OneIPPtpMode | int = ...
+    domain: int = ...
+    port_state: int = ...
+    lock: OneIPPtpLock | int = ...
+    clock_identity: bytes = ...
+    grandmaster_identity: bytes = ...
+    @property
+    def followed(self) -> bool: ...
+    @property
+    def grandmaster(self) -> bytes | None: ...
+
 @dataclass(frozen=True)
 class OneIPVlan:
     flags: OneIPVlanFlag = ...
@@ -747,7 +790,7 @@ class OneIPTestcard:
     def supported(self) -> bool: ...
 
 class OneIPDeviceSettings:
-    def __init__(self, valid: OneIPDeviceSetting = ..., flags: OneIPDeviceSetting = ..., ir_profiles: int = 0, ir_profile: int = 0, ir_profile_sink: int = 0, auto_power_save: int = 0, power_save: OneIPPowerSaveSchedule | None = None) -> None: ...
+    def __init__(self, valid: OneIPDeviceSetting = ..., flags: OneIPDeviceSetting = ..., ir_profiles: int = 0, ir_profile: int = 0, ir_profile_sink: int = 0, auto_power_save: int = 0, power_save: OneIPPowerSaveSchedule | None = None, ptp_mode: OneIPPtpMode | int = ..., ptp_domain: int = 0, ptp_priority1: int = 0) -> None: ...
     @property
     def valid(self) -> OneIPDeviceSetting: ...
     @property
@@ -763,6 +806,12 @@ class OneIPDeviceSettings:
     def auto_power_save(self) -> int | None: ...
     @property
     def power_save_schedule(self) -> OneIPPowerSaveSchedule | None: ...
+    @property
+    def ptp_mode(self) -> OneIPPtpMode | int | None: ...
+    @property
+    def ptp_domain(self) -> int | None: ...
+    @property
+    def ptp_priority1(self) -> int | None: ...
     def merge(self, previous: OneIPDeviceSettings | None) -> OneIPDeviceSettings: ...
     def as_applied_to(self, reported: OneIPDeviceSetting) -> OneIPDeviceSettings: ...
     def __eq__(self, other: Any) -> bool: ...
@@ -956,6 +1005,22 @@ class DeviceBase(ABC):
     def oneip_vlan(self) -> OneIPVlan | None: ...
     @property
     @abstractmethod
+    def unit_status(self) -> UnitStatus | None: ...
+    @abstractmethod
+    async def clear_unit_status(self) -> bool: ...
+    @abstractmethod
+    async def upgrade_unit_video_processor(self, force: bool = False) -> bool: ...
+    @abstractmethod
+    async def set_unit_dhcp(self) -> bool: ...
+    @abstractmethod
+    async def set_unit_network(self, network: UnitNetConfig) -> bool: ...
+    @abstractmethod
+    async def confirm_unit_network(self) -> bool: ...
+    @property
+    @abstractmethod
+    def oneip_ptp(self) -> OneIPPtpState | None: ...
+    @property
+    @abstractmethod
     def oneip_testcard(self) -> OneIPTestcard | None: ...
     @property
     @abstractmethod
@@ -1081,6 +1146,12 @@ class DeviceBase(ABC):
     @abstractmethod
     async def set_oneip_power_save_schedule(self, schedule: OneIPPowerSaveSchedule) -> bool: ...
     @abstractmethod
+    async def set_oneip_ptp_mode(self, mode: OneIPPtpMode) -> bool: ...
+    @abstractmethod
+    async def set_oneip_ptp_domain(self, domain: int) -> bool: ...
+    @abstractmethod
+    async def set_oneip_ptp_priority1(self, priority1: int) -> bool: ...
+    @abstractmethod
     async def set_oneip_vlan(self, vlan: OneIPVlan) -> bool: ...
     @abstractmethod
     async def set_audio_endpoint_locked(self, endpoint: int, locked: bool) -> bool: ...

{mx_remote-6.2.0 → mx_remote-7.0.0}/mx_remote/const.py

@@ -14,7 +14,7 @@ Default communication modes:
 """
 import os
 
-VERSION = '6.2.0'
+VERSION = '7.0.0'
 __version__ = VERSION
 
 MX_BCAST_UDP_PORT = 8811