byt3d4nc3 0.1.0__tar.gz

byt3d4nc3-0.1.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: byt3d4nc3
+Version: 0.1.0
+Summary: Bundled Python runtimes per platform with an architecture-aware selector
+License: Proprietary
+Keywords: runtime,binary,platform
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# byt3d4nc3
+
+Self-contained Python runtimes for a few ABIs, with a small loader that picks
+the binary matching the running machine.
+
+Bundled ABIs:
+
+- `linux64` — x86-64 Linux
+- `armv8` — aarch64 Linux/Android
+- `armv7` — armv7 Linux/Android
+
+The package ships only the runtimes themselves. No tooling, no sources, no
+keys.
+
+## Install
+
+```sh
+pip install ./pypi
+```
+
+## CLI
+
+```sh
+byt3d4nc3 targets        # list bundled ABIs
+byt3d4nc3 arch           # print the running machine's ABI
+byt3d4nc3 path           # path to the runtime for the host
+byt3d4nc3 path armv8     # path to the armv8 runtime
+byt3d4nc3 run app.py     # run app.py under the host's runtime
+```
+
+## Python API
+
+```python
+from byt3d4nc3 import loader
+
+loader.targets()          # {'linux64': ..., 'armv8': ..., 'armv7': ...}
+loader.abi_for_host()     # e.g. 'linux64'
+loader.match_arch('armv8')# path to the armv8 runtime
+loader.run('app.py')      # execute under the host runtime
+```
+
+`run()` accepts a path or a source string and passes extra args through.

byt3d4nc3-0.1.0/README.md

@@ -0,0 +1,42 @@
+# byt3d4nc3
+
+Self-contained Python runtimes for a few ABIs, with a small loader that picks
+the binary matching the running machine.
+
+Bundled ABIs:
+
+- `linux64` — x86-64 Linux
+- `armv8` — aarch64 Linux/Android
+- `armv7` — armv7 Linux/Android
+
+The package ships only the runtimes themselves. No tooling, no sources, no
+keys.
+
+## Install
+
+```sh
+pip install ./pypi
+```
+
+## CLI
+
+```sh
+byt3d4nc3 targets        # list bundled ABIs
+byt3d4nc3 arch           # print the running machine's ABI
+byt3d4nc3 path           # path to the runtime for the host
+byt3d4nc3 path armv8     # path to the armv8 runtime
+byt3d4nc3 run app.py     # run app.py under the host's runtime
+```
+
+## Python API
+
+```python
+from byt3d4nc3 import loader
+
+loader.targets()          # {'linux64': ..., 'armv8': ..., 'armv7': ...}
+loader.abi_for_host()     # e.g. 'linux64'
+loader.match_arch('armv8')# path to the armv8 runtime
+loader.run('app.py')      # execute under the host runtime
+```
+
+`run()` accepts a path or a source string and passes extra args through.

byt3d4nc3-0.1.0/byt3d4nc3/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "0.1.0"
+
+from . import loader
+
+__all__ = ["loader"]

byt3d4nc3-0.1.0/byt3d4nc3/loader.py

