xair-api 2.4.0__py3-none-any.whl → 2.4.2__py3-none-any.whl

xair_api/dca.py

@@ -1,63 +1,63 @@
-import abc
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class IDCA(abc.ABC):
-    """Abstract Base Class for DCA groups"""
-
-    def __init__(self, remote, index: int):
-        self._remote = remote
-        self.index = index + 1
-        self.logger = logger.getChild(self.__class__.__name__)
-
-    def getter(self, param: str) -> tuple:
-        return self._remote.query(f"{self.address}/{param}")
-
-    def setter(self, param: str, val: int):
-        self._remote.send(f"{self.address}/{param}", val)
-
-    @abc.abstractmethod
-    def address(self):
-        pass
-
-
-class DCA(IDCA):
-    """Concrete class for DCA groups"""
-
-    @property
-    def address(self) -> str:
-        return f"/dca/{self.index}"
-
-    @property
-    def on(self) -> bool:
-        return self.getter("on")[0] == 1
-
-    @on.setter
-    def on(self, val: bool):
-        self.setter("on", 1 if val else 0)
-
-    @property
-    def mute(self) -> bool:
-        return not self.on
-
-    @mute.setter
-    def mute(self, val: bool):
-        self.on = not val
-
-    @property
-    def name(self) -> str:
-        return self.getter("config/name")[0]
-
-    @name.setter
-    def name(self, val: str):
-        self.setter("config/name", val)
-
-    @property
-    def color(self) -> int:
-        return self.getter("config/color")[0]
-
-    @color.setter
-    def color(self, val: int):
-        self.setter("config/color", val)
+import abc
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class IDCA(abc.ABC):
+    """Abstract Base Class for DCA groups"""
+
+    def __init__(self, remote, index: int):
+        self._remote = remote
+        self.index = index + 1
+        self.logger = logger.getChild(self.__class__.__name__)
+
+    def getter(self, param: str) -> tuple:
+        return self._remote.query(f'{self.address}/{param}')
+
+    def setter(self, param: str, val: int):
+        self._remote.send(f'{self.address}/{param}', val)
+
+    @abc.abstractmethod
+    def address(self):
+        pass
+
+
+class DCA(IDCA):
+    """Concrete class for DCA groups"""
+
+    @property
+    def address(self) -> str:
+        return f'/dca/{self.index}'
+
+    @property
+    def on(self) -> bool:
+        return self.getter('on')[0] == 1
+
+    @on.setter
+    def on(self, val: bool):
+        self.setter('on', 1 if val else 0)
+
+    @property
+    def mute(self) -> bool:
+        return not self.on
+
+    @mute.setter
+    def mute(self, val: bool):
+        self.on = not val
+
+    @property
+    def name(self) -> str:
+        return self.getter('config/name')[0]
+
+    @name.setter
+    def name(self, val: str):
+        self.setter('config/name', val)
+
+    @property
+    def color(self) -> int:
+        return self.getter('config/color')[0]
+
+    @color.setter
+    def color(self, val: int):
+        self.setter('config/color', val)

xair_api/errors.py

@@ -1,14 +1,14 @@
-class XAirRemoteError(Exception):
-    """Base error class for XAIR Remote."""
-
-
-class XAirRemoteConnectionTimeoutError(XAirRemoteError):
-    """Exception raised when a connection attempt times out"""
-
-    def __init__(self, ip, port):
-        self.ip = ip
-        self.port = port
-
-        super().__init__(
-            f"Timeout attempting to connect to mixer at {self.ip}:{self.port}"
-        )
+class XAirRemoteError(Exception):
+    """Base error class for XAIR Remote."""
+
+
+class XAirRemoteConnectionTimeoutError(XAirRemoteError):
+    """Exception raised when a connection attempt times out"""
+
+    def __init__(self, ip, port):
+        self.ip = ip
+        self.port = port
+
+        super().__init__(
+            f'Timeout attempting to connect to mixer at {self.ip}:{self.port}'
+        )

xair_api/fx.py

