portablepy 0.1.0__tar.gz

portablepy-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Caprine Logic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

portablepy-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include tests *.py

portablepy-0.1.0/PKG-INFO

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: portablepy
+Version: 0.1.0
+Summary: Build portable Python application bundles with verified offline wheels
+Author: depthbomb
+License-Expression: MIT
+Project-URL: Documentation, https://github.com/depthbomb/portablepy#readme
+Project-URL: Source, https://github.com/depthbomb/portablepy
+Project-URL: Issues, https://github.com/depthbomb/portablepy/issues
+Project-URL: Releases, https://github.com/depthbomb/portablepy/releases
+Keywords: python,portable,bundles,packaging,offline,wheels
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: argly<1,>=0.1
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-cov>=6; extra == "dev"
+Requires-Dist: ruff>=0.12; extra == "dev"
+Requires-Dist: mypy>=1.18; extra == "dev"
+Requires-Dist: twine>=6; extra == "dev"
+Dynamic: license-file
+
+# portablepy
+
+Bundle a Python app into a ZIP or tar.gz with its dependencies and a launcher. Share the archive, extract it, and run it. The bundle sets up its own environment and installs dependencies offline.
+
+Python itself isn't included. The person running the app needs a matching CPython version, operating system, and architecture.
+
+## Install
+
+Requires CPython 3.14 or later. Install it in a virtual environment:
+
+```sh
+python -m pip install portablepy
+```
+
+## Build an app
+
+```sh
+portablepy build ./my-app --run "python -m my_app"
+portablepy build ./script.py --run "python script.py" --output app.zip
+portablepy build ./my_app-1.0-py3-none-any.whl --run "my-console-command"
+```
+
+Build on the operating system and architecture your users have. portablepy uses the app's `.venv` when available, or its own Python interpreter otherwise. Use `--python PATH` to choose one.
+
+Without `--output`, the filename includes the app name, platform, architecture, and Python version. Windows gets a ZIP; Linux and macOS get a tar.gz. Use `--replace` to replace an existing archive after the new build passes validation.
+
+## Run the bundle
+
+Extract the whole archive somewhere writable, then double-click `run.cmd` on Windows or `run.command` on macOS. Linux bundles include `run.sh`; your file manager may need permission to run executable scripts.
+
+You can also use a terminal:
+
+```sh
+python run.py
+python run.py --help
+```
+
+Arguments go straight to your app. With `--compile all`, the launcher is `run.pyc`; use `python run.pyc` instead. The double-click launcher picks the right file automatically.
+
+The first launch checks the bundled files and creates a private `.venv` using the included wheels. Later launches reuse it. Moving the bundle or updating it rebuilds the environment as needed. Python needs its standard `venv` and `ensurepip` modules.
+
+If extraction removes executable permissions on macOS or Linux, run `chmod +x run.command` or `chmod +x run.sh`.
+
+## Dependencies and files
+
+For packaged projects and wheels, portablepy reads the package's dependency metadata. For scripts, it follows local imports and looks up dependencies in the selected Python environment. Install your app's dependencies there before building.
+
+A `requirements.txt` beside a script or in a loose app directory supplies explicit dependencies. You can also pass them yourself:
+
+```sh
+portablepy build ./my-app --run "python main.py" --requirements requirements.txt
+portablepy build ./my-app --run "python -m my_app" --extra cli
+portablepy build ./script.py --run "python script.py" --requirement "requests>=2"
+```
+
+Explicit requirements replace import-based dependency detection. Dynamic imports and plugins may need this. Use `--no-index --find-links ./wheels` to build from local packages only.
+
+The bundle includes the selected app's local helpers and resources. Common cache, environment, build, and editor files are excluded, along with `.env` files. Add `--exclude` patterns to leave out other files.
+
+To see what's included before building:
+
+```sh
+portablepy inspect ./my-app --run "python -m my_app"
+portablepy inspect ./my-app --run "python -m my_app" --resolve
+```
+
+`inspect` reports files, dependencies, and estimated size as JSON. `--resolve` also downloads or builds the wheels for a fuller report. Building checks wheel integrity and tests installation in a clean offline environment; it doesn't start your app.
+
+## Keep writable data
+
+Use `--include SOURCE=data/DESTINATION` for default settings, databases, or other files your app changes:
+
+```sh
+portablepy build ./my-app --run "python -m my_app --config {data}/settings.json" --include "settings.json=data/settings.json"
+```
+
+Files and directories both work. Defaults live in `seeds/` and are copied into `data/` only when missing. Extracting an update into the same bundle folder keeps existing data. When moving to a fresh folder, copy `data/` over before launching.
+
+Launch commands support `{bundle}`, `{app}`, `{data}`, `{python}`, and `{bin}` placeholders. The app runs from its application folder, which is named after a content hash. Use `{app}` instead of hardcoding that folder name.
+
+Commands are argument lists, so use forward slashes for paths and quote arguments containing spaces. Shell pipelines and activation commands aren't supported.
+
+## Save build settings
+
+Put defaults and optional profiles in `pyproject.toml`:
+
+```toml
+[tool.portablepy]
+source = 'my-app'
+run = 'python -m my_app --config {data}/settings.json'
+include = ['defaults/settings.json=data/settings.json']
+
+[tool.portablepy.profiles.release]
+compile = 'all'
+strip-source = true
+```
+
+```sh
+portablepy build
+portablepy build --profile release
+portablepy inspect --profile release --resolve
+```
+
+portablepy looks for the nearest `pyproject.toml`, starting from your source or current directory. Use `--config PATH` to choose one. Configured paths are relative to that file; the default output stays in your current directory.
+
+Profiles override defaults, and command-line options override profiles. Lists replace earlier lists. Use `--keep-source`, `--use-index`, or `--no-replace` to turn off those profile settings.
+
+## Compile to bytecode
+
+```sh
+portablepy build ./my-app --run "python -m my_app" --compile all --strip-source
+```
+
+- `--compile app` compiles your application files.
+- `--compile all` also compiles dependency wheels and creates `run.pyc`.
+- `--strip-source` removes compiled `.py` files, including `run.py` with `all`. Sources stay by default.
+
+Compilation keeps assertions and docstrings at optimization level 0. Native extensions, resources, and dependency licenses stay in the bundle. Some packages need their source files at runtime, so test your app before distributing a source-stripped build. Bytecode is specific to the Python version and doesn't hide your code securely.
+
+## Check a bundle
+
+```sh
+portablepy verify app.zip
+portablepy verify ./extracted-app
+python run.py --portable-info
+python run.py --portable-setup
+python run.py --portable-verify
+```
+
+Use `run.pyc` for bundles built with `--compile all`.
+
+`--portable-info` shows bundle details without setting anything up. `--portable-setup` prepares the environment without starting the app. `--portable-verify` checks bundled files and leaves writable data alone.
+
+Each archive includes checksums and gets a `.sha256` sidecar. These detect damaged or changed files; they don't prove who published the bundle.
+
+## Development
+
+Create a `.venv` with `python -m venv .venv`. Activate it with `.venv\Scripts\Activate.ps1` in PowerShell or `source .venv/bin/activate` in a Unix shell, then run:
+
+```sh
+python -m pip install -e ".[dev]"
+python -m pytest --cov=portablepy --cov-branch
+python -m ruff check .
+python -m ruff format --check .
+python -m mypy
+```

