sonusai 0.18.9__py3-none-any.whl → 0.19.5__py3-none-any.whl

sonusai/mixture/augmentation.py

@@ -1,10 +1,9 @@
-from typing import Optional
-
 from sonusai.mixture.datatypes import AudioT
 from sonusai.mixture.datatypes import Augmentation
 from sonusai.mixture.datatypes import AugmentationRule
 from sonusai.mixture.datatypes import AugmentationRules
 from sonusai.mixture.datatypes import ImpulseResponseData
+from sonusai.mixture.datatypes import OptionalNumberStr
 
 
 def get_augmentation_rules(rules: list[dict] | dict, num_ir: int = 0) -> AugmentationRules:
@@ -15,6 +14,7 @@ def get_augmentation_rules(rules: list[dict] | dict, num_ir: int = 0) -> Augment
     :return: List of augmentation rules
     """
     from sonusai.utils import dataclass_from_dict
+
     from .datatypes import AugmentationRule
 
     processed_rules: list[dict] = []
@@ -37,8 +37,8 @@ def _expand_rules(expanded_rules: list[dict], rule: dict) -> list[dict]:
     """
     from copy import deepcopy
 
-    from sonusai import SonusAIError
     from sonusai.utils import convert_string_to_number
+
     from .constants import VALID_AUGMENTATIONS
     from .eq_rule_is_valid import eq_rule_is_valid
 
@@ -47,46 +47,44 @@ def _expand_rules(expanded_rules: list[dict], rule: dict) -> list[dict]:
             del rule[key]
 
     # replace old 'eq' rule with new 'eq1' rule to allow both for backward compatibility
-    rule = {'eq1' if key == 'eq' else key: value for key, value in rule.items()}
+    rule = {"eq1" if key == "eq" else key: value for key, value in rule.items()}
 
     for key in rule:
         if key not in VALID_AUGMENTATIONS:
-            nice_list = '\n'.join([f'  {item}' for item in VALID_AUGMENTATIONS])
-            raise SonusAIError(f'Invalid augmentation: {key}.\nValid augmentations are:\n{nice_list}')
+            nice_list = "\n".join([f"  {item}" for item in VALID_AUGMENTATIONS])
+            raise ValueError(f"Invalid augmentation: {key}.\nValid augmentations are:\n{nice_list}")
 
-        if key in ['eq1', 'eq2', 'eq3']:
+        if key in ["eq1", "eq2", "eq3"]:
             if not eq_rule_is_valid(rule[key]):
-                raise SonusAIError(f'Invalid augmentation value for {key}: {rule[key]}')
+                raise ValueError(f"Invalid augmentation value for {key}: {rule[key]}")
 
-            if all(isinstance(el, list) or (isinstance(el, str) and el == 'none') for el in rule[key]):
+            if all(isinstance(el, list) or (isinstance(el, str) and el == "none") for el in rule[key]):
                 # Expand multiple rules
                 for value in rule[key]:
                     expanded_rule = deepcopy(rule)
-                    if isinstance(value, str) and value == 'none':
+                    if isinstance(value, str) and value == "none":
                         expanded_rule[key] = None
                     else:
                         expanded_rule[key] = deepcopy(value)
                     _expand_rules(expanded_rules, expanded_rule)
                 return expanded_rules
 
-        elif key in ['mixup']:
+        elif key in ["mixup"]:
             pass
 
         else:
             if isinstance(rule[key], list):
                 for value in rule[key]:
                     if isinstance(value, list):
-                        raise SonusAIError(f'Invalid augmentation value for {key}: {rule[key]}')
+                        raise TypeError(f"Invalid augmentation value for {key}: {rule[key]}")
                     expanded_rule = deepcopy(rule)
                     expanded_rule[key] = deepcopy(value)
                     _expand_rules(expanded_rules, expanded_rule)
                 return expanded_rules
             else:
                 rule[key] = convert_string_to_number(rule[key])
