sonusai 1.0.16__cp311-abi3-macosx_11_0_arm64.whl

sonusai/utils/asr_functions/aaware_whisper.py

@@ -0,0 +1,69 @@
+from ...datatypes import AudioT
+from ..asr import ASRResult
+
+
+def aaware_whisper_validate(**_config) -> None:
+    pass
+
+
+def aaware_whisper(audio: AudioT, **_config) -> ASRResult:
+    import tempfile
+    from math import exp
+    from os import getenv
+    from os.path import join
+
+    import requests
+
+    from ..numeric_conversion import float_to_int16
+    from ..write_audio import write_audio
+
+    url = getenv("AAWARE_WHISPER_URL")
+    if url is None:
+        raise OSError("AAWARE_WHISPER_URL environment variable does not exist")
+    url += "/asr?task=transcribe&language=en&encode=true&output=json"
+
+    with tempfile.TemporaryDirectory() as tmp:
+        file = join(tmp, "asr.wav")
+        write_audio(name=file, audio=float_to_int16(audio))
+
+        files = {"audio_file": (file, open(file, "rb"), "audio/wav")}  # noqa: SIM115
+
+        try:
+            response = requests.post(url, files=files)  # noqa: S113
+            if response.status_code != 200:
+                if response.status_code == 422:
+                    raise RuntimeError(f"Validation error: {response.json()}")  # noqa: TRY301
+                raise RuntimeError(f"Invalid response: {response.status_code}")  # noqa: TRY301
+            result = response.json()
+            return ASRResult(
+                text=result["text"],
+                confidence=exp(float(result["segments"][0]["avg_logprob"])),
+            )
+        except Exception as e:
+            raise RuntimeError(f"Aaware Whisper exception: {e.args}") from e
+
+
+"""
+Aaware Whisper Asr Webservice results:
+{
+  "text": " The birch canoes slid on the smooth planks.",
+  "segments": [
+    {
+      "id": 0,
+      "seek": 0,
+      "start": 0.0,
+      "end": 2.32,
+      "text": " The birch canoes slid on the smooth planks.",
+      "tokens": [
+        50364, 440, 1904, 339, 393, 78, 279, 1061, 327, 322, 264, 5508, 499,
+        14592, 13, 50480
+      ],
+      "temperature": 0.0,
+      "avg_logprob": -0.385713913861443,
+      "compression_ratio": 0.86,
+      "no_speech_prob": 0.006166956853121519
+    }
+  ],
+  "language": "en"
+}
+"""

sonusai/utils/audio_devices.py

@@ -0,0 +1,50 @@
+import pyaudio
+
+
+def get_input_device_index_by_name(p: pyaudio.PyAudio, name: str | None = None) -> int:
+    info = p.get_host_api_info_by_index(0)
+    device_count = info.get("deviceCount")
+    if isinstance(device_count, int):
+        for i in range(0, device_count):
+            device_info = p.get_device_info_by_host_api_device_index(0, i)
+            if name is None:
+                device_name = None
+            else:
+                device_name = device_info.get("name")
+            if isinstance(device_name, str) or device_name is None:
+                input_channels = device_info.get("maxInputChannels")
+                if name == device_name and isinstance(input_channels, int) and input_channels > 0:
+                    return i
+
+    raise ValueError(f"Could not find {name}")
+
+
+def get_input_devices(p: pyaudio.PyAudio) -> list[str]:
+    names = []
+    info = p.get_host_api_info_by_index(0)
+    device_count = info.get("deviceCount")
+    if isinstance(device_count, int):
+        for i in range(0, device_count):
+            device_info = p.get_device_info_by_host_api_device_index(0, i)
+            device_name = device_info.get("name")
+            if isinstance(device_name, str):
+                input_channels = device_info.get("maxInputChannels")
+                if isinstance(input_channels, int) and input_channels > 0:
+                    names.append(device_name)
+
+    return names
+
+
+def get_default_input_device(p: pyaudio.PyAudio) -> str:
+    info = p.get_host_api_info_by_index(0)
+    device_count = info.get("deviceCount")
+    if isinstance(device_count, int):
+        for i in range(0, device_count):
+            device_info = p.get_device_info_by_host_api_device_index(0, i)
+            device_name = device_info.get("name")
+            if isinstance(device_name, str):
+                input_channels = device_info.get("maxInputChannels")
+                if isinstance(input_channels, int) and input_channels > 0:
+                    return device_name
+
+    raise ValueError("No input audio devices found")