portablepy-0.1.0/README.md

@@ -0,0 +1,146 @@
+# portablepy
+
+Bundle a Python app into a ZIP or tar.gz with its dependencies and a launcher. Share the archive, extract it, and run it. The bundle sets up its own environment and installs dependencies offline.
+
+Python itself isn't included. The person running the app needs a matching CPython version, operating system, and architecture.
+
+## Install
+
+Requires CPython 3.14 or later. Install it in a virtual environment:
+
+```sh
+python -m pip install portablepy
+```
+
+## Build an app
+
+```sh
+portablepy build ./my-app --run "python -m my_app"
+portablepy build ./script.py --run "python script.py" --output app.zip
+portablepy build ./my_app-1.0-py3-none-any.whl --run "my-console-command"
+```
+
+Build on the operating system and architecture your users have. portablepy uses the app's `.venv` when available, or its own Python interpreter otherwise. Use `--python PATH` to choose one.
+
+Without `--output`, the filename includes the app name, platform, architecture, and Python version. Windows gets a ZIP; Linux and macOS get a tar.gz. Use `--replace` to replace an existing archive after the new build passes validation.
+
+## Run the bundle
+
+Extract the whole archive somewhere writable, then double-click `run.cmd` on Windows or `run.command` on macOS. Linux bundles include `run.sh`; your file manager may need permission to run executable scripts.
+
+You can also use a terminal:
+
+```sh
+python run.py
+python run.py --help
+```
+
+Arguments go straight to your app. With `--compile all`, the launcher is `run.pyc`; use `python run.pyc` instead. The double-click launcher picks the right file automatically.
+
+The first launch checks the bundled files and creates a private `.venv` using the included wheels. Later launches reuse it. Moving the bundle or updating it rebuilds the environment as needed. Python needs its standard `venv` and `ensurepip` modules.
+
+If extraction removes executable permissions on macOS or Linux, run `chmod +x run.command` or `chmod +x run.sh`.
+
+## Dependencies and files
+
+For packaged projects and wheels, portablepy reads the package's dependency metadata. For scripts, it follows local imports and looks up dependencies in the selected Python environment. Install your app's dependencies there before building.
+
+A `requirements.txt` beside a script or in a loose app directory supplies explicit dependencies. You can also pass them yourself:
+
+```sh
+portablepy build ./my-app --run "python main.py" --requirements requirements.txt
+portablepy build ./my-app --run "python -m my_app" --extra cli
+portablepy build ./script.py --run "python script.py" --requirement "requests>=2"
+```
+
+Explicit requirements replace import-based dependency detection. Dynamic imports and plugins may need this. Use `--no-index --find-links ./wheels` to build from local packages only.
+
+The bundle includes the selected app's local helpers and resources. Common cache, environment, build, and editor files are excluded, along with `.env` files. Add `--exclude` patterns to leave out other files.
+
+To see what's included before building:
+
+```sh
+portablepy inspect ./my-app --run "python -m my_app"
+portablepy inspect ./my-app --run "python -m my_app" --resolve
+```
+
+`inspect` reports files, dependencies, and estimated size as JSON. `--resolve` also downloads or builds the wheels for a fuller report. Building checks wheel integrity and tests installation in a clean offline environment; it doesn't start your app.
+
+## Keep writable data
+
+Use `--include SOURCE=data/DESTINATION` for default settings, databases, or other files your app changes:
+
+```sh
+portablepy build ./my-app --run "python -m my_app --config {data}/settings.json" --include "settings.json=data/settings.json"
+```
+
+Files and directories both work. Defaults live in `seeds/` and are copied into `data/` only when missing. Extracting an update into the same bundle folder keeps existing data. When moving to a fresh folder, copy `data/` over before launching.
+
+Launch commands support `{bundle}`, `{app}`, `{data}`, `{python}`, and `{bin}` placeholders. The app runs from its application folder, which is named after a content hash. Use `{app}` instead of hardcoding that folder name.
+
+Commands are argument lists, so use forward slashes for paths and quote arguments containing spaces. Shell pipelines and activation commands aren't supported.
+
+## Save build settings
+
+Put defaults and optional profiles in `pyproject.toml`:
+
+```toml
+[tool.portablepy]
+source = 'my-app'
+run = 'python -m my_app --config {data}/settings.json'
+include = ['defaults/settings.json=data/settings.json']
+
+[tool.portablepy.profiles.release]
+compile = 'all'
+strip-source = true
+```
+
+```sh
+portablepy build
+portablepy build --profile release
+portablepy inspect --profile release --resolve
+```
+
+portablepy looks for the nearest `pyproject.toml`, starting from your source or current directory. Use `--config PATH` to choose one. Configured paths are relative to that file; the default output stays in your current directory.
+
+Profiles override defaults, and command-line options override profiles. Lists replace earlier lists. Use `--keep-source`, `--use-index`, or `--no-replace` to turn off those profile settings.
+
+## Compile to bytecode
+
+```sh
+portablepy build ./my-app --run "python -m my_app" --compile all --strip-source
+```
+
+- `--compile app` compiles your application files.
+- `--compile all` also compiles dependency wheels and creates `run.pyc`.
+- `--strip-source` removes compiled `.py` files, including `run.py` with `all`. Sources stay by default.
+
+Compilation keeps assertions and docstrings at optimization level 0. Native extensions, resources, and dependency licenses stay in the bundle. Some packages need their source files at runtime, so test your app before distributing a source-stripped build. Bytecode is specific to the Python version and doesn't hide your code securely.
+
+## Check a bundle
+
+```sh
+portablepy verify app.zip
+portablepy verify ./extracted-app
+python run.py --portable-info
+python run.py --portable-setup
+python run.py --portable-verify
+```
+
+Use `run.pyc` for bundles built with `--compile all`.
+
+`--portable-info` shows bundle details without setting anything up. `--portable-setup` prepares the environment without starting the app. `--portable-verify` checks bundled files and leaves writable data alone.
+
+Each archive includes checksums and gets a `.sha256` sidecar. These detect damaged or changed files; they don't prove who published the bundle.
+
+## Development
+
+Create a `.venv` with `python -m venv .venv`. Activate it with `.venv\Scripts\Activate.ps1` in PowerShell or `source .venv/bin/activate` in a Unix shell, then run:
+
+```sh
+python -m pip install -e ".[dev]"
+python -m pytest --cov=portablepy --cov-branch
+python -m ruff check .
+python -m ruff format --check .
+python -m mypy
+```

