portable-ffmpeg 0.1.0__py3-none-any.whl

portable_ffmpeg/__init__.py

@@ -0,0 +1,29 @@
+"""Static FFmpeg binaries for Windows, macOS, and Linux.
+
+This package automatically downloads and manages static FFmpeg binaries
+for cross-platform use without requiring system installation.
+"""
+
+from .core import (
+    add_to_path,
+    clear_cache,
+    get_ffmpeg,
+    print_paths,
+    remove_from_path,
+    run_ffmpeg,
+    run_ffprobe,
+)
+from .enums import Architectures, FFmpegVersions, OperatingSystems
+
+__all__ = [
+    "Architectures",
+    "FFmpegVersions",
+    "OperatingSystems",
+    "add_to_path",
+    "clear_cache",
+    "get_ffmpeg",
+    "print_paths",
+    "remove_from_path",
+    "run_ffmpeg",
+    "run_ffprobe",
+]

portable_ffmpeg/config.py

@@ -0,0 +1,106 @@
+"""Configuration for FFmpeg download URLs by platform and architecture."""
+
+from .downloaders import (
+    BaseFFmpegDownloader,
+    FFmpegDownloadSingleTar,
+    FFmpegDownloadSingleZip,
+    FFmpegDownloadTwoZips,
+)
+from .enums import Architectures, FFmpegVersions, OperatingSystems
+
+# Download URLs for different platforms, architectures, and versions
+DOWNLOAD_URLS: dict[
+    OperatingSystems,
+    dict[Architectures, dict[FFmpegVersions, BaseFFmpegDownloader]],
+] = {
+    OperatingSystems.WINDOWS: {
+        Architectures.AMD64: {
+            FFmpegVersions.LATEST: FFmpegDownloadSingleZip(
+                url="https://www.gyan.dev/ffmpeg/builds/ffmpeg-release-essentials.zip",
+                ffmpeg_name="ffmpeg.exe",
+                ffprobe_name="ffprobe.exe",
+            ),
+            FFmpegVersions.V7: FFmpegDownloadSingleZip(
+                url="https://www.gyan.dev/ffmpeg/builds/packages/ffmpeg-7.1.1-essentials_build.zip",
+                ffmpeg_name="ffmpeg.exe",
+                ffprobe_name="ffprobe.exe",
+            ),
+        },
+    },
+    OperatingSystems.OSX: {
+        Architectures.AMD64: {
+            FFmpegVersions.LATEST: FFmpegDownloadTwoZips(
+                ffmpeg_url="https://www.osxexperts.net/ffmpeg71intel.zip",
+                ffprobe_url="https://www.osxexperts.net/ffprobe71intel.zip",
+                ffmpeg_name="ffmpeg",
+                ffprobe_name="ffprobe",
+            ),
+            FFmpegVersions.V7: FFmpegDownloadTwoZips(
+                ffmpeg_url="https://www.osxexperts.net/ffmpeg71intel.zip",
+                ffprobe_url="https://www.osxexperts.net/ffprobe71intel.zip",
+                ffmpeg_name="ffmpeg",
+                ffprobe_name="ffprobe",
+            ),
+        },
+        Architectures.ARM64: {
+            FFmpegVersions.LATEST: FFmpegDownloadTwoZips(
+                ffmpeg_url="https://www.osxexperts.net/ffmpeg711arm.zip",
+                ffprobe_url="https://www.osxexperts.net/ffprobe711arm.zip",
+                ffmpeg_name="ffmpeg",
+                ffprobe_name="ffprobe",
+            ),
+            FFmpegVersions.V7: FFmpegDownloadTwoZips(
+                ffmpeg_url="https://www.osxexperts.net/ffmpeg711arm.zip",
+                ffprobe_url="https://www.osxexperts.net/ffprobe711arm.zip",
+                ffmpeg_name="ffmpeg",
+                ffprobe_name="ffprobe",
+            ),
+        },
+    },
+    OperatingSystems.LINUX: {
+        Architectures.AMD64: {
+            FFmpegVersions.LATEST: FFmpegDownloadSingleTar(
+                url="https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz",
+                ffmpeg_name="ffmpeg",
+                ffprobe_name="ffprobe",
+            ),
+            FFmpegVersions.V7: FFmpegDownloadSingleTar(
+                url="https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz",
+                ffmpeg_name="ffmpeg",
+                ffprobe_name="ffprobe",
+            ),
+            FFmpegVersions.V6: FFmpegDownloadSingleTar(
+                url="https://johnvansickle.com/ffmpeg/old-releases/ffmpeg-6.0.1-amd64-static.tar.xz",
+                ffmpeg_name="ffmpeg",
+                ffprobe_name="ffprobe",
+            ),
+            FFmpegVersions.V5: FFmpegDownloadSingleTar(
+                url="https://johnvansickle.com/ffmpeg/old-releases/ffmpeg-5.1.1-amd64-static.tar.xz",
+                ffmpeg_name="ffmpeg",
+                ffprobe_name="ffprobe",
+            ),
+        },
+        Architectures.ARM64: {
+            FFmpegVersions.LATEST: FFmpegDownloadSingleTar(
+                url="https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-arm64-static.tar.xz",
+                ffmpeg_name="ffmpeg",
+                ffprobe_name="ffprobe",
+            ),
+            FFmpegVersions.V7: FFmpegDownloadSingleTar(
+                url="https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-arm64-static.tar.xz",
+                ffmpeg_name="ffmpeg",
+                ffprobe_name="ffprobe",
+            ),
+            FFmpegVersions.V6: FFmpegDownloadSingleTar(
+                url="https://johnvansickle.com/ffmpeg/old-releases/ffmpeg-6.0.1-arm64-static.tar.xz",
+                ffmpeg_name="ffmpeg",
+                ffprobe_name="ffprobe",
+            ),
+            FFmpegVersions.V5: FFmpegDownloadSingleTar(
+                url="https://johnvansickle.com/ffmpeg/old-releases/ffmpeg-5.1.1-arm64-static.tar.xz",
+                ffmpeg_name="ffmpeg",
+                ffprobe_name="ffprobe",
+            ),
+        },
+    },
+}

