tessl/pypi-pypdfium2

Python bindings to PDFium for comprehensive PDF manipulation, rendering, and processing

—

Pending

Overview

Eval results

Files

Version and Library Information

Name: tessl/pypi-pypdfium2
Author: tessl

Access to pypdfium2 and PDFium version information, build details, feature flags, and compatibility data. The version module provides comprehensive information about both the Python bindings and underlying PDFium library.

Capabilities

Version Objects

Access version information through dedicated version objects with comprehensive metadata.

# Primary version objects
PYPDFIUM_INFO: _version_pypdfium2  # pypdfium2 helpers version
PDFIUM_INFO: _version_pdfium       # PDFium library version

# Deprecated constants (removed in v5)
V_PYPDFIUM2: str      # pypdfium2 version string
V_LIBPDFIUM: str      # PDFium build number string
V_LIBPDFIUM_FULL: str # Full PDFium version string
V_BUILDNAME: str      # PDFium binary origin
V_PDFIUM_IS_V8: bool  # V8/XFA support flag

Basic version access:

import pypdfium2 as pdfium

# Access version objects
pypdfium_version = pdfium.PYPDFIUM_INFO
pdfium_version = pdfium.PDFIUM_INFO

print(f"pypdfium2 version: {pypdfium_version.version}")
print(f"PDFium version: {pdfium_version.version}")

# Deprecated API (still available but will be removed)
print(f"pypdfium2 (deprecated): {pdfium.V_PYPDFIUM2}")
print(f"PDFium build (deprecated): {pdfium.V_LIBPDFIUM}")

pypdfium2 Version Information

Comprehensive version information for the pypdfium2 Python bindings.

class _version_pypdfium2:
    @property
    def version(self) -> str:
        """Complete version string (tag + desc)."""
    
    @property
    def tag(self) -> str:
        """Version numbers as string, including possible beta."""
    
    @property
    def desc(self) -> str:
        """Non-numeric descriptors (commits, dirty state, etc.)."""
    
    @property
    def api_tag(self) -> tuple[int]:
        """Version numbers as tuple, excluding beta."""
    
    @property
    def major(self) -> int:
        """Major version number."""
    
    @property
    def minor(self) -> int:
        """Minor version number."""
    
    @property
    def patch(self) -> int:
        """Patch version number."""
    
    @property
    def beta(self) -> int | None:
        """Beta version number, or None if not a beta."""
    
    @property
    def n_commits(self) -> int:
        """Number of commits after tag at install time."""
    
    @property
    def hash(self) -> str | None:
        """Commit hash if n_commits > 0, None otherwise."""
    
    @property
    def dirty(self) -> bool:
        """True if uncommitted changes at install time."""
    
    @property
    def data_source(self) -> str:
        """Source of version info: 'git', 'given', or 'record'."""
    
    @property
    def is_editable(self) -> bool | None:
        """True for editable install, False otherwise, None if unknown."""

pypdfium2 version analysis:

info = pdfium.PYPDFIUM_INFO

print("pypdfium2 Version Information:")
print(f"  Full version: {info.version}")
print(f"  Tag: {info.tag}")
print(f"  Description: {info.desc}")
print(f"  API tag: {info.api_tag}")
print(f"  Major.Minor.Patch: {info.major}.{info.minor}.{info.patch}")

if info.beta is not None:
    print(f"  Beta version: {info.beta}")

print(f"  Commits after tag: {info.n_commits}")
if info.hash:
    print(f"  Commit hash: {info.hash}")

print(f"  Dirty build: {info.dirty}")
print(f"  Data source: {info.data_source}")
print(f"  Editable install: {info.is_editable}")

# Version comparison
required_version = (4, 30, 0)
if info.api_tag >= required_version:
    print(f"Version {info.api_tag} meets requirement {required_version}")
else:
    print(f"Version {info.api_tag} does not meet requirement {required_version}")

PDFium Version Information

Detailed information about the underlying PDFium library including build details and feature flags.

class _version_pdfium:
    @property
    def version(self) -> str:
        """Complete version string (tag + desc)."""
    
    @property
    def tag(self) -> str:
        """Version numbers as string."""
    
    @property
    def desc(self) -> str:
        """Descriptors (origin, flags) as string."""
    
    @property
    def api_tag(self) -> tuple[int]:
        """Version numbers as tuple."""
    
    @property
    def major(self) -> int:
        """Chromium major version."""
    
    @property
    def minor(self) -> int:
        """Chromium minor version."""
    
    @property
    def build(self) -> int:
        """Chromium/PDFium build number (unique identifier)."""
    
    @property
    def patch(self) -> int:
        """Chromium patch version."""
    
    @property
    def n_commits(self) -> int:
        """Commits after tag at build time."""
    
    @property
    def hash(self) -> str | None:
        """Commit hash if n_commits > 0."""
    
    @property
    def origin(self) -> str:
        """Binary origin: 'pdfium-binaries', 'sourcebuild', or 'system'."""
    
    @property
    def flags(self) -> tuple[str]:
        """Feature flags tuple (e.g., ('V8', 'XFA') for V8 build)."""

