### PyUpdater Build Command for Release Channels

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-cli-advanced.md

Demonstrates how to use the `pyupdater build` command with the `--app-version` flag to specify different release channels. This includes examples for Stable, Beta, and Alpha releases, showing the distinct versioning patterns for each.

```bash
$ pyupdater build --app-version=3.30.1
$ pyupdater build --app-version=2.1
$ pyupdater build --app-version=1.0
```

```bash
$ pyupdater build --app-version=1.0.1b
$ pyupdater build --app-version=3.1b2
$ pyupdater build --app-version=11.3.1beta2
```

```bash
$ pyupdater build --app-version=1.0.1a
$ pyupdater build --app-version=5.0alpha
$ pyupdater build --app-version=1.1.1alpha1
```

--------------------------------

### PyUpdater Release Channel Examples

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-cli-advanced.md

Demonstrates how to specify different release channels (Stable, Beta, Alpha) when building application versions using the PyUpdater CLI.

```APIDOC
## PyUpdater Release Channels

PyUpdater supports three release channels: Stable, Beta, and Alpha. These channels are specified when providing a version number to the `--app-version` flag during the build process. Patches are created for each channel.

### Stable Channel Examples

```bash
$ pyupdater build --app-version=3.30.1
$ pyupdater build --app-version=2.1
$ pyupdater build --app-version=1.0
```

### Beta Channel Examples

```bash
$ pyupdater build --app-version=1.0.1b
$ pyupdater build --app-version=3.1b2
$ pyupdater build --app-version=11.3.1beta2
```

### Alpha Channel Examples

```bash
$ pyupdater build --app-version=1.0.1a
$ pyupdater build --app-version=5.0alpha
$ pyupdater build --app-version=1.1.1alpha1
```

### Method

`build` (CLI command)

### Parameters

#### Command Line Arguments

- **`--app-version`** (string) - Required - The version number for the application, including the release channel suffix if applicable.
```

--------------------------------

### Install PyUpdater with Optional Dependencies

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/changelog.md

Commands to install PyUpdater with specific feature sets. Use the patch flag for patch support or the all flag to include AWS S3 and SCP upload plugins.

```bash
pip install pyupdater[patch]
pip install pyupdater[all]
```

--------------------------------

### PyUpdater Client: Implementing a Custom File Downloader

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-client-advanced.md

Provides an example of creating a custom file downloader class for PyUpdater. The custom downloader must adhere to a specific signature and handle downloading and verification of files.

```python
from pyupdater.client import Client, DefaultClientConfig


class MyDownloader:

    def __init__(self, filename, urls, **kwargs):
        self.filename = filename
        self.urls = urls
        self.hexdigest = kwargs.get("hexdigest")
        
        self._data = None
    
    def download_verify_return(self):
        # Download the data from the endpoint and return
        return self._data
    
    def download_verify_write(self):
        # Write the downloaded data to the current dir
        try:
            with open(self.filename, 'wb') as f:
                f.write(self._data)
            return True
        except:
            return False

client = Client(DefaultClientConfig(), downloader=MyDownloader)
```

--------------------------------

### Manage PyUpdater Plugins

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-cli.md

Lists installed PyUpdater plugins and allows for their configuration. Plugins extend PyUpdater's functionality, such as enabling uploads to different services. Official plugins can be installed using pip.

```bash
# You can install the official plugins with
# pip install pyupdater[s3, scp]
$ pyupdater plugins
```

```bash
$ pyupdater settings --plugin s3
```

--------------------------------

### Install PyUpdater Patch Dependency (>= 2.0.3)

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/upgrading.md

This command installs the PyUpdater patch functionality, which is now included by default and deprecated as a separate installable extra.

```bash
pip install pyupdater[patch]
```

--------------------------------

### GET /update_check

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-client-advanced.md

Checks for available application updates from a specified release channel.

```APIDOC
## GET /update_check

### Description
Checks for updates for a specific application version. Supports different release channels such as stable, beta, or alpha.

### Method
GET

### Endpoint
client.update_check(APP_NAME, APP_VERSION, channel=None)

### Parameters
#### Query Parameters
- **APP_NAME** (string) - Required - The name of the application.
- **APP_VERSION** (string) - Required - The current version of the application.
- **channel** (string) - Optional - The release channel (e.g., 'beta'). Defaults to 'stable'.

### Request Example
client.update_check('MyApp', '1.0.0', channel='beta')

### Response
#### Success Response (200)
- **app_update** (object) - An update object if an update is available, otherwise None.

#### Response Example
{
  "update_available": true,
  "version": "1.1.0"
}
```

--------------------------------

### Initialize PyUpdater Client

Source: https://context7.com/digital-sapphire/pyupdater/llms.txt

Demonstrates how to instantiate the Client class with various configurations, including automatic refresh, progress hooks, custom headers for authentication, and custom data directories.