@@ -0,0 +1,181 @@
+"""Launcher for a host-installed byt3d4nc3 runtime.
+
+Import-side note: this module is both an importable library (``targets()``) and
+a console entry point. When run *as a script* the interpreter puts the script's
+own directory at ``sys.path[0]``, and every module needed below (``platform``,
+``shutil``, ``tempfile``, ...) is resolved through ``sys.path`` rather than being
+a builtin. Anything that can write beside this file could therefore execute
+code in the host interpreter just by being imported, before any of byt3d4nc3's
+own logic runs. So in script mode we drop that entry before the first stdlib
+import and then confirm nothing we imported came from our own directory.
+
+In library mode we deliberately do not touch ``sys.path``: an importer has no
+reason to expect a global path mutation as a side effect of ``import
+byt3d4nc3.loader``, and a directory containing an installed package is not a
+meaningful place to stage an attack against a file you can already edit.
+"""
+import sys as _sy
+
+# Entry-point names that resolve next to this file. ``byt3d4nc3`` is the
+# installed console script; ``runnerx`` is retained so the shadow check still
+# fires for an older checkout, where being wrong here would mean skipping the
+# sys.path sanitisation above.
+_SCRIPT = _sy.argv and _sy.argv[0] and _sy.argv[0].endswith(
+    ("byt3d4nc3", "byt3d4nc3.exe", "runnerx", "runnerx.exe", "loader.py",
+     "loader.exe", "python", "python3"))
+_OD = ''
+if _SCRIPT and _sy.argv[0]:
+    _a = _sy.argv[0]
+    _OD = _a.rsplit('/', 1)[0] if '/' in _a else ''
+    _sy.path[:] = [p for p in _sy.path if p not in ('', '.', _OD)]
+
+import os
+import platform
+import shutil
+import subprocess
+import tempfile
+
+_SHADOW = []
+for _m in (os, platform, shutil, subprocess, tempfile):
+    _f = getattr(_m, '__file__', '') or ''
+    if _OD and _f.startswith(_OD):
+        _SHADOW.append(_f)
+
+_DATA = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data")
+
+_TARGETS = {
+    "linux64": ("linux64", "x86_64"),
+    "armv8": ("armv8", "aarch64/arm64"),
+    "armv7": ("armv7", "armv6l/armv7l"),
+}
+
+
+def _host_abi():
+    machine = platform.machine().lower()
+    if machine in ("x86_64", "amd64"):
+        return "linux64"
+    if machine in ("aarch64", "arm64"):
+        return "armv8"
+    if machine in ("armv6l", "armv6", "armv7l", "armv7", "arm"):
+        return "armv7"
+    raise RuntimeError("unsupported host machine: %s" % platform.machine())
+
+
+def targets():
+    return dict(_TARGETS)
+
+
+def abi_for_host():
+    return _host_abi()
+
+
+def binary_path(abi=None):
+    if abi is None:
+        abi = _host_abi()
+    if abi not in _TARGETS:
+        raise ValueError("unknown ABI %r; choose from %s"
+                         % (abi, ", ".join(sorted(_TARGETS))))
+    return os.path.join(_DATA, abi, "run")
+
+
+def match_arch(abi=None):
+    path = binary_path(abi)
+    if not os.path.isfile(path):
+        raise RuntimeError("missing runtime for %s" % (abi or _host_abi()))
+    return path
+
+
+def host_site_dirs():
+    """Host interpreter's site-packages dirs, handed to the runtime so it can
+    import host-installed packages without any scan in the deployed script.
+    The runtime (crates/vm/src/getpath.rs) consumes BYT3D4NC3_SITEPACKAGES and
+    appends each entry to its own sys.path."""
+    import sys
+    out, seen = [], set()
+    try:
+        import sysconfig
+        for key in ("purelib", "platlib"):
+            p = sysconfig.get_paths().get(key)
+            if p and os.path.isdir(p) and p not in seen:
+                seen.add(p)
+                out.append(p)
+    except Exception:
+        pass
+    for p in sys.path:
+        if os.path.isdir(p) and (
+            p.endswith(("site-packages", "dist-packages"))
+            or "site-packages" in p or "dist-packages" in p
+        ) and p not in seen:
+            seen.add(p)
+            out.append(p)
+    return out
+
+
+def run(script, argv=(), binary=None, env=None, timeout=None):
+    prog = shutil.which(binary) if binary else match_arch()
+    if not prog:
+        raise RuntimeError("no usable runtime for %s" % _host_abi())
+
+    script_path = script
+    _tmp = None
+    if not os.path.isfile(script):
+        fd, script_path = tempfile.mkstemp(suffix=".py", prefix="_sc_")
+        with os.fdopen(fd, "w") as f:
+            f.write(script)
+        _tmp = script_path
+
+    try:
+        spawn_env = dict(os.environ if env is None else env)
+        if not spawn_env.get("BYT3D4NC3_SITEPACKAGES"):
+            dirs = host_site_dirs()
+            if dirs:
+                spawn_env["BYT3D4NC3_SITEPACKAGES"] = os.pathsep.join(dirs)
+        return subprocess.run(
+            [prog, script_path, *map(str, argv)],
+            env=spawn_env, timeout=timeout, check=False,
+        )
+    finally:
+        if _tmp:
+            os.unlink(_tmp)
+
+
+def main(argv=None):
+    if _SHADOW:
+        raise SystemExit(
+            'byt3d4nc3: refusing to run -- these modules resolved from the '
+            'launcher directory and may have executed already: '
+            + ', '.join(_SHADOW))
+    import argparse
+    ap = argparse.ArgumentParser(prog="byt3d4nc3")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    p_targets = sub.add_parser("targets")
+    _ = p_targets
+
+    p_arch = sub.add_parser("arch")
+    _ = p_arch
+
+    p_path = sub.add_parser("path")
+    p_path.add_argument("abi", nargs="?", default=None)
+
+    p_run = sub.add_parser("run")
+    p_run.add_argument("script")
+    p_run.add_argument("args", nargs="*")
+
+    args = ap.parse_args(argv)
+
+    if args.cmd == "targets":
+        for abi in sorted(_TARGETS):
+            print("%-8s %s" % (abi, _TARGETS[abi][1]))
+    elif args.cmd == "arch":
+        print(_host_abi())
+    elif args.cmd == "path":
+        print(match_arch(args.abi))
+    else:
+        cp = run(args.script, args.args)
+        return cp.returncode
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

