tessl/pypi-pyinstaller

PyInstaller bundles a Python application and all its dependencies into a single package.

—

Pending

Overview

Eval results

Files

Platform-Specific Features

Name: tessl/pypi-pyinstaller
Author: tessl

PyInstaller provides platform-specific functionality for Windows and macOS, including icon handling, version resources, manifest embedding, code signing, and application bundle creation.

Capabilities

Windows-Specific Features

Windows-specific utilities for handling icons, version resources, manifests, and other PE file operations.

Icon Handling

# Available in PyInstaller.utils.win32.icon module

def CopyIcons(dstpath, srcpath, iconsdata=None):
    """
    Copy icons from source to destination executable.
    
    Args:
        dstpath (str): Destination executable path
        srcpath (str): Source executable or icon file path
        iconsdata (list, optional): Icon data structures
    """

Version Information

# Available in PyInstaller.utils.win32.versioninfo module

class VSVersionInfo:
    """
    Version information structure for Windows executables.
    
    Contains file version, product version, and string information
    that appears in Windows file properties dialog.
    """
    
    def __init__(self, ffi=None, kids=None, name=None, type_=None):
        """
        Initialize version info structure.
        
        Args:
            ffi (FixedFileInfo): Fixed file version information
            kids (list): Child structures (StringFileInfo, VarFileInfo)
            name (str): Structure name
            type_ (int): Structure type
        """

class FixedFileInfo:
    """
    Fixed file version information structure.
    
    Contains numeric version information and file flags.
    """
    
    def __init__(self, filevers=(0, 0, 0, 0), prodvers=(0, 0, 0, 0),
                 mask=0x3f, flags=0x0, OS=0x40004, fileType=0x1,
                 subtype=0x0, date=(0, 0)):
        """
        Initialize fixed file info.
        
        Args:
            filevers (tuple): File version (major, minor, patch, build)
            prodvers (tuple): Product version (major, minor, patch, build)
            mask (int): File flags mask
            flags (int): File flags (debug, prerelease, etc.)
            OS (int): Target operating system
            fileType (int): File type (application, DLL, etc.)
            subtype (int): File subtype
            date (tuple): File date (high, low)
        """

def load_version_info_from_text(text):
    """
    Load version information from text representation.
    
    Args:
        text (str): Text representation of version info structure
        
    Returns:
        VSVersionInfo: Parsed version information
    """

def write_version_info_to_executable(exe_path, version_info):
    """
    Write version information to Windows executable.
    
    Args:
        exe_path (str): Path to executable file
        version_info (VSVersionInfo): Version information to embed
    """

Manifest Handling

# Available in PyInstaller.utils.win32.winmanifest module

def create_manifest(filename, manifest_xml, console=True):
    """
    Create or update Windows manifest for executable.
    
    Args:
        filename (str): Executable file path
        manifest_xml (str): Manifest XML content
        console (bool): Console application flag
    """

def default_manifest_xml(console=True, uac_admin=False, uac_uiaccess=False):
    """
    Generate default Windows manifest XML.
    
    Args:
        console (bool): Console application
        uac_admin (bool): Require administrator privileges
        uac_uiaccess (bool): Require UI access privileges
        
    Returns:
        str: Default manifest XML content
    """

Windows Resource Utilities

# Available in PyInstaller.utils.win32.winresource module

def add_resources(exe_path, resources):
    """
    Add custom resources to Windows executable.
    
    Args:
        exe_path (str): Path to executable
        resources (list): List of (resource_type, resource_name, data) tuples
    """

Windows EXE Options

Windows-specific options available in the EXE class:

# In spec files
exe = EXE(
    # ... other arguments ...
    
    # Windows-specific options:
    console=True,                    # Console vs windowed application
    icon='app.ico',                 # Application icon (.ico file)
    version='version_info.txt',     # Version resource file
    uac_admin=False,                # Require administrator privileges
    uac_uiaccess=False,             # Require UI access privileges
    embed_manifest=True,            # Embed manifest in executable
    resources=[                     # Additional resources
        ('RT_RCDATA', 'SPLASH', splash_data),
        ('RT_ICON', 1, icon_data)
    ],
    win_no_prefer_redirects=False,  # DLL redirect preferences
    win_private_assemblies=False    # Private assembly handling
)

macOS-Specific Features

macOS-specific functionality for creating application bundles, code signing, and handling platform requirements.

Application Bundle Creation

class BUNDLE:
    """
    Creates macOS application bundle (.app).
    
    Packages executables and resources into standard macOS application
    bundle structure with Info.plist and proper directory hierarchy.
    """
    
    def __init__(self, *args, name='', icon=None, bundle_identifier=None,
                 version=None, info_plist=None):
        """
        Initialize macOS bundle.
        
        Args:
            *args: Target dependencies (typically EXE and COLLECT)
            name (str): Application bundle name (without .app extension)
            icon (str): Application icon file path (.icns)
            bundle_identifier (str): Reverse-DNS bundle identifier
            version (str): Application version string
            info_plist (dict): Custom Info.plist entries
            
        Example:
            app = BUNDLE(
                coll,
                name='MyApplication',
                icon='assets/icon.icns',
                bundle_identifier='com.company.myapp',
                version='1.0.0',
                info_plist={
                    'CFBundleShortVersionString': '1.0',
                    'NSHighResolutionCapable': True,
                    'LSMinimumSystemVersion': '10.13.0'
                }
            )
        """

Code Signing

# macOS code signing options in EXE class
exe = EXE(
    # ... other arguments ...
    
    # macOS-specific options:
    codesign_identity='Developer ID Application: Company Name',
    entitlements_file='entitlements.plist',
    strictArchitecture=True,         # Enforce architecture consistency
    target_arch='universal2'         # Target architecture
)

