sonusai 1.0.16__cp311-abi3-macosx_10_12_x86_64.whl

sonusai/__init__.py

@@ -0,0 +1,170 @@
+import atexit
+import logging
+from os.path import dirname
+
+from rich.logging import RichHandler
+
+from sonusai.rs import __version__ as rs_version
+
+__version__ = rs_version
+
+BASEDIR = dirname(__file__)
+
+commands_doc = """
+   audiofe                      Audio front end
+   calc_metric_spenh            Run speech enhancement and analysis
+   doc                          Documentation
+   genft                        Generate feature and truth data
+   genmetrics                   Generate mixture metrics data
+   genmix                       Generate mixture and truth data
+   genmixdb                     Generate a mixture database
+   lsdb                         List information about a mixture database
+   metrics_summary              Summarize generated metrics in a mixture database
+   mkwav                        Make WAV files from a mixture database
+   onnx_predict                 Run ONNX predict on a trained model
+   vars                         List custom SonusAI variables
+"""
+
+# Global handler registry to prevent duplicates
+_file_handlers = []
+
+
+def _cleanup_handlers():
+    """Clean up file handlers on exit"""
+    for handler in _file_handlers:
+        handler.close()
+
+
+atexit.register(_cleanup_handlers)
+
+
+def setup_logger(name: str = "sonusai") -> logging.Logger:
+    """Setup and return configured logger"""
+    _logger = logging.getLogger(name)
+
+    # Avoid duplicate configuration
+    if _logger.handlers:
+        return _logger
+
+    _logger.setLevel(logging.DEBUG)
+
+    # Setup console handler
+    formatter = logging.Formatter("%(message)s")
+
+    console_handler = RichHandler(show_level=False, show_path=False, show_time=False)
+
+    console_handler.setLevel(logging.DEBUG)
+    console_handler.setFormatter(formatter)
+    _logger.addHandler(console_handler)
+
+    return _logger
+
+
+# Initialize loggers
+logger = setup_logger("sonusai")
+logger_db = setup_logger("sonusai_db")
+
+
+def create_file_handler(filename: str, verbose: bool = False) -> None:
+    """Create a file handler with error handling"""
+    from pathlib import Path
+
+    try:
+        # Ensure directory exists
+        Path(filename).parent.mkdir(parents=True, exist_ok=True)
+
+        formatter = logging.Formatter("%(message)s")
+        formatter_db = logging.Formatter("%(asctime)s %(message)s")
+
+        fh = logging.FileHandler(filename=filename, mode="w")
+        fh.setLevel(logging.DEBUG)
+        fh.setFormatter(formatter)
+        logger.addHandler(fh)
+        _file_handlers.append(fh)
+
+        if verbose:
+            filename_db = Path(filename)
+            filename_db = filename_db.parent / (filename_db.stem + "_dbtrace" + filename_db.suffix)
+            fh_db = logging.FileHandler(filename=filename_db, mode="w")
+            fh_db.setLevel(logging.DEBUG)
+            fh_db.setFormatter(formatter_db)
+            logger_db.addHandler(fh_db)
+            _file_handlers.append(fh_db)
+
+    except (PermissionError, OSError) as e:
+        logger.warning(f"Could not create log file {filename}: {e}")
+
+
+def update_console_handler(verbose: bool) -> None:
+    """Update console handler verbosity"""
+    console_handlers = [h for h in logger.handlers if isinstance(h, logging.StreamHandler | RichHandler)]
+
+    if not console_handlers:
+        return
+
+    handler = console_handlers[0]
+    if not verbose:
+        handler.setLevel(logging.INFO)
+    else:
+        handler.setLevel(logging.DEBUG)
+
+
+def initial_log_messages(name: str, subprocess: str | None = None) -> None:
+    """Write initial log messages with error handling"""
+    from datetime import datetime
+    from getpass import getuser
+    from os import getcwd
+    from socket import gethostname
+    from sys import argv
+
+    try:
+        if subprocess is None:
+            logger.info(f"SonusAI {__version__}")
+        else:
+            logger.info(f"SonusAI {subprocess}")
+        logger.info(f"{name}")
+        logger.info("")
+        logger.debug(f"Host:      {gethostname()}")
+        logger.debug(f"User:      {getuser()}")
+        logger.debug(f"Directory: {getcwd()}")
+        logger.debug(f"Date:      {datetime.now()}")
+        logger.debug(f"Command:   {' '.join(argv)}")
+        logger.debug("")
+    except Exception as e:
+        logger.warning(f"Could not write initial log messages: {e}")
+
+
+def commands_list(doc: str = commands_doc) -> list[str]:
+    """Parse commands from a documentation string"""
+    commands = []
+    for line in doc.strip().split("\n"):
+        line = line.strip()
+        if line:
+            # Get the first word that's not empty
+            parts = line.split()
+            if parts:
+                commands.append(parts[0])
+    return commands
+
+
+def exception_handler(e: Exception) -> None:
+    """Handle exceptions with proper logging"""
+    import sys
+
+    logger.error(f"{type(e).__name__}: {e}")
+
+    # Find file handlers for detailed logs
+    file_handlers = [handler for handler in logger.handlers if isinstance(handler, logging.FileHandler)]
+
+    if file_handlers:
+        filenames = [handler.baseFilename for handler in file_handlers]
+        logger.error(f"See {', '.join(filenames)} for details")
+
+    from rich.console import Console
+
+    console = Console(color_system=None)
+    with console.capture() as capture:
+        console.print_exception(show_locals=False)
+    logger.debug(capture.get())
+
+    sys.exit(1)

