xair-api 2.3.2__py3-none-any.whl → 2.4.1__py3-none-any.whl

xair_api/__init__.py

@@ -1,3 +1,3 @@
 from .xair import request_remote_obj as connect
 
-_ALL__ = ["connect"]
+_ALL__ = ['connect']

xair_api/adapter.py

@@ -1,4 +1,5 @@
 from .bus import Bus as IBus
+from .headamp import HeadAmp as IHeadAmp
 from .lr import LR as ILR
 from .rtn import AuxRtn as IAuxRtn
 from .rtn import FxRtn as IFxRtn
@@ -7,34 +8,40 @@ from .rtn import FxRtn as IFxRtn
 class Bus(IBus):
     @property
     def address(self):
-        return f"/bus/{str(self.index).zfill(2)}"
+        return f'/bus/{str(self.index).zfill(2)}'
 
 
 class AuxRtn(IAuxRtn):
     @property
     def address(self):
-        return f"/auxin/{str(self.index).zfill(2)}"
+        return f'/auxin/{str(self.index).zfill(2)}'
 
 
 class FxRtn(IFxRtn):
     @property
     def address(self):
-        return f"/fxrtn/{str(self.index).zfill(2)}"
+        return f'/fxrtn/{str(self.index).zfill(2)}'
 
 
 class MainStereo(ILR):
     @property
     def address(self) -> str:
-        return "/main/st"
+        return '/main/st'
 
 
 class MainMono(ILR):
     @property
     def address(self) -> str:
-        return "/main/m"
+        return '/main/m'
 
 
 class Matrix(ILR):
     @property
     def address(self) -> str:
-        return f"/mtx/{str(self.index).zfill(2)}"
+        return f'/mtx/{str(self.index).zfill(2)}'
+
+
+class HeadAmp(IHeadAmp):
+    @property
+    def address(self):
+        return f'/headamp/{str(self.index).zfill(3)}'

xair_api/bus.py

@@ -16,10 +16,10 @@ class IBus(abc.ABC):
         self.logger = logger.getChild(self.__class__.__name__)
 
     def getter(self, param: str):
-        return self._remote.query(f"{self.address}/{param}")
+        return self._remote.query(f'{self.address}/{param}')
 
     def setter(self, param: str, val: int):
-        self._remote.send(f"{self.address}/{param}", val)
+        self._remote.send(f'{self.address}/{param}', val)
 
     @abc.abstractmethod
     def address(self):
@@ -39,12 +39,12 @@ class Bus(IBus):
         Returns a Bus class of a kind.
         """
         BUS_cls = type(
-            f"Bus{remote.kind}",
+            f'Bus{remote.kind}',
             (cls,),
             {
                 **{
                     _cls.__name__.lower(): type(
-                        f"{_cls.__name__}{remote.kind}", (_cls, cls), {}
+                        f'{_cls.__name__}{remote.kind}', (_cls, cls), {}
                     )(remote, index)
                     for _cls in (
                         Config,
@@ -56,11 +56,11 @@ class Bus(IBus):
                         Group,
                     )
                 },
-                "mute": mute_prop(),
+                'mute': mute_prop(),
             },
         )
         return BUS_cls(remote, index)
 
     @property
     def address(self) -> str:
-        return f"/bus/{self.index}"
+        return f'/bus/{self.index}'

xair_api/config.py

@@ -15,10 +15,10 @@ class IConfig(abc.ABC):
         self.logger = logger.getChild(self.__class__.__name__)
 
     def getter(self, param: str):
-        return self._remote.query(f"{self.address}/{param}")
+        return self._remote.query(f'{self.address}/{param}')
 
     def setter(self, param: str, val: int):
-        self._remote.send(f"{self.address}/{param}", val)
+        self._remote.send(f'{self.address}/{param}', val)
 
     @abc.abstractmethod
     def address(self):
@@ -36,37 +36,37 @@ class Config(IConfig):
         Returns a Config class of a kind.
         """
         LINKS_cls = _make_links_mixins[remote.kind.id_]
-        MUTEGROUP_cls = type("MuteGroup", (Config.MuteGroup, cls), {})
-        MONITOR_cls = type("ConfigMonitor", (Config.Monitor, cls), {})
+        MUTEGROUP_cls = type('MuteGroup', (Config.MuteGroup, cls), {})
+        MONITOR_cls = type('ConfigMonitor', (Config.Monitor, cls), {})
         CONFIG_cls = type(
-            f"Config{remote.kind}",
+            f'Config{remote.kind}',
             (cls, LINKS_cls),
             {
-                "mute_group": tuple(MUTEGROUP_cls(remote, i) for i in range(4)),
-                "monitor": MONITOR_cls(remote),
+                'mute_group': tuple(MUTEGROUP_cls(remote, i) for i in range(4)),
+                'monitor': MONITOR_cls(remote),
             },
         )
         return CONFIG_cls(remote)
 
     @property
     def address(self) -> str:
-        return "/config"
+        return '/config'
 
     @property
     def amixenable(self) -> bool:
-        return self.getter("mute")[0] == 1
+        return self.getter('mute')[0] == 1
 
     @amixenable.setter
     def amixenable(self, val: bool):
-        self.setter("amixenable", 1 if val else 0)
+        self.setter('amixenable', 1 if val else 0)
 
     @property
     def amixlock(self) -> bool:
-        return self.getter("amixlock")[0] == 1
+        return self.getter('amixlock')[0] == 1
 
     @amixlock.setter
     def amixlock(self, val: bool):
-        self.setter("amixlock", 1 if val else 0)
+        self.setter('amixlock', 1 if val else 0)
 
     class MuteGroup:
         def __init__(self, remote, i):
@@ -76,128 +76,128 @@ class Config(IConfig):
         @property
         def address(self) -> str:
             root = super(Config.MuteGroup, self).address
-            return f"{root}/mute"
+            return f'{root}/mute'
 
         @property
         def on(self) -> bool:
-            return self.getter(f"{self.i}")[0] == 1
+            return self.getter(f'{self.i}')[0] == 1
 
         @on.setter
         def on(self, val: bool):
-            self.setter(f"{self.i}", 1 if val else 0)
+            self.setter(f'{self.i}', 1 if val else 0)
 
     class Monitor:
         @property
         def address(self) -> str:
             root = super(Config.Monitor, self).address
-            return f"{root}/solo"
+            return f'{root}/solo'
 
         @property
         @util.db_from
         def level(self) -> float:
-            return self.getter("level")[0]
+            return self.getter('level')[0]
 
         @level.setter
         @util.db_to
         def level(self, val: float):
-            self.setter("level", val)
+            self.setter('level', val)
 
         @property
         def source(self) -> int:
-            return int(self.getter("source")[0])
+            return int(self.getter('source')[0])
 
         @source.setter
         def source(self, val: int):
-            self.setter("source", val)
+            self.setter('source', val)
 
         @property
         def sourcetrim(self) -> float:
-            return round(util.lin_get(-18, 18, self.getter("sourcetrim")[0]), 1)
+            return round(util.lin_get(-18, 18, self.getter('sourcetrim')[0]), 1)
 
         @sourcetrim.setter
         def sourcetrim(self, val: float):
             if not -18 <= val <= 18:
                 self.logger.warning(
-                    f"sourcetrim got {val}, expected value in range -18.0 to 18.0"
+                    f'sourcetrim got {val}, expected value in range -18.0 to 18.0'
                 )
-            self.setter("sourcetrim", util.lin_set(-18, 18, val))
+            self.setter('sourcetrim', util.lin_set(-18, 18, val))
 
         @property
         def chmode(self) -> bool:
-            return self.getter("chmode")[0] == 1
+            return self.getter('chmode')[0] == 1
 
         @chmode.setter
         def chmode(self, val: bool):
-            self.setter("chmode", 1 if val else 0)
+            self.setter('chmode', 1 if val else 0)
 
         @property
         def busmode(self) -> bool:
-            return self.getter("busmode")[0] == 1
+            return self.getter('busmode')[0] == 1
 
         @busmode.setter
         def busmode(self, val: bool):
-            self.setter("busmode", 1 if val else 0)
+            self.setter('busmode', 1 if val else 0)
 
         @property
         def dimgain(self) -> int:
-            return int(util.lin_get(-40, 0, self.getter("dimatt")[0]))
+            return int(util.lin_get(-40, 0, self.getter('dimatt')[0]))
 
         @dimgain.setter
         def dimgain(self, val: int):
             if not -40 <= val <= 0:
                 self.logger.warning(
-                    f"dimgain got {val}, expected value in range -40 to 0"
+                    f'dimgain got {val}, expected value in range -40 to 0'
                 )
-            self.setter("dimatt", util.lin_set(-40, 0, val))
+            self.setter('dimatt', util.lin_set(-40, 0, val))
 
         @property
         def dim(self) -> bool:
-            return self.getter("dim")[0] == 1
+            return self.getter('dim')[0] == 1
 
         @dim.setter
         def dim(self, val: bool):
-            self.setter("dim", 1 if val else 0)
+            self.setter('dim', 1 if val else 0)
 
         @property
         def mono(self) -> bool:
-            return self.getter("mono")[0] == 1
+            return self.getter('mono')[0] == 1
 
         @mono.setter
         def mono(self, val: bool):