@@ -1,74 +1,74 @@
-import abc
-import logging
-
-from .meta import mute_prop
-from .shared import Config, Group, Mix
-
-logger = logging.getLogger(__name__)
-
-
-class IFX(abc.ABC):
-    """Abstract Base Class for fxs"""
-
-    def __init__(self, remote, index: int):
-        self._remote = remote
-        self.index = index + 1
-        self.logger = logger.getChild(self.__class__.__name__)
-
-    def getter(self, param: str):
-        return self._remote.query(f"{self.address}/{param}")
-
-    def setter(self, param: str, val: int):
-        self._remote.send(f"{self.address}/{param}", val)
-
-    @abc.abstractmethod
-    def address(self):
-        pass
-
-
-class FX(IFX):
-    """Concrete class for fx"""
-
-    @property
-    def address(self) -> str:
-        return f"/fx/{self.index}"
-
-    @property
-    def type(self) -> int:
-        return self.getter("type")[0]
-
-    @type.setter
-    def type(self, val: int):
-        self.setter("type", val)
-
-
-class FXSend(IFX):
-    """Concrete class for fxsend"""
-
-    @classmethod
-    def make(cls, remote, index):
-        """
-        Factory function for FXSend
-
-        Creates a mixin of shared subclasses, sets them as class attributes.
-
-        Returns an FXSend class of a kind.
-        """
-        FXSEND_cls = type(
-            f"FXSend{remote.kind}",
-            (cls,),
-            {
-                **{
-                    _cls.__name__.lower(): type(
-                        f"{_cls.__name__}{remote.kind}", (_cls, cls), {}
-                    )(remote, index)
-                    for _cls in (Config, Mix, Group)
-                },
-                "mute": mute_prop(),
-            },
-        )
-        return FXSEND_cls(remote, index)
-
-    @property
-    def address(self) -> str:
-        return f"/fxsend/{self.index}"
+import abc
+import logging
+
+from .meta import mute_prop
+from .shared import Config, Group, Mix
+
+logger = logging.getLogger(__name__)
+
+
+class IFX(abc.ABC):
+    """Abstract Base Class for fxs"""
+
+    def __init__(self, remote, index: int):
+        self._remote = remote
+        self.index = index + 1
+        self.logger = logger.getChild(self.__class__.__name__)
+
+    def getter(self, param: str):
+        return self._remote.query(f'{self.address}/{param}')
+
+    def setter(self, param: str, val: int):
+        self._remote.send(f'{self.address}/{param}', val)
+
+    @abc.abstractmethod
+    def address(self):
+        pass
+
+
+class FX(IFX):
+    """Concrete class for fx"""
+
+    @property
+    def address(self) -> str:
+        return f'/fx/{self.index}'
+
+    @property
+    def type(self) -> int:
+        return self.getter('type')[0]
+
+    @type.setter
+    def type(self, val: int):
+        self.setter('type', val)
+
+
+class FXSend(IFX):
+    """Concrete class for fxsend"""
+
+    @classmethod
+    def make(cls, remote, index):
+        """
+        Factory function for FXSend
+
+        Creates a mixin of shared subclasses, sets them as class attributes.
+
+        Returns an FXSend class of a kind.
+        """
+        FXSEND_cls = type(
+            f'FXSend{remote.kind}',
+            (cls,),
+            {
+                **{
+                    _cls.__name__.lower(): type(
+                        f'{_cls.__name__}{remote.kind}', (_cls, cls), {}
+                    )(remote, index)
+                    for _cls in (Config, Mix, Group)
+                },
+                'mute': mute_prop(),
+            },
+        )
+        return FXSEND_cls(remote, index)
+
+    @property
+    def address(self) -> str:
+        return f'/fxsend/{self.index}'

xair_api/headamp.py

