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

openconvert/converters/image_converter.py

@@ -1,214 +0,0 @@
-"""
-Image converter module for handling image format conversions.
-"""
-
-import logging
-from pathlib import Path
-from typing import Union, Optional, Dict, Any
-
-logger = logging.getLogger(__name__)
-
-# Define supported conversions
-SUPPORTED_CONVERSIONS = {
-    'png': ['jpg', 'jpeg', 'bmp', 'tiff', 'gif', 'pdf', 'ico', 'svg', 'webp'],
-    'jpg': ['png', 'bmp', 'tiff', 'gif', 'pdf', 'ico', 'svg', 'webp'],
-    'jpeg': ['png', 'bmp', 'tiff', 'gif', 'pdf', 'ico', 'svg', 'webp'],
-    'bmp': ['png', 'jpg', 'tiff', 'gif', 'pdf', 'ico', 'webp'],
-    'gif': ['png', 'jpg', 'bmp', 'tiff', 'pdf', 'ico', 'webp'],
-    'tiff': ['png', 'jpg', 'bmp', 'gif', 'pdf', 'webp'],
-    'ico': ['png', 'jpg', 'bmp', 'tiff', 'gif', 'webp'],
-    'svg': ['png', 'jpg', 'bmp', 'tiff', 'pdf', 'webp'],
-    'webp': ['png', 'jpg', 'bmp', 'tiff', 'gif', 'pdf']
-}
-
-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 image from one format to another.
-    
-    Args:
-        filepath: Path to the source image file
-        source_format: Source image format
-        target_format: Target image format
-        output_path: Path to save the converted image
-        options: Additional conversion options
-        
-    Returns:
-        Path to the converted image
-        
-    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:
-        # Use Pillow for most image conversions
-        from PIL import Image
-        
-        # Special handling for SVG conversions
-        if source_format == 'svg':
-            if target_format in ['png', 'jpg', 'jpeg', 'bmp', 'tiff', 'webp']:
-                return _convert_svg_to_raster(filepath, target_format, output_path, options)
-            elif target_format == 'pdf':
-                return _convert_svg_to_pdf(filepath, output_path, options)
-        
-        # Special handling for PDF output
-        if target_format == 'pdf':
-            return _convert_to_pdf(filepath, source_format, output_path, options)
-        
-        # Standard image conversion using Pillow
-        with Image.open(filepath) as img:
-            # Apply any image processing options
-            if 'resize' in options:
-                width, height = options['resize']
-                img = img.resize((width, height), Image.LANCZOS)
-            
-            if 'rotate' in options:
-                img = img.rotate(options['rotate'])
-            
-            # Convert palette mode (P) to RGB for formats that don't support it
-            if img.mode == 'P' and target_format in ['jpg', 'jpeg']:
-                img = img.convert('RGB')
-            
-            if 'quality' in options and target_format in ['jpg', 'jpeg', 'webp']:
-                img.save(output_path, quality=options['quality'])
-            else:
-                img.save(output_path)
-        
-        logger.info(f"Successfully converted {filepath} to {output_path}")
-        return str(output_path)
-    
-    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 _convert_svg_to_raster(
-    filepath: Path,
-    target_format: str,
-    output_path: Path,
-    options: Dict[str, Any]
-) -> str:
-    """Convert SVG to raster formats like PNG, JPG, etc."""
-    try:
-        # Try using cairosvg for SVG conversion
-        import cairosvg
-        
-        width = options.get('width', 800)
-        height = options.get('height', 600)
-        
-        if target_format == 'png':
-            cairosvg.svg2png(url=str(filepath), write_to=str(output_path), 
-                             width=width, height=height)
-        elif target_format in ['jpg', 'jpeg']:
-            # Convert to PNG first, then to JPG
-            temp_png = output_path.with_suffix('.png')
-            cairosvg.svg2png(url=str(filepath), write_to=str(temp_png), 
-                             width=width, height=height)
-            
-            from PIL import Image
-            with Image.open(temp_png) as img:
-                img.convert('RGB').save(output_path, quality=options.get('quality', 90))
-            
-            # Remove temporary PNG
-            temp_png.unlink()
-        else:
-            # For other formats, convert to PNG first, then use Pillow
-            temp_png = output_path.with_suffix('.png')
-            cairosvg.svg2png(url=str(filepath), write_to=str(temp_png), 
-                             width=width, height=height)
-            
-            from PIL import Image
-            with Image.open(temp_png) as img:
-                img.save(output_path)
-            
-            # Remove temporary PNG
-            temp_png.unlink()
-        
-        return str(output_path)
-    
-    except ImportError:
-        logger.warning("cairosvg not installed. Trying alternative method...")
-        
-        # Try using Inkscape as a fallback
-        try:
-            import subprocess
-            
-            cmd = [
-                'inkscape',
-                '--export-filename', str(output_path),
-                str(filepath)
-            ]
-            
-            subprocess.run(cmd, check=True)
-            return str(output_path)
-        
-        except (ImportError, subprocess.SubprocessError) as e:
-            raise RuntimeError(f"Failed to convert SVG: {str(e)}. Please install cairosvg or Inkscape.")
-
-def _convert_svg_to_pdf(
-    filepath: Path,
-    output_path: Path,
-    options: Dict[str, Any]
-) -> str:
-    """Convert SVG to PDF."""
-    try:
-        # Try using cairosvg
-        import cairosvg
-        cairosvg.svg2pdf(url=str(filepath), write_to=str(output_path))
-        return str(output_path)
-    
-    except ImportError:
-        logger.warning("cairosvg not installed. Trying alternative method...")
-        
-        # Try using Inkscape as a fallback
-        try:
-            import subprocess
-            
-            cmd = [
-                'inkscape',
-                '--export-filename', str(output_path),
-                str(filepath)
-            ]
-            
-            subprocess.run(cmd, check=True)
-            return str(output_path)
-        
-        except (ImportError, subprocess.SubprocessError) as e:
-            raise RuntimeError(f"Failed to convert SVG to PDF: {str(e)}. Please install cairosvg or Inkscape.")
-
-def _convert_to_pdf(
-    filepath: Path,
-    source_format: str,
-    output_path: Path,
-    options: Dict[str, Any]
-) -> str:
-    """Convert image to PDF."""
-    from PIL import Image
-    
-    try:
-        with Image.open(filepath) as img:
-            # Convert to RGB if needed
-            if img.mode == 'RGBA':
-                img = img.convert('RGB')
-            
-            img.save(output_path, 'PDF', resolution=options.get('dpi', 100))
-        
-        return str(output_path)
-    
-    except Exception as e:
-        logger.error(f"Error converting to PDF: {str(e)}")
-        raise RuntimeError(f"Failed to convert to PDF: {str(e)}") 