Entitlements File

macOS entitlements are specified as XML plist files:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>com.apple.security.cs.allow-jit</key>
    <true/>
    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
    <true/>
    <key>com.apple.security.cs.disable-library-validation</key>
    <true/>
    <key>com.apple.security.network.client</key>
    <true/>
    <key>com.apple.security.files.user-selected.read-write</key>
    <true/>
</dict>
</plist>

Cross-Platform Icon Handling

PyInstaller automatically selects appropriate icon formats based on target platform:

# Platform-specific icon formats
# Windows: .ico files
# macOS: .icns files
# Linux: No standard icon embedding

exe = EXE(
    # ... other arguments ...
    icon='icon.ico',      # Windows
    # or
    icon='icon.icns',     # macOS
)

Platform Detection

PyInstaller provides platform detection utilities:

# Available in PyInstaller.compat module
is_win: bool       # Windows platform
is_darwin: bool    # macOS platform  
is_linux: bool     # Linux platform
is_cygwin: bool    # Cygwin environment
is_aix: bool       # AIX platform

# Architecture information
architecture: str  # Platform architecture
machine: str      # Machine type

Platform-Specific Examples

Windows Application with Full Metadata

# windows_app.spec
from PyInstaller.building.build_main import Analysis
from PyInstaller.building.api import PYZ, EXE

a = Analysis(['main.py'])
pyz = PYZ(a.pure, a.zipped_data)

exe = EXE(
    pyz,
    a.scripts,
    a.binaries,
    a.zipfiles,
    a.datas,
    [],
    name='MyApplication',
    debug=False,
    console=False,                  # Windowed application
    icon='assets/app.ico',         # Application icon
    version='version_info.txt',    # Version resource
    uac_admin=False,               # No admin required
    embed_manifest=True,           # Embed manifest
    resources=[                    # Custom resources
        ('RT_RCDATA', 'CONFIG', open('config.dat', 'rb').read())
    ]
)

macOS Application Bundle

# macos_app.spec
from PyInstaller.building.build_main import Analysis
from PyInstaller.building.api import PYZ, EXE, COLLECT
from PyInstaller.building.osx import BUNDLE

a = Analysis(['main.py'])
pyz = PYZ(a.pure, a.zipped_data)

exe = EXE(
    pyz,
    a.scripts,
    exclude_binaries=True,          # Required for BUNDLE
    name='MyApplication',
    debug=False,
    console=False,
    icon='assets/app.icns',
    codesign_identity='Developer ID Application: My Company',
    entitlements_file='entitlements.plist',
    target_arch='universal2'        # Universal binary
)

coll = COLLECT(
    exe,
    a.binaries,
    a.zipfiles,
    a.datas,
    name='MyApplication'
)

app = BUNDLE(
    coll,
    name='MyApplication',
    icon='assets/app.icns',
    bundle_identifier='com.company.myapplication',
    version='1.0.0',
    info_plist={
        'CFBundleShortVersionString': '1.0',
        'NSHighResolutionCapable': True,
        'LSMinimumSystemVersion': '10.15.0',
        'CFBundleDocumentTypes': [
            {
                'CFBundleTypeName': 'My Document',
                'CFBundleTypeExtensions': ['mydoc'],
                'CFBundleTypeRole': 'Editor'
            }
        ]
    }
)

Cross-Platform Conditional Configuration

# cross_platform.spec
import sys
from PyInstaller.building.build_main import Analysis
from PyInstaller.building.api import PYZ, EXE, COLLECT

# Platform-specific configurations
if sys.platform == 'win32':
    icon_file = 'assets/app.ico'
    console = False
    extra_kwargs = {
        'version': 'version_info.txt',
        'uac_admin': False
    }
elif sys.platform == 'darwin':
    icon_file = 'assets/app.icns'
    console = False
    extra_kwargs = {
        'codesign_identity': 'Developer ID Application: My Company',
        'entitlements_file': 'entitlements.plist'
    }
else:  # Linux
    icon_file = None
    console = True
    extra_kwargs = {}

a = Analysis(['main.py'])
pyz = PYZ(a.pure, a.zipped_data)

exe = EXE(
    pyz,
    a.scripts,
    a.binaries,
    a.zipfiles,
    a.datas,
    [],
    name='MyApplication',
    debug=False,
    console=console,
    icon=icon_file,
    **extra_kwargs
)

# macOS bundle creation
if sys.platform == 'darwin':
    from PyInstaller.building.osx import BUNDLE
    
    coll = COLLECT(exe, a.binaries, a.zipfiles, a.datas, name='MyApplication')
    app = BUNDLE(
        coll,
        name='MyApplication',
        icon='assets/app.icns',
        bundle_identifier='com.company.myapplication'
    )

Platform-Specific Troubleshooting

Windows Issues

Missing DLLs: Use pyi-bindepend to identify dependencies
UAC prompts: Check manifest settings and uac_admin flag
Icon not showing: Ensure .ico file is valid and properly formatted
Version info: Use pyi-grab_version to extract from reference executables

macOS Issues

Code signing failures: Verify developer certificates and entitlements
Gatekeeper blocking: Ensure proper code signing with notarization
Bundle structure: Check Info.plist format and bundle directory structure
Architecture mismatches: Use target_arch='universal2' for compatibility

Cross-Platform Considerations

File paths: Use os.path.join() for platform-independent paths
Icon formats: Provide platform-specific icon files
Dependencies: Some packages have platform-specific requirements
Testing: Test builds on all target platforms before release

Install with Tessl CLI

npx tessl i tessl/pypi-pyinstaller

docs