PDFium version analysis:

info = pdfium.PDFIUM_INFO

print("PDFium Version Information:")
print(f"  Full version: {info.version}")
print(f"  Tag: {info.tag}")
print(f"  Description: {info.desc}")
print(f"  API tag: {info.api_tag}")
print(f"  Chromium version: {info.major}.{info.minor}.{info.build}.{info.patch}")
print(f"  Build number: {info.build}")

print(f"  Commits after tag: {info.n_commits}")
if info.hash:
    print(f"  Commit hash: {info.hash}")

print(f"  Binary origin: {info.origin}")
print(f"  Feature flags: {info.flags}")

# Check for specific features
has_v8 = "V8" in info.flags
has_xfa = "XFA" in info.flags
print(f"  V8 JavaScript: {has_v8}")
print(f"  XFA Forms: {has_xfa}")

# Origin-specific information
if info.origin == "pdfium-binaries":
    print("  Using pre-built pdfium-binaries")
elif info.origin == "sourcebuild":
    print("  Using custom-built PDFium")
elif info.origin == "system":
    print("  Using system-installed PDFium")

Version Compatibility

Check version compatibility and feature availability.

def check_compatibility():
    """Check version compatibility and available features."""
    
    pypdfium_info = pdfium.PYPDFIUM_INFO
    pdfium_info = pdfium.PDFIUM_INFO
    
    print("Compatibility Check:")
    
    # Check pypdfium2 version requirements
    min_pypdfium_version = (4, 0, 0)
    if pypdfium_info.api_tag >= min_pypdfium_version:
        print(f"✓ pypdfium2 {pypdfium_info.api_tag} meets minimum requirement")
    else:
        print(f"✗ pypdfium2 {pypdfium_info.api_tag} below minimum {min_pypdfium_version}")
    
    # Check PDFium build requirements  
    min_pdfium_build = 6000  # Example minimum build
    if pdfium_info.build >= min_pdfium_build:
        print(f"✓ PDFium build {pdfium_info.build} meets minimum requirement")
    else:
        print(f"✗ PDFium build {pdfium_info.build} below minimum {min_pdfium_build}")
    
    # Feature availability
    features = {
        'V8 JavaScript': "V8" in pdfium_info.flags,
        'XFA Forms': "XFA" in pdfium_info.flags,
        'Text extraction': True,  # Always available
        'Image rendering': True,  # Always available
        'Page manipulation': True,  # Always available
    }
    
    print("\nFeature Availability:")
    for feature, available in features.items():
        status = "✓" if available else "✗"
        print(f"  {status} {feature}")
    
    # Installation type
    print(f"\nInstallation Info:")
    print(f"  pypdfium2 data source: {pypdfium_info.data_source}")
    print(f"  Editable install: {pypdfium_info.is_editable}")
    print(f"  PDFium origin: {pdfium_info.origin}")
    
    # Development info
    if pypdfium_info.dirty or pypdfium_info.n_commits > 0:
        print("\nDevelopment Build Detected:")
        if pypdfium_info.dirty:
            print("  ⚠ Uncommitted changes present")
        if pypdfium_info.n_commits > 0:
            print(f"  ⚠ {pypdfium_info.n_commits} commits ahead of release")
            if pypdfium_info.hash:
                print(f"  Commit: {pypdfium_info.hash}")

# Usage
check_compatibility()

Version Comparison

Compare versions for compatibility and feature detection.

def compare_versions(required_pypdfium=None, required_pdfium_build=None):
    """Compare current versions against requirements."""
    
    results = {
        'pypdfium2_compatible': True,
        'pdfium_compatible': True,
        'issues': []
    }
    
    if required_pypdfium:
        current = pdfium.PYPDFIUM_INFO.api_tag
        if current < required_pypdfium:
            results['pypdfium2_compatible'] = False
            results['issues'].append(
                f"pypdfium2 {current} < required {required_pypdfium}"
            )
    
    if required_pdfium_build:
        current = pdfium.PDFIUM_INFO.build
        if current < required_pdfium_build:
            results['pdfium_compatible'] = False
            results['issues'].append(
                f"PDFium build {current} < required {required_pdfium_build}"
            )
    
    return results

# Usage examples
result = compare_versions(
    required_pypdfium=(4, 25, 0),
    required_pdfium_build=6000
)