```python
from pyupdater.client import Client
from client_config import ClientConfig

APP_NAME = 'MyApp'
APP_VERSION = '1.0.0'

# Initialize client with refresh on init
client = Client(ClientConfig(), refresh=True)

# Or initialize and refresh manually
client = Client(ClientConfig())
client.refresh()

# Initialize with progress hooks
def print_progress(info):
    print(f"Downloaded: {info['downloaded']}/{info['total']} bytes")
    print(f"Status: {info['status']}")
    print(f"Percent: {info['percent_complete']}%")

client = Client(
    ClientConfig(),
    refresh=True,
    progress_hooks=[print_progress]
)

# Initialize with custom headers (e.g., basic auth)
headers = {'basic_auth': 'username:password'}
client = Client(ClientConfig(), headers=headers)

# Initialize with custom data directory
client = Client(ClientConfig(), data_dir='/custom/update/path')
```

--------------------------------

### Implementing a Custom Uploader Plugin

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/create-upload-plugin.md

This documentation outlines how to create a custom uploader class by extending BaseUploader and registering it via setuptools entry points.

```APIDOC
## Class Implementation: BaseUploader

### Description
Create a custom plugin by inheriting from `pyupdater.core.uploader.BaseUploader`. Plugins must define a `name` and `author`, and implement `init_config` and `set_config` methods.

### Implementation Details
- **init_config(self, config)**: Called after class initialization to load configuration settings.
- **set_config(self, config)**: Used to prompt the user for configuration input or retrieve it from environment variables.
- **upload_file(self, filename)**: Core method to handle the file upload logic.

### Registration
Plugins are registered in `setup.py` using the `pyupdater.plugins` entry point:

```python
entry_points={
    'pyupdater.plugins': [
        'my_uploader = my_uploader:MyUploader',
    ]
}
```

### Configuration Example
```python
def set_config(self, config):
    server_name = self.get_answer("Please enter server name\n--> ")
    config["server_url"] = server_name
```
```

--------------------------------

### CLI Command: pyupdater init

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/commands.md

Initializes a repository for use with PyUpdater.

```APIDOC
## CLI COMMAND: pyupdater init

### Description
Initializes the current directory for PyUpdater. Creates configuration and data directories along with a client_config.py file.

### Method
CLI

### Request Example
$ pyupdater init
```

--------------------------------

### Initialize PyUpdater Repository

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/commands.md

The init command initializes a new or existing repository for use with PyUpdater. It prompts the user for application details and creates necessary configuration files and directories, including a config directory, a data directory, and a client_config.py file. These files manage PyUpdater settings and can be regenerated upon updates.

```bash
pyupdater init [-h]

optional arguments:
  -h, --help            show this help message and exit
```

```bash
$ pyupdater init
```

--------------------------------

### PyUpdater Client Initialization

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-client.md

Demonstrates how to initialize the PyUpdater client, either with or without immediate refresh and progress hooks.

```APIDOC
## PyUpdater Client Initialization

### Description
Initialize a client with the ClientConfig & later call refresh to get latest update data. Progress hooks can also be added later.

### Method
N/A (Initialization)

### Endpoint
N/A (Client-side)

### Parameters
N/A

### Request Example
```python
from pyupdater.client import Client
from client_config import ClientConfig

# Initialize client and refresh later
client = Client(ClientConfig())
client.refresh()

# Add progress hook
def print_status_info(info):
    total = info.get(u'total')
    downloaded = info.get(u'downloaded')
    status = info.get(u'status')
    print downloaded, total, status

client.add_progress_hook(print_status_info)
```

### Response
N/A

---

### Description
Initialize a client with the ClientConfig, add progress hook & refresh during initialization.

### Method
N/A (Initialization)

### Endpoint
N/A (Client-side)

### Parameters
N/A

### Request Example
```python
from pyupdater.client import Client
from client_config import ClientConfig

def print_status_info(info):
    total = info.get(u'total')
    downloaded = info.get(u'downloaded')
    status = info.get(u'status')
    print downloaded, total, status

client = Client(
            ClientConfig(), refresh=True, progress_hooks=[print_status_info]
         )
```

### Response
N/A
```

--------------------------------

### PyUpdater Client: Setting and Adding Progress Callbacks

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-client-advanced.md

Illustrates how to set up progress hooks for downloads, either during client initialization or by adding them later. Progress hooks receive a dictionary with download status details.

```python
# Progress hooks get passed a dict with the below keys.
# total: total file size
# downloaded: data received so far
# status: will show either downloading or finished
# percent_complete: Percentage of file downloaded so far
# time: Time left to complete download

def progress(data):
    print('Time remaining'.format(data['time']))

def log_progress(data):
    log.debug('Total file size %s', data['total'])


# You can initialize the client with a callbacks
client = Client(ClientConfig(), progress_hooks=[progress, log_progress])

# Or you can add them later.
client = Client(ClientConfig())
client.add_progress_hook(log_progress)
client.add_progress_hook(progress)
```

--------------------------------

### Configure PyUpdater Plugin Entry Points

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/create-upload-plugin.md

This Python code snippet demonstrates how to configure PyUpdater to discover custom plugins using setuptools entry points. It specifies that the 'my_uploader' plugin, implemented by the MyUploader class in the 'my_uploader' module, should be available under the 'pyupdater.plugins' namespace. This is typically done within a `setup.py` file.