portable_ffmpeg/core.py

@@ -0,0 +1,149 @@
+"""Core functionality for managing FFmpeg binaries."""
+
+import os
+import shutil
+import subprocess
+import sys
+import threading
+from pathlib import Path
+
+from .config import DOWNLOAD_URLS
+from .enums import Architectures, FFmpegVersions, OperatingSystems
+
+CACHE_DIR = Path(__file__).parent / "binaries"
+_download_lock = threading.Lock()
+_path_lock = threading.Lock()
+
+
+def get_ffmpeg(version: FFmpegVersions = FFmpegVersions.LATEST) -> tuple[Path, Path]:
+    """Download and return paths to static ffmpeg and ffprobe binaries.
+
+    Args:
+        version: FFmpeg major version to download (default: latest).
+
+    Returns:
+        Tuple containing paths to ffmpeg and ffprobe binaries.
+
+    """
+    system = OperatingSystems.from_current_system()
+    arch = Architectures.from_current_architecture()
+
+    # Create cache directory inside the package
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Get platform-specific configuration
+    if system not in DOWNLOAD_URLS:
+        msg = f"Unsupported operating system: {system}"
+        raise ValueError(msg)
+
+    if arch not in DOWNLOAD_URLS[system]:
+        msg = f"Unsupported {system} architecture: {arch}"
+        raise ValueError(msg)
+
+    if version not in DOWNLOAD_URLS[system][arch]:
+        msg = f"Unsupported FFmpeg version {version} for {system} {arch}"
+        raise ValueError(msg)
+
+    config = DOWNLOAD_URLS[system][arch][version]
+
+    # Check if binaries already exist in cache
+    cache_subdir = f"{system.value}-{arch.value}-{version.value}"
+    platform_cache_dir = CACHE_DIR / cache_subdir
+    ffmpeg_path = platform_cache_dir / config.ffmpeg_name
+    ffprobe_path = platform_cache_dir / config.ffprobe_name
+
+    with _download_lock:
+        if not ffmpeg_path.exists() or not ffprobe_path.exists():
+            # Use lock to prevent concurrent downloads
+            print(f"Downloading FFmpeg {version.value} binaries for {system} {arch}...")
+            # Create platform-specific cache directory
+
+            # Handle corrupted cache (file exists where directory should be)
+            if platform_cache_dir.exists() and not platform_cache_dir.is_dir():
+                platform_cache_dir.unlink()
+
+            platform_cache_dir.mkdir(parents=True, exist_ok=True)
+
+            # Download and extract binaries using dataclass method
+            ffmpeg_path, ffprobe_path = config.download_files(platform_cache_dir)
+
+    return ffmpeg_path, ffprobe_path
+
+
+def clear_cache() -> None:
+    """Clear the cached FFmpeg binaries.
+
+    This removes all downloaded binaries from the cache directory,
+    forcing them to be re-downloaded on the next call to get_ffmpeg().
+    """
+    if CACHE_DIR.exists():
+        shutil.rmtree(CACHE_DIR)
+
+
+def add_to_path(*, weak: bool = False, version: FFmpegVersions = FFmpegVersions.LATEST) -> None:
+    """Add FFmpeg binaries to system PATH.
+
+    Args:
+        weak: If True, only add to PATH if ffmpeg is not already available.
+              If False, always add to PATH (taking precedence).
+        version: FFmpeg major version to use (default: latest).
+
+    """
+    with _path_lock:
+        if weak and shutil.which("ffmpeg") is not None:
+            return  # ffmpeg already available, don't override
+
+        ffmpeg_path, _ = get_ffmpeg(version)
+        bin_dir = str(ffmpeg_path.parent)
+
+        current_path = os.environ.get("PATH", "")
+        if bin_dir not in current_path:
+            os.environ["PATH"] = f"{bin_dir}{os.pathsep}{current_path}"
+
+
+def remove_from_path(version: FFmpegVersions = FFmpegVersions.LATEST) -> None:
+    """Remove FFmpeg binaries from system PATH.
+
+    Args:
+        version: FFmpeg major version to use (default: latest).
+
+    """
+    with _path_lock:
+        ffmpeg_path, _ = get_ffmpeg(version)
+        bin_dir = str(ffmpeg_path.parent)
+
+        current_path = os.environ.get("PATH", "")
+        path_parts = current_path.split(os.pathsep)
+
+        # Remove our binary directory from PATH
+        new_path_parts = [part for part in path_parts if part != bin_dir]
+        os.environ["PATH"] = os.pathsep.join(new_path_parts)
+
+
+def run_ffmpeg(version: FFmpegVersions = FFmpegVersions.LATEST) -> None:
+    """Entry point to run ffmpeg binary directly.
+
+    Args:
+        version: FFmpeg major version to use (default: latest).
+
+    """
+    ffmpeg_path, _ = get_ffmpeg(version)
+    subprocess.run([str(ffmpeg_path)] + sys.argv[1:], check=False)
+
+
+def run_ffprobe(version: FFmpegVersions = FFmpegVersions.LATEST) -> None:
+    """Entry point to run ffprobe binary directly.
+
+    Args:
+        version: FFmpeg major version to use (default: latest).
+
+    """
+    _, ffprobe_path = get_ffmpeg(version)
+    subprocess.run([str(ffprobe_path)] + sys.argv[1:], check=False)
+
+
+def print_paths() -> None:
+    """Print the paths to the FFmpeg and FFprobe binaries."""
+    ffmpeg_path, ffprobe_path = get_ffmpeg()
+    print(f"FFmpeg: {ffmpeg_path}")
+    print(f"FFprobe: {ffprobe_path}")

