CLI Utilities

# Console script
pyi-archive_viewer [archive_path]

def run():
    """
    Launch interactive archive viewer for PyInstaller archives.
    
    The archive viewer provides commands to:
    - List archive contents
    - Extract files from archives  
    - View file information and dependencies
    - Navigate directory structures within archives
    
    Interactive commands:
        o <filename>  - Open and display file contents
        x <filename>  - Extract file to current directory
        s             - Search for files by name pattern
        q             - Quit the viewer
    
    Example usage:
        $ pyi-archive_viewer dist/myapp/myapp.exe
        ? help
        ? ls
        ? o PYZ-00.pyz
        ? x somefile.py
    """

# Console script  
pyi-bindepend [options] executable_or_library

def run():
    """
    Analyze binary dependencies of executables and libraries.
    
    Discovers and reports all shared library dependencies, helping
    identify missing dependencies or version conflicts.
    
    Options:
        --upx-dir DIR     Directory containing UPX executable
        
    Output includes:
    - Direct dependencies
    - Recursive dependency tree
    - Missing or unresolved dependencies
    - Library search paths
    
    Example usage:
        $ pyi-bindepend dist/myapp/myapp.exe
        $ pyi-bindepend --upx-dir /usr/local/bin dist/myapp/_internal/numpy.libs/libopenblas.so
    """

# Console script (Windows only)
pyi-grab_version [options] executable_path

def run():
    """
    Extract version information from Windows executables.
    
    Reads version resources from PE files and outputs in format
    suitable for use with pyi-set_version or --version-file option.
    
    Options:
        -o, --out FILE    Output file for version information
        
    Extracted information includes:
    - File version numbers
    - Product version numbers  
    - Company information
    - File description
    - Copyright information
    - Original filename
    
    Example usage:
        $ pyi-grab_version some_app.exe
        $ pyi-grab_version -o version_info.txt target.exe
    """

# Console script
pyi-makespec [options] script [script ...]

def run():
    """
    Generate PyInstaller .spec files without building.
    
    Creates customizable .spec files that can be edited before building.
    Accepts the same options as the main pyinstaller command but only
    generates the specification file.
    
    Common options:
        --onefile         Generate spec for one-file bundle
        --onedir          Generate spec for one-directory bundle
        --windowed        Generate spec for windowed application
        --name NAME       Assign custom name to executable
        --icon ICON       Add application icon
        --add-data SRC:DEST  Add data files
        --hidden-import MODULE  Add hidden imports
        
    The generated .spec file can then be customized and built with:
        pyinstaller myapp.spec
        
    Example usage:
        $ pyi-makespec --onefile --windowed --name MyApp main.py
        $ pyi-makespec --add-data "config/*:config" --icon app.ico script.py
    """

# Console script (Windows only)  
pyi-set_version version_info_file executable_path

def run():
    """
    Set version information on Windows executables.
    
    Embeds version resources into PE files using version information
    from a text file (typically created by pyi-grab_version).
    
    Args:
        version_info_file (str): Path to version information file
        executable_path (str): Path to executable to modify
        
    The version information file format contains:
    - VSVersionInfo structure
    - StringFileInfo with language/codepage
    - VarFileInfo with translations
    
    Example usage:
        $ pyi-set_version version_info.txt dist/myapp.exe
        
    Version info file example:
        VSVersionInfo(
            ffi=FixedFileInfo(
                filevers=(1, 0, 0, 0),
                prodvers=(1, 0, 0, 0),
                ...
            ),
            kids=[
                StringFileInfo([
                    StringTable('040904B0', [
                        StringStruct('CompanyName', 'My Company'),
                        StringStruct('FileDescription', 'My Application'),
                        ...
                    ])
                ]),
                ...
            ]
        )
    """

# Build application
pyinstaller --onefile myapp.py

# Inspect the generated executable
pyi-archive_viewer dist/myapp.exe

# Interactive session:
# ? ls                    # List contents
# ? o PYZ-00.pyz         # Open Python archive
# ? s numpy              # Search for numpy files
# ? x mymodule.pyc       # Extract compiled module
# ? q                    # Quit

# Analyze dependencies of built executable
pyi-bindepend dist/myapp/myapp.exe

# Check specific library dependencies
pyi-bindepend dist/myapp/_internal/numpy/.libs/libopenblas.so

# Analyze with UPX
pyi-bindepend --upx-dir /usr/local/bin dist/myapp.exe

# Extract version info from existing executable
pyi-grab_version -o version_template.txt some_reference.exe

# Edit version_template.txt as needed
# ...

# Build application
pyinstaller myapp.py

# Apply version information
pyi-set_version version_template.txt dist/myapp.exe

# Verify version was applied
pyi-grab_version dist/myapp.exe

# Generate customizable spec file
pyi-makespec --onefile --windowed --name MyApplication \
    --icon assets/icon.ico \
    --add-data "config/*:config" \
    --add-data "templates/*:templates" \
    --hidden-import pkg_resources.py2_warn \
    src/main.py

# Edit MyApplication.spec file to add custom logic
# Add conditional imports, modify file collection, etc.

# Build from customized spec
pyinstaller MyApplication.spec

# Create archive viewer session script
cat > analyze_archive.txt << EOF
ls
o PYZ-00.pyz
ls *.py*
s requests
x requests/__init__.pyc
q
EOF

# Run automated analysis
pyi-archive_viewer dist/myapp.exe < analyze_archive.txt

#!/bin/bash
# build_and_analyze.sh

set -e

echo "Building application..."
pyinstaller --clean myapp.spec

echo "Analyzing dependencies..."
pyi-bindepend dist/myapp/myapp > dependencies.txt

echo "Extracting archive contents..."
echo -e "ls\nq" | pyi-archive_viewer dist/myapp/myapp.exe > archive_contents.txt

echo "Setting version information..."
if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "win32" ]]; then
    pyi-set_version version_info.txt dist/myapp/myapp.exe
fi

echo "Build complete. Check dependencies.txt and archive_contents.txt for analysis results."

# .github/workflows/build.yml
- name: Build with PyInstaller
  run: pyinstaller --onefile myapp.py

- name: Analyze dependencies  
  run: pyi-bindepend dist/myapp > dependencies.txt

- name: Verify archive contents
  run: echo -e "ls\nq" | pyi-archive_viewer dist/myapp > contents.txt

- name: Upload analysis artifacts
  uses: actions/upload-artifact@v3
  with:
    name: build-analysis
    path: |
      dependencies.txt
      contents.txt

# Check what's actually bundled
pyi-archive_viewer dist/myapp.exe
# Look for missing modules in PYZ archive

# Analyze system dependencies
pyi-bindepend dist/myapp/_internal/libsomething.so
# Identify missing system libraries

# List all bundled files with sizes
echo -e "ls -l\nq" | pyi-archive_viewer dist/myapp.exe | grep -E "^\s*\d+"
# Identify large files for exclusion

# Check if UPX compression is working
pyi-bindepend --upx-dir /usr/bin dist/myapp.exe

# Extract template from similar application
pyi-grab_version reference_app.exe -o version_template.txt

# Customize version info programmatically
sed -i 's/Reference App/My Application/g' version_template.txt

# Apply to built executable
pyi-set_version version_template.txt dist/myapp.exe