-                if not (isinstance(rule[key], float | int) or
-                        rule[key].startswith('rand') or
-                        rule[key] == 'none'):
-                    raise SonusAIError(f'Invalid augmentation value for {key}: {rule[key]}')
+                if not (isinstance(rule[key], float | int) or rule[key].startswith("rand") or rule[key] == "none"):
+                    raise ValueError(f"Invalid augmentation value for {key}: {rule[key]}")
 
     expanded_rules.append(rule)
     return expanded_rules
@@ -102,7 +100,7 @@ def _generate_none_rule(rule: dict) -> dict:
 
     out_rule = deepcopy(rule)
     for key in out_rule:
-        if out_rule[key] == 'none':
+        if out_rule[key] == "none":
             out_rule[key] = None
 
     return out_rule
@@ -120,20 +118,20 @@ def _generate_random_rule(rule: dict, num_ir: int = 0) -> dict:
 
     out_rule = deepcopy(rule)
     for key in out_rule:
-        if key == 'ir' and out_rule[key] == 'rand':
+        if key == "ir" and out_rule[key] == "rand":
             # IR is special case
             if num_ir == 0:
                 out_rule[key] = None
             else:
-                out_rule[key] = randint(0, num_ir - 1)
+                out_rule[key] = randint(0, num_ir - 1)  # noqa: S311
         else:
             out_rule[key] = evaluate_random_rule(str(out_rule[key]))
 
         # convert EQ values from strings to numbers
-        if key in ['eq1', 'eq2', 'eq3']:
+        if key in ["eq1", "eq2", "eq3"]:
             for n in range(3):
                 if isinstance(out_rule[key][n], str):
-                    out_rule[key][n] = eval(out_rule[key][n])
+                    out_rule[key][n] = eval(out_rule[key][n])  # noqa: S307
 
     return out_rule
 
@@ -144,14 +142,10 @@ def _rule_has_rand(rule: dict) -> bool:
     :param rule: Rule
     :return: True if rule contains 'rand'
     """
-    for key in rule:
-        if 'rand' in str(rule[key]):
-            return True
-
-    return False
+    return any("rand" in str(rule[key]) for key in rule)
 
 
-def estimate_augmented_length_from_length(length: int, tempo: Optional[float] = None, frame_length: int = 1) -> int:
+def estimate_augmented_length_from_length(length: int, tempo: OptionalNumberStr = None, frame_length: int = 1) -> int:
     """Estimate the length of audio after augmentation
 
     :param length: Number of samples in audio
