bader-comsar 0.0.3__py3-none-any.whl

bader_comsar-0.0.3.dist-info/METADATA

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: bader-comsar
+Version: 0.0.3
+Summary: Computational Music and Sound Archiving
+Author: Michael Blaß, Rolf Bader
+Author-email: R_Bader@t-online.de
+License: BSD-3-Clause
+Project-URL: Source code, https://codeberg.org/rbader/comsar
+Project-URL: Bug tracker, https://codeberg.org/rbader/comsar/issues
+Project-URL: Documentation, https://codeberg.org/rbader/comsar
+Keywords: comsar,music,analysis,ethnomusicology
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Database
+Classifier: Topic :: Multimedia :: Sound/Audio :: Analysis
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: BSD License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bader-apollon>=0.1.5
+Requires-Dist: numpy>=1.23
+Requires-Dist: pandas
+Requires-Dist: scipy>=1.6
+Requires-Dist: matplotlib>=3
+Requires-Dist: scikit-learn>=1.0
+Dynamic: license-file
+
+# comsar — Computational Music and Sound Archiving
+
+**comsar** is a Python toolkit for content-based analysis of music and sound,
+with a focus on ethnomusicology (timbre, pitch/melody, tonal systems, rhythm and
+corpus visualisation with Self-Organizing Maps).
+
+It is the top layer of a three-package stack maintained by **Rolf Bader**:
+
+| Package | Role | Repository |
+|---|---|---|
+| [**apollon**](https://codeberg.org/rbader/apollon) | Backbone: audio I/O, feature extraction, HMM, SOM (C-accelerated) | `codeberg.org/rbader/apollon` |
+| [**chainsaddiction**](https://codeberg.org/rbader/chainsaddiction) | Poisson Hidden-Markov-Models in C (used for rhythm / time-series) | `codeberg.org/rbader/chainsaddiction` |
+| [**comsar**](https://codeberg.org/rbader/comsar) | High-level music analysis (`PitchTrack`, `TimbreTrack`, tonal systems, SOM) | `codeberg.org/rbader/comsar` |
+
+This fork combines the modern comsar code base with the pitch-tracking and
+tonal-system analysis (`PitchTrack`) merged back from the older comsar version.
+
+> **Distribution names.** The original PyPI names `apollon`, `comsar` and
+> `chainsaddiction` belong to the upstream authors. This fork is published as
+> `bader-apollon`, `bader-comsar` and `bader-chainsaddiction`. The **import**
+> names are unchanged: you still write `import comsar`, `import apollon`, etc.
+
+## Installation (no compiler needed)
+
+Pre-compiled wheels are provided for **Windows, macOS and Linux**
+(CPython 3.9–3.13). Installing comsar pulls apollon and chainsaddiction
+automatically:
+
+```
+pip install bader-comsar
+```
+
+To also run the example notebooks:
+
+```
+pip install bader-comsar jupyterlab
+```
+
+For source builds, step-by-step Windows/macOS/Linux instructions, and
+troubleshooting, see the **[full manual](docs/MANUAL.md)**.
+
+## Quick start
+
+```python
+from comsar import PitchTrack, TimbreTrack
+
+# Pitch / melody / tonal-system analysis
+pt = PitchTrack()
+result = pt.extract("my_audio.wav")
+print(result.features)          # pandas DataFrame
+
+# Timbre feature track
+tt = TimbreTrack()
+timbre = tt.extract("my_audio.wav")
+```
+
+Runnable notebooks are in [`examples/`](examples/).
+
+## Documentation
+
+* **[docs/MANUAL.md](docs/MANUAL.md)** — full manual: architecture,
+  installation, module reference, example walkthrough, troubleshooting,
+  and how releases/wheels are built.
+* **[examples/](examples/)** — Jupyter notebooks for the main workflows.
+
+## License
+
+BSD-3-Clause. Original work © Michael Blaß; this fork maintained by Rolf Bader.

bader_comsar-0.0.3.dist-info/RECORD

@@ -0,0 +1,22 @@
+bader_comsar-0.0.3.dist-info/licenses/LICENSE,sha256=F_xD1DpCQksZS0qDb-oEvQ3PKZCWrQPEnT0DkeUfMNU,1521
+comsar/__init__.py,sha256=8xjGvisOkTCfXIWsYcfP8YnmjnZAQMRlsjaoI8Pt8Kg,890
+comsar/scales.csv,sha256=dCkIYiiIZupMLoYNVX9vdDLdZdBxQ8Vfz3fj2lMfSzg,61731
+comsar/_tracks/__init__.py,sha256=42XDpRV-CVC3aOZW5hSU5aY09ydu1SbBF_N7UUeuumw,812
+comsar/cli/__init__.py,sha256=xfOV4mR7CqjCJNvSvtwsv7WxEGoaS4GqSFBhaXlFdIE,229
+comsar/cli/apollon_hmm.py,sha256=OkOGLXq6Z-ABi5sD1XDwykI9C43f1doeqdwfcAJWc6M,2858
+comsar/cli/apollon_onsets.py,sha256=CrnkB0CTWnmIIogqUxXo2UcxOJpnxFH3I6T7AYZE8Mo,1729
+comsar/cli/apollon_position.py,sha256=_-lR8z5wy_G-w0g7M0C1IYTJs-ZXOQ0RoYcXczwUSPY,1978
+comsar/cli/comsar_features.py,sha256=tU6ayne4iQKdGrT4m5LsW24WXvr_XXo9medoyYKy9OQ,1344
+comsar/tracks/__init__.py,sha256=NH0burmLtvJw2HCGxuECwlJAzhIrd_jKADkgvmGOa3U,105
+comsar/tracks/_form.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+comsar/tracks/_pitch.py,sha256=tqwF5LWulc6gNRx-BbcPkqynHqtv4nPaOvo_92sgP3g,18986
+comsar/tracks/_rhythm.py,sha256=1jOpbcF8nNedZ5oJnftsLNVoMYRdokr9jvgEWaTYvPU,1642
+comsar/tracks/_timbre.py,sha256=X4IJrasl-xYXo1B3VcO3KBf5mTSr_6AVxhyfM0WBHG4,7647
+comsar/tracks/helpers.py,sha256=MJZO4pH1YFEpk4ZKJSva7ao5Vs6WJ4jlbR-i-dgm7gA,4035
+comsar/tracks/utilities.py,sha256=r_WsQ9z9IBCgB4PJ6hQfhwthqO4O8NPXTfsyXyC6bNc,4515
+comsar/tracks/schema/TonalSystem.schema.json,sha256=h48TUQW2T2lmbwcw9OJ4fUqnAyhE0Rt9xwOCedWZ87I,1383
+comsar/tracks/schema/ngram.schema.json,sha256=juigmccEP-LFRl6NQy-DFTOxwDL19c9nMjrOVuW3xA0,1266
+bader_comsar-0.0.3.dist-info/METADATA,sha256=7UqdDH6zX1i98dFMT3rGdD9D6316KqLv1c362yCYUes,3944
+bader_comsar-0.0.3.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+bader_comsar-0.0.3.dist-info/top_level.txt,sha256=S_a_RD-oQpzFnKe4Uvm_92PWZQTMysSfk4398zxL1UY,7
+bader_comsar-0.0.3.dist-info/RECORD,,

bader_comsar-0.0.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bader_comsar-0.0.3.dist-info/licenses/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2020, Michael Blaß
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

bader_comsar-0.0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+comsar

comsar/__init__.py

@@ -0,0 +1,22 @@
+"""comsar -- Computational Music and Sound Archiving.
+
+Top-level convenience re-exports so that user code / notebooks can simply do::
+
+    from comsar import PitchTrack, TimbreTrack
+"""
+try:
+    from importlib.metadata import version as _version, PackageNotFoundError
+except ImportError:                       # Python < 3.8 fallback
+    from importlib_metadata import version as _version, PackageNotFoundError
+
+try:
+    # Distribution name on PyPI is "bader-comsar"; the import name stays "comsar".
+    __version__ = _version("bader-comsar")
+except PackageNotFoundError:              # e.g. running from a source checkout
+    __version__ = "0.0.3"
+
+# __version__ is set *before* importing the tracks subpackage, because
+# comsar.tracks._pitch references ``comsar.__version__`` at runtime.
+from .tracks import TimbreTrack, PitchTrack
+
+__all__ = ["TimbreTrack", "PitchTrack", "__version__"]

comsar/_tracks/__init__.py

@@ -0,0 +1,21 @@
+"""Backward-compatibility shim.
+
+Older comsar versions kept the implementation under ``comsar._tracks``.
+The current layout lives under ``comsar.tracks``. This package re-exports the
+old import paths so that legacy notebooks keep working, e.g.::
+
+    from comsar._tracks.utilities import ngramParams, TonalSystemParams
+"""
+import sys as _sys
+
+from comsar.tracks import utilities, helpers
+from comsar.tracks import _pitch as pitch
+from comsar.tracks import _timbre as timbre
+
+# Register the modules under their legacy dotted paths so that
+# ``from comsar._tracks.<name> import ...`` resolves without separate files.
+for _name, _mod in (("utilities", utilities), ("helpers", helpers),
+                    ("pitch", pitch), ("timbre", timbre)):
+    _sys.modules[f"{__name__}.{_name}"] = _mod
+
+del _sys, _name, _mod

comsar/cli/__init__.py

@@ -0,0 +1,8 @@
+# Licensed under the terms of the BSD-3-Clause license.
+# Copyright (C) 2019 Michael Blaß
+# mblass@posteo.net
+
+from . import apollon_features
+from . import apollon_onsets
+from . import apollon_hmm
+from . import apollon_position

comsar/cli/apollon_hmm.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+
+# Licensed under the terms of the BSD-3-Clause license.
+# Copyright (C) 2019 Michael Blaß
+# mblass@posteo.net
+
+
+import argparse
+import json
+import pathlib
+import sys
+import typing
+
+import numpy as np
+
+from .. import io
+from .. hmm import PoissonHmm
+from .. types import Array as _Array
+from .. import tools
+
+
+def _load_track_file(track_file: str) -> dict:
+    track_file = pathlib.Path(track_file)
+    with track_file.open('r') as fobj:
+        track_data = json.load(fobj, object_hook=io.decode_array)
+    return track_data
+
+
+def _parse_feature_file(track_file: str, feature_path: str) -> _Array:
+    feature = _load_track_file(track_file)
+    for key in feature_path.split('.'):
+        try:
+            feature = feature[key]
+        except KeyError:
+            print('Error. Node "{}" not in "{}".'.format(key, track_file))
+            exit(10)
+    return _scaling(feature, key)
+
+
+
+def _scaling(data: _Array, feature: str) -> _Array:
+    features1000 = ['skewness', 'kurtosis', 'loudness',
+                    'roughness', 'sharpness']
+    if feature in features1000:
+        out = tools.scale(data, 1, 1000)
+    else:
+        out = data
+    return out.round().astype(int)
+
+
+def _train_n_hmm(data: _Array, m_states: int, n_trails: int):
+    """Trains ``n_trails`` HMMs each initialized with a random tpm.
+
+    Args:
+        data:      Possibly unporcessed input data set.
+        m_states:  Number of states.
+        n_trails:  Number of trails.
+
+    Returns:
+        Best model regarding to log-likelihood.
+    """
+    trails = []
+    for i in range(n_trails):
+        hmm = PoissonHmm(data, m_states, init_lambda='hist', init_gamma='softmax')
+        hmm.fit(data)
+        if hmm.success and not np.isnan(hmm.quality.nll):
+            trails.append(hmm)
+
+    for i in range(n_trails):
+        hmm = PoissonHmm(data, m_states, init_lambda='linear', init_gamma='softmax')
+        hmm.fit(data)
+        if hmm.success and not np.isnan(hmm.quality.nll):
+            trails.append(hmm)
+
+    for i in range(n_trails):
+        hmm = PoissonHmm(data, m_states, init_lambda='quantile', init_gamma='softmax')
+        hmm.fit(data)
+        if hmm.success and not np.isnan(hmm.quality.nll):
+            trails.append(hmm)
+
+    if len(trails) == 0:
+        return None
+    return min(trails, key=lambda hmm: abs(hmm.quality.nll))
+
+
+def main(argv=None) -> int:
+    if argv is None:
+        argv = sys.argv
+
+    for trf in argv.track_files:
+        feature = _parse_feature_file(trf, argv.feature_path)
+        hmm = _train_n_hmm(feature, argv.mstates, 5)
+        if hmm is None:
+            print('Error. Could not train HMM on {}'.format(trf))
+            continue
+        out_path = io.generate_outpath(trf, argv.outpath, 'hmm')
+        io.dump_json(hmm.to_dict(), out_path)
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

comsar/cli/apollon_onsets.py

@@ -0,0 +1,67 @@
+# Licensed under the terms of the BSD-3-Clause license.
+# Copyright (C) 2019 Michael Blaß
+# mblass@posteo.net
+
+import argparse
+import multiprocessing as mp
+import sys
+
+from .. import onsets
+
+
+def _parse_cml(argv):
+    parser = argparse.ArgumentParser(description='Apollon onset detection engine')
+
+    parser.add_argument('--amplitude', action='store_true',
+                        help='Detect onsets based on local extrema in the time domain signal.')
+
+    parser.add_argument('--entropy', action='store_true',
+                        help='Detect onsets based on time domain entropy maxima.')
+
+    parser.add_argument('--flux', action='store_true',
+                        help='Detect onsets based on spectral flux.')
+
+    parser.add_argument('-o', '--outpath', action='store',
+                        help='Output file path.')
+
+    parser.add_argument('filepath', type=str, nargs=1)
+    return parser.parse_args(argv)
+
+
+def _amp(a):
+    print('Amplitude')
+    return a
+
+def _entropy(a):
+    print('Entropy')
+    return a
+
+def _flux(a):
+    print('Flux')
+    return a
+
+
+def main(argv=None):
+    if argv is None:
+        argv = sys.argv
+
+    args = _parse_cml(argv)
+
+
+    args = _parse_cml(argv)
+    detectors = {'amplitude': _amp,
+                 'entropy': _entropy,
+                 'flux': _flux}
+
+    methods = [func for name, func in detectors.items() if getattr(args, name)]
+    if len(methods) == 0:
+        print('At least one detection method required. Aborting.')
+        return 1
+
+    with mp.Pool(processes=3) as pool:
+        results = [pool.apply_async(meth, (i,)) for i, meth in enumerate(methods)]
+        out = [res.get() for res in results]
+    return out
+
+if __name__ == '__main__':
+    sys.exit(main())

comsar/cli/apollon_position.py

@@ -0,0 +1,59 @@
+# Licensed under the terms of the BSD-3-Clause license.
+# Copyright (C) 2019 Michael Blaß
+# mblass@posteo.net
+
+import argparse
+import pathlib
+import pickle
+import sys
+
+import numpy as np
+import pandas as pd
+
+from .. import io
+from .. som.utilities import get_winner
+
+
+def main(argv=None) -> int:
+    if argv is None:
+        argv = sys.argv
+
+    weights = io.load(argv.som_file)
+
+    if argv.rt:
+        for hmm in argv.objective_files:
+            hmm = io.load_json(hmm)
+            gamma_ = hmm.params.gamma_.astype('float64').flatten()
+            flat_idx = get_winner(weights, gamma_)
+            print(np.unravel_index(flat_idx, (30, 30)))
+
+    elif argv.tt:
+        fs_path = pathlib.Path(argv.som_file).parent.joinpath('fstats.pkl')
+        with fs_path.open('rb') as fobj:
+            fstats = pickle.load(fobj)
+
+        feature_mean, feature_std = fstats
+        for file_name in argv.objective_files:
+            data = io.load_json(file_name)
+            feat = data.timbre.features
+            timbre_vector = np.array([
+                feat.spectral.centroid.mean(), feat.spectral.centroid.std(),
+                feat.spectral.spread.mean(), feat.spectral.spread.std(),
+                feat.spectral.skewness.mean(), feat.spectral.skewness.std(),
+                feat.spectral.kurtosis.mean(), feat.spectral.kurtosis.std(),
+                feat.temporal.flux.mean(), feat.temporal.flux.std(),
+                feat.perceptual.roughness.mean(), feat.perceptual.roughness.std(),
+                feat.perceptual.sharpness.mean(), feat.perceptual.sharpness.std(),
+                feat.perceptual.loudness.mean(), feat.perceptual.loudness.std()])
+
+            timbre_vector = (timbre_vector - feature_mean) / feature_std
+            flat_idx = get_winner(weights, timbre_vector)
+            print(np.unravel_index(flat_idx, (40, 40)))
+    else:
+        print('Error. Need track info.')
+        return -10
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

comsar/cli/comsar_features.py

@@ -0,0 +1,51 @@
+# Licensed under the terms of the BSD-3-Clause license.
+# Copyright (C) 2019 Michael Blaß
+# mblass@posteo.net
+
+import argparse
+import itertools
+import json
+import sys
+import typing
+import logging
+import time
+
+from apollon import io
+
+
+def main(argv: dict = None) -> int:
+    logging.basicConfig(filename='tt.log', filemode='w', level=logging.DEBUG)
+    if argv is None:
+        argv = sys.argv
+
+    timer_total = time.time()
+    for path in argv.files:
+        logging.info('Loading {}'.format(path))
+        print('Processing: {}'.format(path), end=' ... ', flush=True)
+        timer_start = time.time()
+
+        if _check_audio(path) != 0:
+            return 10
+
+        track_data = {}
+        if argv.rhythm:
+            track_data['rhythm'] = analyses.rhythm_track(snd)
+
+        if argv.timbre:
+            track_data['timbre'] = analyses.timbre_track(snd)
+
+        if argv.pitch:
+            track_data['pitch'] = analyses.pitch_track(snd)
+
+        out_path = io.generate_outpath(path, argv.outpath, 'feat')
+        io.dump_json(track_data, out_path)
+        timer_stop = time.time()
+        print('Done in {:.5} s.'.format(timer_stop-timer_start), flush=True)
+
+    logging.info('--- JOB DONE ---')
+    print('Job done. Total time: {:.5} s.'.format(time.time()-timer_total))
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())