openconvert 0.1.0__py3-none-any.whl

openconvert/converters/image_converter.py

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

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

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