BatchalignHK 0.7.22.post14__tar.gz → 0.7.22.post16__tar.gz

{batchalignhk-0.7.22.post14 → batchalignhk-0.7.22.post16}/BatchalignHK.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: BatchalignHK
-Version: 0.7.22.post14
+Version: 0.7.22.post16
 Summary: Python Speech Language Sample Analysis
 Author: Brian MacWhinney, Houjun Liu
 Author-email: macw@cmu.edu, houjun@cmu.edu
@@ -48,9 +48,10 @@ Requires-Dist: cos-python-sdk-v5
 Requires-Dist: openai-whisper
 Requires-Dist: llvmlite>=0.44.0
 Requires-Dist: praat-parselmouth==0.4.6
-Requires-Dist: opensmile>=2.3.0
+Requires-Dist: opensmile>=2.5.0
 Requires-Dist: pyannote.audio
 Requires-Dist: onnxruntime
+Requires-Dist: certifi>=2025.10.5
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Provides-Extra: train

{batchalignhk-0.7.22.post14 → batchalignhk-0.7.22.post16}/BatchalignHK.egg-info/requires.txt

@@ -38,9 +38,10 @@ cos-python-sdk-v5
 openai-whisper
 llvmlite>=0.44.0
 praat-parselmouth==0.4.6
-opensmile>=2.3.0
+opensmile>=2.5.0
 pyannote.audio
 onnxruntime
+certifi>=2025.10.5
 
 [dev]
 pytest