portablepy-0.1.0/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ['setuptools>=77']
+build-backend = 'setuptools.build_meta'
+
+[project]
+name = 'portablepy'
+version = '0.1.0'
+description = 'Build portable Python application bundles with verified offline wheels'
+readme = 'README.md'
+requires-python = '>=3.14'
+license = 'MIT'
+license-files = ['LICENSE']
+dependencies = ['argly>=0.1,<1']
+authors = [{ name = 'depthbomb' }]
+keywords = ['python', 'portable', 'bundles', 'packaging', 'offline', 'wheels']
+classifiers = [
+    'Development Status :: 3 - Alpha',
+    'Intended Audience :: Developers',
+    'Environment :: Console',
+    'Operating System :: OS Independent',
+    'Programming Language :: Python :: 3',
+    'Programming Language :: Python :: 3.14',
+]
+
+[project.urls]
+Documentation = 'https://github.com/depthbomb/portablepy#readme'
+Source = 'https://github.com/depthbomb/portablepy'
+Issues = 'https://github.com/depthbomb/portablepy/issues'
+Releases = 'https://github.com/depthbomb/portablepy/releases'
+
+[project.scripts]
+portablepy = 'portablepy.cli:main'
+
+[project.optional-dependencies]
+dev = ['build>=1.2', 'pytest>=8', 'pytest-cov>=6', 'ruff>=0.12', 'mypy>=1.18', 'twine>=6']
+
+[tool.setuptools.packages.find]
+where = ['src']
+
+[tool.pytest.ini_options]
+testpaths = ['tests']
+addopts = '-ra --strict-config --strict-markers'
+
+[tool.ruff]
+target-version = 'py314'
+line-length = 100
+
+[tool.ruff.lint]
+select = ['E4', 'E7', 'E9', 'F', 'B']
+
+[tool.ruff.format]
+quote-style = 'single'
+
+[tool.mypy]
+python_version = '3.14'
+files = ['src/portablepy']
+check_untyped_defs = true
+warn_unused_ignores = true

