Merge pull request #22 from HEnquist/support_38

Support python 3.8

Author: HEnquist

camilladsp/camilladsp.py

@@ -14,7 +14,7 @@
 
 import json
 import math
-from typing import Optional
+from typing import Dict, Tuple, List, Optional
 from threading import Lock
 import yaml
 from websocket import create_connection, WebSocket  # type: ignore
@@ -47,7 +47,7 @@ def __init__(self, host: str, port: int):
         self._host = host
         self._port = int(port)
         self._ws: Optional[WebSocket] = None
-        self.cdsp_version: Optional[tuple[str, str, str]] = None
+        self.cdsp_version: Optional[Tuple[str, str, str]] = None
         self._lock = Lock()
 
     def query(self, command: str, arg=None):
@@ -217,39 +217,39 @@ def range_decibel(self) -> float:
             range_decibel = -1000
         return range_decibel
 
-    def capture_rms(self) -> list[float]:
+    def capture_rms(self) -> List[float]:
         """
         Get capture signal level rms in dB for the last processed chunk.
         Full scale is 0 dB. Returns a list with one element per channel.
         """
         sigrms = self.client.query("GetCaptureSignalRms")
         return sigrms
 
-    def playback_rms(self) -> list[float]:
+    def playback_rms(self) -> List[float]:
         """
         Get playback signal level rms in dB for the last processed chunk.
         Full scale is 0 dB. Returns a list with one element per channel.
         """
         sigrms = self.client.query("GetPlaybackSignalRms")
         return sigrms
 
-    def capture_peak(self) -> list[float]:
+    def capture_peak(self) -> List[float]:
         """
         Get capture signal level peak in dB for the last processed chunk.
         Full scale is 0 dB. Returns a list with one element per channel.
         """
         sigpeak = self.client.query("GetCaptureSignalPeak")
         return sigpeak
 
-    def playback_peak(self) -> list[float]:
+    def playback_peak(self) -> List[float]:
         """
         Get playback signal level peak in dB for the last processed chunk.
         Full scale is 0 dB. Returns a list with one element per channel.
         """
         sigpeak = self.client.query("GetPlaybackSignalPeak")
         return sigpeak
 
-    def playback_peak_since(self, interval: float) -> list[float]:
+    def playback_peak_since(self, interval: float) -> List[float]:
         """
         Get playback signal level peak in dB for the last `interval` seconds.
         Full scale is 0 dB. Returns a list with one element per channel.
@@ -260,7 +260,7 @@ def playback_peak_since(self, interval: float) -> list[float]:
         sigpeak = self.client.query("GetPlaybackSignalPeakSince", arg=float(interval))
         return sigpeak
 
-    def playback_rms_since(self, interval: float) -> list[float]:
+    def playback_rms_since(self, interval: float) -> List[float]:
         """
         Get playback signal level rms in dB for the last `interval` seconds.
         Full scale is 0 dB. Returns a list with one element per channel.
@@ -271,7 +271,7 @@ def playback_rms_since(self, interval: float) -> list[float]:
         sigrms = self.client.query("GetPlaybackSignalRmsSince", arg=float(interval))
         return sigrms
 
-    def capture_peak_since(self, interval: float) -> list[float]:
+    def capture_peak_since(self, interval: float) -> List[float]:
         """
         Get capture signal level peak in dB for the last `interval` seconds.
         Full scale is 0 dB. Returns a list with one element per channel.
@@ -282,7 +282,7 @@ def capture_peak_since(self, interval: float) -> list[float]:
         sigpeak = self.client.query("GetCaptureSignalPeakSince", arg=float(interval))
         return sigpeak
 
-    def capture_rms_since(self, interval: float) -> list[float]:
+    def capture_rms_since(self, interval: float) -> List[float]:
         """
         Get capture signal level rms in dB for the last `interval` seconds.
         Full scale is 0 dB. Returns a list with one element per channel.
@@ -293,39 +293,39 @@ def capture_rms_since(self, interval: float) -> list[float]:
         sigrms = self.client.query("GetCaptureSignalRmsSince", arg=float(interval))
         return sigrms
 
-    def playback_peak_since_last(self) -> list[float]:
+    def playback_peak_since_last(self) -> List[float]:
         """
         Get playback signal level peak in dB since the last read by the same client.
         Full scale is 0 dB. Returns a list with one element per channel.
         """
         sigpeak = self.client.query("GetPlaybackSignalPeakSinceLast")
         return sigpeak
 
