clipmind 1.0.0__tar.gz

clipmind-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mirmudasir692
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

clipmind-1.0.0/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: clipmind
+Version: 1.0.0
+Summary: A simple and efficient Python tool to extract audio from video files using FFmpeg
+Author-email: Mudasir <your_email@example.com>
+License: MIT
+Keywords: video,audio,ffmpeg,converter,media
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: annotated-types==0.7.0
+Requires-Dist: anyio==4.13.0
+Requires-Dist: arabic-reshaper==3.0.0
+Requires-Dist: certifi==2026.2.25
+Requires-Dist: cffi==2.0.0
+Requires-Dist: charset-normalizer==3.4.6
+Requires-Dist: cryptography==46.0.6
+Requires-Dist: distro==1.9.0
+Requires-Dist: dnspython==2.8.0
+Requires-Dist: ffmpeg-python==0.2.0
+Requires-Dist: future==1.0.0
+Requires-Dist: google-ai-generativelanguage==0.6.15
+Requires-Dist: google-api-core==2.30.0
+Requires-Dist: google-api-python-client==2.193.0
+Requires-Dist: google-auth==2.49.1
+Requires-Dist: google-auth-httplib2==0.3.0
+Requires-Dist: google-genai==1.68.0
+Requires-Dist: googleapis-common-protos==1.73.1
+Requires-Dist: grpcio==1.78.0
+Requires-Dist: grpcio-status==1.71.2
+Requires-Dist: h11==0.16.0
+Requires-Dist: httpcore==1.0.9
+Requires-Dist: httplib2==0.31.2
+Requires-Dist: httpx==0.28.1
+Requires-Dist: idna==3.11
+Requires-Dist: numpy==2.4.4
+Requires-Dist: opencv-python==4.13.0.92
+Requires-Dist: proto-plus==1.27.2
+Requires-Dist: protobuf==5.29.6
+Requires-Dist: pyasn1==0.6.3
+Requires-Dist: pyasn1_modules==0.4.2
+Requires-Dist: pycparser==3.0
+Requires-Dist: pydantic==2.12.5
+Requires-Dist: pydantic_core==2.41.5
+Requires-Dist: pymongo==4.16.0
+Requires-Dist: pyparsing==3.3.2
+Requires-Dist: python-bidi==0.6.7
+Requires-Dist: python-dotenv==1.2.2
+Requires-Dist: requests==2.33.0
+Requires-Dist: sniffio==1.3.1
+Requires-Dist: tenacity==9.1.4
+Requires-Dist: tqdm==4.67.3
+Requires-Dist: typing-inspection==0.4.2
+Requires-Dist: typing_extensions==4.15.0
+Requires-Dist: uritemplate==4.2.0
+Requires-Dist: urllib3==2.6.3
+Requires-Dist: websockets==16.0
+Dynamic: license-file
+
+# clipmind - Video to Audio Converter
+
+A simple and efficient Python tool to extract audio from video files using FFmpeg.
+
+## Features
+
+- 🎵 Extract high-quality audio (MP3, WAV)
+- ✂️ Video tools: merge, crop, overlay, resolve conversion
+- ✅ File validation and error handling
+- 🖥️ CLI interface and Python library API
+- 🛠️ Minimal dependencies
+
+## Installation
+
+### Prerequisites
+
+1. **Python 3.6+**
+2. **FFmpeg** (must be in system PATH)
+
+### Install Dependencies
+
+```bash
+pip install ffmpeg-python
+```
+
+## Usage
+
+### Method 1: Command Line Interface
+
+Once installed, use the `clipmind` command:
+
+```bash
+clipmind -i video.mp4 [-o audio.mp3] [-f mp3]
+```
+
+#### Examples:
+
+```bash
+# Basic extraction
+clipmind -i video.mp4
+
+# Custom output format
+clipmind -i video.mkv -f wav
+```
+
+### Method 2: Python Library
+
+```python
+from clipmind import get_audio_from_video
+
+# Extract audio
+success = get_audio_from_video("video.mp4", "audio.mp3")
+
+# Advanced video tools
+from clipmind import merge_videos, crop_video
+merge_videos("part1.mp4", "part2.mp4", "merged.mp4")
+```
+
+## Project Structure
+
+```
+clipmind/
+├── clipmind/               # Core package
+│   └── src/
+│       ├── cli/          # CLI implementation
+│       ├── core/         # Audio & Video tools
+│       └── utils/        # Validations
+├── pyproject.toml        # Build configuration
+└── README.md             # Documentation
+```
+
+## License
+
+MIT