byt3d4nc3-0.1.0/byt3d4nc3.egg-info/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: byt3d4nc3
+Version: 0.1.0
+Summary: Bundled Python runtimes per platform with an architecture-aware selector
+License: Proprietary
+Keywords: runtime,binary,platform
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# byt3d4nc3
+
+Self-contained Python runtimes for a few ABIs, with a small loader that picks
+the binary matching the running machine.
+
+Bundled ABIs:
+
+- `linux64` — x86-64 Linux
+- `armv8` — aarch64 Linux/Android
+- `armv7` — armv7 Linux/Android
+
+The package ships only the runtimes themselves. No tooling, no sources, no
+keys.
+
+## Install
+
+```sh
+pip install ./pypi
+```
+
+## CLI
+
+```sh
+byt3d4nc3 targets        # list bundled ABIs
+byt3d4nc3 arch           # print the running machine's ABI
+byt3d4nc3 path           # path to the runtime for the host
+byt3d4nc3 path armv8     # path to the armv8 runtime
+byt3d4nc3 run app.py     # run app.py under the host's runtime
+```
+
+## Python API
+
+```python
+from byt3d4nc3 import loader
+
+loader.targets()          # {'linux64': ..., 'armv8': ..., 'armv7': ...}
+loader.abi_for_host()     # e.g. 'linux64'
+loader.match_arch('armv8')# path to the armv8 runtime
+loader.run('app.py')      # execute under the host runtime
+```
+
+`run()` accepts a path or a source string and passes extra args through.

byt3d4nc3-0.1.0/byt3d4nc3.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+byt3d4nc3/__init__.py
+byt3d4nc3/loader.py
+byt3d4nc3.egg-info/PKG-INFO
+byt3d4nc3.egg-info/SOURCES.txt
+byt3d4nc3.egg-info/dependency_links.txt
+byt3d4nc3.egg-info/entry_points.txt
+byt3d4nc3.egg-info/top_level.txt
+byt3d4nc3/data/armv7/run
+byt3d4nc3/data/armv8/run
+byt3d4nc3/data/linux64/run

byt3d4nc3-0.1.0/byt3d4nc3.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

byt3d4nc3-0.1.0/byt3d4nc3.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+byt3d4nc3 = byt3d4nc3.loader:main

byt3d4nc3-0.1.0/byt3d4nc3.egg-info/top_level.txt

@@ -0,0 +1 @@
+byt3d4nc3

byt3d4nc3-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "byt3d4nc3"
+version = "0.1.0"
+description = "Bundled Python runtimes per platform with an architecture-aware selector"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "Proprietary" }
+keywords = ["runtime", "binary", "platform"]
+classifiers = [
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Build Tools",
+]
+
+[project.scripts]
+byt3d4nc3 = "byt3d4nc3.loader:main"
+
+[tool.setuptools]
+packages = ["byt3d4nc3"]
+
+[tool.setuptools.package-data]
+byt3d4nc3 = [
+    "data/linux64/run",
+    "data/armv8/run",
+    "data/armv7/run",
+]

byt3d4nc3-0.1.0/setup.cfg

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