{batchalignhk-0.7.22.post14 → batchalignhk-0.7.22.post16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: BatchalignHK
-Version: 0.7.22.post14
+Version: 0.7.22.post16
 Summary: Python Speech Language Sample Analysis
 Author: Brian MacWhinney, Houjun Liu
 Author-email: macw@cmu.edu, houjun@cmu.edu
@@ -48,9 +48,10 @@ Requires-Dist: cos-python-sdk-v5
 Requires-Dist: openai-whisper
 Requires-Dist: llvmlite>=0.44.0
 Requires-Dist: praat-parselmouth==0.4.6
-Requires-Dist: opensmile>=2.3.0
+Requires-Dist: opensmile>=2.5.0
 Requires-Dist: pyannote.audio
 Requires-Dist: onnxruntime
+Requires-Dist: certifi>=2025.10.5
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Provides-Extra: train

{batchalignhk-0.7.22.post14 → batchalignhk-0.7.22.post16}/batchalign/cli/cli.py

@@ -384,46 +384,67 @@ def benchmark(ctx, in_dir, out_dir, lang, num_speakers, whisper, tencent, **kwar
 #################### AVQI ################################
 
 @batchalign.command()
-@click.argument("cs_file", type=click.Path(exists=True, file_okay=True))
-@click.argument("sv_file", type=click.Path(exists=True, file_okay=True))
+@click.argument("input_dir", type=click.Path(exists=True, file_okay=False))
+@click.argument("output_dir", type=click.Path(exists=True, file_okay=False))
 @click.option("--lang",
               help="sample language in three-letter ISO 3166-1 alpha-3 code",
-              show_default=True,
-              default="eng",
-              type=str)
+              show_default=True, default="eng", type=str)
 @click.pass_context
-def avqi(ctx, cs_file, sv_file, lang, **kwargs):
-    """Calculate Acoustic Voice Quality Index (AVQI) from continuous speech and sustained vowel audio files."""
-    
-    # Import AVQI engine
+def avqi(ctx, input_dir, output_dir, lang, **kwargs):
+    """Calculate AVQI from paired .cs and .sv audio files in input directory."""
+
     from batchalign.pipelines.avqi import AVQIEngine
+    from pathlib import Path
+    import os
+    
+    # Get all .cs files
+    cs_files = []
+    for root, dirs, files in os.walk(input_dir):
+        for f in files:
+            if '.cs.' in f and any(f.endswith(ext) for ext in ['.mp3', '.wav', '.mp4']):
+                cs_files.append(os.path.join(root, f))
     
-    # Get output file path (same directory as cs_file, with .avqi.txt extension)
-    cs_path = Path(cs_file)
-    output_file = cs_path.with_suffix('.avqi.txt')
+    if not cs_files:
+        C.print("[bold red]No .cs audio files found in input directory[/bold red]")
+        return
     
-    # Create AVQI engine
-    avqi_engine = AVQIEngine()
+    C.print(f"\nMode: [blue]avqi[/blue]; got [bold cyan]{len(cs_files)}[/bold cyan] file pair{'s' if len(cs_files) > 1 else ''} to process from {input_dir}:\n")
     
-    try:
-        # Calculate AVQI
-        C.print(f"\n[blue]Calculating AVQI[/blue] for:")
-        C.print(f"  Continuous Speech: [cyan]{cs_file}[/cyan]")
-        C.print(f"  Sustained Vowel:   [cyan]{sv_file}[/cyan]")
-        C.print(f"  Language:          [cyan]{lang}[/cyan]")
-        C.print(f"  Output:            [cyan]{output_file}[/cyan]\n")
+    engine = AVQIEngine()
+    
+    for cs_file in cs_files:
+        cs_path = Path(cs_file)
+        C.print(f"Processing: [cyan]{cs_path.name}[/cyan]")
         
-        results = avqi_engine.analyze(cs_file, sv_file, str(output_file), lang)
+        doc = Document.new(media_path=cs_file, lang=lang)
+        results = engine.analyze(doc)
         
-        C.print(f"[bold green]✓ AVQI calculation completed![/bold green]")
-        C.print(f"[bold]AVQI Score: {results['avqi']:.3f}[/bold]")
-        C.print(f"Results saved to: [cyan]{output_file}[/cyan]\n")
+        # Create output path
+        rel_path = os.path.relpath(cs_file, input_dir)
+        output_path = Path(os.path.join(output_dir, rel_path))
+        os.makedirs(output_path.parent, exist_ok=True)
         
-    except Exception as e:
-        C.print(f"[bold red]ERROR[/bold red]: {str(e)}")
-        if ctx.obj["verbose"] > 0:
-            import traceback
-            C.print(traceback.format_exc())
+        if results.get('success', False):
+            output_txt = output_path.with_suffix('.avqi.txt')
+            with open(output_txt, 'w') as f:
+                f.write(f"AVQI: {results['avqi']:.3f}\n")
+                f.write(f"CPPS: {results['cpps']:.3f}\n")
+                f.write(f"HNR: {results['hnr']:.3f}\n")
+                f.write(f"Shimmer Local: {results['shimmer_local']:.3f}\n")
+                f.write(f"Shimmer Local dB: {results['shimmer_local_db']:.3f}\n")
+                f.write(f"LTAS Slope: {results['slope']:.3f}\n")
+                f.write(f"LTAS Tilt: {results['tilt']:.3f}\n")
+                f.write(f"CS File: {results['cs_file']}\n")
+                f.write(f"SV File: {results['sv_file']}\n")
+                f.write(f"Language: {lang}\n")
+            C.print(f"  [bold green]✓[/bold green] AVQI: {results['avqi']:.3f} → {output_txt.name}")
+        else:
+            error_file = output_path.with_suffix('.error.txt')
+            with open(error_file, 'w') as f:
+                f.write(f"AVQI calculation failed: {results.get('error', 'Unknown error')}\n")
+            C.print(f"  [bold red]✗[/bold red] Failed: {results.get('error', 'Unknown error')}")
+    
+    C.print(f"\nAll done. Results saved to {output_dir}!\n")
 
 #################### OPENSMILE ################################
 

{batchalignhk-0.7.22.post14 → batchalignhk-0.7.22.post16}/batchalign/pipelines/asr/utils.py

@@ -276,6 +276,9 @@ def process_generation(output, lang="eng", utterance_engine=None):
                 continue
             if word not in ENDING_PUNCT+MOR_PUNCT+["؟", "۔", "،", "؛"]:
                 word_replaced = word
+
+                for i in ENDING_PUNCT+MOR_PUNCT+["؟", "۔", "،", "؛"]:
+                    word_replaced = word_replaced.replace(i, "")
                     
                 if start == None or end == None:
                     words.append(Form(text=word_replaced, time=None))

{batchalignhk-0.7.22.post14 → batchalignhk-0.7.22.post16}/batchalign/pipelines/avqi/engine.py

@@ -13,7 +13,7 @@ from pathlib import Path
 import logging
 
 from batchalign.pipelines.base import BatchalignEngine
-from batchalign.document import Task
+from batchalign.document import Task, Document
 
 
 L = logging.getLogger('batchalign')
@@ -21,15 +21,15 @@ L = logging.getLogger('batchalign')
 
 class AVQIEngine(BatchalignEngine):
     """Engine for calculating Acoustic Voice Quality Index (AVQI)."""
-    
+
     def __init__(self):
         super().__init__()
         self._tasks = [Task.FEATURE_EXTRACT]
-    
+
     @property
     def tasks(self):
         return self._tasks
-    
+
     def extract_voiced_segments(self, sound):
         """Extract voiced segments from audio."""
         original = call(sound, "Copy", "original")
@@ -198,34 +198,57 @@ class AVQIEngine(BatchalignEngine):
             "slope": slope,
             "tilt": tilt,
         }
