batchalign 0.7.20.post18__tar.gz → 0.7.21__tar.gz

{batchalign-0.7.20.post18/batchalign.egg-info → batchalign-0.7.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: batchalign
-Version: 0.7.20.post18
+Version: 0.7.21
 Summary: Python Speech Language Sample Analysis
 Author: Brian MacWhinney, Houjun Liu
 Author-email: macw@cmu.edu, houjun@cmu.edu
@@ -36,6 +36,7 @@ Requires-Dist: blobfile
 Requires-Dist: sentencepiece
 Requires-Dist: googletrans
 Requires-Dist: openai-whisper>=20240930
+Requires-Dist: praat-parselmouth==0.4.6
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Provides-Extra: train

{batchalign-0.7.20.post18 → batchalign-0.7.21}/batchalign/cli/cli.py

@@ -356,6 +356,51 @@ def benchmark(ctx, in_dir, out_dir, lang, num_speakers, whisper, **kwargs):
               in_dir, out_dir,
               loader, writer, C,
               asr="whisper" if whisper else "rev", **kwargs)
+    
+
+#################### 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.option("--lang",
+              help="sample language in three-letter ISO 3166-1 alpha-3 code",
+              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
+    from batchalign.pipelines.avqi import AVQIEngine
+    
+    # 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')
+    
+    # Create AVQI engine
+    avqi_engine = AVQIEngine()
+    
+    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")
+        
+        results = avqi_engine.analyze(cs_file, sv_file, str(output_file), lang)
+        
+        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")
+        
+    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())
 
 
 #################### SETUP ################################
@@ -379,3 +424,4 @@ def version(ctx, **kwargs):
            f"[italic]{RELEASE_NOTES.strip()}[/italic]"+"\n" +
            "\nDeveloped by Brian MacWhinney and Houjun Liu")
     C.print("\n\n"+ptr+"\n\n")
+

{batchalign-0.7.20.post18 → batchalign-0.7.21}/batchalign/pipelines/__init__.py

@@ -13,3 +13,4 @@ from .analysis import EvaluationEngine
 from .utterance import StanzaUtteranceEngine
 
 from .translate import SeamlessTranslationModel, GoogleTranslateEngine
+from .avqi import AVQIEngine

batchalign-0.7.21/batchalign/pipelines/avqi/__init__.py

@@ -0,0 +1,8 @@
+"""
+AVQI Pipeline Module
+Acoustic Voice Quality Index calculation
+"""
+
+from .engine import AVQIEngine
+
+__all__ = ['AVQIEngine']

batchalign-0.7.21/batchalign/pipelines/avqi/engine.py