sonusai/utils/braced_glob.py

@@ -0,0 +1,50 @@
+from collections.abc import Generator
+from typing import LiteralString
+
+
+def expand_braces(text: LiteralString | str | bytes, seen: set[str] | None = None) -> Generator[str, None, None]:
+    """Brace-expansion pre-processing for glob.
+
+    Expand all the braces, then run glob on each of the results.
+    (Brace-expansion turns one string into a list of strings.)
+    https://stackoverflow.com/questions/22996645/brace-expansion-in-python-glob
+    """
+    import itertools
+    import re
+
+    if seen is None:
+        seen = set()
+
+    if not isinstance(text, str):
+        text = str(text)
+
+    spans = [m.span() for m in re.finditer(r"\{[^{}]*}", text)][::-1]
+    alts = [text[start + 1 : stop - 1].split(",") for start, stop in spans]
+
+    if len(spans) == 0:
+        if text not in seen:
+            yield text
+        seen.add(text)
+    else:
+        for combo in itertools.product(*alts):
+            replaced = list(text)
+            for (start, stop), replacement in zip(spans, combo, strict=False):
+                replaced[start:stop] = replacement
+            yield from expand_braces("".join(replaced), seen)
+
+
+def braced_glob(pathname: LiteralString | str | bytes, recursive: bool = False) -> list[str]:
+    from glob import glob
+
+    result = []
+    for expanded_path in expand_braces(pathname):
+        result.extend(glob(expanded_path, recursive=recursive))
+
+    return result
+
+
+def braced_iglob(pathname: LiteralString | str | bytes, recursive: bool = False) -> Generator[str, None, None]:
+    from glob import iglob
+
+    for expanded_path in expand_braces(pathname):
+        yield from iglob(expanded_path, recursive=recursive)

sonusai/utils/calculate_input_shape.py

@@ -0,0 +1,26 @@
+def calculate_input_shape(feature: str, flatten: bool = False, timesteps: int = 0, add1ch: bool = False) -> list[int]:
+    """
+    Calculate input shape given feature and user-specified reshape parameters.
+
+    Inputs:
+        feature:     String defining the Aaware feature used in SonusAI, typically  mixdb.feature.
+        flatten:     If true, flatten the 2D spectrogram from SxB to S*B.
+        timesteps:   Pre-pend timesteps dimension if non-zero, size = timesteps.
+        add1ch:      Append channel dimension of size 1, (channel last).
+    """
+    from pyaaware import FeatureGenerator
+
+    fg = FeatureGenerator(feature_mode=feature)
+
+    if flatten:
+        in_shape = [fg.stride * fg.feature_parameters]
+    else:
+        in_shape = [fg.stride, fg.feature_parameters]
+
+    if timesteps > 0:
+        in_shape.insert(0, timesteps)
+
+    if add1ch:
+        in_shape.append(1)
+
+    return in_shape

sonusai/utils/choice.py