```python
setup(
    provides=['pyupdater.plugins',],
    entry_points={
        'pyupdater.plugins': [
            'my_uploader = my_uploader:MyUploader',
            ]
        },

```

--------------------------------

### PyUpdater Client: Checking for Updates with Release Channels

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-client-advanced.md

Demonstrates how to check for application updates using the PyUpdater client, specifying different release channels (stable, beta) or defaulting to stable if no channel is provided.

```python
# Requesting updates from the beta channel
app_update = client.update_check(APP_NAME, APP_VERSION, channel='beta')

# If no channel is specified, stable will be used
app_update = client.update_check(APP_NAME, APP_VERSION)
```

--------------------------------

### Initialize PyUpdater Repository

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-cli.md

Initializes the PyUpdater repository in your project's root directory. This process creates necessary configuration files and directories for PyUpdater to manage updates.

```bash
$ pyupdater init
```

--------------------------------

### Check and Apply Asset Updates

Source: https://context7.com/digital-sapphire/pyupdater/llms.txt

Demonstrates the standard workflow for checking, downloading, and extracting application updates using the PyUpdater client.

```python
lib_update = client.update_check(ASSET_NAME, ASSET_VERSION)

if lib_update is not None:
    print(f"New version available: {lib_update.version}")
    lib_update.download()
    if lib_update.is_downloaded():
        if lib_update.extract():
            print(f"Asset extracted to: {lib_update.update_folder}")
        else:
            print("Extraction failed")
```

--------------------------------

### PyUpdater Plugin Configuration Methods

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/create-upload-plugin.md

This Python code illustrates two methods for handling configuration within a PyUpdater plugin: `set_config` and `init_config`. `set_config` prompts the user for input (e.g., a server name) and stores it in the configuration. `init_config` is called after initialization and retrieves configuration values (e.g., `server_url`) that were previously set.

```python
# Saves the config to disk.
def set_config(self, config):
    server_name = self.get_answer("Please enter server name\n--> ")
    config["server_url"] = server_name


# Will be called after the class is initialized.
def init_config(self, config):
    self.server_url = config["server_url"]

```

--------------------------------

### Create Custom Upload Plugin

Source: https://context7.com/digital-sapphire/pyupdater/llms.txt

Provides a template for creating a custom uploader plugin by subclassing BaseUploader and defining setuptools entry points.

```python
from pyupdater.core.uploader import BaseUploader
import requests

class MyCloudUploader(BaseUploader):
    name = 'mycloud'
    def upload_file(self, filename):
        with open(filename, 'rb') as f:
            response = requests.post(f"{self.endpoint}/upload", files={'file': f})
        return response.status_code == 200

# setup.py entry point
entry_points={'pyupdater.plugins': ['mycloud = my_uploader:MyCloudUploader']}
```

--------------------------------

### Configure Update Strategies

Source: https://context7.com/digital-sapphire/pyupdater/llms.txt

Configures how PyUpdater handles binary replacement on Windows, choosing between overwriting the existing file or renaming it.

```python
from pyupdater.client import Client
from pyupdater.client.updates import UpdateStrategy
from client_config import ClientConfig

client = Client(ClientConfig(), strategy=UpdateStrategy.RENAME)
client.refresh()
app_update = client.update_check('MyApp', '1.0.0')

if app_update:
    app_update.download()
    if app_update.is_downloaded():
        app_update.extract_restart()
```

--------------------------------

### POST /download

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-client-advanced.md

Initiates a file download for an available update, optionally in the background.

```APIDOC
## POST /download

### Description
Downloads the update package. Can be performed in the background and supports progress tracking via hooks.

### Method
POST

### Endpoint
app_update.download(background=bool)

### Parameters
#### Request Body
- **background** (boolean) - Optional - If true, the download runs in a background thread.

### Request Example
app_update.download(background=True)

### Response
#### Success Response (200)
- **status** (boolean) - Returns True if the download was initiated successfully.
```

--------------------------------

### Client Initialization

Source: https://context7.com/digital-sapphire/pyupdater/llms.txt

Initializes the PyUpdater Client to manage update checks and configuration settings.

```APIDOC
## Client Initialization

### Description
Initializes the main client class for checking and downloading updates. Requires a configuration object.

### Method
Constructor

### Parameters
#### Request Body
- **config** (ClientConfig) - Required - Configuration object containing application settings.
- **refresh** (bool) - Optional - Whether to refresh update data on initialization.
- **progress_hooks** (list) - Optional - List of callback functions for download progress.
- **headers** (dict) - Optional - Custom HTTP headers for requests.
- **data_dir** (str) - Optional - Custom directory path for update files.

### Request Example
client = Client(ClientConfig(), refresh=True, progress_hooks=[callback])
```

--------------------------------

### Build Application Executable with PyUpdater

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/commands.md

The build command automates the process of creating a distributable application executable by wrapping PyInstaller. It archives the built executable in a PyUpdater-compatible format and places it in the pyu-data/new directory. Options allow specifying archive format, cleaning the build cache, setting the application version (including alpha/beta tags for specific release channels), and printing PyInstaller logs.