-    def playback_rms_since_last(self) -> list[float]:
+    def playback_rms_since_last(self) -> List[float]:
         """
         Get playback signal level rms in dB since the last read by the same client.
         Full scale is 0 dB. Returns a list with one element per channel.
         """
         sigrms = self.client.query("GetPlaybackSignalRmsSinceLast")
         return sigrms
 
-    def capture_peak_since_last(self) -> list[float]:
+    def capture_peak_since_last(self) -> List[float]:
         """
         Get capture signal level peak in dB since the last read by the same client.
         Full scale is 0 dB. Returns a list with one element per channel.
         """
         sigpeak = self.client.query("GetCaptureSignalPeakSinceLast")
         return sigpeak
 
-    def capture_rms_since_last(self) -> list[float]:
+    def capture_rms_since_last(self) -> List[float]:
         """
         Get capture signal level rms in dB since the last read by the same client.
         Full scale is 0 dB. Returns a list with one element per channel.
         """
         sigrms = self.client.query("GetCaptureSignalRmsSinceLast")
         return sigrms
 
-    def levels(self) -> dict[str, list[float]]:
+    def levels(self) -> Dict[str, List[float]]:
         """
         Get all signal levels in dB for the last processed chunk.
         Full scale is 0 dB.
@@ -336,7 +336,7 @@ def levels(self) -> dict[str, list[float]]:
         siglevels = self.client.query("GetSignalLevels")
         return siglevels
 
-    def levels_since(self, interval: float) -> dict[str, list[float]]:
+    def levels_since(self, interval: float) -> Dict[str, List[float]]:
         """
         Get all signal levels in dB for the last `interval` seconds.
         Full scale is 0 dB.
@@ -350,7 +350,7 @@ def levels_since(self, interval: float) -> dict[str, list[float]]:
         siglevels = self.client.query("GetSignalLevelsSince", arg=float(interval))
         return siglevels
 
-    def levels_since_last(self) -> dict[str, list[float]]:
+    def levels_since_last(self) -> Dict[str, List[float]]:
         """
         Get all signal levels in dB since the last read by the same client.
         Full scale is 0 dB.
@@ -361,7 +361,7 @@ def levels_since_last(self) -> dict[str, list[float]]:
         siglevels = self.client.query("GetSignalLevelsSinceLast")
         return siglevels
 
-    def peaks_since_start(self) -> dict[str, list[float]]:
+    def peaks_since_start(self) -> Dict[str, List[float]]:
         """
         Get the playback and capture peak level since processing started.
         The values are returned as a json object with keys `playback` and `capture`.
@@ -420,31 +420,31 @@ def set_active_raw(self, config_string: str):
         """
         self.client.query("SetConfig", arg=config_string)
 
-    def active(self) -> Optional[dict]:
+    def active(self) -> Optional[Dict]:
         """
         Get the active configuration as a Python object.
 
         Returns:
-            dict | None: Current config as a Python dict, or None.
+            Dict | None: Current config as a Python dict, or None.
         """
         config_string = self.active_raw()
         if config_string is None:
             return None
         config_object = yaml.safe_load(config_string)
         return config_object
 
-    def previous(self) -> Optional[dict]:
+    def previous(self) -> Optional[Dict]:
         """
         Get the previously active configuration as a Python object.
 
         Returns:
-            dict | None: Previous config as a Python dict, or None.
+            Dict | None: Previous config as a Python dict, or None.
         """
         config_string = self.client.query("GetPreviousConfig")
         config_object = yaml.safe_load(config_string)
         return config_object
 
-    def parse_yaml(self, config_string: str) -> dict:
+    def parse_yaml(self, config_string: str) -> Dict:
         """
         Parse a config from yaml string and return the contents
         as a Python object, with defaults filled out with their default values.
@@ -453,47 +453,47 @@ def parse_yaml(self, config_string: str) -> dict:
             config_string (str): A config as raw yaml string.
 
         Returns:
-            dict | None: Parsed config as a Python dict.
+            Dict | None: Parsed config as a Python dict.
         """
         config_raw = self.client.query("ReadConfig", arg=config_string)
         config_object = yaml.safe_load(config_raw)
         return config_object
 
-    def read_and_parse_file(self, filename: str) -> dict:
+    def read_and_parse_file(self, filename: str) -> Dict:
         """
         Read and parse a config file from disk and return the contents as a Python object.
 
         Args:
             filename (str): Path to a config file.
 
         Returns:
-            dict | None: Parsed config as a Python dict.
+            Dict | None: Parsed config as a Python dict.
         """
         config_raw = self.client.query("ReadConfigFile", arg=filename)
         config = yaml.safe_load(config_raw)
         return config
 
-    def set_active(self, config_object: dict):
+    def set_active(self, config_object: Dict):
         """
         Upload and apply a new configuration from a Python object.
 
         Args:
-            config_object (dict): A configuration as a Python dict.
+            config_object (Dict): A configuration as a Python dict.
         """
         config_raw = yaml.dump(config_object)
         self.set_active_raw(config_raw)
 
-    def validate(self, config_object: dict) -> dict:
+    def validate(self, config_object: Dict) -> Dict:
         """
         Validate a configuration object.
         Returns the validated config with all optional fields filled with defaults.
         Raises a CamillaError on errors.
 
         Args:
-            config_object (dict): A configuration as a Python dict.
+            config_object (Dict): A configuration as a Python dict.
 
         Returns:
-            dict | None: Validated config as a Python dict.
+            Dict | None: Validated config as a Python dict.
         """
         config_string = yaml.dump(config_object)
         validated_string = self.client.query("ValidateConfig", arg=config_string)
@@ -773,14 +773,14 @@ def reload(self):
         """
         self.client.query("Reload")
 
-    def supported_device_types(self) -> tuple[list[str], list[str]]:
+    def supported_device_types(self) -> Tuple[List[str], List[str]]:
         """
         Read what device types the running CamillaDSP process supports.
         Returns a tuple with two lists of device types,
         the first for playback and the second for capture.
 
         Returns:
-            tuple[list[str], list[str]]: A tuple containing two lists,
+            Tuple[List[str], List[str]]: A tuple containing two lists,
                 with the supported playback and capture device types.
         """
         (playback, capture) = self.client.query("GetSupportedDeviceTypes")
@@ -806,29 +806,29 @@ def state_file_updated(self) -> bool:
         updated = self.client.query("GetStateFileUpdated")
         return updated
 
-    def list_playback_devices(self, value: str) -> list[tuple[str, str]]:
+    def list_playback_devices(self, value: str) -> List[Tuple[str, str]]:
         """
         List the available playback devices for a given backend.
         Returns a list of tuples. Returns the system name and
         a descriptive name for each device.
         For some backends, those two names are identical.
 
         Returns:
-            list[tuple[str, str]: A list containing tuples of two strings,
+            List[Tuple[str, str]: A list containing tuples of two strings,
                 with system device name and a descriptive name.
         """
         devs = self.client.query("GetAvailablePlaybackDevices", arg=value)
         return devs
 
-    def list_capture_devices(self, value: str) -> list[tuple[str, str]]:
+    def list_capture_devices(self, value: str) -> List[Tuple[str, str]]:
         """
         List the available capture devices for a given backend.
         Returns a list of tuples. Returns the system name and
         a descriptive name for each device.
         For some backends, those two names are identical.
 
         Returns:
-            list[tuple[str, str]: A list containing tuples of two strings,
+            List[Tuple[str, str]: A list containing tuples of two strings,
                 with system device name and a descriptive name.
         """
         devs = self.client.query("GetAvailableCaptureDevices", arg=value)
@@ -840,25 +840,26 @@ class Versions(_CommandGroup):
     Version info
     """
 
-    def camilladsp(self) -> Optional[tuple[str, str, str]]:
+    def camilladsp(self) -> Optional[Tuple[str, str, str]]:
         """
         Read CamillaDSP version.
 
         Returns:
-            tuple[list[str], list[str]] | None: A tuple containing the CamillaDSP version,
+            Tuple[List[str], List[str]] | None: A tuple containing the CamillaDSP version,
                 as (major, minor, patch).
         """
         return self.client.cdsp_version
 
-    def library(self) -> tuple[str, str, str]:
+    def library(self) -> Tuple[str, str, str]:
         """
         Read pyCamillaDSP library version.
 
         Returns:
-            tuple[list[str], list[str]] | None: A tuple containing the pyCamillaDSP version,
+            Tuple[List[str], List[str]] | None: A tuple containing the pyCamillaDSP version,
                 as (major, minor, patch).
         """
-        return VERSION.split(".")
+        v = VERSION.split(".")
+        return (v[0], v[1], v[2])
 
 
 class CamillaClient(_CamillaWS):

tests/test_camillaws.py

@@ -89,7 +89,7 @@ def test_connect(camilla_mockws):
     assert camilla_mockws.is_connected()
     assert camilla_mockws.general.state() == camilladsp.ProcessingState.INACTIVE
     assert camilla_mockws.versions.camilladsp() == ('0', '3', '2')
-    assert camilla_mockws.versions.library() == camilladsp.camilladsp.VERSION.split(".")
+    assert camilla_mockws.versions.library() == tuple(camilladsp.camilladsp.VERSION.split("."))
     camilla_mockws.disconnect()
     assert not camilla_mockws.is_connected()