@@ -0,0 +1,51 @@
+from abc import ABC
+from abc import abstractmethod
+from typing import Any
+
+
+class BaseChoice(ABC):
+    def __init__(self, data: list):
+        self.data = data
+        self.index = 0
+        self.choices: list = []
+
+    @abstractmethod
+    def next(self) -> Any:
+        pass
+
+
+class RandomChoice(BaseChoice):
+    def __init__(self, data: list, repetition: bool = False):
+        from random import sample
+
+        super().__init__(data)
+        self.repeat = repetition
+        self.choices = sample(self.data, len(self.data))
+
+    def next(self) -> Any:
+        from random import choice
+        from random import sample
+
+        if self.repeat:
+            return choice(self.data)  # noqa: S311
+
+        if self.index >= len(self.data):
+            self.choices = sample(self.data, len(self.data))
+            self.index = 0
+
+        item = self.choices[self.index]
+        self.index += 1
+
+        return item
+
+
+class SequentialChoice(BaseChoice):
+    def __init__(self, data: list):
+        super().__init__(data)
+
+    def next(self) -> Any:
+        if self.index >= len(self.data):
+            self.index = 0
+        item = self.data[self.index]
+        self.index += 1
+        return item

sonusai/utils/compress.py

@@ -0,0 +1,25 @@
+from ..datatypes import AudioF
+
+
+def power_compress(feature: AudioF) -> AudioF:
+    import numpy as np
+
+    mag = np.abs(feature)
+    phase = np.angle(feature)
+    mag = mag**0.3
+    real_compress = mag * np.cos(phase)
+    imag_compress = mag * np.sin(phase)
+
+    return real_compress + 1j * imag_compress
+
+
+def power_uncompress(feature: AudioF) -> AudioF:
+    import numpy as np
+
+    mag = np.abs(feature)
+    phase = np.angle(feature)
+    mag = mag ** (1.0 / 0.3)
+    real_uncompress = mag * np.cos(phase)
+    imag_uncompress = mag * np.sin(phase)
+
+    return real_uncompress + 1j * imag_uncompress

sonusai/utils/convert_string_to_number.py

@@ -0,0 +1,6 @@
+def convert_string_to_number(string: str) -> float | int | str:
+    try:
+        result = float(string)
+        return int(result) if result == int(result) else result
+    except ValueError:
+        return string

sonusai/utils/create_timestamp.py

@@ -0,0 +1,5 @@
+def create_timestamp() -> str:
+    """Create a timestamp."""
+    from datetime import datetime
+
+    return datetime.now().strftime("%Y%m%d-%H%M%S")

sonusai/utils/create_ts_name.py

@@ -0,0 +1,14 @@
+def create_ts_name(base: str) -> str:
+    """Create a timestamped name based on 'base'."""
+    from datetime import datetime
+    from os.path import exists
+
+    ts = datetime.now()
+
+    # First try just date
+    dir_name = base + "-" + ts.strftime("%Y%m%d")
+    if exists(dir_name):
+        # add hour-min-sec if necessary
+        dir_name = base + "-" + ts.strftime("%Y%m%d-%H%M%S")
+
+    return dir_name

sonusai/utils/dataclass_from_dict.py

@@ -0,0 +1,27 @@
+from collections.abc import Sequence
+from typing import Any
+
+
+def dataclass_from_dict(klass, dikt: dict) -> Any:
+    """Convert dictionary to dataclass."""
+    try:
+        field_types = klass.__annotations__
+        return klass(**{f: dataclass_from_dict(field_types[f], dikt[f]) for f in dikt})
+    except AttributeError:
+        return dikt
+
+
+def list_dataclass_from_dict(klass, dikt: Sequence[dict]) -> list[Any]:
+    """Convert list of dictionary to list of dataclass."""
+    return [dataclass_from_dict(klass.__args__[0], f) for f in dikt]
+
+
+def original_dataclass_from_dict(klass, dikt):
+    """Convert dictionary to dataclass."""
+    try:
+        field_types = klass.__annotations__
+        return klass(**{f: dataclass_from_dict(field_types[f], dikt[f]) for f in dikt})
+    except AttributeError:
+        if isinstance(dikt, tuple | list):
+            return [dataclass_from_dict(klass.__args__[0], f) for f in dikt]
+        return dikt

sonusai/utils/db.py

