openconvert 0.1.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

openconvert/converter.py

@@ -1,152 +0,0 @@
-"""
-Main converter module that provides the open_convert function.
-"""
-
-import os
-import logging
-from pathlib import Path
-from typing import Optional, Union, List
-
-from .converters import (
-    image_converter,
-    document_converter,
-    audio_converter,
-    video_converter,
-    archive_converter,
-    model_converter,
-    code_converter
-)
-
-# Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-# Define conversion categories
-CONVERSION_CATEGORIES = {
-    # Image formats
-    'png': 'image', 'jpg': 'image', 'jpeg': 'image', 'bmp': 'image', 'tiff': 'image',
-    'gif': 'image', 'ico': 'image', 'svg': 'image', 'webp': 'image',
-    
-    # Document formats
-    'txt': 'document', 'pdf': 'document', 'docx': 'document', 'rtf': 'document',
-    'md': 'document', 'html': 'document', 'csv': 'document', 'xlsx': 'document',
-    'epub': 'document',
-    
-    # Audio formats
-    'mp3': 'audio', 'wav': 'audio', 'ogg': 'audio', 'flac': 'audio', 'aac': 'audio',
-    
-    # Video formats
-    'mp4': 'video', 'avi': 'video', 'mkv': 'video', 'mov': 'video',
-    
-    # Archive formats
-    'zip': 'archive', 'rar': 'archive', '7z': 'archive', 'tar': 'archive', 'gz': 'archive',
-    
-    # 3D Model formats
-    'stl': 'model', 'obj': 'model', 'fbx': 'model', 'ply': 'model',
-    
-    # Code and markup formats
-    'json': 'code', 'yaml': 'code', 'xml': 'code', 'latex': 'code'
-}
-
-def open_convert(
-    filepath: Union[str, Path],
-    source_format: Optional[str] = None,
-    target_format: str = None,
-    output_path: Optional[Union[str, Path]] = None,
-    options: Optional[dict] = None
-) -> str:
-    """
-    Convert a file from one format to another.
-    
-    Args:
-        filepath: Path to the source file
-        source_format: Source file format (if None, will be inferred from file extension)
-        target_format: Target file format
-        output_path: Path to save the converted file (if None, will use the same directory as source)
-        options: Additional conversion options
-        
-    Returns:
-        Path to the converted file
-    
-    Raises:
-        ValueError: If the conversion is not supported or parameters are invalid
-        FileNotFoundError: If the source file doesn't exist
-        RuntimeError: If the conversion fails
-    """
-    if options is None:
-        options = {}
-    
-    # Convert filepath to Path object
-    filepath = Path(filepath)
-    
-    # Check if file exists
-    if not filepath.exists():
-        raise FileNotFoundError(f"Source file not found: {filepath}")
-    
-    # Infer source format from file extension if not provided
-    if source_format is None:
-        source_format = filepath.suffix.lower().lstrip('.')
-        if not source_format:
-            raise ValueError("Could not determine source format from file extension. Please specify source_format.")
-    else:
-        source_format = source_format.lower()
-    
-    # Ensure target format is provided and lowercase
-    if target_format is None:
-        raise ValueError("Target format must be specified")
-    target_format = target_format.lower()
-    
-    # Check if formats are supported
-    if source_format not in CONVERSION_CATEGORIES:
-        raise ValueError(f"Unsupported source format: {source_format}")
-    if target_format not in CONVERSION_CATEGORIES:
-        raise ValueError(f"Unsupported target format: {target_format}")
-    
-    # Determine output path if not provided
-    if output_path is None:
-        output_path = filepath.with_suffix(f".{target_format}")
-    else:
-        output_path = Path(output_path)
-        # If output_path is a directory, use the original filename with new extension
-        if output_path.is_dir():
-            output_path = output_path / filepath.with_suffix(f".{target_format}").name
-    
-    logger.info(f"Converting {filepath} from {source_format} to {target_format}")
-    
-    # Determine conversion category and route to appropriate converter
-    source_category = CONVERSION_CATEGORIES[source_format]
-    target_category = CONVERSION_CATEGORIES[target_format]
-    
-    # Handle conversion based on categories
-    if source_category == 'image':
-        if target_category == 'image' or target_format == 'pdf':
-            return image_converter.convert(filepath, source_format, target_format, output_path, options)
-    
-    elif source_category == 'document':
-        return document_converter.convert(filepath, source_format, target_format, output_path, options)
-    
-    elif source_category == 'audio':
-        if target_category == 'audio':
-            return audio_converter.convert(filepath, source_format, target_format, output_path, options)
-        elif target_format == 'txt':  # Speech-to-text
-            return audio_converter.speech_to_text(filepath, output_path, options)
-    
-    elif source_category == 'video':
-        if target_category == 'video' or target_format == 'gif':
-            return video_converter.convert(filepath, source_format, target_format, output_path, options)
-        elif target_format == 'mp3':  # Audio extraction
-            return video_converter.extract_audio(filepath, output_path, options)
-        elif target_format in ['png', 'jpg']:  # Frame extraction
-            return video_converter.extract_frames(filepath, target_format, output_path, options)
-    
-    elif source_category == 'archive':
-        return archive_converter.convert(filepath, source_format, target_format, output_path, options)
-    
-    elif source_category == 'model':
-        return model_converter.convert(filepath, source_format, target_format, output_path, options)
-    
-    elif source_category == 'code':
-        return code_converter.convert(filepath, source_format, target_format, output_path, options)
-    
-    # If we get here, the specific conversion is not supported
-    raise ValueError(f"Conversion from {source_format} to {target_format} is not supported") 