clipmind-1.0.0/README.md

@@ -0,0 +1,74 @@
+# clipmind - Video to Audio Converter
+
+A simple and efficient Python tool to extract audio from video files using FFmpeg.
+
+## Features
+
+- 🎵 Extract high-quality audio (MP3, WAV)
+- ✂️ Video tools: merge, crop, overlay, resolve conversion
+- ✅ File validation and error handling
+- 🖥️ CLI interface and Python library API
+- 🛠️ Minimal dependencies
+
+## Installation
+
+### Prerequisites
+
+1. **Python 3.6+**
+2. **FFmpeg** (must be in system PATH)
+
+### Install Dependencies
+
+```bash
+pip install ffmpeg-python
+```
+
+## Usage
+
+### Method 1: Command Line Interface
+
+Once installed, use the `clipmind` command:
+
+```bash
+clipmind -i video.mp4 [-o audio.mp3] [-f mp3]
+```
+
+#### Examples:
+
+```bash
+# Basic extraction
+clipmind -i video.mp4
+
+# Custom output format
+clipmind -i video.mkv -f wav
+```
+
+### Method 2: Python Library
+
+```python
+from clipmind import get_audio_from_video
+
+# Extract audio
+success = get_audio_from_video("video.mp4", "audio.mp3")
+
+# Advanced video tools
+from clipmind import merge_videos, crop_video
+merge_videos("part1.mp4", "part2.mp4", "merged.mp4")
+```
+
+## Project Structure
+
+```
+clipmind/
+├── clipmind/               # Core package
+│   └── src/
+│       ├── cli/          # CLI implementation
+│       ├── core/         # Audio & Video tools
+│       └── utils/        # Validations
+├── pyproject.toml        # Build configuration
+└── README.md             # Documentation
+```
+
+## License
+
+MIT

clipmind-1.0.0/clipmind/__init__.py

@@ -0,0 +1,24 @@
+"""Main package file for clipmind."""
+
+from .src.core.audio_extractor import get_audio_from_video, extract_audio, get_default_output_path, chunk_video_adaptive
+from .src.core.video_tools import merge_videos, composite_image_over_video, convert_video_resolutions, get_video_thumbnail, detect_video_vulnerability,crop_video, generate_video_summary, generate_subtitle, video_phash
+from .src.utils.validation import validate_video_file, validate_ffmpeg
+
+__version__ = "1.0.0"
+__author__ = "clipmind Team"
+__all__ = [
+    "get_audio_from_video", 
+    "extract_audio", 
+    "get_default_output_path",
+    "validate_video_file",
+    "validate_ffmpeg",
+    "merge_videos",
+    "composite_image_over_video",
+    "convert_video_resolutions",
+    "get_video_thumbnail",
+    "crop_video",
+    "chunk_video_adaptive",
+    "detect_video_vulnerability",
+    "generate_video_summary",
+    "generate_subtitle","video_phash"
+]

clipmind-1.0.0/clipmind/src/__init__.py

@@ -0,0 +1,7 @@
+"""Package init file for clipmind."""
+from .core.audio_extractor import get_audio_from_video
+from .utils.language import print_urdu
+
+__version__ = "1.0.0"
+__author__ = "clipmind Team"
+__all__ = ["get_audio_from_video", "print_urdu"]

clipmind-1.0.0/clipmind/src/cli/interface.py

