openconvert 0.1.0__py3-none-any.whl

openconvert/__init__.py

@@ -0,0 +1,7 @@
+"""
+OpenConvert - A versatile file conversion library
+"""
+
+__version__ = '0.1.0'
+
+from .converter import open_convert 

openconvert/cli.py

@@ -0,0 +1,145 @@
+"""
+Command-line interface for AGConvert.
+"""
+
+import argparse
+import json
+import logging
+import os
+import sys
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+from . import __version__
+from .converter import open_convert
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+def parse_args() -> argparse.Namespace:
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(
+        description="AGConvert - A versatile file and data conversion tool",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  agconvert image.png image.jpg                # Convert PNG to JPG
+  agconvert document.docx document.pdf         # Convert DOCX to PDF
+  agconvert audio.mp3 audio.wav                # Convert MP3 to WAV
+  agconvert video.mp4 video.gif                # Convert MP4 to GIF
+  agconvert data.json data.yaml                # Convert JSON to YAML
+  agconvert --options '{"quality": 90}' image.png image.jpg  # With options
+"""
+    )
+    
+    parser.add_argument(
+        "input_file",
+        help="Path to the input file"
+    )
+    
+    parser.add_argument(
+        "output_file",
+        help="Path to the output file"
+    )
+    
+    parser.add_argument(
+        "--source-format",
+        help="Source file format (if not specified, will be inferred from input file extension)"
+    )
+    
+    parser.add_argument(
+        "--target-format",
+        help="Target file format (if not specified, will be inferred from output file extension)"
+    )
+    
+    parser.add_argument(
+        "--options",
+        help="Additional conversion options as JSON string",
+        default="{}"
+    )
+    
+    parser.add_argument(
+        "--verbose", "-v",
+        action="store_true",
+        help="Enable verbose output"
+    )
+    
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"AGConvert {__version__}"
+    )
+    
+    return parser.parse_args()
+
+def parse_options(options_str: str) -> Dict[str, Any]:
+    """Parse options from JSON string."""
+    try:
+        return json.loads(options_str)
+    except json.JSONDecodeError as e:
+        logger.error(f"Error parsing options: {str(e)}")
+        logger.error("Options must be a valid JSON string")
+        sys.exit(1)
+
+def infer_format(filepath: str) -> str:
+    """Infer file format from file extension."""
+    ext = os.path.splitext(filepath)[1].lower().lstrip('.')
+    
+    # Handle special cases
+    if ext == 'jpeg':
+        return 'jpg'
+    elif ext == 'tif':
+        return 'tiff'
+    elif ext == 'yml':
+        return 'yaml'
+    elif ext == 'htm':
+        return 'html'
+    elif ext == 'markdown':
+        return 'md'
+    elif ext == 'tex':
+        return 'latex'
+    
+    return ext
+
+def main() -> None:
+    """Main entry point for the CLI."""
+    args = parse_args()
+    
+    # Set logging level
+    if args.verbose:
+        logging.getLogger().setLevel(logging.DEBUG)
+    
+    # Parse options
+    options = parse_options(args.options)
+    
+    # Infer formats if not specified
+    source_format = args.source_format or infer_format(args.input_file)
+    target_format = args.target_format or infer_format(args.output_file)
+    
+    if not source_format:
+        logger.error("Could not determine source format. Please specify --source-format")
+        sys.exit(1)
+    
+    if not target_format:
+        logger.error("Could not determine target format. Please specify --target-format")
+        sys.exit(1)
+    
+    try:
+        # Perform the conversion
+        output_path = open_convert(
+            filepath=args.input_file,
+            source_format=source_format,
+            target_format=target_format,
+            output_path=args.output_file,
+            options=options
+        )
+        
+        logger.info(f"Conversion successful: {args.input_file} → {output_path}")
+    
+    except Exception as e:
+        logger.error(f"Conversion failed: {str(e)}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main() 

openconvert/converter.py

@@ -0,0 +1,152 @@
+"""
+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

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

openconvert/converters/archive_converter.py

@@ -0,0 +1,277 @@
+"""
+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)