lattifai 0.4.5__py3-none-any.whl → 1.0.0__py3-none-any.whl

lattifai/io/text_parser.py

@@ -1,75 +0,0 @@
-import logging
-import re
-from typing import Optional, Tuple
-
-# 来自于字幕中常见的说话人标记格式
-SPEAKER_PATTERN = re.compile(r'((?:>>|>>|>|>).*?[:：])\s*(.*)')
-
-# Transcriber Output Example:
-# 26:19.919 --> 26:34.921
-# [SPEAKER_01]: 越来越多的科技巨头入...
-SPEAKER_LATTIFAI = re.compile(r'(^\[SPEAKER_.*?\][:：])\s*(.*)')
-
-# NISHTHA BHATIA: Hey, everyone.
-# DIETER: Oh, hey, Nishtha.
-# GEMINI: That might
-SPEAKER_PATTERN2 = re.compile(r'^([A-Z]{1,15}(?:\s+[A-Z]{1,15})?[:：])\s*(.*)$')
-
-
-def parse_speaker_text(line) -> Tuple[Optional[str], str]:
-    line = line.replace('\\N', ' ')
-
-    if ':' not in line and '：' not in line:
-        return None, line
-
-    # 匹配以 >> 开头的行，并去除开头的名字和冒号
-    match = SPEAKER_PATTERN.match(line)
-    if match:
-        return match.group(1).strip(), match.group(2).strip()
-
-    match = SPEAKER_LATTIFAI.match(line)
-    if match:
-        assert len(match.groups()) == 2, match.groups()
-        if not match.group(1):
-            logging.error(f'ParseSub LINE [{line}]')
-        else:
-            return match.group(1).strip(), match.group(2).strip()
-
-    match = SPEAKER_PATTERN2.match(line)
-    if match:
-        assert len(match.groups()) == 2, match.groups()
-        return match.group(1).strip(), match.group(2).strip()
-
-    return None, line
-
-
-if __name__ == '__main__':
-    pattern = re.compile(r'>>\s*(.*?)\s*[:：]\s*(.*)')
-    pattern = re.compile(r'(>>.*?[:：])\s*(.*)')
-
-    test_strings = [
-        '>>Key: Value',
-        '>>  Key with space : Value with space ',
-        '>>  全角键 ： 全角值',
-        '>>Key：Value xxx. >>Key：Value',
-    ]
-
-    for text in test_strings:
-        match = pattern.match(text)
-        if match:
-            print(f"Input: '{text}'")
-            print(f"  Key:   '{match.group(1)}'")
-            print(f"  Value: '{match.group(2)}'")
-            print('-------------')
-
-    # pattern2
-    test_strings2 = ['NISHTHA BHATIA: Hey, everyone.', 'DIETER: Oh, hey, Nishtha.', 'GEMINI: That might']
-    for text in test_strings2:
-        match = SPEAKER_PATTERN2.match(text)
-        if match:
-            print(f"  Input: '{text}'")
-            print(f"Speaker: '{match.group(1)}'")
-            print(f"Content: '{match.group(2)}'")
-            print('-------------')
-        else:
-            raise ValueError(f"No match for: '{text}'")

lattifai/io/utils.py

@@ -1,15 +0,0 @@
-"""
-Utility constants and helper functions for subtitle I/O operations
-"""
-
-# Supported subtitle formats for reading/writing
-SUBTITLE_FORMATS = ['srt', 'vtt', 'ass', 'ssa', 'sub', 'sbv', 'txt', 'md']
-
-# Input subtitle formats (includes special formats like 'auto' and 'gemini')
-INPUT_SUBTITLE_FORMATS = ['srt', 'vtt', 'ass', 'ssa', 'sub', 'sbv', 'txt', 'auto', 'gemini']
-
-# Output subtitle formats (includes special formats like 'TextGrid' and 'json')
-OUTPUT_SUBTITLE_FORMATS = ['srt', 'vtt', 'ass', 'ssa', 'sub', 'sbv', 'txt', 'TextGrid', 'json']
-
-# All subtitle formats combined (for file detection)
-ALL_SUBTITLE_FORMATS = list(set(SUBTITLE_FORMATS + ['TextGrid', 'json', 'gemini']))

lattifai/io/writer.py