sonusai/aawscd_probwrite.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""aawscd_probwrite
+
+usage: aawscd_probwrite [-h] [-m MACHINE] [-f FRAMES] FILE
+
+options:
+   -h, --help
+   -m MACHINE, --machine MACHINE    IP address of aawscd platform. [default: localhost].
+   -f FRAMES, --frames FRAMES       Number of frames to capture. [default: 10].
+
+aawscd_probwrite connects to an Aaware platform running aawscd and writes the sound classification
+probability output to an HDF5 file.
+
+"""
+
+from threading import Condition
+
+import numpy as np
+
+from sonusai.utils.parallel import track
+
+CLIENT: str = "aawscd_probwrite"
+TOPIC: str = "aawscd/sc/prob"
+DONE: Condition = Condition()
+FRAMES: int = 10
+FRAME_COUNT: int = 0
+DATA: np.ndarray | None = None
+PROGRESS: track | None = None
+
+
+def shutdown(_signum, _frame) -> None:
+    global DONE
+    with DONE:
+        DONE.notify()
+
+
+def unpack_prob_entry(entry: int) -> tuple[int, int, int]:
+    """Decode the packed probability data: [ 16-bit label | 8-bit zone | 8-bit probability ]."""
+    data = np.array(entry, dtype=np.uint32)
+    label = np.right_shift(data, 16)
+    zone = np.bitwise_and(np.right_shift(data, 8), 0xFF)
+    value = np.bitwise_and(entry, 0xFF)
+    return int(zone), int(label), int(value)
+
+
+def parse_prob(payload: list) -> np.ndarray:
+    """Parse MQTT probability payload from aawscd.
+
+    The 'aawscd/sc/prob' payload is a list of uint32. Each item contains packed data and is
+    unpacked/decoded and inserted into an array.
+    """
+
+    # First pass: get the zones and labels to determine the size of the array
+    zones = set()
+    labels = set()
+    for entry in payload:
+        zone, label, _ = unpack_prob_entry(entry)
+        zones.add(zone)
+        labels.add(label)
+
+    # Create the array
+    prob = np.zeros((len(list(labels)), len(list(zones))), dtype=np.uint8)
+
+    # Second pass: fill in the array probability values.
+    for entry in payload:
+        zone, label, value = unpack_prob_entry(entry)
+        prob[label, zone] = value
+
+    # Return the array
+    return prob
+
+
+def on_message(_client, _userdata, message):
+    import paho.mqtt.client as mqtt
+    import yaml
+
+    global TOPIC
+    if mqtt.topic_matches_sub(TOPIC, message.topic):
+        payload = yaml.safe_load(str(message.payload.decode("utf-8")))
+        prob = parse_prob(payload["prob"])
+
+        global DATA
+        global FRAMES
+        if DATA is None:
+            DATA = np.zeros((FRAMES, prob.shape[0], prob.shape[1]), dtype=prob.dtype)
+
+        global FRAME_COUNT
+        DATA[FRAME_COUNT] = prob
+        FRAME_COUNT += 1
+
+        global PROGRESS
+        PROGRESS.update()  # pyright: ignore [reportOptionalMemberAccess]
+
+        if FRAME_COUNT == FRAMES:
+            global DONE
+            with DONE:
+                DONE.notify()
+
+
+def main() -> None:
+    from docopt import docopt
+
+    args = docopt(__doc__, version="1.0.0", options_first=True)
+
+    import signal
+
+    import h5py
+    import paho.mqtt.client as mqtt
+
+    machine = args["--machine"]
+
+    global FRAMES
+    FRAMES = int(args["--frames"])
+
+    file = args["FILE"]
+
+    signal.signal(signal.SIGINT, shutdown)
+    signal.signal(signal.SIGTERM, shutdown)
+
+    global CLIENT
+    client = mqtt.Client(client_id=CLIENT)
+    client.on_message = on_message
+    client.connect(host=machine)
+    client.loop_start()
+    global TOPIC
+    client.subscribe(topic=TOPIC)
+
+    global PROGRESS
+    PROGRESS = track(total=FRAMES, desc=file)
+
+    with DONE:
+        DONE.wait()
+
+    PROGRESS.close()
+
+    client.unsubscribe(topic=TOPIC)
+    client.loop_stop()
+    client.disconnect()
+
+    global DATA
+    with h5py.File(file, "w") as f:
+        f.create_dataset(name="prob", data=DATA)
+
+    print(f"Wrote {file}")
+
+
+if __name__ == "__main__":
+    main()