portablepy-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

portablepy-0.1.0/src/portablepy/__init__.py

@@ -0,0 +1,3 @@
+"""Portable application bundles with verified wheels and an offline launcher."""
+
+__version__ = '0.1.0'

portablepy-0.1.0/src/portablepy/__main__.py

@@ -0,0 +1,3 @@
+from portablepy.cli import main
+
+raise SystemExit(main())

portablepy-0.1.0/src/portablepy/builder.py

@@ -0,0 +1,199 @@
+"""Assemble, validate, and archive a portable application."""
+
+from json import dumps
+from pathlib import Path
+from re import fullmatch
+from subprocess import run
+from tarfile import open as open_tar
+from importlib.resources import files
+from tempfile import TemporaryDirectory
+from portablepy.discovery import discover
+from zipfile import ZipFile, ZIP_DEFLATED
+from portablepy.models import BuildOptions
+from portablepy.bytecode import compile_tree
+from portablepy.shortcuts import write_shortcut
+from portablepy.publishing import publish_archive
+from portablepy.files import copy_sources, include_data
+from portablepy.output import default_output, output_excludes, validate_output
+from portablepy.launcher import MANIFEST, file_hash, contents_hash, SCHEMA_VERSION
+from portablepy.wheels import collect_wheels, repack_bytecode, wheel_inventory, write_requirements
+
+RUNTIME_FIELDS = (
+    'implementation',
+    'version',
+    'platform',
+    'machine',
+    'bits',
+    'free_threaded',
+    'cache_tag',
+    'magic',
+)
+INSTRUCTIONS = """Portable Python application
+
+Extract this entire folder somewhere writable. Python itself is not included.
+Run: python run.py
+Extra arguments are forwarded to the application: python run.py --help
+
+You can also use the included console launcher: run.cmd on Windows,
+run.command on macOS, or run.sh on Linux. Double-click it to start; Linux
+file managers may require enabling executable scripts or choosing Run.
+If extraction removed executable permissions, run chmod +x run.command
+or chmod +x run.sh. Arguments supplied in a terminal are forwarded.
+Failed launches wait for a key/Enter when started without arguments
+(on Unix, only with an interactive terminal).
+
+The first launch installs the bundled wheels into a private .venv without
+network access. Use the matching CPython version and platform in bundle.json.
+Your Python installation needs the standard venv and ensurepip modules.
+
+Writable files live in data/. Defaults ship in seeds/ and are copied only when
+missing. Extract updates into the same folder to keep your data/.
+Moving the folder or changing the bundle rebuilds only the private environment.
+The application directory is named with a SHA-256 hash of its files and paths.
+The launcher finds it automatically; its name is recorded in bundle.json.
+
+python run.py --portable-info    Show bundle metadata without setup
+python run.py --portable-setup   Set up without starting the application
+python run.py --portable-verify  Verify immutable files without starting it
+
+Wheel versions and SHA-256 hashes are pinned in requirements.txt. Checksums
+detect corruption; they are not publisher signatures. Licenses for dependencies
+are retained in their wheels. Bytecode is version-specific, not encryption.
+"""
+
+
+def _python_command(command):
+    if not command:
+        raise ValueError('Provide the application command with --run')
+    first = command[0]
+    if any(argument in ('&&', '||', '|', '>', '<', ';') for argument in command):
+        raise ValueError('Commands are argument lists, not shell scripts')
+    if first == '{python}' or fullmatch(r'python(?:3(?:\.\d+)?)?(?:\.exe)?', first):
+        return True
+    if Path(first).name != first or '/' in first or '\\' in first:
+        raise ValueError('Use python, {python}, or an installed console command as the executable')
+    return False
+
+
+def build_bundle(options: BuildOptions) -> Path:
+    if options.compile_mode not in ('none', 'app', 'all'):
+        raise ValueError('--compile must be none, app, or all')
+    if options.strip_source and options.compile_mode == 'none':
+        raise ValueError('--strip-source requires --compile app or --compile all')
+    python_command = _python_command(options.command)
+    output = options.output.expanduser().absolute() if options.output is not None else None
+    if output is not None:
+        validate_output(output, replace=options.replace)
+    discovery = discover(options)
+    if output is None:
+        output = default_output(discovery, options.command)
+        validate_output(output, replace=options.replace)
+    if discovery.unresolved:
+        raise ValueError(
+            'Unresolved or ambiguous imports: '
+            + ', '.join(discovery.unresolved)
+            + '. Install them in the selected environment, or declare dependencies with --requirement/--requirements.'
+        )
+    print(f'Using {discovery.python}; dependency source: {discovery.mode}', flush=True)
+    name = output.name.removesuffix('.tar.gz').removesuffix('.zip')
+    if not fullmatch(r'[A-Za-z0-9][A-Za-z0-9._-]*', name):
+        raise ValueError('Archive name must use letters, numbers, dots, underscores, or hyphens')
+    with TemporaryDirectory(prefix='portablepy-build-') as temporary:
+        work = Path(temporary)
+        bundle = work / name
+        app = bundle / 'app'
+        app.mkdir(parents=True)
+        (bundle / 'data').mkdir()
+        source_copy = work / 'source'
+        if discovery.mode == 'project':
+            copy_sources(
+                discovery.source,
+                source_copy,
+                (*options.excludes, *output_excludes(discovery.source, output)),
+            )
+        else:
+            source_copy.mkdir()
+        copy_sources(discovery.source, app, paths=discovery.application_files)
+        wheels = bundle / 'wheels'
+        collect_wheels(discovery, options, wheels, source_copy)
+        if options.compile_mode != 'none':
+            compile_tree(app, discovery.python, strip=options.strip_source)
+        if options.compile_mode == 'all':
+            for wheel in sorted(wheels.glob('*.whl')):
+                repack_bytecode(
+                    wheel, discovery.python, discovery.runtime, strip=options.strip_source
+                )
+        app_directory = contents_hash(
+            {
+                path.relative_to(app).as_posix(): file_hash(path)
+                for path in app.rglob('*')
+                if path.is_file()
+            }
+        )
+        renamed = bundle / app_directory
+        if not app.resolve().is_relative_to(
+            bundle.resolve()
+        ) or not renamed.resolve().is_relative_to(bundle.resolve()):
+            raise ValueError('Application directory must stay inside the bundle')
+        app.rename(renamed)
+        count = write_requirements(wheels, bundle / 'requirements.txt')
+        base = discovery.source if discovery.source.is_dir() else discovery.source.parent
+        seeds = include_data(options.includes, base, bundle)
+        (bundle / 'run.py').write_bytes(files('portablepy').joinpath('launcher.py').read_bytes())
+        compiled_launcher = options.compile_mode == 'all'
+        launcher = 'run.pyc' if compiled_launcher else 'run.py'
+        if compiled_launcher:
+            compile_tree(bundle / 'run.py', discovery.python, strip=options.strip_source)
+        shortcut = write_shortcut(bundle, discovery.runtime, compiled=compiled_launcher)
+        (bundle / 'README.txt').write_text(
+            INSTRUCTIONS.replace('run.py', launcher), encoding='utf-8'
+        )
+        checksums = {
+            path.relative_to(bundle).as_posix(): file_hash(path)
+            for path in sorted(bundle.rglob('*'))
+            if path.is_file()
+        }
+        manifest = {
+            'schema': SCHEMA_VERSION,
+            'name': name,
+            'app_directory': app_directory,
+            'runtime': {key: discovery.runtime[key] for key in RUNTIME_FIELDS},
+            'command': list(options.command),
+            'python_command': python_command,
+            'prefer_installed': discovery.mode in ('project', 'wheel'),
+            'compile': options.compile_mode,
+            'strip_source': options.strip_source,
+            'files': checksums,
+            'seed_files': seeds,
+            'dependencies': wheel_inventory(wheels),
+            'profile': options.profile,
+        }
+        manifest['build_id'] = contents_hash(manifest)
+        (bundle / MANIFEST).write_text(dumps(manifest, indent=2) + '\n', encoding='utf-8')
+        (bundle / f'{MANIFEST}.sha256').write_text(
+            file_hash(bundle / MANIFEST) + '\n', encoding='utf-8'
+        )
+        print(f'Validating {count} wheels in an offline environment...', flush=True)
+        run([str(discovery.python), '-I', str(bundle / launcher), '--portable-setup'], check=True)
+        members = [*checksums, MANIFEST, f'{MANIFEST}.sha256']
+        output.parent.mkdir(parents=True, exist_ok=True)
+        # Publish only after validation; exclude the generated environment entirely.
+        staged = work / output.name
+        if output.name.endswith('.zip'):
+            with ZipFile(staged, 'w', compression=ZIP_DEFLATED) as archive:
+                for relative in sorted(members):
+                    archive.write(bundle / relative, f'{name}/{relative}')
+                    if relative == shortcut and shortcut != 'run.cmd':
+                        entry = archive.getinfo(f'{name}/{relative}')
+                        entry.create_system = 3
+                        entry.external_attr = 0o100755 << 16
+        else:
+            with open_tar(staged, 'w:gz') as archive:
+                for relative in sorted(members):
+                    member = archive.gettarinfo(bundle / relative, arcname=f'{name}/{relative}')
+                    if relative == shortcut and shortcut != 'run.cmd':
+                        member.mode = 0o755
+                    with (bundle / relative).open('rb') as stream:
+                        archive.addfile(member, stream)
+        publish_archive(staged, output, replace=options.replace)
+    return output