```bash
pyupdater build [opts]<script>

optional arguments:
  -h, --help            show this help message and exit
  --archive-format {zip,gztar,bztar,default}
  --clean               Clean build. Bypass the cache
  --app-version APP_VERSION
  -k, --keep            Will not delete executable after archiving
  --pyinstaller-log-info
                        Prints PyInstaller execution info to consoleconsole
```

```bash
# Build from python script
$ pyupdater build -F --app-version 1.0 app.py

# Build from spec file (see Make Spec on how to create spec files)
$ pyupdater build --app-version 1.2 app.spec

# Beta channel
$ pyupdater build --app-version 1.2beta2
```

--------------------------------

### Implement Auto-Update Logic with PyUpdater

Source: https://context7.com/digital-sapphire/pyupdater/llms.txt

This snippet demonstrates how to initialize the PyUpdater Client, check for available updates, monitor download progress using hooks, and trigger an automatic restart upon successful update application.

```python
import sys
from pyupdater.client import Client
from client_config import ClientConfig

APP_NAME = 'MyAwesomeApp'
APP_VERSION = '1.0.0'

def check_for_updates():
    def progress(info):
        sys.stdout.write(f"\rDownloading: {info['percent_complete']:.1f}%")
        sys.stdout.flush()

    try:
        client = Client(ClientConfig(), refresh=True, progress_hooks=[progress])
        app_update = client.update_check(APP_NAME, APP_VERSION)

        if app_update is not None:
            app_update.download()
            if app_update.is_downloaded():
                app_update.extract_restart()
        else:
            print("You're running the latest version!")
    except Exception as e:
        print(f"Update check failed: {e}")
```

--------------------------------

### PyUpdater Client: Background Downloads and Status Check

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-client-advanced.md

Shows how to initiate a background download of an update and check if the download has been completed using the PyUpdater client.

```python
app_update = client.update_check(APP_NAME, APP_VERSION)
if app_update:
    app_update.download(background=True)

# To check the status of the download
# Returns a boolean
app_update.is_downloaded()
```

--------------------------------

### Download and Apply Updates

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-client.md

Downloads the update package and applies it by overwriting the current binary. Supports background downloading and automatic application restart.

```python
if app_update is not None:
    # Download in background
    app_update.download(background=True)

    # Verify and apply update
    if app_update.is_downloaded():
        app_update.extract_restart()
```

--------------------------------

### Create a Simple PyUpdater Upload Plugin

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/create-upload-plugin.md

This Python code defines a basic upload plugin for PyUpdater. It inherits from BaseUploader and implements methods to initialize configuration, set configuration values (prompting the user for a server URL), and upload a file to a specified server URL. Dependencies include the `pyupdater.core.uploader` module and a request library for HTTP POST.

```python
from pyupdater.core.uploader import BaseUploader


class MyUploader(BaseUploader):

    name = 'my uploader'
    author = 'Jane Doe'

    def init_config(self, config):
        self.server_url = config["server_url"]

    def set_config(self, config):
        server_name = self.get_answer("Please enter server name\n--> ")
        config["server_url"] = server_name

    def upload_file(self, filename):
        # Make the magic happen
        files = {'file': open(filename, 'rb')}
        r = request.post(self.server_url, files=files)

```

--------------------------------

### Implement Custom API Downloader

Source: https://context7.com/digital-sapphire/pyupdater/llms.txt

Shows how to create a custom downloader class to fetch files from an API endpoint instead of standard URLs, and register it with the PyUpdater client.

```python
from pyupdater.client import Client, DefaultClientConfig
import requests

class APIDownloader:
    def __init__(self, filename, urls, **kwargs):
        self.filename = filename
        self.urls = urls

    def download_verify_return(self):
        for url in self.urls:
            response = requests.get(f"{url}/api/files/{self.filename}")
            if response.status_code == 200:
                return response.content
        return None

client = Client(DefaultClientConfig(), downloader=APIDownloader)
client.refresh()
```

--------------------------------

### Package and Sign Updates

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-cli.md

Creates update packages, including version manifests and compressed files. The --process flag calculates file hashes and sizes, while the --sign flag cryptographically signs the version manifest and keyfile. These can be combined for a comprehensive packaging process.

```bash
$ pyupdater pkg --process
```

```bash
$ pyupdater pkg --sign
```

```bash
# For CI/CD
$ pyupdater pkg --sign --split-version
```

--------------------------------

### Initialize PyUpdater Client

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-client.md

Configures the PyUpdater client using the ClientConfig class. It supports optional refresh and progress hooks to monitor download status.

```python
from pyupdater.client import Client
from client_config import ClientConfig

def print_status_info(info):
    total = info.get(u'total')
    downloaded = info.get(u'downloaded')
    status = info.get(u'status')
    print downloaded, total, status

# Standard initialization
client = Client(ClientConfig())
client.refresh()
client.add_progress_hook(print_status_info)

# Alternative initialization
client = Client(ClientConfig(), refresh=True, progress_hooks=[print_status_info])
```

--------------------------------

### PyUpdater Apply Update

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-client.md