@@ -0,0 +1,16 @@
+def linear_to_db(linear: float) -> float:
+    """Convert linear value to dB value
+    :param linear: Linear value
+    :return: dB value
+    """
+    import numpy as np
+
+    return 20 * np.log10(abs(linear))
+
+
+def db_to_linear(db: float) -> float:
+    """Convert dB value to linear value
+    :param db: dB value
+    :return: Linear value
+    """
+    return 10 ** (db / 20)

sonusai/utils/docstring.py

@@ -0,0 +1,53 @@
+def trim_docstring(docstring: str | None) -> str:
+    """Trim whitespace from docstring"""
+    from sys import maxsize
+
+    if not docstring:
+        return ""
+
+    # Convert tabs to spaces (following the normal Python rules)
+    # and split into a list of lines:
+    lines = docstring.expandtabs().splitlines()
+
+    # Determine minimum indentation (first line doesn't count)
+    indent = maxsize
+    for line in lines[1:]:
+        stripped = line.lstrip()
+        if stripped:
+            indent = min(indent, len(line) - len(stripped))
+
+    # Remove indentation (first line is special):
+    trimmed = [lines[0].strip()]
+    if indent < maxsize:
+        for line in lines[1:]:
+            trimmed.append(line[indent:].rstrip())
+
+    # Strip off leading blank lines:
+    while trimmed and not trimmed[0]:
+        trimmed.pop(0)
+
+    # Return a single string
+    return "\n".join(trimmed)
+
+
+def add_commands_to_docstring(docstring: str | None, plugin_docstrings: list[str]) -> str:
+    """Add commands to docstring"""
+    import sonusai
+
+    if not docstring:
+        lines = []
+    else:
+        lines = docstring.splitlines()
+
+    start = lines.index("The sonusai commands are:")
+    end = lines.index("", start)
+
+    commands = sonusai.commands_doc.splitlines()
+    for plugin_docstring in plugin_docstrings:
+        commands.extend(plugin_docstring.splitlines())
+    commands.sort()
+    commands = list(filter(None, commands))
+
+    lines = lines[: start + 1] + commands + lines[end:]
+
+    return "\n".join(lines)

sonusai/utils/energy_f.py

@@ -0,0 +1,44 @@
+from pyaaware import ForwardTransform
+
+from ..datatypes import AudioF
+from ..datatypes import AudioT
+from ..datatypes import EnergyF
+
+
+def compute_energy_f(
+    frequency_domain: AudioF | None = None,
+    time_domain: AudioT | None = None,
+    transform: ForwardTransform | None = None,
+) -> EnergyF:
+    """Compute the energy in each bin
+
+    Must provide either frequency domain or time domain input. If time domain input is provided, must also provide
+    ForwardTransform object to use to convert to frequency domain.
+
+    :param frequency_domain: Frequency domain data [frames, bins]
+    :param time_domain: Time domain data [samples]
+    :param transform: ForwardTransform object
+    :return: Frequency domain per-bin energy data [frames, bins]
+    """
+    import numpy as np
+    import torch
+
+    if frequency_domain is None:
+        if time_domain is None:
+            raise ValueError("Must provide time or frequency domain input")
+        if transform is None:
+            raise ValueError("Must provide ForwardTransform object")
+
+        _frequency_domain = transform.execute_all(torch.from_numpy(time_domain))[0].numpy()
+    else:
+        _frequency_domain = frequency_domain
+
+    frames, bins = _frequency_domain.shape
+    result = np.empty((frames, bins), dtype=np.float32)
+
+    for f in range(frames):
+        for b in range(bins):
+            value = _frequency_domain[f, b]
+            result[f, b] = np.real(value) * np.real(value) + np.imag(value) * np.imag(value)
+
+    return result

