Merged branch sdk_plugin_testing

Author: jath03

openrgb/network.py

@@ -167,6 +167,32 @@ def read(self):
                 finally:
                     self.lock.release()
                 self.callback(device_id, packet_type, utils.parse_list(utils.Profile, idata, self._protocol_version))
+            elif packet_type == utils.PacketType.REQUEST_PLUGIN_LIST:
+                try:
+                    data = bytes()
+                    while len(data) < packet_size:
+                        data += self.sock.recv(packet_size - len(data))
+                    idata = iter(data)
+                    for _ in range(4):
+                        next(idata)
+                except utils.CONNECTION_ERRORS as e:
+                    self.stop_connection()
+                    raise utils.OpenRGBDisconnected() from e
+                finally:
+                    self.lock.release()
+                self.callback(device_id, packet_type, utils.parse_list(utils.Plugin, idata, self._protocol_version))
+            elif packet_type == utils.PacketType.PLUGIN_SPECIFIC:
+                try:
+                    data = bytes()
+                    while len(data) < packet_size:
+                        data += self.sock.recv(packet_size - len(data))
+                    idata = iter(data)
+                except utils.CONNECTION_ERRORS as e:
+                    self.stop_connection()
+                    raise utils.OpenRGBDisconnected() from e
+                finally:
+                    self.lock.release()
+                self.callback(device_id, packet_type, idata)
 
     def requestDeviceData(self, device: int):
         '''
@@ -194,7 +220,14 @@ def requestProfileList(self):
         self.send_header(0, utils.PacketType.REQUEST_PROFILE_LIST, 0)
         self.read()
 
-    def send_header(self, device_id: int, packet_type: utils.PacketType, packet_size: int):
+    def requestPluginList(self):
+        '''
+        Sends the request for the available plugins
+        '''
+        self.send_header(0, utils.PacketType.REQUEST_PLUGIN_LIST, 0)
+        self.read()
+
+    def send_header(self, device_id: int, packet_type: utils.PacketType, packet_size: int, release_lock: bool = True):
         '''
         Sends a header to the SDK
 