if result['pypdfium2_compatible'] and result['pdfium_compatible']:
    print("✓ All version requirements met")
else:
    print("✗ Version compatibility issues:")
    for issue in result['issues']:
        print(f"  - {issue}")

Build Information Analysis

Analyze build characteristics and installation details.

def analyze_build_info():
    """Analyze pypdfium2 and PDFium build information."""
    
    pypdfium_info = pdfium.PYPDFIUM_INFO
    pdfium_info = pdfium.PDFIUM_INFO
    
    analysis = {
        'pypdfium2': {
            'is_release': pypdfium_info.n_commits == 0 and not pypdfium_info.dirty,
            'is_beta': pypdfium_info.beta is not None,
            'is_development': pypdfium_info.n_commits > 0 or pypdfium_info.dirty,
            'install_type': 'editable' if pypdfium_info.is_editable else 'standard',
            'version_source': pypdfium_info.data_source
        },
        'pdfium': {
            'is_prebuilt': pdfium_info.origin == 'pdfium-binaries',
            'is_custom': pdfium_info.origin == 'sourcebuild',
            'is_system': pdfium_info.origin == 'system',
            'has_javascript': 'V8' in pdfium_info.flags,
            'has_xfa': 'XFA' in pdfium_info.flags,
            'feature_count': len(pdfium_info.flags)
        }
    }
    
    # Print analysis
    print("Build Analysis:")
    print(f"\npypdfium2:")
    for key, value in analysis['pypdfium2'].items():
        print(f"  {key}: {value}")
    
    print(f"\nPDFium:")
    for key, value in analysis['pdfium'].items():
        print(f"  {key}: {value}")
    
    # Recommendations
    print(f"\nRecommendations:")
    if analysis['pypdfium2']['is_development']:
        print("  ⚠ Using development build - consider stable release for production")
    
    if analysis['pdfium']['is_system']:
        print("  ⚠ Using system PDFium - version may vary across systems")
    
    if not analysis['pdfium']['has_javascript']:
        print("  ℹ JavaScript/V8 not available - some advanced PDF features disabled")
    
    return analysis

# Usage
build_analysis = analyze_build_info()

Environment Information

Get comprehensive environment and dependency information.

def get_environment_info():
    """Get comprehensive environment information."""
    import sys
    import platform
    
    env_info = {
        'python': {
            'version': sys.version,
            'platform': platform.platform(),
            'architecture': platform.architecture(),
        },
        'pypdfium2': {            
            'version': pdfium.PYPDFIUM_INFO.version,
            'api_tag': pdfium.PYPDFIUM_INFO.api_tag,
            'install_type': pdfium.PYPDFIUM_INFO.is_editable,
            'data_source': pdfium.PYPDFIUM_INFO.data_source,
        },
        'pdfium': {
            'version': pdfium.PDFIUM_INFO.version,
            'build': pdfium.PDFIUM_INFO.build,
            'origin': pdfium.PDFIUM_INFO.origin,
            'flags': pdfium.PDFIUM_INFO.flags,
        }
    }
    
    return env_info

def print_environment_report():
    """Print comprehensive environment report."""
    env = get_environment_info()
    
    print("Environment Report")
    print("=" * 50)
    
    print(f"\nPython Environment:")
    print(f"  Version: {env['python']['version'].split()[0]}")
    print(f"  Platform: {env['python']['platform']}")
    print(f"  Architecture: {env['python']['architecture'][0]}")
    
    print(f"\npypdfium2:")
    print(f"  Version: {env['pypdfium2']['version']}")
    print(f"  API Tag: {env['pypdfium2']['api_tag']}")
    print(f"  Install Type: {'Editable' if env['pypdfium2']['install_type'] else 'Standard'}")
    print(f"  Data Source: {env['pypdfium2']['data_source']}")
    
    print(f"\nPDFium Library:")
    print(f"  Version: {env['pdfium']['version']}")
    print(f"  Build: {env['pdfium']['build']}")
    print(f"  Origin: {env['pdfium']['origin']}")
    print(f"  Features: {', '.join(env['pdfium']['flags']) if env['pdfium']['flags'] else 'None'}")

# Usage
print_environment_report()

Data Source Types

Understanding pypdfium2 version data sources:

git: Parsed from git repository (highest accuracy, development installs)
given: Pre-supplied version file (sdist packages, custom builds)
record: Parsed from autorelease record (some information may be incomplete)

PDFium Origins

Understanding PDFium binary origins:

pdfium-binaries: Pre-built binaries from bblanchon/pdfium-binaries project
sourcebuild: Custom-built PDFium using pypdfium2's build scripts
system: System-installed PDFium library loaded dynamically