Details on how to verify, extract, and apply downloaded updates, including restarting the application.

```APIDOC
## PyUpdater Apply Update

### Description
Ensure file downloaded successfully, extract update & overwrite current application. Note that is_downloaded verifies the files hash.

### Method
N/A (Client-side method call)

### Endpoint
N/A (Client-side)

### Parameters
N/A

### Request Example
```python
if app_update.is_downloaded():
    app_update.extract_overwrite()
```

---

### Description
Ensure file downloaded successfully, extract update, overwrite current application & restart application with the updated binary.

### Method
N/A (Client-side method call)

### Endpoint
N/A (Client-side)

### Parameters
N/A

### Request Example
```python
if app_update.is_downloaded():
    app_update.extract_restart()
```

### Response
N/A
```

--------------------------------

### Build Application Updates

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-cli.md

Builds the application updates either from a spec file or a main script. This command is essential for creating distributable update packages. Version information can be specified using the --app-version flag.

```bash
# Build from a spec file.
$ pyupdater build --app-version=1.0.0 main.spec
```

```bash
# Build from a script.
$ pyupdater build --app-version=1.0.0 main.py
```

```bash
# To show pyinstaller build info use --pyinstaller-log-info
```

--------------------------------

### Download and Apply Updates

Source: https://context7.com/digital-sapphire/pyupdater/llms.txt

Handles the lifecycle of an update object, including downloading, verifying completion, extracting, and cleaning up temporary archives.

```python
from pyupdater.client import Client
from client_config import ClientConfig

client = Client(ClientConfig(), refresh=True)
app_update = client.update_check('MyApp', '1.0.0')

if app_update is not None:
    # Download update (blocking)
    app_update.download()

    # Or download in background thread
    app_update.download(background=True)

    # Check if download completed
    while not app_update.is_downloaded():
        import time
        time.sleep(1)
        print("Waiting for download...")

    # Verify download and extract
    if app_update.is_downloaded():
        # Option 1: Extract and overwrite current binary
        app_update.extract_overwrite()

        # Option 2: Extract, overwrite, and restart application
        app_update.extract_restart()

    # Clean up old update archives
    app_update.cleanup()
```

--------------------------------

### Initialize PyUpdater Client

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-client-asset.md

Initializes the PyUpdater client with configuration and optionally refreshes update data or adds progress hooks during initialization. This sets up the client for subsequent update operations.

```python
from pyupdater.client import Client
from client_config import ClientConfig

APP_NAME = 'Super App'
APP_VERSION = '1.1.0'

ASSET_NAME = 'ffmpeg'
ASSET_VERSION = '2.3.2'

def print_status_info(info):
    total = info.get(u'total')
    downloaded = info.get(u'downloaded')
    status = info.get(u'status')
    print downloaded, total, status

# Initialize client and refresh later
client = Client(ClientConfig())
client.refresh()
client.add_progress_hook(print_status_info)

# Initialize client with refresh and progress hooks
client = Client(ClientConfig(), refresh=True,
                        progress_hooks=[print_status_info])
```

--------------------------------

### CLI Command: pyupdater build

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/commands.md

Wraps PyInstaller to create a final executable and prepare it for distribution.

```APIDOC
## CLI COMMAND: pyupdater build

### Description
Builds the application using PyInstaller, archives the result in a PyUpdater-compatible format, and places it in the pyu-data/new directory.

### Method
CLI

### Parameters
#### Options
- **--archive-format** (string) - Optional - Format: zip, gztar, bztar, default.
- **--clean** (boolean) - Optional - Bypass the cache for a clean build.
- **--app-version** (string) - Optional - Version string for the application.
- **-k, --keep** (boolean) - Optional - Do not delete the executable after archiving.

### Request Example
$ pyupdater build -F --app-version 1.0 app.py
```

--------------------------------

### CLI Command: pyupdater keys

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/commands.md

Manages cryptographic keypacks for signing metadata files.

```APIDOC
## CLI COMMAND: pyupdater keys

### Description
Used to create or import keypack files for cryptographically signing metadata.

### Method
CLI

### Parameters
#### Options
- **-i, --import** (boolean) - Optional - Imports a keypack from the current directory.
- **-c, --create** (boolean) - Optional - Creates a new keypack.
- **-y, --yes** (boolean) - Optional - Skip confirmation prompts.

### Request Example
$ pyupdater keys --create
```

--------------------------------

### AppUpdate / LibUpdate Lifecycle

Source: https://context7.com/digital-sapphire/pyupdater/llms.txt

Manages the download, verification, and extraction process for application binaries or external assets.

```APIDOC
## AppUpdate / LibUpdate Operations

### Description
Handles the lifecycle of an update object, including downloading, verifying, and applying updates.

### Methods
- **download(background=False)**: Downloads the update file.
- **is_downloaded()**: Checks if the download is complete.
- **extract_overwrite()**: Extracts and overwrites the current binary.
- **extract_restart()**: Extracts, overwrites, and restarts the application.
- **cleanup()**: Removes old update archives.

### Response Example
if app_update is not None:
    app_update.download()
    app_update.extract_restart()
```

--------------------------------