@@ -1,90 +0,0 @@
-import json
-from abc import ABCMeta
-from typing import Any, List, Optional
-
-import pysubs2
-from lhotse.supervision import AlignmentItem
-from lhotse.utils import Pathlike
-
-from .reader import Supervision
-
-
-class SubtitleWriter(ABCMeta):
-    """Class for writing subtitle files with optional word-level alignment."""
-
-    @classmethod
-    def write(cls, alignments: List[Supervision], output_path: Pathlike) -> Pathlike:
-        if str(output_path)[-4:].lower() == '.txt':
-            with open(output_path, 'w', encoding='utf-8') as f:
-                for sup in alignments:
-                    word_items = parse_alignment_from_supervision(sup)
-                    if word_items:
-                        for item in word_items:
-                            f.write(f'[{item.start:.2f}-{item.end:.2f}] {item.symbol}\n')
-                    else:
-                        text = f'{sup.speaker} {sup.text}' if sup.speaker is not None else sup.text
-                        f.write(f'[{sup.start:.2f}-{sup.end:.2f}] {text}\n')
-
-        elif str(output_path)[-5:].lower() == '.json':
-            with open(output_path, 'w', encoding='utf-8') as f:
-                # Enhanced JSON export with word-level alignment
-                json_data = []
-                for sup in alignments:
-                    sup_dict = sup.to_dict()
-                    json_data.append(sup_dict)
-                json.dump(json_data, f, ensure_ascii=False, indent=4)
-        elif str(output_path).endswith('.TextGrid') or str(output_path).endswith('.textgrid'):
-            from tgt import Interval, IntervalTier, TextGrid, write_to_file
-
-            tg = TextGrid()
-            supervisions, words = [], []
-            for supervision in sorted(alignments, key=lambda x: x.start):
-                text = (
-                    f'{supervision.speaker} {supervision.text}' if supervision.speaker is not None else supervision.text
-                )
-                supervisions.append(Interval(supervision.start, supervision.end, text or ''))
-                # Extract word-level alignment using helper function
-                word_items = parse_alignment_from_supervision(supervision)
-                if word_items:
-                    for item in word_items:
-                        words.append(Interval(item.start, item.end, item.symbol))
-
-            tg.add_tier(IntervalTier(name='utterances', objects=supervisions))
-            if words:
-                tg.add_tier(IntervalTier(name='words', objects=words))
-            write_to_file(tg, output_path, format='long')
-        else:
-            subs = pysubs2.SSAFile()
-            for sup in alignments:
-                # Add word-level timing as metadata in the subtitle text
-                word_items = parse_alignment_from_supervision(sup)
-                if word_items:
-                    for word in word_items:
-                        subs.append(
-                            pysubs2.SSAEvent(start=int(word.start * 1000), end=int(word.end * 1000), text=word.symbol)
-                        )
-                else:
-                    text = f'{sup.speaker} {sup.text}' if sup.speaker is not None else sup.text
-                    subs.append(pysubs2.SSAEvent(start=int(sup.start * 1000), end=int(sup.end * 1000), text=text or ''))
-            subs.save(output_path)
-
-        return output_path
-
-
-def parse_alignment_from_supervision(supervision: Any) -> Optional[List[AlignmentItem]]:
-    """
-    Extract word-level alignment items from Supervision object.
-
-    Args:
-        supervision: Supervision object with potential alignment data
-
-    Returns:
-        List of AlignmentItem objects, or None if no alignment data present
-    """
-    if not hasattr(supervision, 'alignment') or not supervision.alignment:
-        return None
-
-    if 'word' not in supervision.alignment:
-        return None
-
-    return supervision.alignment['word']

lattifai/tokenizer/__init__.py

@@ -1,3 +0,0 @@
-from .tokenizer import AsyncLatticeTokenizer, LatticeTokenizer
-
-__all__ = ['LatticeTokenizer', 'AsyncLatticeTokenizer']

lattifai/workers/__init__.py

@@ -1,3 +0,0 @@
-from .lattice1_alpha import Lattice1AlphaWorker
-
-__all__ = ['Lattice1AlphaWorker']

lattifai/workers/lattice1_alpha.py