@@ -0,0 +1,73 @@
+import argparse
+import sys
+from pathlib import Path
+
+
+def parse_arguments():
+    parser = argparse.ArgumentParser(
+        prog="clipmind",
+        description="clipmind - Extract audio from video files",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  clipmind -i video.mp4                    # Extract to video.mp3
+  clipmind -i video.mp4 -o audio.wav      # Extract to audio.wav
+  clipmind -i video.mkv -f mp3            # Extract to video.mp3
+        """
+    )
+
+    parser.add_argument('-i', '--input', required=True, help='Input video file path')
+    parser.add_argument('-o', '--output', help='Output audio file path (optional)')
+    parser.add_argument('-f', '--format', choices=['mp3', 'wav'], default='mp3',
+                       help='Output audio format (default: mp3)')
+
+    return parser.parse_args()
+
+
+def show_usage_instructions():
+    print("clipmind - Audio Extraction Tool")
+    print("==============================")
+    print("This tool extracts audio from video files using FFmpeg.")
+    print()
+    print("Usage: clipmind -i <input_video> [-o <output_audio>] [-f <format>]")
+    print()
+    print("Options:")
+    print("  -i, --input   Input video file path (required)")
+    print("  -o, --output  Output audio file path (optional)")
+    print("  -f, --format  Output format: mp3 or wav (default: mp3)")
+    print()
+    print("Example: clipmind -i video.mp4 -o audio.mp3")
+
+
+def validate_and_get_output_path(input_path, output_path=None, audio_format='mp3'):
+    if output_path:
+        output_path = Path(output_path)
+    else:
+        input_path = Path(input_path)
+        output_filename = input_path.stem + '.' + audio_format
+        output_path = input_path.parent / output_filename
+
+    output_dir = output_path.parent
+    if not output_dir.exists():
+        print(f"Error: Output directory does not exist: {output_dir}")
+        sys.exit(1)
+
+    return output_path
+
+
+def main():
+    from ..core.audio_extractor import get_audio_from_video
+    args = parse_arguments()
+    
+    success = get_audio_from_video(
+        args.input, 
+        args.output, 
+        args.format
+    )
+    
+    if success:
+        print(f"Successfully extracted audio to: {args.output if args.output else 'default path'}")
+        sys.exit(0)
+    else:
+        print("Error: Audio extraction failed.")
+        sys.exit(1)

clipmind-1.0.0/clipmind/src/core/__init__.py

@@ -0,0 +1,4 @@
+"""Core module for clipmind package."""
+from .audio_extractor import get_audio_from_video, extract_audio, get_default_output_path
+from .video_tools import merge_videos, composite_image_over_video, convert_video_resolutions, get_video_thumbnail, crop_video, video_phash
+__all__ = ["get_audio_from_video", "extract_audio", "get_default_output_path", "merge_videos", "composite_image_over_video",  "convert_video_resolutions", "get_video_thumbnail", "crop_video", "video_phash"]

clipmind-1.0.0/clipmind/src/core/audio_extractor.py

@@ -0,0 +1,226 @@
+import ffmpeg
+from pathlib import Path
+
+
+from ..utils.validation import validate_video_file, validate_ffmpeg
+from ..cli.interface import validate_and_get_output_path
+from ..utils.resolution import RESOLUTION_PROFILES
+
+
+def extract_audio(video_path, output_path, audio_format='mp3', start=None, end=None):
+    try:
+        audio_codec = 'mp3' if audio_format.lower() == 'mp3' else 'pcm_s16le'
+
+        input_kwargs = {}
+        if start is not None:
+            input_kwargs['ss'] = start
+        if end is not None:
+            input_kwargs['to'] = end
+
+        stream = ffmpeg.input(str(video_path), **input_kwargs)
+        stream = ffmpeg.output(stream, str(output_path), acodec=audio_codec, loglevel='quiet')
+
+        ffmpeg.run(stream, overwrite_output=True, quiet=True)
+
+        return True
+
+    except ImportError:
+        return False
+    except ffmpeg.Error as e:
+        return False
+    except Exception as e:
+        return False
+
+def get_default_output_path(video_path, audio_format='mp3'):
+    video_path = Path(video_path)
+    output_filename = video_path.stem + '.' + audio_format
+    return video_path.parent / output_filename
+
+
+def get_audio_from_video(video_path, output_path=None, audio_format='mp3', start=None, end=None):
+    """
+    Library function to extract audio from video.
+    
+    Args:
+        video_path (str): Path to the input video file
+        output_path (str, optional): Path for the output audio file
+        audio_format (str): Audio format ('mp3' or 'wav')
+        start (float/str, optional): Start time of the slice (e.g., 10.5 or "00:00:10")
+        end (float/str, optional): End time of the slice (e.g., 15.0 or "00:00:15")
+        
+    Returns:
+        bool: True if extraction was successful, False otherwise
+    """
+    if not validate_video_file(video_path):
+        return False
+    
+    if not validate_ffmpeg():
+        return False
+    
+    output_path = validate_and_get_output_path(video_path, output_path, audio_format)
+    
+    return extract_audio(video_path, str(output_path), audio_format, start, end)
+
+def chunk_video_adaptive(video_path, output_dir=None, resolutions=None, segment_duration=10):
+    """
+    Break video into HLS chunks at multiple resolutions with master manifest.
+    Works with both local paths and URLs (http/https).
+    
+    Args:
+        video_path (str): Path or URL to input video
+        output_dir (str, optional): Directory for output chunks. Default: ./video_chunks/
+        resolutions (list): List of resolution keys (e.g., ['360p', '720p']). Default: ['360p', '720p', '1080p']
+        segment_duration (int): Target duration of each segment in seconds. Default: 10
+        
+    Returns:
+        dict or False: On success returns {
+            'master_manifest': Path,           # Path to master.m3u8
+            'output_dir': Path,                # Root output directory
+            'variants': {                      # Dict of generated variants
+                '360p': {
+                    'manifest': Path,          # Path to variant playlist
+                    'segments_dir': Path,      # Directory containing .ts files
+                    'segment_count': int       # Number of segments generated
+                },
+                ...
+            }
+        }, returns False on failure
+    """
+    try:
+        if not validate_ffmpeg():
+            return False
+        
+        # Setup paths
+        video_path_str = str(video_path)
+        if output_dir is None:
+            # Extract filename from URL or path for default naming
+            base_name = Path(video_path_str.split('?')[0]).stem or 'video'
+            output_dir = Path(f"{base_name}_chunks")
+        else:
+            output_dir = Path(output_dir)
+        
+        output_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Default resolutions if not specified
+        if resolutions is None:
+            resolutions = ['360p', '720p', '1080p']
+        
+        # Validate resolutions
+        for res in resolutions:
+            if res not in RESOLUTION_PROFILES:
+                return False
+        
+        variants = {}
+        
+        # Generate chunks for each resolution
+        for res_key in resolutions:
+            profile = RESOLUTION_PROFILES[res_key]
+            
+            # Create subdirectory for this resolution
+            res_dir = output_dir / res_key
+            res_dir.mkdir(exist_ok=True)
+            
+            manifest_path = res_dir / "playlist.m3u8"
+            segment_pattern = str(res_dir / "segment_%03d.ts")
+            
+            # Build ffmpeg stream
+            stream = ffmpeg.input(video_path_str)
+            
+            # Apply scaling and encoding settings
+            stream = ffmpeg.filter(stream, 'scale', profile['width'], profile['height'])
+            
+            # HLS output settings
+            stream = ffmpeg.output(
+                stream,
+                str(manifest_path),
+                format='hls',
+                start_number=0,
+                hls_time=segment_duration,
+                hls_playlist_type='vod',
+                hls_segment_filename=segment_pattern,
+                hls_base_url=f"{res_key}/",  # Relative path for client resolution
+                vcodec='h264',
+                acodec='aac',
+                video_bitrate=profile['video_bitrate'],
+                audio_bitrate=profile['audio_bitrate'],
+                preset='fast',
+                pix_fmt='yuv420p',
+                loglevel='quiet'
+            )
+            
+            ffmpeg.run(stream, overwrite_output=True, quiet=True)
+            
+            # Count generated segments
+            segments = list(res_dir.glob("segment_*.ts"))
+            
+            variants[res_key] = {
+                'manifest': manifest_path,
+                'segments_dir': res_dir,
+                'segment_count': len(segments)
+            }
+        
+        # Generate master playlist
+        master_manifest = output_dir / "master.m3u8"
+        _write_master_playlist(master_manifest, resolutions, variants)
+        
+        return {
+            'master_manifest': master_manifest,
+            'output_dir': output_dir,
+            'variants': variants
+        }
+        
+    except ImportError:
+        return False
+    except ffmpeg.Error as e:
+        return False
+    except Exception as e:
+        return False
+
+
+def _write_master_playlist(master_path, resolutions, variants):
+    """Generate master HLS playlist referencing all variant playlists."""
+    lines = ["#EXTM3U"]
+    
+    for res_key in resolutions:
+        profile = RESOLUTION_PROFILES[res_key]
+        # Relative path to variant playlist (e.g., "360p/playlist.m3u8")
+        variant_path = f"{res_key}/playlist.m3u8"
+        
+        lines.append(
+            f"#EXT-X-STREAM-INF:"
+            f"BANDWIDTH={profile['bandwidth']},"
+            f"RESOLUTION={profile['width']}x{profile['height']},"
+            f"NAME=\"{res_key}\""
+        )
+        lines.append(variant_path)
+    
+    master_path.write_text('\n'.join(lines) + '\n')
+
+
+def chunk_video_single(video_path, output_dir=None, resolution='720p', segment_duration=10):
+    """
+    Generate HLS chunks for single resolution only.
+    
+    Args:
+        video_path (str): Path or URL to input video
+        output_dir (str, optional): Output directory
+        resolution (str): Single resolution (e.g., '720p')
+        segment_duration (int): Seconds per segment
+        
+    Returns:
+        dict or False: {'manifest': Path, 'segments_dir': Path, 'output_dir': Path} or False
+    """
+    result = chunk_video_adaptive(
+        video_path=video_path,
+        output_dir=output_dir,
+        resolutions=[resolution],
+        segment_duration=segment_duration
+    )
+    
+    if result:
+        return {
+            'manifest': result['variants'][resolution]['manifest'],
+            'segments_dir': result['variants'][resolution]['segments_dir'],
+            'output_dir': result['output_dir']
+        }
+    return False

clipmind-1.0.0/clipmind/src/core/validation/__init__.py

@@ -0,0 +1,2 @@
+from .video_validators import validate_video
+__all__ = ["validate_video"]

clipmind-1.0.0/clipmind/src/core/validation/video_validators.py

@@ -0,0 +1,73 @@
+import subprocess
+import os
+import json
+
+def validate_video(video_path: str = ""):
+    """
+    Validates a video file for corruption and malicious structure.
+    
+    Args:
+        video_path (str): Path to the video file.
+        
+    Returns:
+        tuple: (bool, str) -> (is_valid, reason)
+    """
+    
+    if video_path == "":
+        raise ValueError("video_path must be provided")
+
+    if not os.path.exists(video_path):
+        return False, "File does not exist."
+
+    if os.path.getsize(video_path) == 0:
+        return False, "File is empty (corrupt)."
+    cmd = [
+        'ffprobe',
+        '-v', 'error',
+        '-show_streams',
+        '-select_streams', 'v', 
+        '-of', 'json',
+        video_path
+    ]
+
+    try:
+        result = subprocess.run(
+            cmd, 
+            stdout=subprocess.PIPE, 
+            stderr=subprocess.PIPE, 
+            text=True,
+            timeout=10
+        )
+        if result.returncode != 0:
+            error_msg = result.stderr.strip()
+            if not error_msg:
+                error_msg = "Unknown parsing error."
+            return False, f"File is corrupted or invalid format: {error_msg}"
+        try:
+            data = json.loads(result.stdout)
+            streams = data.get('streams', [])
+            
+            if not streams:
+                return False, "Malicious/Invalid: No video stream found. File might be renamed or mislabeled."
+            
+            video_stream = streams[0]
+            codec_name = video_stream.get('codec_name', '')
+            width = video_stream.get('width', 0)
+            
+            if not codec_name:
+                return False, "Invalid video stream detected."
+                
+            if width == 0:
+                return False, "Corrupted video metadata (invalid resolution)."
+
+        except json.JSONDecodeError:
+            return False, "Malicious/Corrupt: File structure is unreadable."
+        if result.stderr and "Invalid data" in result.stderr:
+             return False, f"Warning: File contains corrupted segments. {result.stderr[:100]}"
+
+        return True, "Video file is valid."
+
+    except subprocess.TimeoutExpired:
+        return False, "Validation timed out. File might be malformed or infinite."
+    except Exception as e:
+        return False, f"An unexpected error occurred: {str(e)}"