added patel features (nPVI and MIV) as custom_features

.gitignore

@@ -26,4 +26,5 @@ docs/source/__tutorial_cache
 docs/source/musif.log.2023-01-31
 docs/source/.ipynb_checkpoints
 dist
+.DS_Store
 .pdm-python

musif/extract/extract.py

@@ -762,3 +762,7 @@ def _update_score_module_features(
             raise FeatureError(
                 f"In {score_name} while computing {module.__name__}"
             ) from e
+        # except Exception:
+        #     score_name = score_data["file"]
+        #     print(f"{score_name} gives trouble, going to the next one")
+        #     pass

musif/extract/features/ambitus/handler.py

@@ -49,7 +49,7 @@ def update_score_objects(
     parts_data = _filter_parts_data(parts_data, cfg.parts_filter)
     if len(parts_data) == 0:
         return
-
+    
     for part_data, part_features in zip(parts_data, parts_features):
         part = part_data[DATA_PART_ABBREVIATION]
         for feature_name in SCORE_FEATURES:

musif/extract/features/melody/handler.py

@@ -22,6 +22,8 @@
     get_sound_prefix,
 )
 
+import pandas as pd
+
 from .constants import *
 
 
@@ -37,6 +39,7 @@ def update_part_objects(
     part_features.update(get_interval_stats_features(intervals))
 
 
+
 def update_score_objects(
     score_data: dict,
     parts_data: List[dict],

musif/extract/features/patel/__init__.py

@@ -0,0 +1 @@
+from .constants import *

musif/extract/features/patel/constants.py

@@ -0,0 +1,3 @@
+MIV = "MIV"
+NPVI="nPVI"
+

musif/extract/features/patel/handler.py

@@ -0,0 +1,58 @@
+from music21.analysis.patel import nPVI, melodicIntervalVariability
+
+import musif.extract.constants as C
+from musif.extract.features.prefix import get_part_feature
+from musif.config import ExtractConfiguration
+from typing import List
+
+
+from musif.extract.features.patel.constants import *
+
+
+def update_part_objects(
+    score_data: dict, part_data: dict, cfg: ExtractConfiguration, part_features: dict
+):
+    # "update_part_objects from module inside a package given its parent package (score)!"
+
+    for measure in part_data["measures"]:
+        try:
+            _nPVI = nPVI(measure)
+            _melodicIntervalVariability = melodicIntervalVariability(measure)
+        except Exception:
+            _nPVI = 0.0
+            _melodicIntervalVariability = 0.0
+
+        # print('_nPVI: ', _nPVI)
+        part_features['NPVI'] =  _nPVI
+
+        # print('_melodicIntervalVariability: ', _melodicIntervalVariability)
+        part_features['MIV'] =  _melodicIntervalVariability
+
+
+def update_score_objects(
+    score_data: dict,
+    parts_data: List[dict],
+    cfg: ExtractConfiguration,
+    parts_features: List[dict],
+    score_features: dict,
+):
+    # We need to add the data to score_features, 
+    # the dictionary where all final info is stored. 
+    # Otherwise it will not be reflected in the final dataframe.
+    # "Updating stuffs from module inside a package  given its parent package (part)!"
+
+    features = {}
+    for part_data, part_features in zip(parts_data, parts_features):
+        part_abbreviation = part_data[C.DATA_PART_ABBREVIATION]
+        # get NPVI
+        feature_name = get_part_feature(part_abbreviation, NPVI)
+        features[feature_name] = part_features['NPVI']
+        # get MIV
+        feature_name = get_part_feature(part_abbreviation, MIV)
+        features[feature_name] = part_features['MIV']
+
+    score_features.update(features)
+
+
+
+

musif/extract/features/rhythm/handler.py

@@ -87,6 +87,7 @@ def update_part_objects(
     notes_duration = [
         i for i in notes_duration if i != 0.0
     ]  # remove notes with duration equal to 0
+
 
     part_features.update(
         {
@@ -164,3 +165,77 @@ def update_score_objects(
     score_features.update(features)
 
 
+def get_motion_features(part_data) -> dict:
+    notes_midi = []
+    notes_duration = []
+    for note in part_data["notes_and_rests"]:
+        if hasattr(note, "pitch"):
+            notes_midi.append(note.pitch.midi)
+            notes_duration.append(note.duration.quarterLength)
+
+    notes_midi = np.asarray(notes_midi)
+    notes_duration = np.asarray(notes_duration)
+
+    if len(notes_midi) == 0:
+        return {
+            SPEED_AVG_ABS: 0,
+            ACCELERATION_AVG_ABS: 0,
+            ASCENDENT_AVERAGE: 0,
+            DESCENDENT_AVERAGE: 0,
+            ASCENDENT_PROPORTION: 0,
+            DESCENDENT_PROPORTION: 0
+        }
+
+    step = 0.125
+    midis_raw = np.repeat(notes_midi, [i / step for i in notes_duration], axis=0)
+    spe_raw = np.diff(midis_raw) / step
+    acc_raw = np.diff(spe_raw) / step
+
+    # Absolute means of speed and acceleration
+    spe_avg_abs = np.mean(abs(spe_raw))
+    acc_avg_abs = np.mean(abs(acc_raw))
+
+    # Rolling mean to smooth the midis by +-1 compasses -- not required for
+    # statistics based on means but important for detecting increasing sequences
+    # with a tolerance.
+    measure = 4
+    midis_smo_series = pd.Series(midis_raw)
+    midis_smo = [
+        np.mean(i.to_list())
+        for i in midis_smo_series.rolling(2 * measure + 1, center=True)
+    ]
+
+    # midis_smo = np.rollmean(midis_raw, k = 2 * compass + 1, align = "center")
+
+    # spe_smo = np.diff(midis_smo) / step
+    # acc_smo = np.diff(spe_smo) / step
+
+    # Prolonged ascent/descent chunks in smoothed midis of the aria (allows for
+    # small violations in the form of decrements/increments that do not
+    # decrease/increase the rolling mean).
+
+    dife = np.diff(midis_smo)
+
+    asc = [(k, sum(1 for i in g)) for k, g in groupby(dife > 0)]
+    dsc = [(k, sum(1 for i in g)) for k, g in groupby(dife < 0)]
+
+    asc = [i for b, i in asc if b]
+    dsc = [i for b, i in dsc if b]
+
+    # Average length of ascent/descent chunks of the aria
+    asc_avg = mean(asc) if asc else np.nan
+    dsc_avg = mean(dsc) if dsc else np.nan
+
+    # Proportion of ascent/descent chunks over the total of the aria
+    asc_prp = sum(asc) / (len(dife) - 1) if asc else np.nan
+    dsc_prp = sum(dsc) / (len(dife) - 1) if dsc else np.nan
+
+    return {
+        SPEED_AVG_ABS: spe_avg_abs,
+        ACCELERATION_AVG_ABS: acc_avg_abs,
+        ASCENDENT_AVERAGE: asc_avg,
+        DESCENDENT_AVERAGE: dsc_avg,
+        ASCENDENT_PROPORTION: asc_prp,
+        DESCENDENT_PROPORTION: dsc_prp
+    }
+

musif/extract/features/scale_relative/utils.py

@@ -75,9 +75,12 @@ def get_emphasised_scale_degrees_relative(
     notes_list: list, score_data: dict
 ) -> List[list]:
     harmonic_analysis, tonality = extract_harmony(score_data)
-    if harmonic_analysis.size == 0:
-        return None
-
+    try:
+        if harmonic_analysis.size == 0:
+            return None
+    except:  # noqa: E722
+        print('harmonic_analysis has NoneType')
+        return None 
     measures = [
         m for p in score_data[C.DATA_SCORE].parts for m in
         p.getElementsByClass(Measure)

musif/musicxml/key.py

@@ -50,11 +50,13 @@ def get_key_and_mode(score: Score) -> Tuple[Key, str, str]:
         score : Score
       Music21 score to take the info from
     """
-
-    score_key = score.analyze("key")
-    mode, tonality = get_name_from_key(score_key)
-    return score_key, tonality, mode
-
+    try:
+        score_key = score.analyze("key")
+        mode, tonality = get_name_from_key(score_key)
+        return score_key, tonality, mode
+    except Exception as e:
+        print(f'{e}')
+        return 'NA', 'NA', 'NA'
 
 def get_name_from_key(score_key: Key) -> Tuple[str, str]:
     """