openconvert/converters/__init__.py

@@ -1,3 +0,0 @@
-"""
-Converters package for handling different types of file conversions.
-""" 

openconvert/converters/archive_converter.py

@@ -1,277 +0,0 @@
-"""
-Archive converter module for handling archive format conversions.
-"""
-
-import logging
-import os
-import shutil
-import tempfile
-from pathlib import Path
-from typing import Union, Optional, Dict, Any
-
-logger = logging.getLogger(__name__)
-
-# Define supported conversions
-SUPPORTED_CONVERSIONS = {
-    'zip': ['rar', '7z', 'tar', 'gz'],
-    'rar': ['zip', '7z', 'tar', 'gz'],
-    '7z': ['zip', 'rar', 'tar', 'gz'],
-    'tar': ['zip', 'rar', '7z', 'gz'],
-    'gz': ['zip', 'rar', '7z', 'tar']
-}
-
-def convert(
-    filepath: Union[str, Path],
-    source_format: str,
-    target_format: str,
-    output_path: Union[str, Path],
-    options: Optional[Dict[str, Any]] = None
-) -> str:
-    """
-    Convert an archive from one format to another.
-    
-    Args:
-        filepath: Path to the source archive file
-        source_format: Source archive format
-        target_format: Target archive format
-        output_path: Path to save the converted archive
-        options: Additional conversion options
-        
-    Returns:
-        Path to the converted archive
-        
-    Raises:
-        ValueError: If the conversion is not supported
-        RuntimeError: If the conversion fails
-    """
-    if options is None:
-        options = {}
-    
-    # Check if conversion is supported
-    if target_format not in SUPPORTED_CONVERSIONS.get(source_format, []):
-        raise ValueError(f"Conversion from {source_format} to {target_format} is not supported")
-    
-    filepath = Path(filepath)
-    output_path = Path(output_path)
-    
-    try:
-        # Create a temporary directory for extraction
-        with tempfile.TemporaryDirectory() as temp_dir:
-            temp_dir_path = Path(temp_dir)
-            
-            # Extract the source archive
-            extract_dir = _extract_archive(filepath, source_format, temp_dir_path)
-            
-            # Create the target archive
-            return _create_archive(extract_dir, target_format, output_path, options)
-    
-    except Exception as e:
-        logger.error(f"Error converting {filepath} to {target_format}: {str(e)}")
-        raise RuntimeError(f"Failed to convert {filepath} to {target_format}: {str(e)}")
-
-def _extract_archive(
-    filepath: Path,
-    format: str,
-    output_dir: Path
-) -> Path:
-    """Extract an archive to a directory."""
-    if format == 'zip':
-        return _extract_zip(filepath, output_dir)
-    elif format == 'rar':
-        return _extract_rar(filepath, output_dir)
-    elif format == '7z':
-        return _extract_7z(filepath, output_dir)
-    elif format == 'tar':
-        return _extract_tar(filepath, output_dir)
-    elif format == 'gz':
-        return _extract_gz(filepath, output_dir)
-    else:
-        raise ValueError(f"Unsupported archive format for extraction: {format}")
-
-def _create_archive(
-    source_dir: Path,
-    format: str,
-    output_path: Path,
-    options: Dict[str, Any]
-) -> str:
-    """Create an archive from a directory."""
-    if format == 'zip':
-        return _create_zip(source_dir, output_path, options)
-    elif format == 'rar':
-        return _create_rar(source_dir, output_path, options)
-    elif format == '7z':
-        return _create_7z(source_dir, output_path, options)
-    elif format == 'tar':
-        return _create_tar(source_dir, output_path, options)
-    elif format == 'gz':
-        return _create_gz(source_dir, output_path, options)
-    else:
-        raise ValueError(f"Unsupported archive format for creation: {format}")
-
-def _extract_zip(filepath: Path, output_dir: Path) -> Path:
-    """Extract a ZIP archive."""
-    import zipfile
-    
-    with zipfile.ZipFile(filepath, 'r') as zip_ref:
-        zip_ref.extractall(output_dir)
-    
-    return output_dir
-
-def _extract_rar(filepath: Path, output_dir: Path) -> Path:
-    """Extract a RAR archive."""
-    try:
-        import rarfile
-        
-        with rarfile.RarFile(filepath) as rf:
-            rf.extractall(output_dir)
-        
-        return output_dir
-    
-    except ImportError:
-        # Try using unrar command-line tool
-        import subprocess
-        
-        try:
-            cmd = ['unrar', 'x', str(filepath), str(output_dir)]
-            subprocess.run(cmd, check=True, capture_output=True)
-            return output_dir
-        
-        except subprocess.SubprocessError as e:
-            raise RuntimeError(f"Failed to extract RAR archive: {str(e)}. Please install rarfile or unrar.")
-
-def _extract_7z(filepath: Path, output_dir: Path) -> Path:
-    """Extract a 7Z archive."""
-    try:
-        import py7zr
-        
-        with py7zr.SevenZipFile(filepath, mode='r') as z:
-            z.extractall(output_dir)
-        
-        return output_dir
-    
-    except ImportError:
-        # Try using 7z command-line tool
-        import subprocess
-        
-        try:
-            cmd = ['7z', 'x', str(filepath), f'-o{output_dir}']
-            subprocess.run(cmd, check=True, capture_output=True)
-            return output_dir
-        
-        except subprocess.SubprocessError as e:
-            raise RuntimeError(f"Failed to extract 7Z archive: {str(e)}. Please install py7zr or 7z.")
-
-def _extract_tar(filepath: Path, output_dir: Path) -> Path:
-    """Extract a TAR archive."""
-    import tarfile
-    
-    with tarfile.open(filepath, 'r') as tar:
-        tar.extractall(output_dir)
-    
-    return output_dir
-
-def _extract_gz(filepath: Path, output_dir: Path) -> Path:
-    """Extract a GZ archive."""
-    import gzip
-    import tarfile
-    
-    # Check if it's a tar.gz file
-    if filepath.name.endswith('.tar.gz') or filepath.name.endswith('.tgz'):
-        with tarfile.open(filepath, 'r:gz') as tar:
-            tar.extractall(output_dir)
-        return output_dir
-    
-    # Otherwise, it's a single gzipped file
-    with gzip.open(filepath, 'rb') as f_in:
-        output_file = output_dir / filepath.with_suffix('').name
-        with open(output_file, 'wb') as f_out:
-            shutil.copyfileobj(f_in, f_out)
-    
-    return output_dir
-
-def _create_zip(source_dir: Path, output_path: Path, options: Dict[str, Any]) -> str:
-    """Create a ZIP archive."""
-    import zipfile
-    
-    compression = options.get('compression', zipfile.ZIP_DEFLATED)
-    compression_level = options.get('compression_level', 9)  # 0-9, 9 is highest
-    
-    with zipfile.ZipFile(output_path, 'w', compression=compression, compresslevel=compression_level) as zipf:
-        for root, _, files in os.walk(source_dir):
-            for file in files:
-                file_path = Path(root) / file
-                arcname = file_path.relative_to(source_dir)
-                zipf.write(file_path, arcname)
-    
-    return str(output_path)
-
-def _create_rar(source_dir: Path, output_path: Path, options: Dict[str, Any]) -> str:
-    """Create a RAR archive."""
-    # RAR creation requires command-line tool
-    import subprocess
-    
-    try:
-        # Determine compression level
-        compression_level = options.get('compression_level', 5)  # 0-5, 5 is highest
-        
-        cmd = ['rar', f'a{compression_level}', str(output_path), str(source_dir)]
-        subprocess.run(cmd, check=True, capture_output=True)
-        return str(output_path)
-    
-    except subprocess.SubprocessError as e:
-        raise RuntimeError(f"Failed to create RAR archive: {str(e)}. Please install rar command-line tool.")
-
-def _create_7z(source_dir: Path, output_path: Path, options: Dict[str, Any]) -> str:
-    """Create a 7Z archive."""
-    try:
-        import py7zr
-        
-        compression_level = options.get('compression_level', 9)  # 0-9, 9 is highest
-        
-        with py7zr.SevenZipFile(output_path, 'w', compression_level=compression_level) as z:
-            z.writeall(source_dir)
-        
-        return str(output_path)
-    
-    except ImportError:
-        # Try using 7z command-line tool
-        import subprocess
-        
-        try:
-            compression_level = options.get('compression_level', 9)  # 0-9, 9 is highest
-            
-            cmd = ['7z', 'a', f'-mx={compression_level}', str(output_path), f'{source_dir}/*']
-            subprocess.run(cmd, check=True, capture_output=True, shell=True)
-            return str(output_path)
-        
-        except subprocess.SubprocessError as e:
-            raise RuntimeError(f"Failed to create 7Z archive: {str(e)}. Please install py7zr or 7z.")
-
-def _create_tar(source_dir: Path, output_path: Path, options: Dict[str, Any]) -> str:
-    """Create a TAR archive."""
-    import tarfile
-    
-    with tarfile.open(output_path, 'w') as tar:
-        tar.add(source_dir, arcname=os.path.basename(source_dir))
-    
-    return str(output_path)
-
-def _create_gz(source_dir: Path, output_path: Path, options: Dict[str, Any]) -> str:
-    """Create a GZ archive."""
-    import tarfile
-    
-    # If there are multiple files, create a tar.gz
-    files = list(source_dir.glob('*'))
-    if len(files) > 1 or any(f.is_dir() for f in files):
-        with tarfile.open(output_path, 'w:gz') as tar:
-            tar.add(source_dir, arcname='')
-    else:
-        # If there's only one file, create a simple .gz
-        import gzip
-        
-        input_file = files[0]
-        with open(input_file, 'rb') as f_in:
-            with gzip.open(output_path, 'wb') as f_out:
-                shutil.copyfileobj(f_in, f_out)
-    
-    return str(output_path) 