@@ -215,10 +248,12 @@ def send_header(self, device_id: int, packet_type: utils.PacketType, packet_size
             if sent != len(data):
                 self.stop_connection()
                 raise utils.OpenRGBDisconnected()
-            if packet_size == 0 and packet_type not in (utils.PacketType.REQUEST_CONTROLLER_COUNT,
-                                                        utils.PacketType.REQUEST_CONTROLLER_DATA,
-                                                        utils.PacketType.REQUEST_PROTOCOL_VERSION,
-                                                        utils.PacketType.REQUEST_PROFILE_LIST):
+            if release_lock and packet_size == 0 and packet_type not in (utils.PacketType.REQUEST_CONTROLLER_COUNT,
+                                                                         utils.PacketType.REQUEST_CONTROLLER_DATA,
+                                                                         utils.PacketType.REQUEST_PROTOCOL_VERSION,
+                                                                         utils.PacketType.REQUEST_PROFILE_LIST,
+                                                                         utils.PacketType.REQUEST_PLUGIN_LIST,
+                                                                         utils.PacketType.PLUGIN_SPECIFIC):
                 self.lock.release()
         except utils.CONNECTION_ERRORS as e:
             self.stop_connection()
@@ -257,6 +292,9 @@ def check_version(self, packet_type: utils.PacketType):
             raise utils.SDKVersionError("Profile controls not supported on protocol versions < 2.  You probably need to update OpenRGB")
         elif self._protocol_version < 3 and packet_type == utils.PacketType.RGBCONTROLLER_SAVEMODE:
             raise utils.SDKVersionError("Saving modes not supported on protocol versions < 3.  You probably need to update OpenRGB")
+        elif self._protocol_version < 4 and packet_type in (utils.PacketType.REQUEST_PLUGIN_LIST,
+                                                            utils.PacketType.PLUGIN_SPECIFIC):
+            raise utils.SDKVersionError("Plugin controls not supported on protocol versions < 4.  You probably need to update OpenRGB")
 
     @property
     def connected(self) -> bool:

openrgb/orgb.py

@@ -4,7 +4,8 @@
 from openrgb import utils
 from typing import Union, Any, Optional
 from openrgb.network import NetworkClient
-# from dataclasses import dataclass
+from openrgb.plugins import create_plugin, ORGBPlugin
+from time import sleep
 from os import environ
 
 
@@ -376,6 +377,7 @@ def __init__(self, address: str = "127.0.0.1", port: int = 6742, name: str = "op
         self.device_num = 0
         self.devices: list[Device] = []
         self.profiles: list[utils.Profile] = []
+        self.plugins: list[ORGBPlugin] = []
         self.comms = NetworkClient(
             self._callback, address, port, name, protocol_version)
         self.address = address
@@ -407,6 +409,12 @@ def _callback(self, device: int, type: int, data: Any):
             self.comms.requestDeviceNum()
         elif type == utils.PacketType.REQUEST_PROFILE_LIST:
             self.profiles = data
+        elif type == utils.PacketType.REQUEST_PLUGIN_LIST:
+            for plugin in data:
+                if (all(plugin.id != existing.id for existing in self.plugins)):
+                    self.plugins.append(create_plugin(plugin, self.comms))
+        elif type == utils.PacketType.PLUGIN_SPECIFIC:
+            next(plugin for plugin in self.plugins if plugin.id == device)._recv(data)
 
     def set_color(self, color: utils.RGBColor, fast: bool = False):
         '''
@@ -562,13 +570,23 @@ def update(self):
             self.comms.requestDeviceData(x)
         if self.comms._protocol_version >= 2:
             self.update_profiles()
+        if self.comms._protocol_version >= 4:
+            self.update_plugins()
 
     def update_profiles(self):
         '''
         Gets the list of available profiles from the server.
         '''
         self.comms.requestProfileList()
 
+    def update_plugins(self):
+        '''
+        Gets the list of enabled plugins from the server.
+        '''
+        self.comms.requestPluginList()
+        for plugin in self.plugins:
+            plugin.update()
+
     def show(self, fast: bool = False, force: bool = False):
         '''
         Shows all devices

openrgb/plugins/__init__.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+from openrgb.utils import Plugin
+from openrgb.network import NetworkClient
+from openrgb.plugins.common import ORGBPlugin
+
+from openrgb.plugins.effects import EffectsPlugin
+
+PLUGIN_NAMES = {
+    "OpenRGB Effects Plugin": EffectsPlugin
+}
+
+
+def create_plugin(plugin: Plugin, comms: NetworkClient) -> ORGBPlugin:
+    return PLUGIN_NAMES[plugin.name](plugin, comms)

openrgb/plugins/common.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+from openrgb import utils
+from openrgb.network import NetworkClient
+from typing import Iterator, Optional, Type
+from enum import IntEnum
+import struct
+
+
+class ORGBPlugin:
+    version = -1
+    pkt_type_enum = object()
+
+    def __init__(self, plugin_data: utils.Plugin, comms: NetworkClient):
+        self.name = plugin_data.name
+        self.description = plugin_data.description
+        self.plugin_version = plugin_data.version
+        self.id = plugin_data.id
+        self.sdk_version = plugin_data.sdk_version
+        self.comms = comms
+        assert self.sdk_version == self.version
+
+    def __repr__(self):
+        return type(self).__name__
+
+    def send_packet(self, packet_type: int, data: Optional[bytes] = None, request: bool = False):
+        if not data:
+            data = bytes()
+        self.comms.send_header(self.id, utils.PacketType.PLUGIN_SPECIFIC, len(data) + struct.calcsize('I'), not request)
+        data = struct.pack('I', packet_type) + data
+        self.comms.send_data(data, not request)
+
+    def _recv(self, data: Iterator[int]):
+        pkt_id = self.pkt_type_enum(utils.parse_var('I', data))  # type: ignore
+        self.recv(pkt_id, data)
+
+    def recv(self, pkt_id: Type[IntEnum], data: Iterator[int]):
+        # To be implemented per plugin
+        pass
+
+    def update(self):
+        # Optional, called with `OpenRGBClient.update_plugins`
+        pass

openrgb/plugins/effects.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+from openrgb import utils
+from openrgb.plugins import ORGBPlugin
+from dataclasses import dataclass
+from typing import Iterator, Union
+from enum import IntEnum
+
+class EffectPacketType(IntEnum):
+    REQUEST_EFFECT_LIST = 0
+    START_EFFECT = 20
+    STOP_EFFECT = 21
+
+
+@dataclass
+class Effect:
+    name: str
+    description: str
+    enabled: bool
+
+    @classmethod
+    def unpack(cls, data: Iterator[int], version: int, *args) -> Effect:
+        name = utils.parse_string(data)
+        description = utils.parse_string(data)
+        enabled = utils.parse_var('?', data)
+
+        return cls(
+            name,
+            description,
+            enabled
+        )
+
+
+class EffectsPlugin(ORGBPlugin):
+    version = 1
+    pkt_type_enum = EffectPacketType
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.effects = []
+
+    def update(self):
+        self.send_packet(EffectPacketType.REQUEST_EFFECT_LIST, request=True)
+        self.comms.read()
+
+    def recv(self, pkt_id: EffectPacketType, data: Iterator[int]):  # type: ignore
+        if pkt_id == EffectPacketType.REQUEST_EFFECT_LIST:
+            self.effects = utils.parse_list(Effect, data, self.version)
+
+    def start_effect(self, effect: Union[int, str, Effect]):
+        if type(effect) == int:
+            effect = self.effects[effect]  # type: ignore
+        elif type(effect) == str:
+            try:
+                effect = next(m for m in self.effects if m.name.lower() == effect.lower())  # type: ignore
+            except StopIteration as e:
+                raise ValueError(f"Effect `{effect}` not found") from e
+        data = utils.pack_string(effect.name)  # type: ignore
+
+        self.send_packet(EffectPacketType.START_EFFECT, data)
+
+    def stop_effect(self, effect: Union[int, str, Effect]):
+        if type(effect) == int:
+            effect = self.effects[effect]  # type: ignore
+        elif type(effect) == str:
+            try:
+                effect = next(m for m in self.effects if m.name.lower() == effect.lower())  # type: ignore
+            except StopIteration as e:
+                raise ValueError(f"Effect `{effect}` not found") from e
+        data = utils.pack_string(effect.name)  # type: ignore
+
+        self.send_packet(EffectPacketType.STOP_EFFECT, data)

openrgb/utils.py

@@ -76,6 +76,8 @@ class PacketType(IntEnum):
     REQUEST_SAVE_PROFILE = 151
     REQUEST_LOAD_PROFILE = 152
     REQUEST_DELETE_PROFILE = 153
+    REQUEST_PLUGIN_LIST = 200
+    PLUGIN_SPECIFIC = 201
     RGBCONTROLLER_RESIZEZONE = 1000
     RGBCONTROLLER_UPDATELEDS = 1050
     RGBCONTROLLER_UPDATEZONELEDS = 1051
@@ -678,6 +680,36 @@ def unpack(cls, data: Iterator[int], version: int, *args) -> Profile:
         return cls(s)
 
 
+@dataclass
+class Plugin:
+    '''
+
+    '''
+    name: str
+    description: str
+    version: str
+    id: int
+    sdk_version: int
+
+    def pack(self):
+        pass
+
+    @classmethod
+    def unpack(cls, data: Iterator[int], version: int, *args) -> Plugin:
+        name = parse_string(data)
+        description = parse_string(data)
+        version_str = parse_string(data)
+        id = parse_var('i', data)
+        sdk_version = parse_var('I', data)
+        return cls(
+            name,
+            description,
+            version_str,
+            id,
+            sdk_version
+        )
+
+
 class RGBObject:
     '''
     A parent class that includes a few generic functions that use the