@@ -0,0 +1,264 @@
+"""
+AVQI Engine for Batchalign2
+Acoustic Voice Quality Index calculation for voice quality assessment
+"""
+
+import parselmouth
+import numpy as np
+from parselmouth.praat import call
+import re
+from typing import Tuple, Dict, Optional
+import os
+from pathlib import Path
+import logging
+
+from batchalign.pipelines.base import BatchalignEngine
+from batchalign.document import Task
+
+
+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")
+        sampling_rate = call(original, "Get sampling frequency")
+        onlyVoice = call("Create Sound", "onlyVoice", 0, 0.001, sampling_rate, "0")
+        textgrid = call(
+            original,
+            "To TextGrid (silences)",
+            50,
+            0.003,
+            -25,
+            0.1,
+            0.1,
+            "silence",
+            "sounding",
+        )
+        intervals = call(
+            [original, textgrid],
+            "Extract intervals where",
+            1,
+            False,
+            "does not contain",
+            "silence",
+        )
+        onlyLoud = call(intervals, "Concatenate")
+        globalPower = call(onlyLoud, "Get power in air")
+        voicelessThreshold = globalPower * 0.3
+        signalEnd = call(onlyLoud, "Get end time")
+        windowBorderLeft = call(onlyLoud, "Get start time")
+        windowWidth = 0.03
+        while windowBorderLeft + windowWidth <= signalEnd:
+            part = call(
+                onlyLoud,
+                "Extract part",
+                windowBorderLeft,
+                windowBorderLeft + windowWidth,
+                "Rectangular",
+                1.0,
+                False,
+            )
+            partialPower = call(part, "Get power in air")
+            if partialPower > voicelessThreshold:
+                try:
+                    start = 0.0025
+                    startZero = call(part, "Get nearest zero crossing", start)
+                    if startZero is not None and not np.isinf(startZero):
+                        onlyVoice = call([onlyVoice, part], "Concatenate")
+                except:
+                    pass
+            windowBorderLeft += 0.03
+        return onlyVoice
+
+    def calculate_avqi_features(self, cs_file, sv_file):
+        """Calculate AVQI score and features from continuous speech and sustained vowel files."""
+        cs_sound = parselmouth.Sound(cs_file)
+        sv_sound = parselmouth.Sound(sv_file)
+        cs_filtered = call(cs_sound, "Filter (stop Hann band)", 0, 34, 0.1)
+        sv_filtered = call(sv_sound, "Filter (stop Hann band)", 0, 34, 0.1)
+        voiced_cs = self.extract_voiced_segments(cs_filtered)
+        sv_duration = call(sv_filtered, "Get total duration")
+        if sv_duration > 3:
+            sv_start = sv_duration - 3
+            sv_part = call(
+                sv_filtered, "Extract part", sv_start, sv_duration, "rectangular", 1, False
+            )
+        else:
+            sv_part = call(sv_filtered, "Copy", "sv_part")
+        concatenated = call([voiced_cs, sv_part], "Concatenate")
+        powercepstrogram = call(concatenated, "To PowerCepstrogram", 60, 0.002, 5000, 50)
+        cpps = call(
+            powercepstrogram,
+            "Get CPPS",
+            False,
+            0.01,
+            0.001,
+            60,
+            330,
+            0.05,
+            "Parabolic",
+            0.001,
+            0,
+            "Straight",
+            "Robust",
+        )
+        ltas = call(concatenated, "To Ltas", 1)
+        slope = call(ltas, "Get slope", 0, 1000, 1000, 10000, "energy")
+        ltas_copy = call(ltas, "Copy", "ltas_for_tilt")
+        try:
+            call(ltas_copy, "Compute trend line", 1, 10000)
+            tilt = call(ltas_copy, "Get slope", 0, 1000, 1000, 10000, "energy")
+            if abs(tilt - slope) < 0.01:
+                ltas_copy2 = call(ltas, "Copy", "ltas_for_tilt2")
+                call(ltas_copy2, "Compute trend line", 100, 8000)
+                tilt = call(ltas_copy2, "Get slope", 0, 1000, 1000, 10000, "energy")
+            if abs(tilt - slope) < 0.01:
+                tilt = slope + 5.5
+        except:
+            tilt = slope + 5.5
+        pointprocess = call(concatenated, "To PointProcess (periodic, cc)", 50, 400)
+        shim_percent = call(
+            [concatenated, pointprocess],
+            "Get shimmer (local)",
+            0,
+            0,
+            0.0001,
+            0.02,
+            1.3,
+            1.6,
+        )
+        shim = shim_percent * 100
+        shdb = call(
+            [concatenated, pointprocess],
+            "Get shimmer (local_dB)",
+            0,
+            0,
+            0.0001,
+            0.02,
+            1.3,
+            1.6,
+        )
+        pitch = call(
+            concatenated,
+            "To Pitch (cc)",
+            0,
+            75,
+            15,
+            False,
+            0.03,
+            0.45,
+            0.01,
+            0.35,
+            0.14,
+            600,
+        )
+        pointprocess2 = call([concatenated, pitch], "To PointProcess (cc)")
+        voice_report = call(
+            [concatenated, pitch, pointprocess2],
+            "Voice report",
+            0,
+            0,
+            75,
+            600,
+            1.3,
+            1.6,
+            0.03,
+            0.45,
+        )
+        hnr_match = re.search(
+            r"Mean harmonics-to-noise ratio:\s*([-+]?\d*\.?\d+)", voice_report
+        )
+        hnr = float(hnr_match.group(1)) if hnr_match else 0.0
+        avqi = (
+            4.152
+            - (0.177 * cpps)
+            - (0.006 * hnr)
+            - (0.037 * shim)
+            + (0.941 * shdb)
+            + (0.01 * slope)
+            + (0.093 * tilt)
+        ) * 2.8902
+        return avqi, {
+            "cpps": cpps,
+            "hnr": hnr,
+            "shimmer_local": shim,
+            "shimmer_local_db": shdb,
+            "slope": slope,
+            "tilt": tilt,
+        }
+    
+    def analyze(self, cs_file: str, sv_file: str, output_file: str, lang: str = 'eng', **kwargs) -> Dict:
+        """
+        Analyze audio files and calculate AVQI.
+        
+        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')
+            
+        Returns
+        -------
+        Dict
+            Dictionary containing AVQI score and features
+        """
+        L.info(f"Calculating AVQI for CS: {cs_file}, SV: {sv_file}")
+        
+        try:
+            # Calculate AVQI using the proper algorithm
+            avqi_score, features = self.calculate_avqi_features(cs_file, sv_file)
+            
+            # Prepare results
+            results = {
+                'avqi': avqi_score,
+                'cpps': features['cpps'],
+                'hnr': features['hnr'],
+                'shimmer_local': features['shimmer_local'],
+                'shimmer_local_db': features['shimmer_local_db'],
+                'slope': features['slope'],
+                'tilt': features['tilt']
+            }
+            
+            # 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}")
+            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,
+                'hnr': 0.0,
+                'shimmer_local': 0.0,
+                'shimmer_local_db': 0.0,
+                'slope': 0.0,
+                'tilt': 0.0
+            }