portable_ffmpeg/downloaders.py

@@ -0,0 +1,155 @@
+"""Download classes for different FFmpeg binary formats."""
+
+import sys
+import tarfile
+import tempfile
+import urllib.request
+import zipfile
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+
+
+def _download_file(url: str, file_path: Path | str) -> None:
+    """Download a file from a URL."""
+    print(f"🔽 Downloading from {url}")
+    last_value = 0
+
+    def reporthook(block_num: int, block_size: int, total_size: int) -> None:
+        nonlocal last_value
+        if total_size > 0:
+            downloaded = block_num * block_size
+            percent = downloaded * 100 // total_size
+            if percent != last_value:
+                last_value = percent
+                if percent == 100:
+                    sys.stdout.write("\r✅ Download complete!\n")
+                else:
+                    sys.stdout.write(f"\r🔽 {percent:3d}%")
+                sys.stdout.flush()
+        else:
+            total = block_num * block_size
+            if last_value != total:
+                last_value = total
+                sys.stdout.write(f"\r🔽 {block_num * block_size} bytes")
+                sys.stdout.flush()
+
+    # Kick off download
+    urllib.request.urlretrieve(url, file_path, reporthook)
+
+
+def _extract_zip_files(zip_file: Path, outfolder: Path, target_names: list[str]) -> list[Path]:
+    """Extract specific files from a zip archive."""
+    extracted_files = []
+    with zipfile.ZipFile(zip_file, "r") as zip_ref:
+        for member in zip_ref.namelist():
+            filename = Path(member).name
+            if filename in target_names:
+                # Extract the file to outfolder with just the filename
+                member_data = zip_ref.read(member)
+                output_path = outfolder / filename
+                output_path.write_bytes(member_data)
+                # Set executable permissions on Unix systems
+                if sys.platform != "win32":
+                    output_path.chmod(0o755)
+                extracted_files.append(output_path)
+    return extracted_files
+
+
+def _extract_tar_files(tar_file: Path, outfolder: Path, target_names: list[str]) -> list[Path]:
+    """Extract specific files from a tar archive."""
+    extracted_files = []
+    with tarfile.open(tar_file, "r:*") as tar_ref:
+        for member in tar_ref.getmembers():
+            if member.isfile():
+                filename = Path(member.name).name
+                if filename in target_names:
+                    # Extract the file to outfolder with just the filename
+                    extracted_file = tar_ref.extractfile(member)
+                    if extracted_file:
+                        output_path = outfolder / filename
+                        output_path.write_bytes(extracted_file.read())
+                        # Set executable permissions on Unix systems
+                        if sys.platform != "win32":
+                            output_path.chmod(0o755)
+                        extracted_files.append(output_path)
+    return extracted_files
+
+
+@dataclass
+class BaseFFmpegDownloader(ABC):
+    """Base class for downloading FFmpeg binaries."""
+
+    ffmpeg_name: str
+    ffprobe_name: str
+
+    @abstractmethod
+    def download_files(self, outfolder: Path) -> tuple[Path, Path]:
+        """Download and extract the FFmpeg and FFprobe binaries."""
+
+
+@dataclass
+class FFmpegDownloadSingleZip(BaseFFmpegDownloader):
+    """Configuration for downloading ffmpeg and ffprobe binaries."""
+
+    url: str
+
+    def download_files(self, outfolder: Path) -> tuple[Path, Path]:
+        """Download and extract zip archive containing both binaries."""
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            tmp_file = Path(tmp_dir) / "download.zip"
+            _download_file(self.url, tmp_file)
+
+            _extract_zip_files(
+                zip_file=tmp_file,
+                outfolder=outfolder,
+                target_names=[self.ffmpeg_name, self.ffprobe_name],
+            )
+
+        return outfolder / self.ffmpeg_name, outfolder / self.ffprobe_name
+
+
+@dataclass
+class FFmpegDownloadSingleTar(BaseFFmpegDownloader):
+    """Configuration for downloading ffmpeg and ffprobe binaries as a single tar archive."""
+
+    url: str
+
+    def download_files(self, outfolder: Path) -> tuple[Path, Path]:
+        """Download and extract tar archive containing both binaries."""
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            tmp_file = Path(tmp_dir) / "download.tar.xz"
+            _download_file(self.url, tmp_file)
+
+            _extract_tar_files(
+                tar_file=tmp_file,
+                outfolder=outfolder,
+                target_names=[self.ffmpeg_name, self.ffprobe_name],
+            )
+
+        return outfolder / self.ffmpeg_name, outfolder / self.ffprobe_name
+
+
+@dataclass
+class FFmpegDownloadTwoZips(BaseFFmpegDownloader):
+    """Configuration for downloading ffmpeg and ffprobe binaries as separate zip files."""
+
+    ffmpeg_url: str
+    ffprobe_url: str
+
+    def download_files(self, outfolder: Path) -> tuple[Path, Path]:
+        """Download and extract two separate zip files for ffmpeg and ffprobe."""
+        target_binaries = {self.ffmpeg_url: self.ffmpeg_name, self.ffprobe_url: self.ffprobe_name}
+
+        for url, target_name in target_binaries.items():
+            with tempfile.TemporaryDirectory() as tmp_dir:
+                tmp_file = Path(tmp_dir) / f"{target_name}.zip"
+                _download_file(url, tmp_file)
+
+                _extract_zip_files(
+                    zip_file=tmp_file,
+                    outfolder=outfolder,
+                    target_names=[target_name],
+                )
+
+        return outfolder / self.ffmpeg_name, outfolder / self.ffprobe_name

