openconvert 0.1.0__py3-none-any.whl

openconvert/converters/audio_converter.py

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

openconvert/converters/code_converter.py

@@ -0,0 +1,412 @@
+"""
+Code and markup converter module for handling code and markup 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 = {
+    'json': ['xml', 'yaml', 'csv', 'txt'],
+    'yaml': ['json', 'xml', 'txt'],
+    'xml': ['json', 'yaml', 'txt'],
+    'html': ['md', 'txt', 'pdf'],
+    'md': ['html', 'txt', 'pdf'],
+    'latex': ['pdf', 'docx', 'html']
+}
+
+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 code or markup from one format to another.
+    
+    Args:
+        filepath: Path to the source file
+        source_format: Source format
+        target_format: Target format
+        output_path: Path to save the converted file
+        options: Additional conversion options
+        
+    Returns:
+        Path to the converted file
+        
+    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:
+        # Route to appropriate conversion method
+        if source_format == 'json':
+            return _convert_from_json(filepath, target_format, output_path, options)
+        elif source_format == 'yaml':
+            return _convert_from_yaml(filepath, target_format, output_path, options)
+        elif source_format == 'xml':
+            return _convert_from_xml(filepath, target_format, output_path, options)
+        elif source_format == 'html':
+            return _convert_from_html(filepath, target_format, output_path, options)
+        elif source_format == 'md':
+            return _convert_from_md(filepath, target_format, output_path, options)
+        elif source_format == 'latex':
+            return _convert_from_latex(filepath, target_format, output_path, options)
+        else:
+            raise ValueError(f"Unsupported source format: {source_format}")
+    
+    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_from_json(
+    filepath: Path,
+    target_format: str,
+    output_path: Path,
+    options: Dict[str, Any]
+) -> str:
+    """Convert from JSON to other formats."""
+    import json
+    
+    # Read the JSON file
+    with open(filepath, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    
+    if target_format == 'xml':
+        try:
+            import dicttoxml
+            
+            # Convert to XML
+            xml = dicttoxml.dicttoxml(data, custom_root=options.get('root_name', 'root'), attr_type=False)
+            
+            # Write to file
+            with open(output_path, 'wb') as f:
+                f.write(xml)
+        
+        except ImportError:
+            raise RuntimeError("dicttoxml library is required for JSON to XML conversion. Please install it.")
+    
+    elif target_format == 'yaml':
+        try:
+            import yaml
+            
+            # Convert to YAML
+            with open(output_path, 'w', encoding='utf-8') as f:
+                yaml.dump(data, f, default_flow_style=False, sort_keys=False)
+        
+        except ImportError:
+            raise RuntimeError("PyYAML library is required for JSON to YAML conversion. Please install it.")
+    
+    elif target_format == 'csv':
+        try:
+            import csv
+            
+            # Check if the JSON is a list of dictionaries (suitable for CSV)
+            if not isinstance(data, list) or not all(isinstance(item, dict) for item in data):
+                raise ValueError("JSON must be a list of dictionaries to convert to CSV")
+            
+            # Get all unique keys as CSV headers
+            headers = set()
+            for item in data:
+                headers.update(item.keys())
+            headers = sorted(headers)
+            
+            # Write to CSV
+            with open(output_path, 'w', encoding='utf-8', newline='') as f:
+                writer = csv.DictWriter(f, fieldnames=headers)
+                writer.writeheader()
+                writer.writerows(data)
+        
+        except ValueError as e:
+            raise ValueError(f"Error converting JSON to CSV: {str(e)}")
+    
+    elif target_format == 'txt':
+        # Simple pretty-printed JSON to text
+        with open(output_path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=4)
+    
+    return str(output_path)
+
+def _convert_from_yaml(
+    filepath: Path,
+    target_format: str,
+    output_path: Path,
+    options: Dict[str, Any]
+) -> str:
+    """Convert from YAML to other formats."""
+    try:
+        import yaml
+        
+        # Read the YAML file
+        with open(filepath, 'r', encoding='utf-8') as f:
+            data = yaml.safe_load(f)
+        
+        if target_format == 'json':
+            import json
+            
+            # Convert to JSON
+            with open(output_path, 'w', encoding='utf-8') as f:
+                json.dump(data, f, indent=4)
+        
+        elif target_format == 'xml':
+            import dicttoxml
+            
+            # Convert to XML
+            xml = dicttoxml.dicttoxml(data, custom_root=options.get('root_name', 'root'), attr_type=False)
+            
+            # Write to file
+            with open(output_path, 'wb') as f:
+                f.write(xml)
+        
+        elif target_format == 'txt':
+            # Simple YAML to text (just copy the content)
+            with open(filepath, 'r', encoding='utf-8') as f_in:
+                with open(output_path, 'w', encoding='utf-8') as f_out:
+                    f_out.write(f_in.read())
+    
+    except ImportError:
+        raise RuntimeError("PyYAML library is required for YAML conversions. Please install it.")
+    
+    return str(output_path)
+
+def _convert_from_xml(
+    filepath: Path,
+    target_format: str,
+    output_path: Path,
+    options: Dict[str, Any]
+) -> str:
+    """Convert from XML to other formats."""
+    try:
+        import xmltodict
+        
+        # Read the XML file
+        with open(filepath, 'r', encoding='utf-8') as f:
+            xml_content = f.read()
+        
+        # Convert XML to dict
+        data = xmltodict.parse(xml_content)
+        
+        if target_format == 'json':
+            import json
+            
+            # Convert to JSON
+            with open(output_path, 'w', encoding='utf-8') as f:
+                json.dump(data, f, indent=4)
+        
+        elif target_format == 'yaml':
+            import yaml
+            
+            # Convert to YAML
+            with open(output_path, 'w', encoding='utf-8') as f:
+                yaml.dump(data, f, default_flow_style=False, sort_keys=False)
+        
+        elif target_format == 'txt':
+            # Simple XML to text (just copy the content)
+            with open(filepath, 'r', encoding='utf-8') as f_in:
+                with open(output_path, 'w', encoding='utf-8') as f_out:
+                    f_out.write(f_in.read())
+    
+    except ImportError:
+        raise RuntimeError("xmltodict library is required for XML conversions. Please install it.")
+    
+    return str(output_path)
+
+def _convert_from_html(
+    filepath: Path,
+    target_format: str,
+    output_path: Path,
+    options: Dict[str, Any]
+) -> str:
+    """Convert from HTML to other formats."""
+    if target_format == 'md':
+        try:
+            import html2text
+            
+            # Read the HTML file
+            with open(filepath, 'r', encoding='utf-8') as f:
+                html_content = f.read()
+            
+            # Convert to Markdown
+            h = html2text.HTML2Text()
+            h.ignore_links = options.get('ignore_links', False)
+            h.ignore_images = options.get('ignore_images', False)
+            h.body_width = options.get('body_width', 0)  # 0 means no wrapping
+            
+            markdown = h.handle(html_content)
+            
+            # Write to file
+            with open(output_path, 'w', encoding='utf-8') as f:
+                f.write(markdown)
+        
+        except ImportError:
+            # Alternative method using pandoc
+            _convert_using_pandoc(filepath, target_format, output_path)
+    
+    elif target_format == 'txt':
+        try:
+            from bs4 import BeautifulSoup
+            
+            # Read the HTML file
+            with open(filepath, 'r', encoding='utf-8') as f:
+                html_content = f.read()
+            
+            # Parse HTML and extract text
+            soup = BeautifulSoup(html_content, 'html.parser')
+            text = soup.get_text(separator='\n\n')
+            
+            # Write to file
+            with open(output_path, 'w', encoding='utf-8') as f:
+                f.write(text)
+        
+        except ImportError:
+            # Alternative method using pandoc
+            _convert_using_pandoc(filepath, target_format, output_path)
+    
+    elif target_format == 'pdf':
+        # Use pandoc for HTML to PDF conversion
+        _convert_using_pandoc(filepath, target_format, output_path)
+    
+    return str(output_path)
+
+def _convert_from_md(
+    filepath: Path,
+    target_format: str,
+    output_path: Path,
+    options: Dict[str, Any]
+) -> str:
+    """Convert from Markdown to other formats."""
+    if target_format == 'html':
+        try:
+            import markdown
+            
+            # Read the Markdown file
+            with open(filepath, 'r', encoding='utf-8') as f:
+                md_content = f.read()
+            
+            # Convert to HTML
+            html = markdown.markdown(md_content, extensions=['tables', 'fenced_code'])
+            
+            # Add HTML boilerplate
+            html = f"""<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>{filepath.stem}</title>
+    <style>
+        body {{ font-family: Arial, sans-serif; line-height: 1.6; padding: 20px; max-width: 800px; margin: 0 auto; }}
+        pre {{ background-color: #f5f5f5; padding: 10px; border-radius: 5px; overflow-x: auto; }}
+        code {{ font-family: monospace; }}
+        img {{ max-width: 100%; }}
+        table {{ border-collapse: collapse; width: 100%; }}
+        th, td {{ border: 1px solid #ddd; padding: 8px; }}
+        th {{ background-color: #f2f2f2; }}
+    </style>
+</head>
+<body>
+{html}
+</body>
+</html>"""
+            
+            # Write to file
+            with open(output_path, 'w', encoding='utf-8') as f:
+                f.write(html)
+        
+        except ImportError:
+            # Alternative method using pandoc
+            _convert_using_pandoc(filepath, target_format, output_path)
+    
+    elif target_format == 'txt':
+        # Simple conversion - just strip markdown syntax
+        with open(filepath, 'r', encoding='utf-8') as f:
+            md_content = f.read()
+        
+        # Very basic markdown stripping
+        import re
+        
+        # Remove headers
+        text = re.sub(r'^#+\s+', '', md_content, flags=re.MULTILINE)
+        
+        # Remove bold/italic
+        text = re.sub(r'\*\*(.*?)\*\*', r'\1', text)
+        text = re.sub(r'\*(.*?)\*', r'\1', text)
+        
+        # Remove links
+        text = re.sub(r'\[(.*?)\]\(.*?\)', r'\1', text)
+        
+        # Remove code blocks
+        text = re.sub(r'```.*?```', '', text, flags=re.DOTALL)
+        
+        with open(output_path, 'w', encoding='utf-8') as f:
+            f.write(text)
+    
+    elif target_format == 'pdf':
+        # Use pandoc for Markdown to PDF conversion
+        _convert_using_pandoc(filepath, target_format, output_path)
+    
+    return str(output_path)
+
+def _convert_from_latex(
+    filepath: Path,
+    target_format: str,
+    output_path: Path,
+    options: Dict[str, Any]
+) -> str:
+    """Convert from LaTeX to other formats."""
+    # Use pandoc for all LaTeX conversions
+    _convert_using_pandoc(filepath, target_format, output_path)
+    return str(output_path)
+
+def _convert_using_pandoc(
+    filepath: Path,
+    target_format: str,
+    output_path: Path
+) -> None:
+    """Use pandoc for document conversion."""
+    try:
+        import subprocess
+        
+        # Map our format names to pandoc format names
+        format_map = {
+            'md': 'markdown',
+            'html': 'html',
+            'pdf': 'pdf',
+            'docx': 'docx',
+            'latex': 'latex',
+            'txt': 'plain'
+        }
+        
+        source_ext = filepath.suffix.lower().lstrip('.')
+        if source_ext == 'tex':
+            source_ext = 'latex'
+        
+        pandoc_source = format_map.get(source_ext, source_ext)
+        pandoc_target = format_map.get(target_format, target_format)
+        
+        cmd = [
+            'pandoc',
+            '-f', pandoc_source,
+            '-t', pandoc_target,
+            '-o', str(output_path),
+            str(filepath)
+        ]
+        
+        subprocess.run(cmd, check=True, capture_output=True)
+    
+    except (ImportError, subprocess.SubprocessError) as e:
+        raise RuntimeError(f"Failed to convert using pandoc: {str(e)}. Please install pandoc.")