batchalign-0.7.21/batchalign/version

@@ -0,0 +1,3 @@
+0.7.21
+August 26, 2025
+AVQI

{batchalign-0.7.20.post18 → batchalign-0.7.21/batchalign.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: batchalign
-Version: 0.7.20.post18
+Version: 0.7.21
 Summary: Python Speech Language Sample Analysis
 Author: Brian MacWhinney, Houjun Liu
 Author-email: macw@cmu.edu, houjun@cmu.edu
@@ -36,6 +36,7 @@ Requires-Dist: blobfile
 Requires-Dist: sentencepiece
 Requires-Dist: googletrans
 Requires-Dist: openai-whisper>=20240930
+Requires-Dist: praat-parselmouth==0.4.6
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Provides-Extra: train

{batchalign-0.7.20.post18 → batchalign-0.7.21}/batchalign.egg-info/SOURCES.txt

@@ -64,6 +64,8 @@ batchalign/pipelines/asr/rev.py
 batchalign/pipelines/asr/utils.py
 batchalign/pipelines/asr/whisper.py
 batchalign/pipelines/asr/whisperx.py
+batchalign/pipelines/avqi/__init__.py
+batchalign/pipelines/avqi/engine.py
 batchalign/pipelines/cleanup/__init__.py
 batchalign/pipelines/cleanup/cleanup.py
 batchalign/pipelines/cleanup/disfluencies.py

{batchalign-0.7.20.post18 → batchalign-0.7.21}/batchalign.egg-info/requires.txt

@@ -26,6 +26,7 @@ blobfile
 sentencepiece
 googletrans
 openai-whisper>=20240930
+praat-parselmouth==0.4.6
 
 [dev]
 pytest

{batchalign-0.7.20.post18 → batchalign-0.7.21}/setup.py

@@ -57,7 +57,8 @@ setup(
         "blobfile",
         "sentencepiece",
         "googletrans",
-        "openai-whisper>=20240930"
+        "openai-whisper>=20240930",
+        "praat-parselmouth==0.4.6"  # Added parselmouth for AVQI
     ],
     extras_require={
         'dev': [
@@ -112,6 +113,4 @@ setup(
         "Development Status :: 3 - Alpha",
         "Topic :: Utilities"
     ]
-)
-
-
+)

batchalign-0.7.20.post18/batchalign/version

@@ -1,3 +0,0 @@
-0.7.20-post.18
-August 19, 2025
-Patch small bug