-    
-    def analyze(self, cs_file: str, sv_file: str, output_file: str, lang: str = 'eng', **kwargs) -> Dict:
+
+    def analyze(self, doc: Document, **kwargs) -> Dict:
         """
         Analyze audio files and calculate AVQI.
         
+        Expects the document to have a .cs audio file, and looks for matching .sv file.
+        
         Parameters
         ----------
-        cs_file : str
-            Path to continuous speech audio file
-        sv_file : str  
-            Path to sustained vowel audio file
-        output_file : str
-            Path to output file
-        lang : str
-            Language code (default: 'eng')
+        doc : Document
+            Document with .cs media attached
+        **kwargs : dict
+            Additional arguments
             
         Returns
         -------
         Dict
             Dictionary containing AVQI score and features
         """
-        L.info(f"Calculating AVQI for CS: {cs_file}, SV: {sv_file}")
         
+        if not doc.media or not doc.media.url:
+            return {
+                'error': 'Document has no media attached',
+                'success': False
+            }
+        
+        cs_file = doc.media.url
+        cs_path = Path(cs_file)
+        
+        # Check if this is a .cs file
+        if not '.cs.' in cs_path.name:
+            return {
+                'error': f'Expected .cs audio file, got {cs_path.name}',
+                'success': False
+            }
+        
+        # Find matching .sv file by replacing .cs. with .sv.
+        sv_name = cs_path.name.replace('.cs.', '.sv.')
+        sv_file = cs_path.parent / sv_name
+        
+        if not sv_file.exists():
+            return {
+                'error': f'Matching .sv file not found: {sv_name}',
+                'success': False
+            }
+        
+        L.info(f"Calculating AVQI for CS: {cs_path.name}, SV: {sv_name}")
+
         try:
-            # Calculate AVQI using the proper algorithm
-            avqi_score, features = self.calculate_avqi_features(cs_file, sv_file)
-            
-            # Prepare results
+            avqi_score, features = self.calculate_avqi_features(str(cs_file), str(sv_file))
+
             results = {
                 'avqi': avqi_score,
                 'cpps': features['cpps'],
@@ -233,26 +256,17 @@ class AVQIEngine(BatchalignEngine):
                 'shimmer_local': features['shimmer_local'],
                 'shimmer_local_db': features['shimmer_local_db'],
                 'slope': features['slope'],
-                'tilt': features['tilt']
+                'tilt': features['tilt'],
+                'cs_file': cs_path.name,
+                'sv_file': sv_name,
+                'success': True
             }
-            
-            # Write results to file
-            with open(output_file, 'w') as f:
-                f.write(f"AVQI: {avqi_score:.3f}\n")
-                f.write(f"CPPS: {features['cpps']:.3f}\n")
-                f.write(f"HNR: {features['hnr']:.3f}\n")
-                f.write(f"Shimmer Local: {features['shimmer_local']:.3f}\n")
-                f.write(f"Shimmer Local dB: {features['shimmer_local_db']:.3f}\n")
-                f.write(f"LTAS Slope: {features['slope']:.3f}\n")
-                f.write(f"LTAS Tilt: {features['tilt']:.3f}\n")
-                f.write(f"Language: {lang}\n")
-            
-            L.info(f"AVQI results written to: {output_file}")
+
+            L.info(f"AVQI Score: {avqi_score:.3f}")
             return results
-            
+
         except Exception as e:
             L.error(f"Error calculating AVQI: {e}")