-            self.setter("mono", 1 if val else 0)
+            self.setter('mono', 1 if val else 0)
 
         @property
         def mute(self) -> bool:
-            return self.getter("mute")[0] == 1
+            return self.getter('mute')[0] == 1
 
         @mute.setter
         def mute(self, val: bool):
-            self.setter("mute", 1 if val else 0)
+            self.setter('mute', 1 if val else 0)
 
         @property
         def dimfpl(self) -> bool:
-            return self.getter("dimfpl")[0] == 1
+            return self.getter('dimfpl')[0] == 1
 
         @dimfpl.setter
         def dimfpl(self, val: bool):
-            self.setter("dimfpl", 1 if val else 0)
+            self.setter('dimfpl', 1 if val else 0)
 
 
 def _make_links_mixin(kind):
     """Creates a links mixin"""
     return type(
-        f"Links{kind}",
+        f'Links{kind}',
         (),
         {
-            "link_eq": bool_prop("linkcfg/eq"),
-            "link_dyn": bool_prop("linkcfg/dyn"),
-            "link_fader_mute": bool_prop("linkcfg/fdrmute"),
+            'link_eq': bool_prop('linkcfg/eq'),
+            'link_dyn': bool_prop('linkcfg/dyn'),
+            'link_fader_mute': bool_prop('linkcfg/fdrmute'),
             **{
-                f"chlink{i}_{i+1}": bool_prop(f"chlink/{i}-{i+1}")
+                f'chlink{i}_{i+1}': bool_prop(f'chlink/{i}-{i+1}')
                 for i in range(1, kind.num_strip, 2)
             },
             **{
-                f"buslink{i}_{i+1}": bool_prop(f"buslink/{i}-{i+1}")
+                f'buslink{i}_{i+1}': bool_prop(f'buslink/{i}-{i+1}')
                 for i in range(1, kind.num_bus, 2)
             },
         },

xair_api/dca.py

@@ -13,10 +13,10 @@ class IDCA(abc.ABC):
         self.logger = logger.getChild(self.__class__.__name__)
 
     def getter(self, param: str) -> tuple:
-        return self._remote.query(f"{self.address}/{param}")
+        return self._remote.query(f'{self.address}/{param}')
 
     def setter(self, param: str, val: int):
-        self._remote.send(f"{self.address}/{param}", val)
+        self._remote.send(f'{self.address}/{param}', val)
 
     @abc.abstractmethod
     def address(self):
@@ -28,15 +28,15 @@ class DCA(IDCA):
 
     @property
     def address(self) -> str:
-        return f"/dca/{self.index}"
+        return f'/dca/{self.index}'
 
     @property
     def on(self) -> bool:
-        return self.getter("on")[0] == 1
+        return self.getter('on')[0] == 1
 
     @on.setter
     def on(self, val: bool):
-        self.setter("on", 1 if val else 0)
+        self.setter('on', 1 if val else 0)
 
     @property
     def mute(self) -> bool:
@@ -48,16 +48,16 @@ class DCA(IDCA):
 
     @property
     def name(self) -> str:
-        return self.getter("config/name")[0]
+        return self.getter('config/name')[0]
 
     @name.setter
     def name(self, val: str):
-        self.setter("config/name", val)
+        self.setter('config/name', val)
 
     @property
     def color(self) -> int:
-        return self.getter("config/color")[0]
+        return self.getter('config/color')[0]
 
     @color.setter
     def color(self, val: int):
-        self.setter("config/color", val)
+        self.setter('config/color', val)

xair_api/errors.py

@@ -10,5 +10,5 @@ class XAirRemoteConnectionTimeoutError(XAirRemoteError):
         self.port = port
 
         super().__init__(
-            f"Timeout attempting to connect to mixer at {self.ip}:{self.port}"
+            f'Timeout attempting to connect to mixer at {self.ip}:{self.port}'
         )

xair_api/fx.py

@@ -16,10 +16,10 @@ class IFX(abc.ABC):
         self.logger = logger.getChild(self.__class__.__name__)
 
     def getter(self, param: str):
-        return self._remote.query(f"{self.address}/{param}")
+        return self._remote.query(f'{self.address}/{param}')
 
     def setter(self, param: str, val: int):
-        self._remote.send(f"{self.address}/{param}", val)
+        self._remote.send(f'{self.address}/{param}', val)
 
     @abc.abstractmethod
     def address(self):
@@ -31,15 +31,15 @@ class FX(IFX):
 
     @property
     def address(self) -> str:
-        return f"/fx/{self.index}"
+        return f'/fx/{self.index}'
 
     @property
     def type(self) -> int:
-        return self.getter("type")[0]
+        return self.getter('type')[0]
 
     @type.setter
     def type(self, val: int):
-        self.setter("type", val)
+        self.setter('type', val)
 
 
 class FXSend(IFX):
@@ -55,20 +55,20 @@ class FXSend(IFX):
         Returns an FXSend class of a kind.
         """
         FXSEND_cls = type(
-            f"FXSend{remote.kind}",
+            f'FXSend{remote.kind}',
             (cls,),
             {
                 **{
                     _cls.__name__.lower(): type(
-                        f"{_cls.__name__}{remote.kind}", (_cls, cls), {}
+                        f'{_cls.__name__}{remote.kind}', (_cls, cls), {}
                     )(remote, index)
                     for _cls in (Config, Mix, Group)
                 },
-                "mute": mute_prop(),
+                'mute': mute_prop(),
             },
         )
         return FXSEND_cls(remote, index)
 
     @property
     def address(self) -> str:
-        return f"/fxsend/{self.index}"
+        return f'/fxsend/{self.index}'

xair_api/headamp.py

@@ -0,0 +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)

xair_api/kinds.py

@@ -1,45 +1,44 @@
 from dataclasses import dataclass
 
 
-@dataclass
+@dataclass(frozen=True)
 class KindMap:
+    id_: str
+
     def __str__(self) -> str:
         return self.id_
 
 
-@dataclass
+@dataclass(frozen=True)
 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
+@dataclass(frozen=True)
 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
+@dataclass(frozen=True)
 class XR16KindMap(KindMap):
-    id_: str
     num_dca: int = 4
     num_strip: int = 16
     num_bus: int = 4
     num_fx: int = 4
 
 
-@dataclass
+@dataclass(frozen=True)
 class XR12KindMap(KindMap):
-    id_: str
     num_dca: int = 4
     num_strip: int = 12
     num_bus: int = 2
@@ -47,11 +46,11 @@ class XR12KindMap(KindMap):
 
 
 _kinds = {
-    "X32": X32KindMap(id_="X32"),
-    "MR18": XR18KindMap(id_="MR18"),
-    "XR18": XR18KindMap(id_="XR18"),
-    "XR16": XR16KindMap(id_="XR16"),
-    "XR12": XR12KindMap(id_="XR12"),
+    'X32': X32KindMap(id_='X32'),
+    'MR18': XR18KindMap(id_='MR18'),
+    'XR18': XR18KindMap(id_='XR18'),
+    'XR16': XR16KindMap(id_='XR16'),
+    'XR12': XR12KindMap(id_='XR12'),
 }
 
 
@@ -59,4 +58,4 @@ def get(kind_id):
     return _kinds[kind_id]
 
 
-all = list(kind for kind in _kinds.values())
+all = list(_kinds.values())

xair_api/lr.py

@@ -18,10 +18,10 @@ class ILR(abc.ABC):
         self.logger = logger.getChild(self.__class__.__name__)
 
     def getter(self, param: str):
-        return self._remote.query(f"{self.address}/{param}")
+        return self._remote.query(f'{self.address}/{param}')
 
     def setter(self, param: str, val: int):
-        self._remote.send(f"{self.address}/{param}", val)
+        self._remote.send(f'{self.address}/{param}', val)
 
     @abc.abstractmethod
     def address(self):
@@ -41,12 +41,12 @@ class LR(ILR):
         Returns an LR class of a kind.
         """
         LR_cls = type(
-            f"LR{remote.kind}",
+            f'LR{remote.kind}',
             (cls,),
             {
                 **{
                     _cls.__name__.lower(): type(
-                        f"{_cls.__name__}{remote.kind}", (_cls, cls), {}
+                        f'{_cls.__name__}{remote.kind}', (_cls, cls), {}
                     )(remote, index)
                     for _cls in (
                         Config,
@@ -57,11 +57,11 @@ class LR(ILR):
                         Mix,
                     )
                 },
-                "mute": mute_prop(),
+                'mute': mute_prop(),
             },
         )
         return LR_cls(remote, index)
 
     @property
     def address(self) -> str:
-        return "/lr"
+        return '/lr'

xair_api/meta.py

@@ -50,7 +50,7 @@ def float_prop(param):
 
 
 def geq_prop(param):
-    param = param.replace("_", ".")
+    param = param.replace('_', '.')
 
     def fget(self) -> float:
         return round(lin_get(-15, 15, self.getter(param)[0]), 1)
@@ -58,7 +58,7 @@ def geq_prop(param):
     def fset(self, val):
         if not -15 <= val <= 15:
             self.logger.warning(
-                f"slider_{param} got {val}, expected value in range -15.0 to 15.0"
+                f'slider_{param} got {val}, expected value in range -15.0 to 15.0'
             )
         self.setter(param, lin_set(-15, 15, val))