sonusai/utils/engineering_number.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Any
+from typing import ClassVar
+
+
+class EngineeringNumber:
+    """Easy manipulation of numbers which use engineering notation"""
+
+    _suffix_lookup: ClassVar = {
+        "Y": "e24",
+        "Z": "e21",
+        "E": "e18",
+        "P": "e15",
+        "T": "e12",
+        "G": "e9",
+        "M": "e6",
+        "k": "e3",
+        "": "e0",
+        "m": "e-3",
+        "u": "e-6",
+        "n": "e-9",
+        "p": "e-12",
+        "f": "e-15",
+        "a": "e-18",
+        "z": "e-21",
+        "y": "e-24",
+    }
+
+    _exponent_lookup_scaled: ClassVar = {
+        "-12": "Y",
+        "-15": "Z",
+        "-18": "E",
+        "-21": "P",
+        "-24": "T",
+        "-27": "G",
+        "-30": "M",
+        "-33": "k",
+        "-36": "",
+        "-39": "m",
+        "-42": "u",
+        "-45": "n",
+        "-48": "p",
+        "-51": "f",
+        "-54": "a",
+        "-57": "z",
+        "-60": "y",
+    }
+
+    def __init__(
+        self,
+        value: str | float | int | EngineeringNumber,
+        precision: int = 2,
+        significant: int = 0,
+    ):
+        """
+        :param value: string, integer, or float representing the numeric value of the number
+        :param precision: the precision past the decimal
+        :param significant: the number of significant digits
+        if given, significant takes precedence over precision
+        """
+        self.precision = precision
+        self.significant = significant
+
+        if isinstance(value, str):
+            suffix_keys = [key for key in self._suffix_lookup if key != ""]
+
+            str_value = str(value)
+            for suffix in suffix_keys:
+                if suffix in str_value:
+                    str_value = str_value[:-1] + self._suffix_lookup[suffix]
+                    break
+
+            self.number = Decimal(str_value)
+
+        elif isinstance(value, int | float | EngineeringNumber):
+            self.number = Decimal(str(value))
+
+        else:
+            raise TypeError("value has unsupported type")
+
+    def __repr__(self):
+        """Returns the string representation"""
+        # The Decimal class only really converts numbers that are very small into engineering notation.
+        # So we will simply make all numbers small numbers and take advantage of the Decimal class.
+        number_str = self.number * Decimal("10e-37")
+        number_str = number_str.to_eng_string().lower()
+
+        base, exponent = number_str.split("e")
+
+        if self.significant > 0:
+            abs_base = abs(Decimal(base))
+            num_digits = 1
+            num_digits += 1 if abs_base >= 10 else 0
+            num_digits += 1 if abs_base >= 100 else 0
+            num_digits = self.significant - num_digits
+        else:
+            num_digits = self.precision
+
+        base = str(round(Decimal(base), num_digits))
+
+        if "e" in base.lower():
+            base = str(int(Decimal(base)))
+
+        # Remove trailing decimal
+        if "." in base:
+            base = base.rstrip(".")
+
+        return base + self._exponent_lookup_scaled[exponent]
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+    def __int__(self) -> int:
+        return int(self.number)
+
+    def __float__(self):
+        return float(self.number)
+
+    @staticmethod
+    def _to_decimal(other: str | float | int | EngineeringNumber) -> Decimal:
+        if not isinstance(other, EngineeringNumber):
+            other = EngineeringNumber(other)
+        return other.number
+
+    def __add__(self, other: str | float | int | EngineeringNumber) -> EngineeringNumber:
+        return EngineeringNumber(str(self.number + self._to_decimal(other)))
+
+    def __radd__(self, other: str | float | int | EngineeringNumber) -> EngineeringNumber:
+        return self.__add__(other)
+
+    def __sub__(self, other: str | float | int | EngineeringNumber) -> EngineeringNumber:
+        return EngineeringNumber(str(self.number - self._to_decimal(other)))
+
+    def __rsub__(self, other: str | float | int | EngineeringNumber) -> EngineeringNumber:
+        return EngineeringNumber(str(self._to_decimal(other) - self.number))
+
+    def __mul__(self, other: str | float | int | EngineeringNumber) -> EngineeringNumber:
+        return EngineeringNumber(str(self.number * self._to_decimal(other)))
+
+    def __rmul__(self, other: str | float | int | EngineeringNumber) -> EngineeringNumber:
+        return self.__mul__(other)
+
+    def __truediv__(self, other: str | float | int | EngineeringNumber) -> EngineeringNumber:
+        return EngineeringNumber(str(self.number / self._to_decimal(other)))
+
+    def __rtruediv__(self, other: str | float | int | EngineeringNumber) -> EngineeringNumber:
+        return EngineeringNumber(str(self._to_decimal(other) / self.number))
+
+    def __lt__(self, other: str | float | int | EngineeringNumber) -> bool:
+        return self.number < self._to_decimal(other)
+
+    def __gt__(self, other: str | float | int | EngineeringNumber) -> bool:
+        return self.number > self._to_decimal(other)
+
+    def __le__(self, other: str | float | int | EngineeringNumber) -> bool:
+        return self.number <= self._to_decimal(other)
+
+    def __ge__(self, other: str | float | int | EngineeringNumber) -> bool:
+        return self.number >= self._to_decimal(other)
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, str | float | int | EngineeringNumber):
+            return NotImplemented
+        return self.number == self._to_decimal(other)