-            # Return default values on error
             return {
                 'avqi': 0.0,
                 'cpps': 0.0,
@@ -260,5 +274,7 @@ class AVQIEngine(BatchalignEngine):
                 'shimmer_local': 0.0,
                 'shimmer_local_db': 0.0,
                 'slope': 0.0,
-                'tilt': 0.0
-            }
+                'tilt': 0.0,
+                'error': str(e),
+                'success': False
+            }

{batchalignhk-0.7.22.post14 → batchalignhk-0.7.22.post16}/batchalign/pipelines/opensmile/engine.py

@@ -1,14 +1,14 @@
 """
-OpenSMILE Engine for Batchalign2 - M1 Mac Compatible Version
+OpenSMILE Engine for Batchalign2
 Audio feature extraction using the openSMILE toolkit
 """
 
 import opensmile
+from opensmile import FeatureSet, FeatureLevel
 import pandas as pd
 from pathlib import Path
 import logging
-from typing import Dict, Optional
-import platform
+from typing import Dict
 
 from batchalign.pipelines.base import BatchalignEngine
 from batchalign.document import Task, TaskType, Document
@@ -18,6 +18,14 @@ L = logging.getLogger('batchalign')
 class OpenSMILEEngine(BatchalignEngine):
     """Engine for extracting openSMILE audio features."""
 
+    # Map string names to FeatureSet enums
+    FEATURE_SET_MAP = {
+        'eGeMAPSv02': FeatureSet.eGeMAPSv02,
+        'eGeMAPSv01b': FeatureSet.eGeMAPSv01b,
+        'GeMAPSv01b': FeatureSet.GeMAPSv01b,
+        'ComParE_2016': FeatureSet.ComParE_2016,
+    }
+
     def __init__(self, feature_set: str = 'eGeMAPSv02', 
                  feature_level: str = 'functionals'):
         super().__init__()
@@ -26,20 +34,15 @@ class OpenSMILEEngine(BatchalignEngine):
         self.feature_set = feature_set
         self.feature_level = feature_level
 
-        self.is_m1_mac = (platform.system() == 'Darwin' and 
-                         platform.processor() == 'arm')
-
         try:
-            if self.is_m1_mac:
-                L.info("M1 Mac detected - using default openSMILE configuration")
-                self.smile = opensmile.Smile()
-                self._requested_feature_set = feature_set
-            else:
-                self.smile = opensmile.Smile(
-                    feature_set=feature_set,
-                    feature_level=feature_level,
-                )
-            L.debug(f"OpenSMILE initialized (M1 compatibility mode: {self.is_m1_mac})")
+            feature_set_enum = self.FEATURE_SET_MAP.get(feature_set, FeatureSet.eGeMAPSv02)
+            feature_level_enum = FeatureLevel.Functionals if feature_level == 'functionals' else FeatureLevel.LowLevelDescriptors
+            
+            self.smile = opensmile.Smile(
+                feature_set=feature_set_enum,
+                feature_level=feature_level_enum,
+            )
+            L.debug(f"OpenSMILE initialized with {feature_set}")
         except Exception as e:
             L.error(f"Failed to initialize openSMILE: {e}")
             raise
@@ -48,13 +51,12 @@ class OpenSMILEEngine(BatchalignEngine):
     def tasks(self):
         return self._tasks
 
