audio-scribe 0.1.0__tar.gz → 0.1.1__tar.gz

{audio_scribe-0.1.0 → audio_scribe-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: audio_scribe
-Version: 0.1.0
+Version: 0.1.1
 Summary: A command-line tool for audio transcription with Whisper and Pyannote.
 Home-page: https://gitlab.genomicops.cloud/genomicops/audio-scribe
 Author: Gurasis Osahan
@@ -50,6 +50,17 @@ Dynamic: summary
 
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
 
+
+
+# Current Working Badges
+[![Pipeline Status](https://gitlab.genomicops.cloud/innovation-hub/audio-scribe/badges/main/pipeline.svg)](https://gitlab.genomicops.cloud/innovation-hub/audio-scribe/-/commits/main)
+[![PyPI version](https://badge.fury.io/py/audio-scribe.svg)](https://badge.fury.io/py/audio-scribe)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/audio-scribe)](https://pypi.org/project/audio-scribe/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/audio-scribe)](https://pypi.org/project/audio-scribe/)
+[![PyPI - License](https://img.shields.io/pypi/l/audio-scribe)](https://pypi.org/project/audio-scribe/)
+[![Coverage Report](https://gitlab.genomicops.cloud/innovation-hub/audio-scribe/badges/main/coverage.svg)](https://gitlab.genomicops.cloud/innovation-hub/audio-scribe/-/commits/main)
+![Coverage](https://img.shields.io/badge/coverage-{percentage}%25-{color})
+
 ## Overview
 
 **Audio Scribe** is a command-line tool that transcribes audio files with speaker diarization. Leveraging [OpenAI Whisper](https://github.com/openai/whisper) for transcription and [Pyannote Audio](https://github.com/pyannote/pyannote-audio) for speaker diarization, this solution converts audio into segmented text files, identifying each speaker turn. Key features include:
@@ -67,6 +78,7 @@ This repository is licensed under the [Apache License 2.0](#license).
 ## Table of Contents
 
 - [Audio Scribe](#audio-scribe)
+- [Current Working Badges](#current-working-badges)
   - [Overview](#overview)
   - [Table of Contents](#table-of-contents)
   - [Features](#features)

{audio_scribe-0.1.0 → audio_scribe-0.1.1}/README.md

@@ -4,6 +4,17 @@
 
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
 
+
+
+# Current Working Badges
+[![Pipeline Status](https://gitlab.genomicops.cloud/innovation-hub/audio-scribe/badges/main/pipeline.svg)](https://gitlab.genomicops.cloud/innovation-hub/audio-scribe/-/commits/main)
+[![PyPI version](https://badge.fury.io/py/audio-scribe.svg)](https://badge.fury.io/py/audio-scribe)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/audio-scribe)](https://pypi.org/project/audio-scribe/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/audio-scribe)](https://pypi.org/project/audio-scribe/)
+[![PyPI - License](https://img.shields.io/pypi/l/audio-scribe)](https://pypi.org/project/audio-scribe/)
+[![Coverage Report](https://gitlab.genomicops.cloud/innovation-hub/audio-scribe/badges/main/coverage.svg)](https://gitlab.genomicops.cloud/innovation-hub/audio-scribe/-/commits/main)
+![Coverage](https://img.shields.io/badge/coverage-{percentage}%25-{color})
+
 ## Overview
 
 **Audio Scribe** is a command-line tool that transcribes audio files with speaker diarization. Leveraging [OpenAI Whisper](https://github.com/openai/whisper) for transcription and [Pyannote Audio](https://github.com/pyannote/pyannote-audio) for speaker diarization, this solution converts audio into segmented text files, identifying each speaker turn. Key features include:
@@ -21,6 +32,7 @@ This repository is licensed under the [Apache License 2.0](#license).
 ## Table of Contents
 
 - [Audio Scribe](#audio-scribe)
+- [Current Working Badges](#current-working-badges)
   - [Overview](#overview)
   - [Table of Contents](#table-of-contents)
   - [Features](#features)

audio_scribe-0.1.1/audio_scribe/__init__.py

@@ -0,0 +1,32 @@
+try:
+    from alive_progress import alive_bar
+    import psutil
+    import GPUtil
+    HAVE_PROGRESS_SUPPORT = True
+except ImportError:
+    HAVE_PROGRESS_SUPPORT = False
+
+from .cli import (
+    main,
+    TranscriptionPipeline,
+    TranscriptionConfig,
+    AudioProcessor,
+    TokenManager,
+    DependencyManager,
+    get_token,
+    complete_path,
+)
+
+__version__ = "0.1.1"
+
+__all__ = [
+    "main",
+    "TranscriptionPipeline",
+    "TranscriptionConfig",
+    "AudioProcessor",
+    "TokenManager",
+    "DependencyManager",
+    "get_token",
+    "complete_path",
+    "HAVE_PROGRESS_SUPPORT",
+]

{audio_scribe-0.1.0 → audio_scribe-0.1.1}/audio_scribe/cli.py

@@ -19,26 +19,24 @@ import json
 import logging
 import warnings
 import argparse
-import readline  # <--- For enabling tab-completion on Unix/Linux
+import readline
 from pathlib import Path
 from datetime import datetime
 from typing import Optional, Dict
 from dataclasses import dataclass
 import base64
 
+# Core dependencies
 from cryptography.fernet import Fernet
 from cryptography.hazmat.primitives import hashes
 from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
-
 import torch
 import whisper
-
 import importlib.metadata
 from importlib.metadata import PackageNotFoundError
-
 from pyannote.audio import Pipeline
 
-# Attempt to import optional packages for progress bar and resource monitoring
+# Progress bar dependencies - imported via HAVE_PROGRESS_SUPPORT from __init__
 try:
     from alive_progress import alive_bar
     import psutil
@@ -47,6 +45,7 @@ try:
 except ImportError:
     HAVE_PROGRESS_SUPPORT = False
 
+
 # Configure logging
 LOG_FORMAT = "%(asctime)s - %(levelname)s - %(message)s"
 logging.basicConfig(
@@ -387,13 +386,14 @@ class TranscriptionPipeline:
                             self.config.temp_directory
                             / f"segment_{speaker}_{turn.start:.2f}_{turn.end:.2f}.wav"
                         )
-                        if audio_processor.load_audio_segment(audio_path, turn.start, turn.end, segment_path):
+                        if self.audio_processor.load_audio_segment(audio_path, turn.start, turn.end, segment_path):
                             transcription = self.whisper_model.transcribe(str(segment_path))["text"]
                             segment_path.unlink(missing_ok=True)
 
                             line = f"[{turn.start:.2f}s - {turn.end:.2f}s] Speaker {speaker}: {transcription.strip()}\n"
                             f.write(line)
                             logger.info(line.strip())
+                return True
             else:
                 # Use a progress bar to track segment transcription
                 from alive_progress import alive_bar

{audio_scribe-0.1.0 → audio_scribe-0.1.1}/audio_scribe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: audio_scribe
-Version: 0.1.0
+Version: 0.1.1
 Summary: A command-line tool for audio transcription with Whisper and Pyannote.
 Home-page: https://gitlab.genomicops.cloud/genomicops/audio-scribe
 Author: Gurasis Osahan
@@ -50,6 +50,17 @@ Dynamic: summary
 
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
 
+
+
+# Current Working Badges
+[![Pipeline Status](https://gitlab.genomicops.cloud/innovation-hub/audio-scribe/badges/main/pipeline.svg)](https://gitlab.genomicops.cloud/innovation-hub/audio-scribe/-/commits/main)
+[![PyPI version](https://badge.fury.io/py/audio-scribe.svg)](https://badge.fury.io/py/audio-scribe)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/audio-scribe)](https://pypi.org/project/audio-scribe/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/audio-scribe)](https://pypi.org/project/audio-scribe/)
+[![PyPI - License](https://img.shields.io/pypi/l/audio-scribe)](https://pypi.org/project/audio-scribe/)
+[![Coverage Report](https://gitlab.genomicops.cloud/innovation-hub/audio-scribe/badges/main/coverage.svg)](https://gitlab.genomicops.cloud/innovation-hub/audio-scribe/-/commits/main)
+![Coverage](https://img.shields.io/badge/coverage-{percentage}%25-{color})
+
 ## Overview
 
 **Audio Scribe** is a command-line tool that transcribes audio files with speaker diarization. Leveraging [OpenAI Whisper](https://github.com/openai/whisper) for transcription and [Pyannote Audio](https://github.com/pyannote/pyannote-audio) for speaker diarization, this solution converts audio into segmented text files, identifying each speaker turn. Key features include:
@@ -67,6 +78,7 @@ This repository is licensed under the [Apache License 2.0](#license).
 ## Table of Contents
 
 - [Audio Scribe](#audio-scribe)
+- [Current Working Badges](#current-working-badges)
   - [Overview](#overview)
   - [Table of Contents](#table-of-contents)
   - [Features](#features)

{audio_scribe-0.1.0 → audio_scribe-0.1.1}/audio_scribe.egg-info/SOURCES.txt

@@ -7,4 +7,6 @@ audio_scribe.egg-info/SOURCES.txt
 audio_scribe.egg-info/dependency_links.txt
 audio_scribe.egg-info/entry_points.txt
 audio_scribe.egg-info/requires.txt
-audio_scribe.egg-info/top_level.txt
+audio_scribe.egg-info/top_level.txt
+tests/__init__.py
+tests/test_audio_scribe_main.py

{audio_scribe-0.1.0 → audio_scribe-0.1.1}/audio_scribe.egg-info/top_level.txt

@@ -1 +1,2 @@
 audio_scribe
+tests

{audio_scribe-0.1.0 → audio_scribe-0.1.1}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setuptools.setup(
     name="audio_scribe",
-    version="0.1.0",
+    version="0.1.1",
     author="Gurasis Osahan",
     author_email="contact@genomicops.com",
     description="A command-line tool for audio transcription with Whisper and Pyannote.",

audio_scribe-0.1.1/tests/test_audio_scribe_main.py

@@ -0,0 +1,468 @@
+import os
+import sys
+import pytest
+import shutil
+import tempfile
+import subprocess
+from unittest.mock import patch, MagicMock, mock_open
+from pathlib import Path
+from importlib.metadata import PackageNotFoundError
+
+# Import everything needed from audio_scribe.py
+# Adjust this import statement to match your actual structure/naming
+# NEW (explicitly import from cli.py where main, etc. are defined)
+
+from audio_scribe.cli import (
+    main,
+    TranscriptionPipeline,
+    TranscriptionConfig,
+    AudioProcessor,
+    TokenManager,
+    DependencyManager,
+    get_token,
+    complete_path,
+)
+
+
+
+# ---------------
+#  GLOBAL FIXTURES
+# ---------------
+@pytest.fixture
+def tmp_dir():
+    """
+    Creates a temporary directory for output and returns its path.
+    Cleans up afterward.
+    """
+    d = tempfile.mkdtemp()
+    yield Path(d)
+    shutil.rmtree(d)
+
+
+# -------------------------------------------
+# TEST: COMPLETE_PATH (TAB-COMPLETION LOGIC)
+# -------------------------------------------
+@pytest.fixture
+def path_test_params(request):
+    return request.param
+
+@pytest.mark.parametrize(
+    "path_test_params",
+    [
+        ("test", ["test.wav", "test.txt"], "./test.wav", 0),
+        ("nope", ["test.wav"], None, 0),
+    ],
+    indirect=True
+)
+
+def test_complete_path(path_test_params, monkeypatch):
+    """Test the complete_path function for tab-completion."""
+    input_text, directory_contents, expected, state = path_test_params
+
+    # Create a stateful path completer 
+    matches = []
+    current_state = [0]  # Using list to allow modification in closure
+
+    def mock_listdir(_dir):
+        return directory_contents
+
+    def stateful_complete(text, state):
+        # First call or new text - rebuild matches
+        if state == 0:
+            matches.clear()
+            for entry in directory_contents:
+                if entry.startswith(text):
+                    matches.append(f"./{entry}")
+        # Return match based on state if available
+        return matches[state] if state < len(matches) else None
+
+    monkeypatch.setattr(os, "listdir", mock_listdir)
+    monkeypatch.setattr(os.path, "isdir", lambda p: p.endswith("folder1"))
+    monkeypatch.setattr("audio_scribe.cli.complete_path", stateful_complete)
+
+    result = stateful_complete(input_text, state)
+    assert result == expected
+
+
+
+
+
+# -------------------------------------------
+# TEST: DEPENDENCY MANAGER
+# -------------------------------------------
+def test_verify_dependencies_missing():
+    """Force missing packages to check that verify_dependencies returns False."""
+    with patch("importlib.metadata.version") as mock_version:
+        mock_version.side_effect = PackageNotFoundError("mock")
+        assert DependencyManager.verify_dependencies() is False
+
+
+def test_verify_dependencies_outdated():
+    """Force a version mismatch to check that verify_dependencies returns False."""
+    with patch.dict(DependencyManager.REQUIRED_PACKAGES, {"torch": "0.0.1"}):
+        def mock_version(pkg):
+            return "999.0.0"  # Version that won't match our requirement
+        
+        with patch("importlib.metadata.version", side_effect=mock_version):
+            assert DependencyManager.verify_dependencies() is False
+
+
+def test_verify_dependencies_ok():
+    """Simulate all packages present and matching -> returns True."""
+    with patch("importlib.metadata.version", return_value="1.0.0"):
+        assert DependencyManager.verify_dependencies() is True
+
+
+# -------------------------------------------
+# TEST: TOKEN MANAGER & GET_TOKEN
+# -------------------------------------------
+@pytest.fixture
+def token_manager():
+    tm = TokenManager()
+    tm.config_dir = Path(tempfile.mkdtemp())
+    tm.config_file = tm.config_dir / "config.json"
+    tm._initialize_config()
+    yield tm
+    # Cleanup - modify to handle non-empty directories
+    if tm.config_file.exists():
+        tm.config_file.unlink()
+    # Remove all remaining files in the directory
+    for file in tm.config_dir.glob('*'):
+        file.unlink()
+    tm.config_dir.rmdir()
+
+
+def test_get_token_stored(monkeypatch, token_manager):
+    """Test get_token using a stored token (user says 'y' to use it)."""
+    token_manager.store_token("my-stored-token")
+    monkeypatch.setattr("builtins.input", lambda _: "y")
+    assert get_token(token_manager) == "my-stored-token"
+
+
+def test_get_token_new_save(monkeypatch, token_manager):
+    """
+    Test get_token where no stored token,
+    user enters a new token, chooses to save it => stored successfully.
+    """
+    responses = iter(["new-token-123", "y"])
+    monkeypatch.setattr("builtins.input", lambda _: next(responses))
+
+    tok = get_token(token_manager)
+    assert tok == "new-token-123"
+    assert token_manager.retrieve_token() == "new-token-123"
+
+
+def test_get_token_new_dont_save(monkeypatch, token_manager):
+    """Test get_token where user enters a new token, chooses NOT to save."""
+    input_responses = ["another-token", "n"]
+    input_mock = MagicMock(side_effect=input_responses)
+    monkeypatch.setattr("builtins.input", input_mock)
+
+    tok = get_token(token_manager)
+    assert tok == "another-token"
+    assert token_manager.retrieve_token() is None
+
+
+def test_get_token_none(monkeypatch, token_manager):
+    """User has no stored token, enters nothing => returns None."""
+    input_responses = ["", "n"]
+    input_mock = MagicMock(side_effect=input_responses)
+    monkeypatch.setattr("builtins.input", input_mock)
+
+    tok = get_token(token_manager)
+    assert tok is None
+
+
+# -------------------------------------------
+# TEST: TRANSCRIPTION CONFIG
+# -------------------------------------------
+def test_transcription_config_defaults(tmp_dir):
+    """Ensure default device, temp directory, etc."""
+    cfg = TranscriptionConfig(output_directory=tmp_dir)
+    assert cfg.output_directory == tmp_dir
+    assert cfg.whisper_model == "base.en"
+    # Device is either 'cuda' or 'cpu'
+    assert cfg.device in ("cuda", "cpu")
+    assert cfg.temp_directory.exists()
+
+
+def test_transcription_config_custom(tmp_dir):
+    """Verify custom initialization."""
+    cfg = TranscriptionConfig(
+        output_directory=tmp_dir,
+        whisper_model="medium",
+        diarization_model="pyannote/test-model",
+        temp_directory=tmp_dir / "custom_temp",
+        device="cpu",
+    )
+    assert cfg.whisper_model == "medium"
+    assert cfg.diarization_model == "pyannote/test-model"
+    assert cfg.device == "cpu"
+    assert cfg.temp_directory == tmp_dir / "custom_temp"
+    assert cfg.temp_directory.exists()
+
+
+# -------------------------------------------
+# TEST: AUDIO PROCESSOR
+# -------------------------------------------
+def test_audio_processor_ok(tmp_dir):
+    """Test load_audio_segment success path."""
+    from audio_scribe import AudioProcessor
+    cfg = TranscriptionConfig(output_directory=tmp_dir)
+    processor = AudioProcessor(cfg)
+
+    # We'll mock wave.open to simulate a valid read
+    with patch("wave.open", autospec=True) as mock_wave:
+        mock_infile = MagicMock()
+        mock_outfile = MagicMock()
+        mock_wave.return_value.__enter__.side_effect = [mock_infile, mock_outfile]
+
+        mock_infile.getparams.return_value = MagicMock(
+            framerate=44100, nchannels=2, sampwidth=2, nframes=441000
+        )
+        mock_infile.getnframes.return_value = 441000
+        mock_infile.readframes.return_value = b"fakeaudio"
+
+        ok = processor.load_audio_segment(
+            audio_path=Path("somefile.wav"),
+            start_time=1.0,
+            end_time=2.0,
+            output_path=tmp_dir / "out.wav"
+        )
+        assert ok is True
+
+
+def test_audio_processor_fail(tmp_dir, caplog):
+    """Test load_audio_segment failure path (file doesn't exist)."""
+    from audio_scribe import AudioProcessor
+    cfg = TranscriptionConfig(output_directory=tmp_dir)
+    processor = AudioProcessor(cfg)
+
+    ok = processor.load_audio_segment(
+        audio_path=Path("non_existent.wav"),
+        start_time=0,
+        end_time=1,
+        output_path=tmp_dir / "out.wav"
+    )
+    assert ok is False
+    assert "Failed to process audio segment:" in caplog.text
+
+
+# -------------------------------------------
+# TEST: TRANSCRIPTION PIPELINE
+# -------------------------------------------
+@pytest.fixture
+def pipeline(tmp_dir):
+    """Returns a TranscriptionPipeline with basic config."""
+    cfg = TranscriptionConfig(output_directory=tmp_dir)
+    from audio_scribe import TranscriptionPipeline
+    return TranscriptionPipeline(cfg)
+
+
+def test_initialize_models_ok(pipeline):
+    with patch("whisper.load_model") as mock_whisper, \
+         patch("pyannote.audio.Pipeline.from_pretrained") as mock_from_pretrained:
+        mock_whisper.return_value = MagicMock()
+        mock_from_pretrained.return_value = MagicMock()
+        assert pipeline.initialize_models("fake-token")
+
+
+def test_initialize_models_fail(pipeline, caplog):
+    with patch("whisper.load_model", side_effect=Exception("Model loading failed")):
+        res = pipeline.initialize_models("fake-token")
+        assert not res
+        assert "Model initialization failed" in caplog.text
+
+
+def test_process_file_ok(pipeline, tmp_dir):
+    """
+    Test process_file success path using a mocked diarization pipeline
+    that returns fake segments.
+    """
+    pipeline.diarization_pipeline = MagicMock()
+    # We'll create 2 segments to test iteration
+    fake_segment1 = MagicMock()
+    fake_segment1.start = 0.0
+    fake_segment1.end = 1.5
+    fake_segment2 = MagicMock()
+    fake_segment2.start = 1.5
+    fake_segment2.end = 2.5
+
+    # itertracks returns an iterable of (segment, _, label)
+    pipeline.diarization_pipeline.return_value.itertracks.return_value = [
+        (fake_segment1, None, "SpeakerA"),
+        (fake_segment2, None, "SpeakerB"),
+    ]
+
+    pipeline.whisper_model = MagicMock()
+    pipeline.whisper_model.transcribe.return_value = {"text": "Hello world"}
+
+    # Try calling process_file
+    test_audio = tmp_dir / "fake.wav"
+    test_audio.touch()  # create an empty file
+
+    ok = pipeline.process_file(test_audio)
+    assert ok is True
+    # Verify pipeline called
+    pipeline.diarization_pipeline.assert_called_once_with(str(test_audio))
+
+
+def test_process_file_exception(pipeline, tmp_dir, caplog):
+    """
+    Test process_file with an exception, verifying it returns False
+    and logs the error.
+    """
+    pipeline.diarization_pipeline = MagicMock(side_effect=Exception("Boom!"))
+    test_audio = tmp_dir / "fake.wav"
+    test_audio.touch()
+
+    ok = pipeline.process_file(test_audio)
+    assert not ok
+    assert "Processing failed: Boom!" in caplog.text
+
+
+# -------------------------------------------
+# TEST: MAIN FUNCTION
+# -------------------------------------------
+@pytest.mark.parametrize(
+    "test_params",
+    [
+        {
+            "cli_args": ["--audio", "fake.wav"],
+            "stored_token": None,
+            "user_input_sequence": [],
+            "expected_exit_code": 1
+        },
+        {
+            "cli_args": ["--delete-token"],
+            "stored_token": "some-token",
+            "user_input_sequence": [],
+            "expected_exit_code": 0
+        },
+        {
+            "cli_args": [],
+            "stored_token": "token123",
+            "user_input_sequence": ["\n", "non_existent.wav\n", "somefile.wav\n"],
+            "expected_exit_code": 1
+        }
+    ]
+)
+def test_main_general_scenarios(test_params, monkeypatch, token_manager, tmp_dir):
+    """End-to-end tests that run 'main()' with certain CLI args."""
+    # Extract parameters from the test_params dictionary
+    cli_args = test_params["cli_args"]
+    stored_token = test_params["stored_token"]
+    user_input_sequence = test_params["user_input_sequence"]
+    expected_exit_code = test_params["expected_exit_code"]
+
+    # 1) Mock out sys.argv
+    test_argv = ["audio_scribe.py"] + cli_args
+    monkeypatch.setattr(sys, "argv", test_argv)
+
+    # 2) Ensure we simulate the environment
+    monkeypatch.setattr("audio_scribe.cli.DependencyManager.verify_dependencies", lambda: False)
+    if "--delete-token" in cli_args:
+        monkeypatch.setattr("audio_scribe.cli.DependencyManager.verify_dependencies", lambda: True)
+
+    # 3) Setup token if needed
+    if stored_token:
+        token_manager.store_token(stored_token)
+
+    # 4) Mock user input
+    input_iter = iter(user_input_sequence)
+    monkeypatch.setattr("builtins.input", lambda _: next(input_iter, ""))
+
+    # 5) We also need to patch TokenManager usage in main
+    monkeypatch.setattr("audio_scribe.cli.TokenManager", lambda: token_manager)
+
+    # 6) Patch out file existence checks
+    def mock_exists(path):
+        return "somefile.wav" in str(path)
+
+    monkeypatch.setattr(Path, "exists", mock_exists)
+
+    # 7) To test sys.exit calls, we can wrap main in a try/except
+    exit_code = None
+    try:
+        main()
+    except SystemExit as e:
+        exit_code = e.code
+
+    assert exit_code == expected_exit_code
+    
+def test_main_full_success(monkeypatch, tmp_dir, token_manager):
+    """
+    A scenario that covers dependencies => OK,
+    user has token stored, user passes a valid audio path => pipeline runs fine => exit(0).
+    """
+    # Mock sys.argv
+    monkeypatch.setattr(sys, "argv", ["audio_scribe.py", "--audio", "valid.wav"])
+
+    # Dependencies pass
+    monkeypatch.setattr("audio_scribe.cli.DependencyManager.verify_dependencies", lambda: True)
+
+    # Token is already stored - this is key to avoiding the input prompt
+    token_manager.store_token("mytoken")
+    monkeypatch.setattr("audio_scribe.cli.TokenManager", lambda: token_manager)
+    monkeypatch.setattr("audio_scribe.cli.get_token", lambda tm: "mytoken")
+
+    # We'll say 'valid.wav' path exists
+    def mock_exists(path):
+        return "valid.wav" in str(path)
+
+    monkeypatch.setattr(Path, "exists", mock_exists)
+
+    # Patch pipeline initialization => True
+    mock_pipeline = MagicMock()
+    mock_pipeline.initialize_models.return_value = True
+    mock_pipeline.process_file.return_value = True
+
+    # We also patch TranscriptionPipeline to return our mock
+    monkeypatch.setattr("audio_scribe.cli.TranscriptionPipeline", lambda cfg: mock_pipeline)
+
+    exit_code = None
+    try:
+        main()
+    except SystemExit as e:
+        exit_code = e.code
+
+    # Expect success
+    assert exit_code is None or exit_code == 0
+    mock_pipeline.initialize_models.assert_called_once()
+    mock_pipeline.process_file.assert_called_once()
+
+
+def test_main_show_warnings(monkeypatch, tmp_dir):
+    """
+    Test scenario for --show-warnings branch
+    """
+    monkeypatch.setattr(sys, "argv", ["audio_scribe.py", "--show-warnings", "--audio", "valid.wav"])
+
+    # Dependencies pass
+    monkeypatch.setattr("audio_scribe.cli.DependencyManager.verify_dependencies", lambda: True)
+
+    # Mock the token handling to avoid input prompts
+    monkeypatch.setattr("audio_scribe.cli.get_token", lambda tm: "test-token")
+
+    # Pretend the file exists
+    def mock_exists(path):
+        return "valid.wav" in str(path)
+
+    monkeypatch.setattr(Path, "exists", mock_exists)
+
+    # Mock the pipeline
+    mock_pipeline = MagicMock()
+    mock_pipeline.initialize_models.return_value = True
+    mock_pipeline.process_file.return_value = True
+    monkeypatch.setattr("audio_scribe.cli.TranscriptionPipeline", lambda cfg: mock_pipeline)
+
+    exit_code = None
+    try:
+        main()
+    except SystemExit as e:
+        exit_code = e.code
+
+    # Expect success
+    assert exit_code is None or exit_code == 0
+    mock_pipeline.initialize_models.assert_called_once()
+    mock_pipeline.process_file.assert_called_once()