portable_ffmpeg/enums.py

@@ -0,0 +1,54 @@
+"""Operating system and architecture enums for FFmpeg binary selection."""
+
+import platform
+from enum import Enum
+
+
+class OperatingSystems(Enum):
+    """Supported operating systems for ffmpeg binaries."""
+
+    WINDOWS = "windows"
+    OSX = "osx"
+    LINUX = "linux"
+
+    @classmethod
+    def from_current_system(cls) -> "OperatingSystems":
+        """Get the current operating system."""
+        system = platform.system().lower()
+        if system == "windows":
+            return cls.WINDOWS
+        if system == "darwin":
+            return cls.OSX
+        if system == "linux":
+            return cls.LINUX
+
+        msg = f"Unsupported operating system: {system}"
+        raise ValueError(msg)
+
+
+class Architectures(Enum):
+    """Supported architectures for ffmpeg binaries."""
+
+    AMD64 = "amd64"
+    ARM64 = "arm64"
+
+    @classmethod
+    def from_current_architecture(cls) -> "Architectures":
+        """Get the current architecture."""
+        machine = platform.machine().lower()
+        if machine in ["x86_64", "amd64"]:
+            return cls.AMD64
+        if machine in ["aarch64", "arm64"]:
+            return cls.ARM64
+
+        msg = f"Unsupported architecture: {machine}"
+        raise ValueError(msg)
+
+
+class FFmpegVersions(Enum):
+    """Supported FFmpeg major versions."""
+
+    LATEST = "latest"
+    V7 = "7"
+    V6 = "6"
+    V5 = "5"