@@ -1,284 +0,0 @@
-import json
-import time
-from collections import defaultdict
-from typing import Any, BinaryIO, Dict, Iterable, Optional, Tuple, Union
-
-import numpy as np
-import onnxruntime as ort
-import soundfile as sf
-import torch
-from lhotse import FbankConfig
-from lhotse.augmentation import get_or_create_resampler
-from lhotse.features.kaldi.layers import Wav2LogFilterBank
-from lhotse.utils import Pathlike
-
-from lattifai.errors import AlignmentError, AudioFormatError, AudioLoadError, DependencyError, ModelLoadError
-
-ChannelSelectorType = Union[int, Iterable[int], str]
-
-
-def resample_audio(
-    audio_sr: Tuple[torch.Tensor, int],
-    sampling_rate: int,
-    device: Optional[str],
-    channel_selector: Optional[ChannelSelectorType] = 'average',
-) -> torch.Tensor:
-    """
-    return:
-        (1, T)
-    """
-    audio, sr = audio_sr
-
-    if channel_selector is None:
-        # keep the original multi-channel signal
-        tensor = audio
-    elif isinstance(channel_selector, int):
-        assert audio.shape[0] >= channel_selector, f'Invalid channel: {channel_selector}'
-        tensor = audio[channel_selector : channel_selector + 1].clone()
-        del audio
-    elif isinstance(channel_selector, str):
-        assert channel_selector == 'average'
-        tensor = torch.mean(audio.to(device), dim=0, keepdim=True)
-        del audio
-    else:
-        assert isinstance(channel_selector, Iterable)
-        num_channels = audio.shape[0]
-        print(f'Selecting channels {channel_selector} from the signal with {num_channels} channels.')
-        assert isinstance(channel_selector, Iterable)
-        if max(channel_selector) >= num_channels:
-            raise ValueError(
-                f'Cannot select channel subset {channel_selector} from a signal with {num_channels} channels.'
-            )
-        tensor = audio[channel_selector]
-
-    tensor = tensor.to(device)
-    if sr != sampling_rate:
-        resampler = get_or_create_resampler(sr, sampling_rate).to(device=device)
-        length = tensor.size(-1)
-        chunk_size = sampling_rate * 3600
-        if length > chunk_size:
-            resampled_chunks = []
-            for i in range(0, length, chunk_size):
-                resampled_chunks.append(resampler(tensor[..., i : i + chunk_size]))
-            tensor = torch.cat(resampled_chunks, dim=-1)
-        else:
-            tensor = resampler(tensor)
-
-    return tensor
-
-
-class Lattice1AlphaWorker:
-    """Worker for processing audio with LatticeGraph."""
-
-    def __init__(self, model_path: Pathlike, device: str = 'cpu', num_threads: int = 8) -> None:
-        try:
-            self.config = json.load(open(f'{model_path}/config.json'))
-        except Exception as e:
-            raise ModelLoadError(f'config from {model_path}', original_error=e)
-
-        # SessionOptions
-        sess_options = ort.SessionOptions()
-        # sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
-        sess_options.intra_op_num_threads = num_threads  # CPU cores
-        sess_options.execution_mode = ort.ExecutionMode.ORT_PARALLEL
-        sess_options.add_session_config_entry('session.intra_op.allow_spinning', '0')
-
-        providers = []
-        if device.startswith('cuda') and ort.get_all_providers().count('CUDAExecutionProvider') > 0:
-            providers.append('CUDAExecutionProvider')
-        elif device.startswith('mps') and ort.get_all_providers().count('MPSExecutionProvider') > 0:
-            providers.append('MPSExecutionProvider')
-
-        try:
-            self.acoustic_ort = ort.InferenceSession(
-                f'{model_path}/acoustic_opt.onnx',
-                sess_options,
-                providers=providers + ['CPUExecutionProvider', 'CoreMLExecutionProvider'],
-            )
-        except Exception as e:
-            raise ModelLoadError(f'acoustic model from {model_path}', original_error=e)
-
-        try:
-            config = FbankConfig(num_mel_bins=80, device=device, snip_edges=False)
-            config_dict = config.to_dict()
-            config_dict.pop('device')
-            self.extractor = Wav2LogFilterBank(**config_dict).to(device).eval()
-        except Exception as e:
-            raise ModelLoadError(f'feature extractor for device {device}', original_error=e)
-
-        self.device = torch.device(device)
-        self.timings = defaultdict(lambda: 0.0)
-
-    @torch.inference_mode()
-    def emission(self, audio: torch.Tensor) -> torch.Tensor:
-        _start = time.time()
-        # audio -> features -> emission
-        features = self.extractor(audio)  # (1, T, D)
-        if features.shape[1] > 6000:
-            features_list = torch.split(features, 6000, dim=1)
-            emissions = []
-            for features in features_list:
-                ort_inputs = {
-                    'features': features.cpu().numpy(),
-                    'feature_lengths': np.array([features.size(1)], dtype=np.int64),
-                }
-                emission = self.acoustic_ort.run(None, ort_inputs)[0]  # (1, T, vocab_size) numpy
-                emissions.append(emission)
-            emission = torch.cat(
-                [torch.from_numpy(emission).to(self.device) for emission in emissions], dim=1
-            )  # (1, T, vocab_size)
-        else:
-            ort_inputs = {
-                'features': features.cpu().numpy(),
-                'feature_lengths': np.array([features.size(1)], dtype=np.int64),
-            }
-            emission = self.acoustic_ort.run(None, ort_inputs)[0]  # (1, T, vocab_size) numpy
-            emission = torch.from_numpy(emission).to(self.device)
-
-        self.timings['emission'] += time.time() - _start
-        return emission  # (1, T, vocab_size) torch
-
-    def load_audio(
-        self, audio: Union[Pathlike, BinaryIO], channel_selector: Optional[ChannelSelectorType] = 'average'
-    ) -> Tuple[torch.Tensor, int]:
-        # load audio
-        try:
-            waveform, sample_rate = sf.read(audio, always_2d=True, dtype='float32')  # numpy array
-            waveform = waveform.T  # (channels, samples)
-        except Exception as primary_error:
-            # Fallback to PyAV for formats not supported by soundfile
-            try:
-                import av
-            except ImportError:
-                raise DependencyError(
-                    'av (PyAV)', install_command='pip install av', context={'primary_error': str(primary_error)}
-                )
-
-            try:
-                container = av.open(audio)
-                audio_stream = next((s for s in container.streams if s.type == 'audio'), None)
-
-                if audio_stream is None:
-                    raise AudioFormatError(str(audio), 'No audio stream found in file')
-
-                # Resample to target sample rate during decoding
-                audio_stream.codec_context.format = av.AudioFormat('flt')  # 32-bit float
-
-                frames = []
-                for frame in container.decode(audio_stream):
-                    # Convert frame to numpy array
-                    array = frame.to_ndarray()
-                    # Ensure shape is (channels, samples)
-                    if array.ndim == 1:
-                        array = array.reshape(1, -1)
-                    elif array.ndim == 2 and array.shape[0] > array.shape[1]:
-                        array = array.T
-                    frames.append(array)
-
-                container.close()
-
-                if not frames:
-                    raise AudioFormatError(str(audio), 'No audio data found in file')
-
-                # Concatenate all frames
-                waveform = np.concatenate(frames, axis=1)
-                sample_rate = audio_stream.codec_context.sample_rate
-            except Exception as e:
-                raise AudioLoadError(str(audio), original_error=e)
-
-        return resample_audio(
-            (torch.from_numpy(waveform), sample_rate),
-            self.config.get('sampling_rate', 16000),
-            device=self.device.type,
-            channel_selector=channel_selector,
-        )
-
-    def alignment(
-        self, audio: Union[Union[Pathlike, BinaryIO], torch.tensor], lattice_graph: Tuple[str, int, float]
-    ) -> Dict[str, Any]:
-        """Process audio with LatticeGraph.
-
-        Args:
-            audio: Audio file path or binary data
-            lattice_graph: LatticeGraph data
-
-        Returns:
-            Processed LatticeGraph
-
-        Raises:
-            AudioLoadError: If audio cannot be loaded
-            DependencyError: If required dependencies are missing
-            AlignmentError: If alignment process fails
-        """
-        # load audio
-        if isinstance(audio, torch.Tensor):
-            waveform = audio
-        else:
-            waveform = self.load_audio(audio)  # (1, L)
-
-        _start = time.time()
-        try:
-            emission = self.emission(waveform.to(self.device))  # (1, T, vocab_size)
-        except Exception as e:
-            raise AlignmentError(
-                'Failed to compute acoustic features from audio',
-                audio_path=str(audio) if not isinstance(audio, torch.Tensor) else 'tensor',
-                context={'original_error': str(e)},
-            )
-        self.timings['emission'] += time.time() - _start
-
-        try:
-            import k2
-        except ImportError:
-            raise DependencyError('k2', install_command='pip install install-k2 && python -m install_k2')
-
-        try:
-            from lattifai_core.lattice.decode import align_segments
-        except ImportError:
-            raise DependencyError('lattifai_core', install_command='Contact support for lattifai_core installation')
-
-        lattice_graph_str, final_state, acoustic_scale = lattice_graph
-
-        _start = time.time()
-        try:
-            # graph
-            decoding_graph = k2.Fsa.from_str(lattice_graph_str, acceptor=False)
-            decoding_graph.requires_grad_(False)
-            decoding_graph = k2.arc_sort(decoding_graph)
-            decoding_graph.skip_id = int(final_state)
-            decoding_graph.return_id = int(final_state + 1)
-        except Exception as e:
-            raise AlignmentError(
-                'Failed to create decoding graph from lattice',
-                context={'original_error': str(e), 'lattice_graph_length': len(lattice_graph_str)},
-            )
-        self.timings['decoding_graph'] += time.time() - _start
-
-        _start = time.time()
-        if self.device.type == 'mps':
-            device = 'cpu'  # k2 does not support mps yet
-        else:
-            device = self.device
-
-        try:
-            results, labels = align_segments(
-                emission.to(device) * acoustic_scale,
-                decoding_graph.to(device),
-                torch.tensor([emission.shape[1]], dtype=torch.int32),
-                search_beam=200,
-                output_beam=80,
-                min_active_states=400,
-                max_active_states=10000,
-                subsampling_factor=1,
-                reject_low_confidence=False,
-            )
-        except Exception as e:
-            raise AlignmentError(
-                'Failed to perform forced alignment',
-                audio_path=str(audio) if not isinstance(audio, torch.Tensor) else 'tensor',
-                context={'original_error': str(e), 'emission_shape': list(emission.shape), 'device': str(device)},
-            )
-        self.timings['align_segments'] += time.time() - _start
-
-        channel = 0
-        return emission, results, labels, 0.02, 0.0, channel  # frame_shift=20ms, offset=0.0s