### PyUpdater Download Update

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-client.md

Illustrates how to download an available update, including options for background downloads.

```APIDOC
## PyUpdater Download Update

### Description
If an update object was returned, we can proceed to download the update.

### Method
N/A (Client-side method call)

### Endpoint
N/A (Client-side)

### Parameters
N/A

### Request Example
```python
if app_update is not None:
    app_update.download()
```

---

### Description
We can also download in a background thread.

### Method
N/A (Client-side method call)

### Endpoint
N/A (Client-side)

### Parameters
N/A

### Request Example
```python
if app_update is not None:
    app_update.download(background=True)
```

### Response
N/A
```

--------------------------------

### Create and Manage PyUpdater Keypacks

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-cli.md

This command generates a new keypack for secure update verification. It's crucial to use the same application name for all keypacks related to a single application to ensure proper metadata verification and auto-updating.

```bash
$ pyupdater keys -c
```

```bash
$ scp dev-machine:keypack.pyu .
```

```bash
$ pyupdater keys -i
```

--------------------------------

### PyUpdater Client: Basic Authentication Configuration

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-client-advanced.md

Explains how to configure basic authentication for the PyUpdater client to secure access to the update repository. This involves passing a 'basic_auth' header with credentials.

```python
headers = {'basic_auth': 'user:pass'}
client = Client(ClientConfig(), headers=headers)
```

--------------------------------

### POST /client_config

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-client-advanced.md

Configures the PyUpdater client with authentication headers and progress hooks.

```APIDOC
## POST /client_config

### Description
Initializes the client with custom configurations, including basic authentication headers and progress reporting callbacks.

### Method
POST

### Endpoint
Client(ClientConfig, headers=dict, progress_hooks=list)

### Parameters
#### Request Body
- **headers** (dict) - Optional - Dictionary of HTTP headers (e.g., {'basic_auth': 'user:pass'}).
- **progress_hooks** (list) - Optional - List of callback functions to receive download progress data.

### Request Example
headers = {'basic_auth': 'user:pass'}
client = Client(ClientConfig(), headers=headers)
```

--------------------------------

### Upload Updates to Service

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-cli.md

Uploads the created updates, patches, and metadata to a configured service. This is the final step in distributing your application updates. The --service flag specifies the target upload service.

```bash
$ pyupdater upload --service s3
```

--------------------------------

### Register Progress Hooks

Source: https://context7.com/digital-sapphire/pyupdater/llms.txt

Registers callback functions to monitor download progress. Callbacks receive a dictionary containing total size, downloaded bytes, status, and completion percentage.

```python
from pyupdater.client import Client
from client_config import ClientConfig

def progress_callback(info):
    percent = info.get('percent_complete', 0)
    status = info.get('status', '')
    print(f"Download progress: {percent:.1f}% - {status}")

def log_callback(info):
    import logging
    logging.debug(f"Total size: {info['total']}, Downloaded: {info['downloaded']}")

client = Client(ClientConfig())
client.add_progress_hook(progress_callback)
client.add_progress_hook(log_callback)
client.refresh()
```

--------------------------------

### Manage PyUpdater Keys

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/commands.md

The keys command is used for managing cryptographic keys used by PyUpdater to sign metadata files. It supports importing keypacks from the current directory and creating new keypacks, which should ideally be done on an offline machine for security. The '--yes' flag can bypass confirmation prompts.

```bash
pyupdater keys [-h] [-i] [-c] [-y]

optional arguments:
  -h, --help    show this help message and exit
  -i, --import  Imports a keypack from the current working directory
  -c, --create  Creates keypack. Should only be used on your off-line machine
  -y, --yes     Will run command without conformation prompt
```

```bash
# Create
$ pyupdater keys --create

# Once you initialized your repo & copied the keypack to the root of the repo.
$ pyupdater keys --import
```

--------------------------------

### CLI Command: pyupdater archive

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/commands.md

Archives an external asset for use with the application update system.

```APIDOC
## CLI COMMAND: pyupdater archive

### Description
The archive command archives an external asset, allowing it to be updated independently of the main application bundle.

### Method
CLI

### Parameters
#### Options
- **--name** (string) - Optional - Name used when renaming binary before archiving.
- **--version** (string) - Optional - Version of the file.
- **-k, --keep** (boolean) - Optional - If set, will not delete the source file after archiving.

### Request Example
$ pyupdater archive --name ffmpeg --version 2.1.4
```

--------------------------------

### PyUpdater Update Check

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-client.md

Shows how to check for available application updates, including checking a specific channel.

```APIDOC
## PyUpdater Update Check

### Description
Method update_check returns an AppUpdate object if there is an update available else None.

### Method
N/A (Client-side method call)

### Endpoint
N/A (Client-side)

### Parameters
N/A

### Request Example
```python
APP_NAME = 'Super App'
APP_VERSION = '1.1.0'

app_update = client.update_check(APP_NAME, APP_VERSION)
```

---

### Description
Checking for updates on the beta channel.

### Method
N/A (Client-side method call)

### Endpoint
N/A (Client-side)

### Parameters
N/A

### Request Example
```python
APP_NAME = 'Super App'
APP_VERSION = '1.1.0'