-    def analyze(self, doc: Document, feature_set: str = None, **kwargs) -> Dict:
+    def analyze(self, doc: Document, **kwargs) -> Dict:
         """
         Extract openSMILE features from Document.
         
         Args:
             doc: Document with media attached
-            feature_set: Feature set to use (ignored on M1 Mac)
             **kwargs: Additional arguments
             
         Returns:
@@ -69,32 +71,9 @@ class OpenSMILEEngine(BatchalignEngine):
 
         actual_audio_path = doc.media.url
 
-        if feature_set and feature_set != self.feature_set:
-            if self.is_m1_mac:
-                L.warning(f"Feature set switching not supported on M1 Mac - using default features instead of {feature_set}")
-            else:
-                L.info(f"Switching feature set from {self.feature_set} to {feature_set}")
-                try:
-                    self.feature_set = feature_set
-                    self.smile = opensmile.Smile(
-                        feature_set=feature_set,
-                        feature_level=self.feature_level,
-                    )
-                except Exception as e:
-                    L.error(f"Failed to switch to feature set {feature_set}: {e}")
-                    return {
-                        'feature_set': self.feature_set,
-                        'num_features': 0,
-                        'error': f"Feature set switch failed: {str(e)}",
-                        'success': False
-                    }
-
         try:
             L.info(f"Extracting features from: {Path(actual_audio_path).name}")
-            if self.is_m1_mac:
-                L.info("Using M1-compatible default feature set (eGeMAPSv02 equivalent)")
-            else:
-                L.info(f"Using {self.feature_set} feature set")
+            L.info(f"Using {self.feature_set} feature set")
 
             features_df = self.smile.process_file(actual_audio_path)
 
@@ -110,26 +89,17 @@ class OpenSMILEEngine(BatchalignEngine):
             if duration_segments > 0:
                 first_row_features = features_df.iloc[0].to_dict()
 
-            actual_feature_set = self.feature_set
-            if self.is_m1_mac:
-                actual_feature_set = "M1-default (eGeMAPSv02-like)"
-
             results = {
-                'feature_set': actual_feature_set,
+                'feature_set': self.feature_set,
                 'feature_level': self.feature_level,
                 'num_features': num_features,
                 'duration_segments': duration_segments,
                 'audio_file': str(actual_audio_path),
                 'features_sample': first_row_features,
                 'success': True,
-                'm1_compatibility_mode': self.is_m1_mac,
                 'features_df': results_df,
             }
 
-            if self.is_m1_mac and hasattr(self, '_requested_feature_set'):
-                results['requested_feature_set'] = self._requested_feature_set
-                results['warning'] = f"M1 Mac compatibility: used default features instead of {self._requested_feature_set}"
-
             L.info(f"Successfully extracted {num_features} features from {duration_segments} segments")
             return results
 
@@ -142,30 +112,15 @@ class OpenSMILEEngine(BatchalignEngine):
                 'duration_segments': 0,
                 'audio_file': str(actual_audio_path),
                 'error': str(e),
-                'success': False,
-                'm1_compatibility_mode': self.is_m1_mac
+                'success': False
             }
 
     def get_available_feature_sets(self) -> list:
-        """Return list of available feature sets (limited on M1 Mac)."""
-        if self.is_m1_mac:
-            return ['M1-default (eGeMAPSv02-like)']
-        return [
-            'eGeMAPSv02',
-            'eGeMAPSv01b', 
-            'GeMAPSv01b',
-            'ComParE_2016'
-        ]
+        """Return list of available feature sets."""
+        return list(self.FEATURE_SET_MAP.keys())
 
     def get_feature_set_info(self, feature_set: str) -> dict:
         """Get information about a specific feature set."""
-        if self.is_m1_mac:
-            return {
-                'description': 'M1 Mac compatible default feature set (similar to eGeMAPSv02)',
-                'num_features': 'Variable',
-                'recommended_for': 'General audio analysis on Apple Silicon'
-            }
-
         info = {
             'eGeMAPSv02': {
                 'description': 'Extended Geneva Minimalistic Acoustic Parameter Set v02',
@@ -188,4 +143,4 @@ class OpenSMILEEngine(BatchalignEngine):
                 'recommended_for': 'Comprehensive analysis (large feature space)'
             }
         }
-        return info.get(feature_set, {'description': 'Unknown feature set', 'num_features': 'Unknown'})
+        return info.get(feature_set, {'description': 'Unknown feature set', 'num_features': 'Unknown'})

batchalignhk-0.7.22.post16/batchalign/version

@@ -0,0 +1,3 @@
+0.7.22-post.16
+October 17th, 2025
+Bump certs

{batchalignhk-0.7.22.post14 → batchalignhk-0.7.22.post16}/setup.py

@@ -70,9 +70,10 @@ setup(
         "openai-whisper",
         "llvmlite>=0.44.0",
         "praat-parselmouth==0.4.6",  
-        "opensmile>=2.3.0",
+        "opensmile>=2.5.0",
         "pyannote.audio",
-        "onnxruntime"
+        "onnxruntime",
+        "certifi>=2025.10.5"
     ],
     extras_require={
         'dev': [

batchalignhk-0.7.22.post14/batchalign/version

@@ -1,3 +0,0 @@
-0.7.22-post.14
-October 15th, 2025
-Fix abbreviations