portablepy-0.1.0/src/portablepy/bytecode.py

@@ -0,0 +1,29 @@
+"""Compile application and wheel sources with the selected interpreter."""
+
+from pathlib import Path
+from subprocess import run
+
+COMPILE = """
+from sys import argv
+from pathlib import Path
+from py_compile import compile, PycInvalidationMode
+from importlib.util import cache_from_source
+root, strip = Path(argv[1]), argv[2] == 'strip'
+single = root.is_file()
+for path in [root] if single else sorted(root.rglob('*.py')):
+    relative = Path(path.name) if single else path.relative_to(root)
+    if '__pycache__' in relative.parts or any(part.endswith('.dist-info') for part in relative.parts):
+        continue
+    if any(part.endswith('.data') for part in relative.parts) and 'scripts' in relative.parts:
+        continue
+    output = str(path.with_suffix('.pyc')) if strip or single else cache_from_source(str(path))
+    compile(str(path), cfile=output, dfile=relative.as_posix(), doraise=True,
+            invalidation_mode=PycInvalidationMode.CHECKED_HASH)
+    if strip:
+        path.unlink()
+"""
+
+
+def compile_tree(root: Path, python: Path, *, strip=False):
+    """Compile a directory, or a single launcher to an adjacent executable .pyc."""
+    run([str(python), '-I', '-c', COMPILE, str(root), 'strip' if strip else 'keep'], check=True)