app_update = client.update_check(APP_NAME, APP_VERSION, channel='beta')
```

### Response
N/A
```

--------------------------------

### Create PyUpdater Compatible Spec File

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/commands.md

The make-spec command generates a PyUpdater-compatible spec file, which is used by PyInstaller to build the application executable. This command takes the main Python script as an argument and can optionally print PyInstaller execution information to the console.

```bash
pyupdater make-spec <script> [opts]

optional arguments:
  -h, --help            show this help message and exit
  --pyinstaller-log-info
                        Prints PyInstaller execution info to console
```

```bash
$ pyupdater make-spec app.py
```

--------------------------------

### Download and Extract Updates

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-client-asset.md

Downloads and extracts an available update for an asset. The download can be performed in the foreground or background thread. After successful download, the update can be extracted, and the update folder path can be accessed.

```python
from pyupdater.client import Client
from client_config import ClientConfig

APP_NAME = 'Super App'
APP_VERSION = '1.1.0'

ASSET_NAME = 'ffmpeg'
ASSET_VERSION = '2.3.2'

def print_status_info(info):
    total = info.get(u'total')
    downloaded = info.get(u'downloaded')
    status = info.get(u'status')
    print downloaded, total, status

client = Client(ClientConfig(), refresh=True,
                        progress_hooks=[print_status_info])
lib_update = client.update_check(ASSET_NAME, ASSET_VERSION)

if lib_update is not None:
    # Download the update
    lib_update.download()
    
    # Download in a background thread
    # lib_update.download(background=True)

    # Ensure file downloaded successfully and extract
    if lib_update.is_downloaded():
        lib_update.extract()

        # Update will be extracted in the update folder
        print(lib_update.update_folder)
```

--------------------------------

### Client.update_check()

Source: https://context7.com/digital-sapphire/pyupdater/llms.txt

Checks for available updates based on application name, current version, and release channel.

```APIDOC
## Client.update_check()

### Description
Queries the update server for new versions. Supports multiple release channels like stable, beta, or alpha.

### Parameters
#### Query Parameters
- **app_name** (str) - Required - Name of the application.
- **current_version** (str) - Required - Current version string.
- **channel** (str) - Optional - Release channel (default: 'stable').
- **strict** (bool) - Optional - If false, gets the highest version across all channels.

### Response
#### Success Response (200)
- **AppUpdate/LibUpdate** (Object) - Returns an update object if available, otherwise None.
```

--------------------------------

### pyupdater.client.LibUpdate

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/api.md

Manages the download, extraction, and cleanup of library updates for an application. This object is typically obtained from a client's update check.

```APIDOC
## LibUpdate Class

### Description
Used to update library files used by an application. This object is returned by `pyupdater.client.Client.update_check`.

### Methods

#### `cleanup()`

Cleans up old update archives for this app or asset.

#### `download(background=False)`

Downloads the update.

##### Args:
* `background` (bool) - Optional - Perform download in background thread.

#### `extract()`

Will extract the update from its archive to the update folder. If updating a lib, you can take over from there. If updating an app, this call should be followed by the `restart` method to complete the update.

##### Returns:
* `bool` - True if extraction was successful, False otherwise.

#### `is_downloaded()`

Used to check if an update has already been downloaded.

##### Returns:
* `bool` - True if the file is already downloaded, False otherwise.
```

--------------------------------

### Check for Application Updates

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-client.md

Checks for available updates for a specific application version. Supports specifying channels like 'beta' to target different release streams.

```python
APP_NAME = 'Super App'
APP_VERSION = '1.1.0'

# Standard check
app_update = client.update_check(APP_NAME, APP_VERSION)

# Beta channel check
app_update_beta = client.update_check(APP_NAME, APP_VERSION, channel='beta')
```

--------------------------------

### Archive External Assets with PyUpdater

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/commands.md

The archive command allows you to archive external assets used by your application, such as dependencies like ffmpeg. This is useful for managing assets separately from your main application bundle. It supports specifying a name and version for the archived asset and can optionally keep the source file after archiving.

```bash
pyupdater archive [opts] filename

optional arguments:
  -h, --help            show this help message and exit
  --name NAME           Name used when renaming binary before archiving.
  --version VERSION     Version of file
  -k, --keep            Will not delete source file after archiving
```

```bash
$ pyupdater archive --name ffmpeg --version 2.1.4

$ pyupdater archive --name ffmpeg --version 2.2
```

--------------------------------

### Update PyUpdater Settings (>= 2.0)

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/upgrading.md

This command is used to update PyUpdater settings when migrating from versions prior to 2.0. It prompts the user to press enter to use default values.

```bash
$ pyupdater settings --config-path
```

--------------------------------

### Check for Application Updates

Source: https://context7.com/digital-sapphire/pyupdater/llms.txt

Checks for available updates using the update_check method. Supports specifying release channels like stable, beta, or alpha, and toggling strict version checking.