@@ -1,49 +1,49 @@
-import abc
-import logging
-
-from . import util
-
-logger = logging.getLogger(__name__)
-
-
-class IHeadAmp(abc.ABC):
-    """Abstract Base Class for headamps"""
-
-    def __init__(self, remote, index: int):
-        self._remote = remote
-        self.index = index + 1
-        self.logger = logger.getChild(self.__class__.__name__)
-
-    def getter(self, param: str):
-        return self._remote.query(f"{self.address}/{param}")
-
-    def setter(self, param: str, val: int):
-        self._remote.send(f"{self.address}/{param}", val)
-
-    @abc.abstractmethod
-    def address(self):
-        pass
-
-
-class HeadAmp(IHeadAmp):
-    """Concrete class for headamps"""
-
-    @property
-    def address(self):
-        return f"/headamp/{str(self.index).zfill(2)}"
-
-    @property
-    def gain(self):
-        return round(util.lin_get(-12, 60, self.getter("gain")[0]), 1)
-
-    @gain.setter
-    def gain(self, val):
-        self.setter("gain", util.lin_set(-12, 60, val))
-
-    @property
-    def phantom(self):
-        return self.getter("phantom")[0] == 1
-
-    @phantom.setter
-    def phantom(self, val):
-        self.setter("phantom", 1 if val else 0)
+import abc
+import logging
+
+from . import util
+
+logger = logging.getLogger(__name__)
+
+
+class IHeadAmp(abc.ABC):
+    """Abstract Base Class for headamps"""
+
+    def __init__(self, remote, index: int):
+        self._remote = remote
+        self.index = index + 1
+        self.logger = logger.getChild(self.__class__.__name__)
+
+    def getter(self, param: str):
+        return self._remote.query(f'{self.address}/{param}')
+
+    def setter(self, param: str, val: int):
+        self._remote.send(f'{self.address}/{param}', val)
+
+    @abc.abstractmethod
+    def address(self):
+        pass
+
+
+class HeadAmp(IHeadAmp):
+    """Concrete class for headamps"""
+
+    @property
+    def address(self):
+        return f'/headamp/{str(self.index).zfill(2)}'
+
+    @property
+    def gain(self):
+        return round(util.lin_get(-12, 60, self.getter('gain')[0]), 1)
+
+    @gain.setter
+    def gain(self, val):
+        self.setter('gain', util.lin_set(-12, 60, val))
+
+    @property
+    def phantom(self):
+        return self.getter('phantom')[0] == 1
+
+    @phantom.setter
+    def phantom(self, val):
+        self.setter('phantom', 1 if val else 0)

xair_api/kinds.py

@@ -1,63 +1,61 @@
-from dataclasses import dataclass
-
-
-@dataclass
-class KindMap:
-    def __str__(self) -> str:
-        return self.id_
-
-
-@dataclass
-class X32KindMap(KindMap):
-    id_: str
-    num_dca: int = 8
-    num_strip: int = 32
-    num_bus: int = 16
-    num_fx: int = 8
-    num_auxrtn: int = 8
-    num_matrix: int = 6
-    num_headamp: int = 127
-
-
-@dataclass
-class XR18KindMap(KindMap):
-    # note ch 17-18 defined as aux return
-    id_: str
-    num_dca: int = 4
-    num_strip: int = 16
-    num_bus: int = 6
-    num_fx: int = 4
-
-
-@dataclass
-class XR16KindMap(KindMap):
-    id_: str
-    num_dca: int = 4
-    num_strip: int = 16
-    num_bus: int = 4
-    num_fx: int = 4
-
-
-@dataclass
-class XR12KindMap(KindMap):
-    id_: str
-    num_dca: int = 4
-    num_strip: int = 12
-    num_bus: int = 2
-    num_fx: int = 4
-
-
-_kinds = {
-    "X32": X32KindMap(id_="X32"),
-    "MR18": XR18KindMap(id_="MR18"),
-    "XR18": XR18KindMap(id_="XR18"),
-    "XR16": XR16KindMap(id_="XR16"),
-    "XR12": XR12KindMap(id_="XR12"),
-}
-
-
-def get(kind_id):
-    return _kinds[kind_id]
-
-
-all = list(kind for kind in _kinds.values())
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class KindMap:
+    id_: str
+
+    def __str__(self) -> str:
+        return self.id_
+
+
+@dataclass(frozen=True)
+class X32KindMap(KindMap):
+    num_dca: int = 8
+    num_strip: int = 32
+    num_bus: int = 16
+    num_fx: int = 8
+    num_auxrtn: int = 8
+    num_matrix: int = 6
+    num_headamp: int = 127
+
+
+@dataclass(frozen=True)
+class XR18KindMap(KindMap):
+    # note ch 17-18 defined as aux return
+    num_dca: int = 4
+    num_strip: int = 16
+    num_bus: int = 6
+    num_fx: int = 4
+
+
+@dataclass(frozen=True)
+class XR16KindMap(KindMap):
+    num_dca: int = 4
+    num_strip: int = 16
+    num_bus: int = 4
+    num_fx: int = 4
+
+
+@dataclass(frozen=True)
+class XR12KindMap(KindMap):
+    num_dca: int = 4
+    num_strip: int = 12
+    num_bus: int = 2
+    num_fx: int = 4
+
+
+_kinds = {
+    'X32': X32KindMap(id_='X32'),
+    'MR18': XR18KindMap(id_='MR18'),
+    'XR18': XR18KindMap(id_='XR18'),
+    'XR16': XR16KindMap(id_='XR16'),
+    'XR12': XR12KindMap(id_='XR12'),
+}
+
+
+def get(kind_id):
+    return _kinds[kind_id]
+
+
+all = list(_kinds.values())