lattifai/workflows/__init__.py

@@ -1,34 +0,0 @@
-"""
-LattifAI Agentic Workflows
-
-This module provides agentic workflow capabilities for automated processing
-of multimedia content through intelligent agent-based pipelines.
-"""
-
-# Import transcript processing functionality
-from lattifai.io import (
-    ALL_SUBTITLE_FORMATS,
-    INPUT_SUBTITLE_FORMATS,
-    OUTPUT_SUBTITLE_FORMATS,
-    SUBTITLE_FORMATS,
-    GeminiReader,
-    GeminiWriter,
-)
-
-from .agents import YouTubeSubtitleAgent
-from .base import WorkflowAgent, WorkflowResult, WorkflowStep
-from .file_manager import FileExistenceManager
-
-__all__ = [
-    'WorkflowAgent',
-    'WorkflowStep',
-    'WorkflowResult',
-    'YouTubeSubtitleAgent',
-    'FileExistenceManager',
-    'GeminiReader',
-    'GeminiWriter',
-    'SUBTITLE_FORMATS',
-    'INPUT_SUBTITLE_FORMATS',
-    'OUTPUT_SUBTITLE_FORMATS',
-    'ALL_SUBTITLE_FORMATS',
-]

lattifai/workflows/agents.py

@@ -1,10 +0,0 @@
-"""
-Subtitle Agents
-
-An agentic workflow for processing YouTube(or more) videos through:
-1. URL processing and audio download
-2. Gemini 2.5 Pro transcription
-3. LattifAI alignment
-"""
-
-from .youtube import YouTubeSubtitleAgent