```python
from pyupdater.client import Client
from client_config import ClientConfig

client = Client(ClientConfig(), refresh=True)

# Check for stable updates (default)
app_update = client.update_check('MyApp', '1.0.0')

# Check for beta updates
app_update = client.update_check('MyApp', '1.0.0', channel='beta')

# Check for alpha updates
app_update = client.update_check('MyApp', '1.0.0', channel='alpha')

# Non-strict mode: get highest version across all channels
app_update = client.update_check('MyApp', '1.0.0', channel='stable', strict=False)

if app_update is not None:
    print(f"Update available: {app_update.version}")
else:
    print("No updates available")
```

--------------------------------

### Debugging PyUpdater Issues

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-cli.md

Enables detailed logging for debugging PyUpdater issues, such as misconfigured upload URLs or keys. Creating the `pyu.log` file in the application's root directory will activate debug logging.

```bash
# Create pyu.log in the root of your app to enable debug logging.
```

--------------------------------

### Update PyUpdater Download Method (>= 3.0)

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/upgrading.md

This snippet shows the change in the download method signature from `async=True` to `background=True` for both `AppUpdate` and `LibUpdate` classes in PyUpdater versions 3.0 and above.

```python
AppUpdate.download(async=True) 
# To
AppUpdate.download(background=True)
```

```python
LibUpdate.download(async=True)
# To
LibUpdate.download(background=True)
```

--------------------------------

### pyupdater.client.UpdateStrategy

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/api.md

An enumeration representing the different update strategies available in PyUpdater.

```APIDOC
## UpdateStrategy Enum

### Description
Enum representing the update strategies available.

### Methods
(No specific methods detailed in the provided text, implies enum members)
```

--------------------------------

### Generate PyInstaller Spec File

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-cli.md

Generates a spec file for PyInstaller, which can be further customized for your application's build process. This is useful for applications with specific build requirements.

```bash
$ pyupdater make-spec -w main.py
```

```bash
$ pyupdater make-spec -F -w main.py
```

```bash
# To show pyinstaller build info use --pyinstaller-log-info
```

--------------------------------

### Check for Asset Updates

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/usage-client-asset.md

Checks for available updates for a specific asset, identified by its name and version. It can optionally target a specific update channel, such as 'beta'. Returns an update object if an update is found.

```python
from pyupdater.client import Client
from client_config import ClientConfig

APP_NAME = 'Super App'
APP_VERSION = '1.1.0'

ASSET_NAME = 'ffmpeg'
ASSET_VERSION = '2.3.2'

client = Client(ClientConfig())
client.refresh()

# Check for updates on the default channel
lib_update = client.update_check(ASSET_NAME, ASSET_VERSION)

# Check for updates on the beta channel
lib_update = client.update_check(ASSET_NAME, ASSET_VERSION, channel='beta')
```

--------------------------------

### Collect Debug Information with PyUpdater

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/commands.md

The collect-debug-info command gathers debugging logs from the PyUpdater CLI and uploads them to a private GitHub Gist. This is helpful for troubleshooting issues with PyUpdater. The command requires no arguments.

```bash
pyupdater collect-debug-info [-h]

optional arguments:
  -h, --help  show this help message and exit
```

```bash
$ pyupdater collect-debug-info
```

--------------------------------

### pyupdater.client.VerifyKey

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/api.md

Represents the public key counterpart to an Ed25519 SigningKey, used for verifying digital signatures.

```APIDOC
## VerifyKey Class

### Description
The public key counterpart to an Ed25519 SigningKey for producing digital signatures.

:param key: [:class:`bytes`] Serialized Ed25519 public key
:param encoder: A class that is able to decode the `key`

### Methods
(No specific methods detailed in the provided text)
```

--------------------------------

### Clean PyUpdater Repository Files

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/commands.md

The clean command removes all PyUpdater-related files and directories from the current repository, including the pyu-data and .pyupdater folders. This is useful for resetting PyUpdater's state or removing old build artifacts. A '-y' or '--yes' flag can be used to bypass the confirmation prompt.

```bash
pyupdater clean [-h] [-y]

optional arguments:
  -h, --help  show this help message and exit
  -y, --yes   Confirms removal of pyu-data & .pyupdater folder
```

```bash
$ pyupdater clean
```

--------------------------------

### Clean PyUpdater Repository

Source: https://context7.com/digital-sapphire/pyupdater/llms.txt

Removes all PyUpdater-generated files and directories from the current repository. Supports an optional confirmation bypass flag.

```bash
# Clean with confirmation prompt
$ pyupdater clean

# Clean without confirmation
$ pyupdater clean --yes
```

--------------------------------

### pyupdater.client.UnpaddedBase64Encoder

Source: https://github.com/digital-sapphire/pyupdater/blob/main/docs/api.md

A base64 encoder and decoder that removes padding characters. This is useful for compatibility with libraries like PyNaCL.

```APIDOC
## UnpaddedBase64Encoder Class

### Description
A simple encoder class to encode/decode to base64 with the 'padding' (trailing equal characters) removed. This is needed for PyNaCL to be compatible with keys generated by the old ed25519 library.

### Methods

#### `decode(data)`

Decodes base64 data without padding.

#### `encode(data)`

Encodes data to base64 without padding.
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.