mx-remote 9.1.0__tar.gz → 9.2.0__tar.gz

{mx_remote-9.1.0 → mx_remote-9.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mx_remote
-Version: 9.1.0
+Version: 9.2.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-9.1.0 → mx_remote-9.2.0}/docs/oneip.md

@@ -225,27 +225,36 @@ 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.
 
-How far a device powers down is its power save level: reduced, low or off, each
-powering more down than the one before. Its unit status says which levels it
-supports and what wakes it at each.
+Power save is switched on or off. Switched on, a device powers down by itself
+to its power save level: reduced, low or off, each powering more down than the
+one before. The device picks the level itself, the one that saves the most
+while its input and display can still wake it, and reports it. Its unit status
+says which levels it supports and what wakes it at each.
 
 ```python
 from mx_remote import OneIPPowerSaveLevel, UnitPowerSave
 
-print(settings.power_save_level)
+print(settings.get(OneIPDeviceSetting.POWER_SAVE_DISABLED))         # False: switched on
+print(settings.power_save_level)                                    # the level it picked
 print(device.unit_status.power_save_level(OneIPPowerSaveLevel.LOW))  # e.g. SUPPORTED|INPUT_WAKE
 
-await device.set_oneip_power_save_level(OneIPPowerSaveLevel.LOW)
+await device.set_oneip_power_save(True)
+await mx.set_all_oneip_power_save(False)   # every OneIP device of the mesh
 ```
 
-A level this library does not name is refused before it is sent, and not cached
-from another controller's write.
-
-`OneIPDeviceSetting.POWER_SAVE_DISABLED` is a switch that keeps a device from
-powering down by itself; a power save request still powers it down. A device
-that takes a power save level switches it off, so a level write, this client's
-or another sender's, clears it unless the same frame states it. Firmware
-without the bit never reports it, and the switch is refused there.
+Switched off, `OneIPDeviceSetting.POWER_SAVE_DISABLED` is on: the device does
+not power down by itself, and a power save request still powers it down.
+Switching on is written as a mesh controller writes it, with that switch clear
+and the power save level at 0, so a device whose firmware still takes the level
+as its setting returns to its own default.
+
+`set_oneip_power_save_level()` writes a level, which switches power save on. A
+current device ignores the level; one whose firmware predates picking it takes
+it. A written level is never cached, from this client or another controller:
+`power_save_level` is what the device reports. A level write without the switch
+only clears `POWER_SAVE_DISABLED` on a device that reports it. A level this
+library does not name is refused before it is sent. Firmware without the switch
+never reports it, and switching is refused there.
 
 `OneIPDeviceSetting.CLOUD` is a switch for whether a device connects to the
 cloud service. A device that does not report it connects regardless, and the

{mx_remote-9.1.0 → mx_remote-9.2.0}/mx_remote/Interface.py

@@ -2712,6 +2712,16 @@ class OneIPDeviceSettings:
         self._power_save_level = int(power_save_level)
         self._ptp_messages = ptp_messages if (ptp_messages is not None) else OneIPPtpMessages()
 
+    @classmethod
+    def power_save_switch(cls, enabled:bool) -> 'OneIPDeviceSettings':
+        """The settings that switch a device's power save on or off. On is both
+        POWER_SAVE_DISABLED, clear, and POWER_SAVE_LEVEL, at 0."""
+        disabled = OneIPDeviceSetting.POWER_SAVE_DISABLED
+        if enabled:
+            return cls(valid=(disabled | OneIPDeviceSetting.POWER_SAVE_LEVEL),
+                       power_save_level=OneIPPowerSaveLevel.NONE)
+        return cls(valid=disabled, flags=disabled)
+
     @property
     def valid(self) -> OneIPDeviceSetting:
         """The settings reported so far."""
@@ -2791,8 +2801,9 @@ class OneIPDeviceSettings:
 
     @property
     def power_save_level(self) -> OneIPPowerSaveLevel|int|None:
-        """The level the device powers down to in power save, a raw int for one
-        this library does not name, None while it is not reported."""
+        """The level the device powers down to in power save, which it picks
+        itself, a raw int for one this library does not name, None while it is
+        not reported."""
         if (OneIPDeviceSetting.POWER_SAVE_LEVEL not in self._valid):
             return None
         return _wire_enum(OneIPPowerSaveLevel, self._power_save_level)
