Spaces:
Build error
Build error
| """ | |
| Dataset organization service — analyzes an audio file and derives real | |
| acoustic metadata (duration, tempo, key, loudness, energy tier) used to | |
| auto-tag and categorize entries in a dataset, per the "Veri Seti | |
| Organizasyonu" tool advertised on the data-manipulation page. | |
| Deliberately independent from feature_extractor.py (AURIS's 49-feature | |
| AI-detection pipeline) — that module is tuned for AI-vs-human classification | |
| and pulls in a much heavier feature set than dataset tagging needs. Coupling | |
| this to it would make a simple tagging tool fragile to AI-detection changes. | |
| """ | |
| import io | |
| import logging | |
| import librosa | |
| import numpy as np | |
| logger = logging.getLogger(__name__) | |
| PITCH_CLASSES = [ | |
| "C", "C#", "D", "D#", "E", "F", | |
| "F#", "G", "G#", "A", "A#", "B", | |
| ] | |
| # Krumhansl-Schmuckler key profiles — standard weights for major/minor | |
| # key detection via correlation against the chroma vector. | |
| _MAJOR_PROFILE = np.array( | |
| [6.35, 2.23, 3.48, 2.33, 4.38, 4.09, 2.52, 5.19, 2.39, 3.66, 2.29, 2.88] | |
| ) | |
| _MINOR_PROFILE = np.array( | |
| [6.33, 2.68, 3.52, 5.38, 2.60, 3.53, 2.54, 4.75, 3.98, 2.69, 3.34, 3.17] | |
| ) | |
| def detect_key(chroma_mean: np.ndarray) -> str: | |
| """Correlate the mean chroma vector against all 24 rotated key profiles.""" | |
| best_score = -np.inf | |
| best_key = "C major" | |
| for shift in range(12): | |
| major_rot = np.roll(_MAJOR_PROFILE, shift) | |
| minor_rot = np.roll(_MINOR_PROFILE, shift) | |
| major_score = float(np.corrcoef(chroma_mean, major_rot)[0, 1]) | |
| minor_score = float(np.corrcoef(chroma_mean, minor_rot)[0, 1]) | |
| if major_score > best_score: | |
| best_score = major_score | |
| best_key = f"{PITCH_CLASSES[shift]} major" | |
| if minor_score > best_score: | |
| best_score = minor_score | |
| best_key = f"{PITCH_CLASSES[shift]} minor" | |
| return best_key | |
| def _tempo_tag(bpm: float) -> str: | |
| # librosa.beat.beat_track returns ~0 when it can't lock onto a beat at | |
| # all (e.g. a sustained tone or ambient texture with no rhythm) — that's | |
| # "no beat detected", not literally "slow", so tag it separately rather | |
| # than lump it into the slow bucket. | |
| if bpm < 1: | |
| return "beatless" | |
| if bpm < 76: | |
| return "slow" | |
| if bpm < 120: | |
| return "moderate" | |
| if bpm < 150: | |
| return "upbeat" | |
| return "fast" | |
| def _energy_tag(rms_mean: float) -> str: | |
| # RMS on a float32 waveform normalized to [-1, 1]; these thresholds are | |
| # calibrated against typical mixed/mastered music, not raw voice memos. | |
| if rms_mean < 0.03: | |
| return "ambient" | |
| if rms_mean < 0.08: | |
| return "calm" | |
| if rms_mean < 0.15: | |
| return "energetic" | |
| return "intense" | |
| def _loudness_lufs_approx(y: np.ndarray) -> float: | |
| """ | |
| Rough integrated-loudness estimate in LUFS-like dB, using RMS as a | |
| stand-in for full ITU-R BS.1770 K-weighting (that needs a dedicated | |
| filter chain this tool doesn't need for a dataset-tagging heuristic). | |
| """ | |
| rms = float(np.sqrt(np.mean(np.square(y)))) if len(y) else 0.0 | |
| if rms <= 0: | |
| return -70.0 | |
| return round(float(20 * np.log10(rms)), 1) | |
| class DatasetEntryMetadata: | |
| """Plain result container — kept dependency-free so routes can shape | |
| the JSON response without importing pydantic into this module.""" | |
| def __init__( | |
| self, | |
| duration_sec: float, | |
| tempo_bpm: float, | |
| key: str, | |
| loudness_db: float, | |
| tags: list[str], | |
| ) -> None: | |
| self.duration_sec = duration_sec | |
| self.tempo_bpm = tempo_bpm | |
| self.key = key | |
| self.loudness_db = loudness_db | |
| self.tags = tags | |
| def to_dict(self) -> dict: | |
| return { | |
| "durationSec": self.duration_sec, | |
| "tempoBpm": self.tempo_bpm, | |
| "key": self.key, | |
| "loudnessDb": self.loudness_db, | |
| "tags": self.tags, | |
| } | |
| def analyze_for_organization(file_bytes: bytes) -> DatasetEntryMetadata: | |
| """ | |
| Extract real acoustic metadata from an audio file for dataset tagging: | |
| duration, tempo (BPM), musical key, approximate loudness, and a set of | |
| auto-generated descriptive tags (tempo feel, energy level, duration | |
| bucket) suitable for filtering/categorizing a growing dataset. | |
| """ | |
| try: | |
| y, sr = librosa.load(io.BytesIO(file_bytes), sr=22050, mono=True) | |
| except Exception as e: | |
| logger.error(f"Failed to load audio for organization: {e}", exc_info=True) | |
| raise ValueError(f"Could not read audio file: {e}") | |
| if y.size == 0 or float(np.max(np.abs(y))) < 1e-6: | |
| raise ValueError("Audio file is empty or silent") | |
| duration_sec = round(float(librosa.get_duration(y=y, sr=sr)), 2) | |
| tempo, _ = librosa.beat.beat_track(y=y, sr=sr) | |
| tempo_bpm = round(float(np.atleast_1d(tempo)[0]), 1) | |
| chroma = librosa.feature.chroma_cqt(y=y, sr=sr) | |
| key = detect_key(np.mean(chroma, axis=1)) | |
| loudness_db = _loudness_lufs_approx(y) | |
| rms_mean = float(np.mean(librosa.feature.rms(y=y)[0])) | |
| tags = [_tempo_tag(tempo_bpm), _energy_tag(rms_mean)] | |
| if duration_sec < 30: | |
| tags.append("short-clip") | |
| elif duration_sec > 240: | |
| tags.append("long-form") | |
| return DatasetEntryMetadata( | |
| duration_sec=duration_sec, | |
| tempo_bpm=tempo_bpm, | |
| key=key, | |
| loudness_db=loudness_db, | |
| tags=tags, | |
| ) | |