@@ -162,7 +156,7 @@ def estimate_augmented_length_from_length(length: int, tempo: Optional[float] =
     import numpy as np
 
     if tempo is not None:
-        length = int(np.round(length / tempo))
+        length = int(np.round(length / float(tempo)))
 
     length = _get_padded_length(length, frame_length)
 
@@ -175,7 +169,7 @@ def get_mixups(augmentations: AugmentationRules) -> list[int]:
     :param augmentations: List of augmentations
     :return: List of mixup values used
     """
-    return sorted(list(set([augmentation.mixup for augmentation in augmentations])))
+    return sorted({augmentation.mixup for augmentation in augmentations})
 
 
 def get_augmentation_indices_for_mixup(augmentations: AugmentationRules, mixup: int) -> list[int]:
@@ -249,53 +243,52 @@ def evaluate_random_rule(rule: str) -> str | float:
     from .constants import RAND_PATTERN
 
     def rand_repl(m):
-        return f'{uniform(float(m.group(1)), float(m.group(4))):.2f}'
+        return f"{uniform(float(m.group(1)), float(m.group(4))):.2f}"  # noqa: S311
 
-    return eval(re.sub(RAND_PATTERN, rand_repl, rule))
+    return eval(re.sub(RAND_PATTERN, rand_repl, rule))  # noqa: S307
 
 
 def _parse_ir(rule: dict, num_ir: int) -> dict:
-    from sonusai import SonusAIError
     from .helpers import generic_ids_to_list
 
     def _resolve_str(rule_in: str) -> str | list[int]:
-        if rule_in in ['rand', 'none']:
+        if rule_in in ["rand", "none"]:
             return rule_in
 
         rule_out = generic_ids_to_list(num_ir, rule_in)
         if not all(ro in range(num_ir) for ro in rule_out):
-            raise SonusAIError(f'Invalid ir entry of {rule_in}')
+            raise ValueError(f"Invalid ir entry of {rule_in}")
         return rule_out
 
-    if 'ir' not in rule:
+    if "ir" not in rule:
         return rule
 
-    ir = rule['ir']
+    ir = rule["ir"]
 
     if ir is None:
         return rule
 
     if isinstance(ir, str):
-        rule['ir'] = _resolve_str(ir)
+        rule["ir"] = _resolve_str(ir)
         return rule
 
     if isinstance(ir, list):
-        rule['ir'] = []
+        rule["ir"] = []
         for item in ir:
             result = _resolve_str(item)
             if isinstance(result, str):
-                rule['ir'].append(_resolve_str(item))
+                rule["ir"].append(_resolve_str(item))
             else:
-                rule['ir'] += _resolve_str(item)
+                rule["ir"] += _resolve_str(item)
 
         return rule
 
     if isinstance(ir, int):
         if ir not in range(num_ir):
-            raise SonusAIError(f'Invalid ir of {ir}')
+            raise ValueError(f"Invalid ir of {ir}")
         return rule
 
-    raise SonusAIError(f'Invalid ir of {ir}')
+    raise ValueError(f"Invalid ir of {ir}")
 
 
 def apply_augmentation(audio: AudioT, augmentation: Augmentation, frame_length: int = 1) -> AudioT:
@@ -325,10 +318,11 @@ def apply_impulse_response(audio: AudioT, ir: ImpulseResponseData) -> AudioT:
 
 def augmentation_from_rule(rule: AugmentationRule, num_ir: int) -> Augmentation:
     from sonusai.utils import dataclass_from_dict
+
     from .datatypes import Augmentation
 
     processed_rule = rule.to_dict()
-    del processed_rule['mixup']
+    del processed_rule["mixup"]
     processed_rule = _generate_none_rule(processed_rule)
     if _rule_has_rand(processed_rule):
         processed_rule = _generate_random_rule(processed_rule, num_ir)

sonusai/mixture/class_count.py

@@ -3,22 +3,13 @@ from sonusai.mixture.datatypes import GeneralizedIDs
 from sonusai.mixture.mixdb import MixtureDatabase
 
 
-def get_class_count_from_mixids(mixdb: MixtureDatabase, mixids: GeneralizedIDs = None) -> ClassCount:
-    """ Sums the class counts for given mixids
-    """
-    from sonusai import SonusAIError
-
+def get_class_count_from_mixids(mixdb: MixtureDatabase, mixids: GeneralizedIDs | None = None) -> ClassCount:
+    """Sums the class counts for given mixids"""
     total_class_count = [0] * mixdb.num_classes
-    mixids = mixdb.mixids_to_list(mixids)
-    for mixid in mixids:
-        class_count = mixdb.mixture_class_count(mixid)
+    m_ids = mixdb.mixids_to_list(mixids)
+    for m_id in m_ids:
+        class_count = mixdb.mixture_class_count(m_id)
         for cl in range(mixdb.num_classes):
             total_class_count[cl] += class_count[cl]
 
-    if mixdb.truth_mutex:
-        # Compute the class count for the 'other' class
-        if total_class_count[-1] != 0:
-            raise SonusAIError('Error: truth_mutex was set, but the class count for the last count was non-zero.')
-        total_class_count[-1] = sum([mixdb.mixture(mixid).samples for mixid in mixids]) - sum(total_class_count)
-
     return total_class_count