lattifai/workflows/gemini.py

@@ -1,167 +0,0 @@
-"""
-Gemini 2.5 Pro transcription module
-"""
-
-import asyncio
-from typing import Optional
-
-# Import Google GenAI SDK
-from google import genai
-from google.genai.types import GenerateContentConfig, Part, ThinkingConfig
-
-from .base import setup_workflow_logger
-from .prompts import get_prompt_loader
-
-
-class GeminiTranscriber:
-    """Gemini 2.5 Pro audio transcription using the specified Gem
-
-    Configuration (in __init__):
-        - api_key: Gemini API key (required)
-
-    Runtime parameters (in __call__):
-        - youtube_url: YouTube URL to transcribe
-    """
-
-    # The specific Gem URL provided by the user
-    GEM_URL = 'https://gemini.google.com/gem/1870ly7xvW2hU_umtv-LedGsjywT0sQiN'
-
-    def __init__(self, api_key: Optional[str] = None):
-        self.api_key = api_key
-        self.logger = setup_workflow_logger('gemini')
-        self.prompt_loader = get_prompt_loader()
-
-        if not self.api_key:
-            self.logger.warning(
-                '⚠️ Gemini API key not provided. API key will be required when calling transcription methods.'
-            )
-
-    async def __call__(self, youtube_url: str) -> str:
-        """Main entry point for transcription"""
-        return await self.transcribe_url(youtube_url)
-
-    async def transcribe_url(self, youtube_url: str) -> str:
-        """
-        Transcribe audio from YouTube URL using Gemini 2.5 Pro Gem
-
-        Args:
-            youtube_url: YouTube URL to transcribe
-
-        Returns:
-            Transcribed text
-        """
-        if not self.api_key:
-            raise ValueError('Gemini API key is required for transcription')
-
-        self.logger.info(f'🎤 Starting Gemini transcription for: {youtube_url}')
-
-        try:
-            # Initialize client
-            client = genai.Client(api_key=self.api_key)
-
-            # Load prompt from Gem configuration
-            system_prompt = self.prompt_loader.get_gemini_transcription_prompt()
-
-            # Generate transcription with extended thinking
-            self.logger.info('🔄 Sending request to Gemini 2.5 Pro...')
-            config = GenerateContentConfig(
-                system_instruction=system_prompt,
-                # Enable thinking by including it in response modalities
-                response_modalities=['TEXT'],
-                thinking_config=ThinkingConfig(
-                    include_thoughts=False,
-                    thinking_budget=-1,
-                ),
-            )
-            response = await asyncio.get_event_loop().run_in_executor(
-                None,
-                lambda: client.models.generate_content(
-                    model='gemini-2.5-pro',
-                    contents=Part.from_uri(file_uri=youtube_url, mime_type='video/*'),
-                    config=config,
-                ),
-            )
-
-            if not response.text:
-                raise RuntimeError('Empty response from Gemini API')
-
-            transcript = response.text.strip()
-
-            self.logger.info(f'✅ Transcription completed: {len(transcript)} characters')
-            return transcript
-
-        except ImportError:
-            raise RuntimeError('Google GenAI SDK not installed. Please install with: pip install google-genai')
-        except Exception as e:
-            self.logger.error(f'Gemini transcription failed: {str(e)}')
-            raise RuntimeError(f'Gemini transcription failed: {str(e)}')
-
-    async def transcribe_file(self, media_file_path: str) -> str:
-        """
-        Transcribe audio/video from local file using Gemini 2.5 Pro
-
-        Args:
-            media_file_path: Path to local audio file
-
-        Returns:
-            Transcribed text
-        """
-        if not self.api_key:
-            raise ValueError('Gemini API key is required for transcription')
-
-        self.logger.info(f'🎤 Starting Gemini transcription for file: {media_file_path}')
-
-        try:
-            # Initialize client
-            client = genai.Client(api_key=self.api_key)
-
-            # Load prompt from Gem configuration
-            system_prompt = self.prompt_loader.get_gemini_transcription_prompt()
-
-            # Upload audio file
-            self.logger.info('📤 Uploading audio file to Gemini...')
-            media_file = client.files.upload(path=media_file_path)
-
-            # Generate transcription with extended thinking
-            # Note: For thinking mode, you may want to use 'gemini-2.0-flash-thinking-exp' or similar models
-            self.logger.info('🔄 Sending transcription request...')
-            config = GenerateContentConfig(
-                system_instruction=system_prompt,
-                # Enable thinking by including it in response modalities
-                response_modalities=['TEXT'],
-                thinking_config=ThinkingConfig(
-                    include_thoughts=False,
-                    thinking_budget=-1,
-                ),
-            )
-            response = await asyncio.get_event_loop().run_in_executor(
-                None,
-                lambda: client.models.generate_content(
-                    model='gemini-2.5-pro',
-                    contents=Part.from_uri(file_uri=media_file.uri, mime_type=media_file.mime_type),
-                    config=config,
-                ),
-            )
-
-            if not response.text:
-                raise RuntimeError('Empty response from Gemini API')
-
-            transcript = response.text.strip()
-
-            self.logger.info(f'✅ Transcription completed: {len(transcript)} characters')
-            return transcript
-
-        except ImportError:
-            raise RuntimeError('Google GenAI SDK not installed. Please install with: pip install google-genai')
-        except Exception as e:
-            self.logger.error(f'Gemini transcription failed: {str(e)}')
-            raise RuntimeError(f'Gemini transcription failed: {str(e)}')
-
-    def get_gem_info(self) -> dict:
-        """Get information about the Gem being used"""
-        return {
-            'gem_name': 'Audio Transcription Gem',
-            'gem_url': self.GEM_URL,
-            'model': 'Gemini 2.5 Pro',
-            'description': 'Specialized Gem for media content transcribe',
-        }