@@ -2812,18 +2823,14 @@ class OneIPDeviceSettings:
 
         Each bit in this block's ``valid`` replaces its own setting and leaves
         the others alone, so a write about one setting does not clear what was
-        known about the rest. The exception is POWER_SAVE_DISABLED: a device
-        takes a power save level as switching it off.
+        known about the rest.
         """
         if (previous is None):
             previous = OneIPDeviceSettings()
         valid = self._valid
-        flags = (previous._flags & ~valid) | (self._flags & valid)
-        if (OneIPDeviceSetting.POWER_SAVE_LEVEL in valid) and (OneIPDeviceSetting.POWER_SAVE_DISABLED not in valid):
-            flags &= ~OneIPDeviceSetting.POWER_SAVE_DISABLED
         return OneIPDeviceSettings(
             valid=(previous._valid | valid),
-            flags=flags,
+            flags=((previous._flags & ~valid) | (self._flags & valid)),
             ir_profiles=(self._ir_profiles if (OneIPDeviceSetting.IR_PROFILES in valid)
                          else previous._ir_profiles),
             ir_profile=(self._ir_profile if (OneIPDeviceSetting.IR_PROFILE in valid)
@@ -2850,9 +2857,11 @@ class OneIPDeviceSettings:
         write about it.
 
         A device applies a setting only if it has it, a profile, PTP mode, PTP
-        domain, power save level or PTP DSCP only within its range, a stream
-        TTL only when it is not 0, a rotation only by its own step, and never
-        what only it can report about itself. The step stays the device's.
+        domain or PTP DSCP only within its range, a stream TTL only when it is
+        not 0, a rotation only by its own step, and never what only it can
+        report about itself. The step stays the device's. It picks its power
+        save level itself, and takes a level it is written, without
+        POWER_SAVE_DISABLED, as switching power save on.
 
         reported may be only the bits the device reported, which says nothing
         of its step, so a rotation other than 0 is then left out.
@@ -2871,15 +2880,20 @@ class OneIPDeviceSettings:
             valid &= ~OneIPDeviceSetting.PTP_MODE
         if (self._ptp_domain > ONEIP_PTP_DOMAIN_MAX):
             valid &= ~OneIPDeviceSetting.PTP_DOMAIN
-        if (self._power_save_level > OneIPPowerSaveLevel.OFF):
-            valid &= ~OneIPDeviceSetting.POWER_SAVE_LEVEL
         if (self._ptp_messages.dscp > ONEIP_DSCP_MAX):
             valid &= ~OneIPDeviceSetting.PTP_DSCP
         if (self._ptp_messages.stream_ttl == 0):
             valid &= ~OneIPDeviceSetting.STREAM_TTL
         if not own.takes_sink_rotation(self._ptp_messages.sink_rotation):
             valid &= ~OneIPDeviceSetting.SINK_ROTATION
-        return OneIPDeviceSettings(valid=valid, flags=self._flags, ir_profiles=self._ir_profiles,
+        flags = self._flags
+        if (OneIPDeviceSetting.POWER_SAVE_LEVEL in valid):
+            valid &= ~OneIPDeviceSetting.POWER_SAVE_LEVEL
+            if (OneIPDeviceSetting.POWER_SAVE_DISABLED not in valid) \
+                    and (OneIPDeviceSetting.POWER_SAVE_DISABLED in reported._valid):
+                valid |= OneIPDeviceSetting.POWER_SAVE_DISABLED
+                flags &= ~OneIPDeviceSetting.POWER_SAVE_DISABLED
+        return OneIPDeviceSettings(valid=valid, flags=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,
                                   ptp_mode=self._ptp_mode, ptp_domain=self._ptp_domain,
@@ -3572,9 +3586,13 @@ class DeviceBase(ABC):
     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_power_save(self, enabled:bool) -> bool:
+        '''switch power save on, so the device powers down by itself to the level it picks, or off'''
+
     @abstractmethod
     async def set_oneip_power_save_level(self, level:OneIPPowerSaveLevel) -> bool:
-        '''set the level the device powers down to in power save'''
+        '''write the level the device powers down to in power save, which switches power save on'''
 
     @abstractmethod
     async def set_oneip_ptp_messages(self, which:OneIPDeviceSetting, messages:OneIPPtpMessages) -> bool:

{mx_remote-9.1.0 → mx_remote-9.2.0}/mx_remote/Interface.pyi

@@ -962,6 +962,8 @@ class OneIPTestcard:
 
 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, ptp_mode: OneIPPtpMode | int = ..., ptp_domain: int = 0, ptp_priority1: int = 0, power_save_level: OneIPPowerSaveLevel | int = ..., ptp_messages: OneIPPtpMessages | None = None) -> None: ...
+    @classmethod
+    def power_save_switch(cls, enabled: bool) -> OneIPDeviceSettings: ...
     @property
     def valid(self) -> OneIPDeviceSetting: ...
     @property
@@ -1330,6 +1332,8 @@ class DeviceBase(ABC):
     @abstractmethod
     async def set_oneip_ptp_priority1(self, priority1: int) -> bool: ...
     @abstractmethod
+    async def set_oneip_power_save(self, enabled: bool) -> bool: ...
+    @abstractmethod
     async def set_oneip_power_save_level(self, level: OneIPPowerSaveLevel) -> bool: ...
     @abstractmethod
     async def set_oneip_ptp_messages(self, which: OneIPDeviceSetting, messages: OneIPPtpMessages) -> bool: ...

{mx_remote-9.1.0 → mx_remote-9.2.0}/mx_remote/const.py

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

{mx_remote-9.1.0 → mx_remote-9.2.0}/mx_remote/proto/Constants.py

@@ -349,7 +349,11 @@ class OneIPDeviceSetting(IntFlag):
 	AES67              = (1 << 17)
 	'''Sends the source's audio as an AES67 flow, where the source allows.'''
 	POWER_SAVE_LEVEL   = (1 << 18)
-	'''The power save level the device powers down to.'''
+	'''The level the device powers down to in power save. A device picks it
+	itself: the level that saves the most while its input and display can
+	still wake it. Written without POWER_SAVE_DISABLED, it switches power save
+	on, and the level written is ignored, except by a device whose firmware
+	predates picking it, which takes the level as its setting.'''
 	PTP_ANNOUNCE       = (1 << 19)
 	'''The interval between the device's PTP announce messages.'''
 	PTP_SYNC           = (1 << 20)

{mx_remote-9.1.0 → mx_remote-9.2.0}/mx_remote/remote/Device.py

@@ -76,7 +76,6 @@ from typing import Any, Callable
 from ..compat import override
 from datetime import datetime
 from enum import Enum
-import dataclasses
 import logging
 import time
 
@@ -1572,12 +1571,28 @@ class Device(DeviceBase):
 		return self._send_v2ip_settings(OneIPDeviceSettings(
 			valid=OneIPDeviceSetting.PTP_PRIORITY1, ptp_priority1=priority1))
 
-	async def set_oneip_power_save_level(self, level:OneIPPowerSaveLevel) -> bool:
-		'''Set the level this OneIP device powers down to in power save.
+	async def set_oneip_power_save(self, enabled:bool) -> bool:
+		'''Switch this OneIP device's power save on, so it powers down by itself
+		to the level it picks, or off, so it powers down only when asked.
 
-		A level this library does not name is refused, since a device ignores it.
-		One the unit does not offer is one its unit_status reports without
-		UnitPowerSave.SUPPORTED. The terms of set_oneip_setting() apply.
+		On is written as a mesh controller writes it: both POWER_SAVE_DISABLED,
+		clear, and POWER_SAVE_LEVEL, at 0, so a device whose firmware takes the
+		level as its setting returns to its own default. The terms of
+		set_oneip_setting() apply.
+		'''
+		return self._send_v2ip_settings(OneIPDeviceSettings.power_save_switch(enabled))
+
+	async def set_oneip_power_save_level(self, level:OneIPPowerSaveLevel) -> bool:
+		'''Write the level this OneIP device powers down to in power save, which
+		switches power save on.
+
+		A device picks its level itself and ignores the one written, except one
+		whose firmware predates picking it, which takes the level as its
+		setting. A level that unit does not offer is one its unit_status
+		reports without UnitPowerSave.SUPPORTED. A level this library does not
+		name is refused. The level is not cached: oneip_settings reads what the
+		device reports. set_oneip_power_save() switches power save on or off
+		without naming a level. The terms of set_oneip_setting() apply.
 		'''
 		if not (OneIPPowerSaveLevel.NONE <= level <= OneIPPowerSaveLevel.OFF):
 			_LOGGER.warning(f"not setting power save level {level} on {self}: no such level")
@@ -1612,7 +1627,6 @@ class Device(DeviceBase):
 				_LOGGER.warning(f"not turning the output of {self} by {messages.sink_rotation} degrees: "
 				                f"it turns by steps of {own.sink_rotation_step}")
 				return False
-			messages = dataclasses.replace(messages, sink_rotation_step=own.sink_rotation_step)
 		return self._send_v2ip_settings(OneIPDeviceSettings(valid=which, ptp_messages=messages))
 
 	def _on_oneip_downmix(self, downmix:OneIPDownmix|None, reported:bool) -> None:
@@ -1932,7 +1946,7 @@ class Device(DeviceBase):
 			return False
 		if self.registry.transmit(frame.frame) != len(frame.frame):
 			return False
-		self._merge_v2ip_settings(settings)
+		self._merge_v2ip_settings(settings.as_applied_to(reported))
 		return True
 
 	@property

{mx_remote-9.1.0 → mx_remote-9.2.0}/mx_remote/remote/Device.pyi

@@ -270,6 +270,7 @@ class Device(DeviceBase):
     async def set_oneip_ptp_mode(self, mode: OneIPPtpMode) -> bool: ...
     async def set_oneip_ptp_domain(self, domain: int) -> bool: ...
     async def set_oneip_ptp_priority1(self, priority1: int) -> bool: ...
+    async def set_oneip_power_save(self, enabled: bool) -> bool: ...
     async def set_oneip_power_save_level(self, level: OneIPPowerSaveLevel) -> bool: ...
     async def set_oneip_ptp_messages(self, which: OneIPDeviceSetting, messages: OneIPPtpMessages) -> bool: ...
     async def set_oneip_downmix(self, downmix: OneIPDownmix) -> bool: ...

{mx_remote-9.1.0 → mx_remote-9.2.0}/mx_remote/remote/Remote.py

@@ -561,6 +561,12 @@ class Remote(DeviceRegistry, ConnectionCallbacks):
             return False
         return self._send_to_all(FrameV2IPSettingsAll.construct(mxr=self, settings=settings))
 
+    async def set_all_oneip_power_save(self, enabled:bool) -> bool:
+        '''Switch power save on or off on every OneIP device of the mesh with
+        one frame, written as Device.set_oneip_power_save() writes it.
+        Otherwise as set_all_oneip_device_settings().'''
+        return await self.set_all_oneip_device_settings(OneIPDeviceSettings.power_save_switch(enabled))
+
     async def request_all_oneip_privacy(self) -> bool:
         '''Ask every OneIP source unit of the mesh how its streams are
         encrypted, as Device.request_oneip_privacy() asks one. A unit below

{mx_remote-9.1.0 → mx_remote-9.2.0}/mx_remote/remote/Remote.pyi

@@ -73,6 +73,7 @@ class Remote(DeviceRegistry, ConnectionCallbacks):
     def transmit(self, data: bytes) -> int: ...
     def tx_discover(self) -> int: ...
     async def set_all_oneip_device_settings(self, settings: OneIPDeviceSettings) -> bool: ...
+    async def set_all_oneip_power_save(self, enabled: bool) -> bool: ...
     async def request_all_oneip_privacy(self) -> bool: ...
     async def set_mesh_time_zone(self, zone: str, rule: str) -> bool: ...
     async def clear_mesh_time_zone(self) -> bool: ...

{mx_remote-9.1.0 → mx_remote-9.2.0}/tests/v2ipsettings.py

@@ -373,7 +373,8 @@ assert call(level.set_oneip_power_save_level(mx_remote.OneIPPowerSaveLevel.OFF))
 block = sent[-1][24 + 128:]
 assert struct.unpack('<I', block[:4])[0] == int(S.POWER_SAVE_LEVEL)
 assert block[44:48] == bytes([0, 0, 0, 3]), block[44:48].hex()
-assert level.oneip_settings.power_save_level is mx_remote.OneIPPowerSaveLevel.OFF
+assert level.oneip_settings.power_save_level is mx_remote.OneIPPowerSaveLevel.LOW, 'a written level was cached'
+assert level.oneip_settings.get(S.POWER_SAVE_DISABLED) is None, 'a switch the device does not have'
 assert call(level.set_oneip_setting(S.AES67, False)) is True, 'AES67 is not switched'
 assert level.oneip_settings.get(S.AES67) is False
 refused(level.set_oneip_power_save_level(4), 'a power save level with no name')
@@ -397,6 +398,35 @@ assert struct.unpack('<II', sent[-1][24 + 128:24 + 136]) == (DIS, DIS)
 refused(ptp.set_oneip_setting(S.POWER_SAVE_DISABLED, True), 'a unit that never reported the bit')
 print('ps disabled : a switch, and a level switches it off')
 
+# Power save is switched on as a mesh controller switches it, with both bits
+# and a level of 0, and off with the switch alone. A device picks its level
+# itself, so a written level, ours or another sender's, is never cached, and
+# only switches power save on.
+BOTH = int(S.POWER_SAVE_LEVEL) | DIS
+rx(uid(0x22), 0x3C, cfg_level(uid(0x22), LEVEL | DIS, 2, flags=DIS))
+cached = lambda: (level.oneip_settings.get(S.POWER_SAVE_DISABLED), level.oneip_settings.power_save_level)
+LOW = mx_remote.OneIPPowerSaveLevel.LOW
+assert call(level.set_oneip_power_save(True)) is True
+block = sent[-1][24 + 128:]
+assert struct.unpack('<II', block[:8]) == (BOTH, 0), block[:8].hex()
+assert block[47] == 0, 'the level'
+assert cached() == (False, LOW), cached()
+assert call(level.set_oneip_power_save(False)) is True
+block = sent[-1][24 + 128:]
+assert struct.unpack('<II', block[:8]) == (DIS, DIS), block[:8].hex()
+assert cached() == (True, LOW), cached()
+assert call(level.set_oneip_power_save_level(mx_remote.OneIPPowerSaveLevel.OFF)) is True
+assert cached() == (False, LOW), "our level"
+# Another sender's level: a flag outside valid says nothing, and one behind its
+# own bit decides.
+assert call(level.set_oneip_power_save(False)) is True
+rx(uid(0x04), 0x3C, cfg_level(uid(0x22), int(S.POWER_SAVE_LEVEL), 3, flags=DIS))
+assert cached() == (False, LOW), "another sender's level"
+rx(uid(0x04), 0x3C, cfg_level(uid(0x22), BOTH, 3, flags=DIS))
+assert cached() == (True, LOW), 'and its switch'
+refused(ptp.set_oneip_power_save(True), 'a unit that never reported the bits')
+print('ps switch   : both bits and level 0 on, the switch alone off; the level is the device\'s')
+
 # The cloud connection is a switch too. A unit without the bit connects
 # regardless, and never reports it, so the switch is refused there.
 CLOUD = int(S.CLOUD)
@@ -540,6 +570,16 @@ write = mx_remote.OneIPDeviceSettings(valid=S.STATUS_LED | S.SINK_ROTATION,
 assert write.as_applied_to(S.STATUS_LED | S.SINK_ROTATION).valid == S.STATUS_LED
 print('rotation    : a u16 at 10, by the unit\'s own step, which a write leaves 0')
 
+# The mesh-wide power save switch writes what the per-device one does, in the
+# frame every unit of the mesh applies.
+for enabled, valid, flags in ((True, BOTH, 0), (False, DIS, DIS)):
+    assert call(mx.set_all_oneip_power_save(enabled)) is True, enabled
+    p = sent[-1][24:]
+    assert len(p) == 48, (enabled, len(p))
+    assert struct.unpack('<II', p[:8]) == (valid, flags), (enabled, p[:8].hex())
+    assert p[47] == 0, enabled
+print('ps all      : the mesh-wide switch is the per-device one')
+
 # What the builder writes, the decoder reads back as the same settings.
 assert call(target.set_oneip_ir_profile(7)) is True
 rx(uid(0x10), 0x3C, sent[-1][24:])