sonusai/utils/evaluate_random_rule.py

@@ -0,0 +1,15 @@
+def evaluate_random_rule(rule: str) -> str | float:
+    """Evaluate 'rand' directive
+
+    :param rule: Rule
+    :return: Resolved value
+    """
+    import re
+    from random import uniform
+
+    rand_pattern = re.compile(r"rand\(([-+]?(\d+(\.\d*)?|\.\d+)),\s*([-+]?(\d+(\.\d*)?|\.\d+))\)")
+
+    def rand_repl(m):
+        return f"{uniform(float(m.group(1)), float(m.group(4))):.2f}"  # noqa: S311
+
+    return eval(re.sub(rand_pattern, rand_repl, rule))  # noqa: S307

sonusai/utils/get_frames_per_batch.py

@@ -0,0 +1,2 @@
+def get_frames_per_batch(batch_size: int, timesteps: int) -> int:
+    return batch_size if timesteps == 0 else batch_size * timesteps

sonusai/utils/get_label_names.py

@@ -0,0 +1,20 @@
+def get_label_names(num_labels: int, file: str | None = None) -> list:
+    """Return label names in a list. Read from CSV file, if provided."""
+    import csv
+
+    if file is None:
+        return [f"Class {val + 1}" for val in range(num_labels)]
+
+    label_names = [""] * num_labels
+    with open(file) as f:
+        reader = csv.DictReader(f)
+        if reader.fieldnames is None or "index" not in reader.fieldnames or "display_name" not in reader.fieldnames:
+            raise ValueError("Missing required fields in labels CSV.")
+
+        for row in reader:
+            index = int(row["index"]) - 1
+            if index >= num_labels:
+                raise ValueError("The number of given label names does not match the number of labels.")
+            label_names[index] = row["display_name"]
+
+    return label_names

sonusai/utils/grouper.py

@@ -0,0 +1,6 @@
+def grouper(iterable, n):
+    from itertools import zip_longest
+
+    args = [iter(iterable)] * n
+    result = zip_longest(*args, fillvalue=None)
+    return [list(filter(None.__ne__, x)) for x in result]

sonusai/utils/human_readable_size.py

@@ -0,0 +1,7 @@
+def human_readable_size(num: float, decimal_places: int = 3, suffix: str = "B") -> str:
+    """Convert number into string with units"""
+    for unit in ("", "k", "M", "G", "T", "P", "E", "Z"):
+        if abs(num) < 1024.0:
+            return f"{num:.{decimal_places}f} {unit}{suffix}"
+        num /= 1024.0
+    return f"{num:.{decimal_places}f} Y{suffix}"