xair_api/lr.py

@@ -1,67 +1,67 @@
-import abc
-import logging
-from typing import Optional
-
-from .meta import mute_prop
-from .shared import EQ, GEQ, Config, Dyn, Insert, Mix
-
-logger = logging.getLogger(__name__)
-
-
-class ILR(abc.ABC):
-    """Abstract Base Class for lr"""
-
-    def __init__(self, remote, index: Optional[int] = None):
-        self._remote = remote
-        if index is not None:
-            self.index = index + 1
-        self.logger = logger.getChild(self.__class__.__name__)
-
-    def getter(self, param: str):
-        return self._remote.query(f"{self.address}/{param}")
-
-    def setter(self, param: str, val: int):
-        self._remote.send(f"{self.address}/{param}", val)
-
-    @abc.abstractmethod
-    def address(self):
-        pass
-
-
-class LR(ILR):
-    """Concrete class for lr"""
-
-    @classmethod
-    def make(cls, remote, index=None):
-        """
-        Factory function for LR
-
-        Creates a mixin of shared subclasses, sets them as class attributes.
-
-        Returns an LR class of a kind.
-        """
-        LR_cls = type(
-            f"LR{remote.kind}",
-            (cls,),
-            {
-                **{
-                    _cls.__name__.lower(): type(
-                        f"{_cls.__name__}{remote.kind}", (_cls, cls), {}
-                    )(remote, index)
-                    for _cls in (
-                        Config,
-                        Dyn,
-                        Insert,
-                        GEQ.make(),
-                        EQ.make_sixband(cls, remote, index),
-                        Mix,
-                    )
-                },
-                "mute": mute_prop(),
-            },
-        )
-        return LR_cls(remote, index)
-
-    @property
-    def address(self) -> str:
-        return "/lr"
+import abc
+import logging
+from typing import Optional
+
+from .meta import mute_prop
+from .shared import EQ, GEQ, Config, Dyn, Insert, Mix
+
+logger = logging.getLogger(__name__)
+
+
+class ILR(abc.ABC):
+    """Abstract Base Class for lr"""
+
+    def __init__(self, remote, index: Optional[int] = None):
+        self._remote = remote
+        if index is not None:
+            self.index = index + 1
+        self.logger = logger.getChild(self.__class__.__name__)
+
+    def getter(self, param: str):
+        return self._remote.query(f'{self.address}/{param}')
+
+    def setter(self, param: str, val: int):
+        self._remote.send(f'{self.address}/{param}', val)
+
+    @abc.abstractmethod
+    def address(self):
+        pass
+
+
+class LR(ILR):
+    """Concrete class for lr"""
+
+    @classmethod
+    def make(cls, remote, index=None):
+        """
+        Factory function for LR
+
+        Creates a mixin of shared subclasses, sets them as class attributes.
+
+        Returns an LR class of a kind.
+        """
+        LR_cls = type(
+            f'LR{remote.kind}',
+            (cls,),
+            {
+                **{
+                    _cls.__name__.lower(): type(
+                        f'{_cls.__name__}{remote.kind}', (_cls, cls), {}
+                    )(remote, index)
+                    for _cls in (
+                        Config,
+                        Dyn,
+                        Insert,
+                        GEQ.make(),
+                        EQ.make_sixband(cls, remote, index),
+                        Mix,
+                    )
+                },
+                'mute': mute_prop(),
+            },
+        )
+        return LR_cls(remote, index)
+
+    @property
+    def address(self) -> str:
+        return '/lr'