openconvert/converters/model_converter.py

@@ -1,208 +0,0 @@
-"""
-3D model converter module for handling 3D model 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 = {
-    'stl': ['obj', 'fbx', 'ply'],
-    'obj': ['stl', 'fbx', 'ply'],
-    'fbx': ['stl', 'obj', 'ply'],
-    'ply': ['stl', 'obj', 'fbx']
-}
-
-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 a 3D model from one format to another.
-    
-    Args:
-        filepath: Path to the source model file
-        source_format: Source model format
-        target_format: Target model format
-        output_path: Path to save the converted model
-        options: Additional conversion options
-        
-    Returns:
-        Path to the converted model
-        
-    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 trimesh for model conversion
-        return _convert_with_trimesh(filepath, source_format, target_format, output_path, options)
-    
-    except ImportError:
-        logger.warning("trimesh not installed. Trying alternative method...")
-        
-        # Try using Blender for conversion
-        return _convert_with_blender(filepath, source_format, target_format, output_path, options)
-
-def _convert_with_trimesh(
-    filepath: Path,
-    source_format: str,
-    target_format: str,
-    output_path: Path,
-    options: Dict[str, Any]
-) -> str:
-    """Convert 3D model using trimesh library."""
-    import trimesh
-    
-    # Load the model
-    mesh = trimesh.load(str(filepath))
-    
-    # Apply transformations if specified
-    if 'scale' in options:
-        scale = options['scale']
-        if isinstance(scale, (int, float)):
-            # Uniform scaling
-            mesh.apply_scale(scale)
-        elif isinstance(scale, (list, tuple)) and len(scale) == 3:
-            # Non-uniform scaling
-            mesh.apply_scale(scale)
-    
-    if 'rotation' in options:
-        # Rotation in degrees around x, y, z axes
-        import numpy as np
-        from scipy.spatial.transform import Rotation as R
-        
-        rotation = options['rotation']
-        if isinstance(rotation, (list, tuple)) and len(rotation) == 3:
-            # Convert degrees to radians
-            rotation_rad = [np.radians(r) for r in rotation]
-            r = R.from_euler('xyz', rotation_rad)
-            mesh.apply_transform(np.eye(4))
-            mesh.apply_transform(np.vstack((np.hstack((r.as_matrix(), np.zeros((3, 1)))), [0, 0, 0, 1])))
-    
-    if 'translation' in options:
-        # Translation along x, y, z axes
-        translation = options['translation']
-        if isinstance(translation, (list, tuple)) and len(translation) == 3:
-            mesh.apply_translation(translation)
-    
-    # Export to target format
-    export_options = {}
-    
-    if target_format == 'stl' and 'ascii' in options:
-        export_options['file_type'] = 'ascii' if options['ascii'] else 'binary'
-    
-    mesh.export(str(output_path), file_type=target_format, **export_options)
-    
-    return str(output_path)
-
-def _convert_with_blender(
-    filepath: Path,
-    source_format: str,
-    target_format: str,
-    output_path: Path,
-    options: Dict[str, Any]
-) -> str:
-    """Convert 3D model using Blender."""
-    import subprocess
-    import tempfile
-    
-    # Create a temporary Python script for Blender
-    with tempfile.NamedTemporaryFile(suffix='.py', mode='w', delete=False) as script_file:
-        script_path = script_file.name
-        
-        # Write Blender Python script
-        script_file.write(f"""
-import bpy
-import os
-import math
-
-# Clear existing objects
-bpy.ops.object.select_all(action='SELECT')
-bpy.ops.object.delete()
-
-# Import the model
-if '{source_format}' == 'stl':
-    bpy.ops.import_mesh.stl(filepath='{filepath}')
-elif '{source_format}' == 'obj':
-    bpy.ops.import_scene.obj(filepath='{filepath}')
-elif '{source_format}' == 'fbx':
-    bpy.ops.import_scene.fbx(filepath='{filepath}')
-elif '{source_format}' == 'ply':
-    bpy.ops.import_mesh.ply(filepath='{filepath}')
-
-# Select all objects
-bpy.ops.object.select_all(action='SELECT')
-
-# Apply transformations
-""")
-        
-        # Add transformation code if options are provided
-        if 'scale' in options:
-            scale = options['scale']
-            if isinstance(scale, (int, float)):
-                script_file.write(f"bpy.ops.transform.resize(value=({scale}, {scale}, {scale}))\n")
-            elif isinstance(scale, (list, tuple)) and len(scale) == 3:
-                script_file.write(f"bpy.ops.transform.resize(value=({scale[0]}, {scale[1]}, {scale[2]}))\n")
-        
-        if 'rotation' in options:
-            rotation = options['rotation']
-            if isinstance(rotation, (list, tuple)) and len(rotation) == 3:
-                script_file.write(f"""
-bpy.ops.transform.rotate(value={math.radians(rotation[0])}, orient_axis='X')
-bpy.ops.transform.rotate(value={math.radians(rotation[1])}, orient_axis='Y')
-bpy.ops.transform.rotate(value={math.radians(rotation[2])}, orient_axis='Z')
-""")
-        
-        if 'translation' in options:
-            translation = options['translation']
-            if isinstance(translation, (list, tuple)) and len(translation) == 3:
-                script_file.write(f"bpy.ops.transform.translate(value=({translation[0]}, {translation[1]}, {translation[2]}))\n")
-        
-        # Add export code
-        script_file.write(f"""
-# Export the model
-if '{target_format}' == 'stl':
-    bpy.ops.export_mesh.stl(filepath='{output_path}', {'ascii=True' if options.get('ascii', False) else ''})
-elif '{target_format}' == 'obj':
-    bpy.ops.export_scene.obj(filepath='{output_path}')
-elif '{target_format}' == 'fbx':
-    bpy.ops.export_scene.fbx(filepath='{output_path}')
-elif '{target_format}' == 'ply':
-    bpy.ops.export_mesh.ply(filepath='{output_path}')
-""")
-    
-    try:
-        # Run Blender with the script
-        cmd = ['blender', '--background', '--python', script_path]
-        subprocess.run(cmd, check=True, capture_output=True)
-        
-        # Clean up the temporary script
-        os.unlink(script_path)
-        
-        return str(output_path)
-    
-    except subprocess.SubprocessError as e:
-        # Clean up the temporary script
-        os.unlink(script_path)
-        
-        logger.error(f"Error running Blender: {str(e)}")
-        raise RuntimeError(f"Failed to convert model with Blender: {str(e)}. Please install Blender.") 

openconvert/converters/video_converter.py

@@ -1,259 +0,0 @@
-"""
-Video converter module for handling video 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 = {
-    'mp4': ['avi', 'mkv', 'mov', 'gif'],
-    'avi': ['mp4', 'mkv', 'mov', 'gif'],
-    'mkv': ['mp4', 'avi', 'mov'],
-    'mov': ['mp4', 'avi', 'mkv'],
-    'gif': ['mp4', 'avi']
-}
-
-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 a video file from one format to another.
-    
-    Args:
-        filepath: Path to the source video file
-        source_format: Source video format
-        target_format: Target video format
-        output_path: Path to save the converted video
-        options: Additional conversion options
-        
-    Returns:
-        Path to the converted video
-        
-    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:
-        # Use ffmpeg for video conversion
-        return _convert_with_ffmpeg(filepath, source_format, 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_audio(
-    filepath: Union[str, Path],
-    output_path: Union[str, Path],
-    options: Optional[Dict[str, Any]] = None
-) -> str:
-    """
-    Extract audio from a video file.
-    
-    Args:
-        filepath: Path to the source video file
-        output_path: Path to save the extracted audio
-        options: Additional extraction options
-        
-    Returns:
-        Path to the extracted audio
-        
-    Raises:
-        RuntimeError: If the extraction fails
-    """
-    if options is None:
-        options = {}
-    
-    filepath = Path(filepath)
-    output_path = Path(output_path)
-    
-    try:
-        import subprocess
-        
-        # Basic ffmpeg command for audio extraction
-        cmd = ['ffmpeg', '-i', str(filepath), '-vn']  # -vn means no video
-        
-        # Add audio options
-        if 'audio_codec' in options:
-            cmd.extend(['-acodec', options['audio_codec']])
-        else:
-            cmd.extend(['-acodec', 'libmp3lame'])  # Default to MP3
-        
-        if 'bitrate' in options:
-            cmd.extend(['-b:a', options['bitrate']])
-        else:
-            cmd.extend(['-b:a', '192k'])  # Default bitrate
-        
-        if 'sample_rate' in options:
-            cmd.extend(['-ar', str(options['sample_rate'])])
-        
-        if 'channels' in options:
-            cmd.extend(['-ac', str(options['channels'])])
-        
-        # Add output file
-        cmd.append(str(output_path))
-        
-        # Run ffmpeg
-        subprocess.run(cmd, check=True, capture_output=True)
-        return str(output_path)
-    
-    except Exception as e:
-        logger.error(f"Error extracting audio: {str(e)}")
-        raise RuntimeError(f"Failed to extract audio: {str(e)}")
-
-def extract_frames(
-    filepath: Union[str, Path],
-    target_format: str,
-    output_path: Union[str, Path],
-    options: Optional[Dict[str, Any]] = None
-) -> str:
-    """
-    Extract frames from a video file.
-    
-    Args:
-        filepath: Path to the source video file
-        target_format: Target image format (png or jpg)
-        output_path: Path to save the extracted frames
-        options: Additional extraction options
-        
-    Returns:
-        Path to the directory containing extracted frames
-        
-    Raises:
-        ValueError: If the target format is not supported
-        RuntimeError: If the extraction fails
-    """
-    if options is None:
-        options = {}
-    
-    if target_format not in ['png', 'jpg', 'jpeg']:
-        raise ValueError(f"Unsupported frame format: {target_format}")
-    
-    filepath = Path(filepath)
-    output_path = Path(output_path)
-    
-    # If output_path is a file, use its parent directory and name as prefix
-    if output_path.suffix:
-        output_dir = output_path.parent
-        output_prefix = output_path.stem
-    else:
-        # If output_path is a directory, use it as is
-        output_dir = output_path
-        output_prefix = 'frame'
-    
-    # Create output directory if it doesn't exist
-    os.makedirs(output_dir, exist_ok=True)
-    
-    try:
-        import subprocess
-        
-        # Get frame rate for extraction
-        fps = options.get('fps', 1)  # Default: 1 frame per second
-        
-        # Determine output pattern
-        output_pattern = str(output_dir / f"{output_prefix}_%04d.{target_format}")
-        
-        # Basic ffmpeg command for frame extraction
-        cmd = ['ffmpeg', '-i', str(filepath)]
-        
-        if 'start_time' in options:
-            cmd.extend(['-ss', str(options['start_time'])])
-        
-        if 'duration' in options:
-            cmd.extend(['-t', str(options['duration'])])
-        
-        # Set frame rate
-        cmd.extend(['-vf', f'fps={fps}'])
-        
-        # Set quality
-        if target_format in ['jpg', 'jpeg']:
-            quality = options.get('quality', 95)
-            cmd.extend(['-q:v', str(int(quality / 10))])  # ffmpeg uses 1-10 scale
-        
-        # Add output pattern
-        cmd.append(output_pattern)
-        
-        # Run ffmpeg
-        subprocess.run(cmd, check=True, capture_output=True)
-        return str(output_dir)
-    
-    except Exception as e:
-        logger.error(f"Error extracting frames: {str(e)}")
-        raise RuntimeError(f"Failed to extract frames: {str(e)}")
-
-def _convert_with_ffmpeg(
-    filepath: Path,
-    source_format: str,
-    target_format: str,
-    output_path: Path,
-    options: Dict[str, Any]
-) -> str:
-    """Convert video using ffmpeg."""
-    import subprocess
-    
-    # Basic ffmpeg command
-    cmd = ['ffmpeg', '-i', str(filepath)]
-    
-    # Special handling for GIF output
-    if target_format == 'gif':
-        # Optimize for GIF output
-        scale = options.get('scale', 320)
-        fps = options.get('fps', 10)
-        cmd.extend([
-            '-vf', f'fps={fps},scale={scale}:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse'
-        ])
-    else:
-        # Add video options
-        if 'video_codec' in options:
-            cmd.extend(['-c:v', options['video_codec']])
-        
-        if 'audio_codec' in options:
-            cmd.extend(['-c:a', options['audio_codec']])
-        
-        if 'bitrate' in options:
-            cmd.extend(['-b:v', options['bitrate']])
-        
-        if 'resolution' in options:
-            width, height = options['resolution']
-            cmd.extend(['-s', f'{width}x{height}'])
-        
-        if 'framerate' in options:
-            cmd.extend(['-r', str(options['framerate'])])
-        
-        if 'crf' in options:
-            # Constant Rate Factor (quality)
-            cmd.extend(['-crf', str(options['crf'])])
-        
-        if 'preset' in options:
-            # Encoding preset (slower = better compression)
-            cmd.extend(['-preset', options['preset']])
-    
-    # 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 video with ffmpeg: {str(e)}")