portable_ffmpeg-0.1.0.dist-info/METADATA

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: portable-ffmpeg
+Version: 0.1.0
+Summary: Downloads static ffmpeg builds for Windows, macOS, and Linux
+Project-URL: Homepage, https://github.com/mrkbac/portable-ffmpeg
+Project-URL: Repository, https://github.com/mrkbac/portable-ffmpeg
+Project-URL: Issues, https://github.com/mrkbac/portable-ffmpeg/issues
+Author-email: Marko Bausch <60338487+mrkbac@users.noreply.github.com>
+License: MIT
+Keywords: audio,ffmpeg,ffprobe,multimedia,portable,static,video
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: pyright; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=8.4.0; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Portable FFmpeg
+
+Downloads static ffmpeg builds for Windows, macOS, and Linux.
+
+- Supports Windows, macOS, and Linux
+- Supports x86_64 architecture on all platforms, ARM64 on macOS and Linux
+- Automatic platform detection and binary caching
+
+## Usage
+
+### Python API
+
+```python
+from portable_ffmpeg import get_ffmpeg
+ffmpeg_path, ffprobe_path = get_ffmpeg()
+print(ffmpeg_path)  # Path to ffmpeg executable
+```
+
+### Command Line Interface
+
+After installation, you can use `static_ffmpeg` and `static_ffprobe` directly from the command line:
+
+```bash
+# Use static ffmpeg
+static_ffmpeg -i input.mp4 output.mp3
+
+# Use static ffprobe
+static_ffprobe -v quiet -print_format json -show_format input.mp4
+
+# Print paths to the binaries
+print_paths
+```
+
+The CLI commands automatically download and cache the appropriate static binaries for your platform.
+
+### PATH Management
+
+You can also programmatically manage your PATH:
+
+```python
+from portable_ffmpeg import add_to_path, remove_from_path
+
+# Add FFmpeg binaries to PATH
+add_to_path()
+
+# Add only if FFmpeg is not already available (weak mode)
+add_to_path(weak=True)
+
+# Remove from PATH
+remove_from_path()
+```
+
+## Sources of Static Builds
+
+This package downloads static FFmpeg binaries from the following trusted sources:
+
+### Windows (x86_64 only)
+
+- **Source**: [CODEX FFMPEG @ gyan.dev](https://www.gyan.dev/ffmpeg/builds/)
+- **URL**: `https://www.gyan.dev/ffmpeg/builds/ffmpeg-release-essentials.zip`
+- **Description**: Official Windows builds, 64-bit static binaries licensed as GPLv3
+
+### macOS
+
+#### Intel (x86_64)
+
+- **Source**: [OSXExperts.net](http://www.osxexperts.net/)
+- **URLs**:
+  - FFmpeg: `https://www.osxexperts.net/ffmpeg71intel.zip`
+  - FFprobe: `https://www.osxexperts.net/ffprobe71intel.zip`
+- **Description**: Static FFmpeg 7.1 binaries for macOS Intel processors
+
+#### Apple Silicon (arm64)
+
+- **Source**: [OSXExperts.net](http://www.osxexperts.net/)
+- **URLs**:
+  - FFmpeg: `https://www.osxexperts.net/ffmpeg711arm.zip`
+  - FFprobe: `https://www.osxexperts.net/ffprobe711arm.zip`
+- **Description**: Static FFmpeg 7.1.1 binaries optimized for Apple Silicon processors
+
+### Linux (x86_64 and arm64)
+
+- **Source**: [John Van Sickle - FFmpeg Static Builds](https://johnvansickle.com/ffmpeg/)
+- **URLs**:
+  - x86_64: `https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz`
+  - arm64: `https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-arm64-static.tar.xz`
+- **Description**: Latest versions of FFmpeg for Linux kernels 3.2.0+, statically linked
+
+
+### Alternative Sources
+
+The following sources provide FFmpeg static builds but are not currently supported by this package. They could be considered for future releases:
+
+- **[FFmpeg Martin Riedl](https://ffmpeg.martin-riedl.de/)**
+  - **Platforms**: macOS, Linux
+  - **Architectures**: x86_64, ARM64
+  - **Description**: Regularly updated static builds with comprehensive codec support
+
+- **[BtbN FFmpeg Builds](https://github.com/BtbN/FFmpeg-Builds)**
+  - **Platforms**: Windows, Linux
+  - **Architectures**: x86_64, ARM64, x86 (Windows only)
+  - **Description**: GitHub Actions-built binaries with automated releases
+
+- **[EverMeet FFmpeg](https://evermeet.cx/ffmpeg/)**
+  - **Platforms**: macOS only
+  - **Architectures**: x86_64
+  - **Description**: Long-standing macOS static builds provider
+
+- **[FreeBSD FFmpeg Static](https://github.com/Thefrank/ffmpeg-static-freebsd/)**
+  - **Platforms**: FreeBSD only
+  - **Architectures**: Various
+  - **Description**: Static builds specifically for FreeBSD systems
+
+- **[John Van Sickle Extended](https://johnvansickle.com/ffmpeg/)**
+  - **Additional Architectures**: i686, armhf, armel (beyond the currently supported x86_64 and ARM64)
+  - **Description**: Comprehensive Linux support including older and embedded architectures
+
+## Caching
+
+Downloaded binaries are cached in the package's `binaries/` directory to avoid re-downloading. Each virtual environment gets its own copy of the binaries.
+
+The cache is organized by platform and architecture (e.g., `linux-amd64`, `windows-amd64`, `osx-arm64`).
+
+### Cache Management
+
+```python
+from portable_ffmpeg import clear_cache
+
+# Clear all cached binaries
+clear_cache()
+```
+
+Or use the command line:
+
+```bash
+clear_cache
+```

portable_ffmpeg-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+portable_ffmpeg/__init__.py,sha256=krQpv5t46LGAk9_lwbpGjViMbbnJkyaSPaeq-6TwUqs,626
+portable_ffmpeg/config.py,sha256=jvLmGk0NWVzflZd8xgslIqWjU06bw7XUGmwqiYGM5AQ,4509
+portable_ffmpeg/core.py,sha256=H6Q1XhgE1D87UwiuSSBZeg4J2t8EWN6juLl9cXcLyCc,4918
+portable_ffmpeg/downloaders.py,sha256=a6NX9FPODujrtpCvZloTOqPv9Th32FqjaYeCgAH9z44,5706
+portable_ffmpeg/enums.py,sha256=FxA4jboyEpBvtwsLAgRaWScToyMttPlyZCGwQZ2uYEY,1353
+portable_ffmpeg/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+portable_ffmpeg-0.1.0.dist-info/METADATA,sha256=xlW8wlDUt4zWLgB-blONcOWAVv21rSxbtZCnkDUiSyE,5629
+portable_ffmpeg-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+portable_ffmpeg-0.1.0.dist-info/entry_points.txt,sha256=fUJF_ovTj115pznpHnUAkHqY1kUuV2gniiNJqJGxTs4,190
+portable_ffmpeg-0.1.0.dist-info/RECORD,,

portable_ffmpeg-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

portable_ffmpeg-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+clear_cache = portable_ffmpeg:clear_cache
+print_paths = portable_ffmpeg:print_paths
+static_ffmpeg = portable_ffmpeg:run_ffmpeg
+static_ffprobe = portable_ffmpeg:run_ffprobe