openconvert/converters/audio_converter.py

@@ -1,223 +0,0 @@
-"""
-Audio converter module for handling audio format conversions.
-"""
-
-import logging
-import os
-import tempfile
-from pathlib import Path
-from typing import Union, Optional, Dict, Any
-
-logger = logging.getLogger(__name__)
-
-# Define supported conversions
-SUPPORTED_CONVERSIONS = {
-    'mp3': ['wav', 'ogg', 'flac', 'aac'],
-    'wav': ['mp3', 'ogg', 'flac', 'aac'],
-    'ogg': ['mp3', 'wav', 'flac', 'aac'],
-    'flac': ['mp3', 'wav', 'ogg', 'aac'],
-    'aac': ['mp3', 'wav', 'ogg', 'flac']
-}
-
-def convert(
-    filepath: Union[str, Path],
-    source_format: str,
-    target_format: str,
-    output_path: Union[str, Path],
-    options: Optional[Dict[str, Any]] = None
-) -> str:
-    """
-    Convert an audio file from one format to another.
-    
-    Args:
-        filepath: Path to the source audio file
-        source_format: Source audio format
-        target_format: Target audio format
-        output_path: Path to save the converted audio
-        options: Additional conversion options
-        
-    Returns:
-        Path to the converted audio
-        
-    Raises:
-        ValueError: If the conversion is not supported
-        RuntimeError: If the conversion fails
-    """
-    if options is None:
-        options = {}
-    
-    # Check if conversion is supported
-    if target_format not in SUPPORTED_CONVERSIONS.get(source_format, []):
-        raise ValueError(f"Conversion from {source_format} to {target_format} is not supported")
-    
-    filepath = Path(filepath)
-    output_path = Path(output_path)
-    
-    try:
-        # Try using pydub for audio conversion
-        return _convert_with_pydub(filepath, source_format, target_format, output_path, options)
-    except ImportError:
-        logger.warning("pydub not installed. Trying alternative method...")
-        
-        # Try using ffmpeg directly
-        return _convert_with_ffmpeg(filepath, source_format, target_format, output_path, options)
-
-def speech_to_text(
-    filepath: Union[str, Path],
-    output_path: Union[str, Path],
-    options: Optional[Dict[str, Any]] = None
-) -> str:
-    """
-    Convert speech audio to text.
-    
-    Args:
-        filepath: Path to the source audio file
-        output_path: Path to save the text file
-        options: Additional conversion options
-        
-    Returns:
-        Path to the text file
-        
-    Raises:
-        RuntimeError: If the conversion fails
-    """
-    if options is None:
-        options = {}
-    
-    filepath = Path(filepath)
-    output_path = Path(output_path)
-    
-    try:
-        # Try using SpeechRecognition library
-        import speech_recognition as sr
-        
-        # Initialize recognizer
-        recognizer = sr.Recognizer()
-        
-        # Load the audio file
-        with sr.AudioFile(str(filepath)) as source:
-            # Adjust for ambient noise
-            recognizer.adjust_for_ambient_noise(source)
-            
-            # Record the audio
-            audio_data = recognizer.record(source)
-            
-            # Recognize speech using Google Speech Recognition
-            language = options.get('language', 'en-US')
-            text = recognizer.recognize_google(audio_data, language=language)
-            
-            # Write the text to the output file
-            with open(output_path, 'w', encoding='utf-8') as f:
-                f.write(text)
-            
-            return str(output_path)
-    
-    except ImportError:
-        logger.error("SpeechRecognition library is required for speech-to-text conversion")
-        raise RuntimeError("SpeechRecognition library is required for speech-to-text conversion. Please install it.")
-    
-    except Exception as e:
-        logger.error(f"Error in speech-to-text conversion: {str(e)}")
-        raise RuntimeError(f"Failed to convert speech to text: {str(e)}")
-
-def _convert_with_pydub(
-    filepath: Path,
-    source_format: str,
-    target_format: str,
-    output_path: Path,
-    options: Dict[str, Any]
-) -> str:
-    """Convert audio using pydub library."""
-    from pydub import AudioSegment
-    
-    # Load the audio file
-    audio = AudioSegment.from_file(str(filepath), format=source_format)
-    
-    # Apply audio processing options
-    if 'volume' in options:
-        # Adjust volume (in dB)
-        audio = audio + options['volume']
-    
-    if 'speed' in options:
-        # Change speed (requires ffmpeg with rubberband)
-        speed = options['speed']
-        audio = audio._spawn(audio.raw_data, overrides={
-            "frame_rate": int(audio.frame_rate * speed)
-        })
-    
-    if 'sample_rate' in options:
-        # Change sample rate
-        audio = audio.set_frame_rate(options['sample_rate'])
-    
-    if 'channels' in options:
-        # Change number of channels
-        if options['channels'] == 1:
-            audio = audio.set_channels(1)
-        elif options['channels'] == 2:
-            audio = audio.set_channels(2)
-    
-    if 'trim' in options:
-        # Trim audio (start_ms, end_ms)
-        start_ms, end_ms = options['trim']
-        audio = audio[start_ms:end_ms]
-    
-    # Set export parameters
-    export_params = {}
-    
-    if 'bitrate' in options:
-        export_params['bitrate'] = options['bitrate']
-    
-    # Export to target format
-    audio.export(str(output_path), format=target_format, **export_params)
-    
-    return str(output_path)
-
-def _convert_with_ffmpeg(
-    filepath: Path,
-    source_format: str,
-    target_format: str,
-    output_path: Path,
-    options: Dict[str, Any]
-) -> str:
-    """Convert audio using ffmpeg directly."""
-    import subprocess
-    
-    # Basic ffmpeg command
-    cmd = ['ffmpeg', '-i', str(filepath)]
-    
-    # Add options
-    if 'volume' in options:
-        # Volume adjustment in dB
-        cmd.extend(['-filter:a', f'volume={options["volume"]}dB'])
-    
-    if 'speed' in options:
-        # Speed adjustment
-        cmd.extend(['-filter:a', f'atempo={options["speed"]}'])
-    
-    if 'sample_rate' in options:
-        # Sample rate
-        cmd.extend(['-ar', str(options['sample_rate'])])
-    
-    if 'channels' in options:
-        # Number of channels
-        cmd.extend(['-ac', str(options['channels'])])
-    
-    if 'bitrate' in options:
-        # Bitrate
-        cmd.extend(['-b:a', options['bitrate']])
-    
-    if 'trim' in options:
-        # Trim (start_seconds, duration_seconds)
-        start_sec, duration_sec = options['trim']
-        cmd.extend(['-ss', str(start_sec), '-t', str(duration_sec)])
-    
-    # Add output file
-    cmd.append(str(output_path))
-    
-    # Run ffmpeg
-    try:
-        subprocess.run(cmd, check=True, capture_output=True)
-        return str(output_path)
-    except subprocess.SubprocessError as e:
-        logger.error(f"Error running ffmpeg: {str(e)}")
-        raise RuntimeError(f"Failed to convert audio with ffmpeg: {str(e)}")