pyodex 0.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pyodex/__init__.py +5 -0
- pyodex/builder.py +257 -0
- pyodex/capabilities/314.0.8.json +449 -0
- pyodex/cli.py +172 -0
- pyodex/compat.json +442 -0
- pyodex/compat.py +290 -0
- pyodex/deps.py +97 -0
- pyodex/packages.py +336 -0
- pyodex/pyodide_caps.py +121 -0
- pyodex/runtime/pyodex_natural.py +540 -0
- pyodex/runtime/pyodex_runtime.py +401 -0
- pyodex/scaffold.py +55 -0
- pyodex/templates/bootstrap.js +104 -0
- pyodex/templates/injector.js +157 -0
- pyodex/templates/overlay.html +67 -0
- pyodex-0.1.0.dist-info/METADATA +213 -0
- pyodex-0.1.0.dist-info/RECORD +19 -0
- pyodex-0.1.0.dist-info/WHEEL +4 -0
- pyodex-0.1.0.dist-info/entry_points.txt +2 -0
pyodex/__init__.py
ADDED
pyodex/builder.py
ADDED
|
@@ -0,0 +1,257 @@
|
|
|
1
|
+
"""Assemble a loadable Chrome extension from a pyodex project directory.
|
|
2
|
+
|
|
3
|
+
Project layout (input):
|
|
4
|
+
|
|
5
|
+
myext/
|
|
6
|
+
├── pyodex.toml # extension config
|
|
7
|
+
├── main.py # Python entry point (runs inside Pyodide)
|
|
8
|
+
├── overlay.css # optional: styles for the overlay page
|
|
9
|
+
├── overlay.body.html # optional: markup injected into overlay <body>
|
|
10
|
+
└── <extra files / packages listed in pyodex.toml>
|
|
11
|
+
|
|
12
|
+
Output (dist/<slug>/) is a flat unpacked extension ready for "Load unpacked".
|
|
13
|
+
"""
|
|
14
|
+
|
|
15
|
+
from __future__ import annotations
|
|
16
|
+
|
|
17
|
+
import json
|
|
18
|
+
import re
|
|
19
|
+
import shutil
|
|
20
|
+
import tomllib
|
|
21
|
+
import zipfile
|
|
22
|
+
from dataclasses import dataclass, field
|
|
23
|
+
from pathlib import Path
|
|
24
|
+
|
|
25
|
+
from . import PYODIDE_VERSION
|
|
26
|
+
from .deps import HTTP_SHIM_PACKAGES, PYODIDE_CORE_FILES, ensure_pyodide, ensure_url_asset
|
|
27
|
+
from .packages import (Pin, abi_from_lock, ensure_in_store, link_cow, lock, pyodide_constraints,
|
|
28
|
+
record_digests, script_dependencies, uv_platform, verify_against_lock)
|
|
29
|
+
|
|
30
|
+
TEMPLATES = Path(__file__).parent / "templates"
|
|
31
|
+
RUNTIME = Path(__file__).parent / "runtime"
|
|
32
|
+
|
|
33
|
+
|
|
34
|
+
@dataclass
|
|
35
|
+
class ExtConfig:
|
|
36
|
+
name: str
|
|
37
|
+
version: str = "0.1.0"
|
|
38
|
+
description: str = ""
|
|
39
|
+
matches: list[str] = field(default_factory=lambda: ["<all_urls>"])
|
|
40
|
+
entry: str = "main.py"
|
|
41
|
+
python_files: list[str] = field(default_factory=list) # extra .py files / packages
|
|
42
|
+
scripts: list[str] = field(default_factory=list) # classic JS loaded in overlay before Python
|
|
43
|
+
assets: list[str] = field(default_factory=list) # extra files copied verbatim
|
|
44
|
+
vendor: dict[str, str] = field(default_factory=dict) # filename -> URL
|
|
45
|
+
pyodide_version: str = PYODIDE_VERSION
|
|
46
|
+
pyodide_packages: list[str] = field(default_factory=list) # extra pure-Python PyPI packages to bundle
|
|
47
|
+
http: bool = True # bundle requests/urllib shims (pyodide-http, requests, urllib3, ...)
|
|
48
|
+
host_permissions: list[str] = field(default_factory=list) # cross-origin fetch; defaults to `matches`
|
|
49
|
+
url_filter: str = "" # optional substring the page URL must contain
|
|
50
|
+
icon: str = ""
|
|
51
|
+
overlay_css: str = "" # inline alternative to overlay.css (single-script mode)
|
|
52
|
+
overlay_body: str = "" # inline alternative to overlay.body.html
|
|
53
|
+
natural: bool = True # install pyodex_natural shims (socket/ssl/input/sleep/persistent fs/pip)
|
|
54
|
+
|
|
55
|
+
@property
|
|
56
|
+
def slug(self) -> str:
|
|
57
|
+
return re.sub(r"[^a-z0-9]+", "-", self.name.lower()).strip("-")
|
|
58
|
+
|
|
59
|
+
|
|
60
|
+
def _config_from_data(data: dict, *, default_name: str, default_entry: str) -> ExtConfig:
|
|
61
|
+
ext = data.get("extension", {})
|
|
62
|
+
return ExtConfig(
|
|
63
|
+
name=ext.get("name", default_name),
|
|
64
|
+
version=ext.get("version", "0.1.0"),
|
|
65
|
+
description=ext.get("description", ""),
|
|
66
|
+
matches=ext.get("matches", ["<all_urls>"]),
|
|
67
|
+
entry=ext.get("entry", default_entry),
|
|
68
|
+
python_files=ext.get("python_files", []),
|
|
69
|
+
scripts=ext.get("scripts", []),
|
|
70
|
+
assets=ext.get("assets", []),
|
|
71
|
+
vendor=data.get("vendor", {}),
|
|
72
|
+
pyodide_version=ext.get("pyodide_version", PYODIDE_VERSION),
|
|
73
|
+
pyodide_packages=ext.get("pyodide_packages", []),
|
|
74
|
+
http=ext.get("http", True),
|
|
75
|
+
host_permissions=ext.get("host_permissions", ext.get("matches", ["<all_urls>"])),
|
|
76
|
+
url_filter=ext.get("url_filter", ""),
|
|
77
|
+
icon=ext.get("icon", ""),
|
|
78
|
+
overlay_css=ext.get("overlay_css", ""),
|
|
79
|
+
overlay_body=ext.get("overlay_body", ""),
|
|
80
|
+
natural=ext.get("natural", True),
|
|
81
|
+
)
|
|
82
|
+
|
|
83
|
+
|
|
84
|
+
def resolve_project(target: Path) -> tuple[Path, ExtConfig]:
|
|
85
|
+
"""Accept a project dir (pyodex.toml) or a single script (PEP 723 `[tool.pyodex]`).
|
|
86
|
+
|
|
87
|
+
Returns (project_root, config). For a single script, project_root is the
|
|
88
|
+
script's directory and `entry` is the script filename.
|
|
89
|
+
"""
|
|
90
|
+
if target.is_dir():
|
|
91
|
+
cfg_path = target / "pyodex.toml"
|
|
92
|
+
if not cfg_path.exists():
|
|
93
|
+
raise FileNotFoundError(f"no pyodex.toml in {target}")
|
|
94
|
+
data = tomllib.loads(cfg_path.read_text())
|
|
95
|
+
return target, _config_from_data(data, default_name=target.name, default_entry="main.py")
|
|
96
|
+
if target.suffix == ".py":
|
|
97
|
+
from .packages import read_pep723
|
|
98
|
+
|
|
99
|
+
meta = read_pep723(target)
|
|
100
|
+
tool = meta.get("tool", {}).get("pyodex", {})
|
|
101
|
+
# [tool.pyodex] is flat; [tool.pyodex.vendor] holds URL assets.
|
|
102
|
+
data = {"extension": {k: v for k, v in tool.items() if k != "vendor"}, "vendor": tool.get("vendor", {})}
|
|
103
|
+
return target.parent, _config_from_data(data, default_name=target.stem, default_entry=target.name)
|
|
104
|
+
raise FileNotFoundError(f"{target}: not a project dir or .py script")
|
|
105
|
+
|
|
106
|
+
|
|
107
|
+
def load_config(project: Path) -> ExtConfig:
|
|
108
|
+
return resolve_project(project)[1]
|
|
109
|
+
|
|
110
|
+
|
|
111
|
+
def _render(text: str, ctx: dict[str, str]) -> str:
|
|
112
|
+
for k, v in ctx.items():
|
|
113
|
+
text = text.replace("{{" + k + "}}", v)
|
|
114
|
+
return text
|
|
115
|
+
|
|
116
|
+
|
|
117
|
+
def _copy(src: Path, dst: Path) -> None:
|
|
118
|
+
if src.is_dir():
|
|
119
|
+
shutil.copytree(src, dst, dirs_exist_ok=True)
|
|
120
|
+
else:
|
|
121
|
+
dst.parent.mkdir(parents=True, exist_ok=True)
|
|
122
|
+
shutil.copy2(src, dst)
|
|
123
|
+
|
|
124
|
+
|
|
125
|
+
def _manifest(cfg: ExtConfig, resources: list[str]) -> dict:
|
|
126
|
+
m = {
|
|
127
|
+
"manifest_version": 3,
|
|
128
|
+
"name": cfg.name,
|
|
129
|
+
"version": cfg.version,
|
|
130
|
+
"description": cfg.description,
|
|
131
|
+
"content_scripts": [
|
|
132
|
+
{"matches": cfg.matches, "js": ["injector.js"], "run_at": "document_idle"}
|
|
133
|
+
],
|
|
134
|
+
"web_accessible_resources": [{"resources": sorted(set(resources)), "matches": cfg.matches}],
|
|
135
|
+
"content_security_policy": {
|
|
136
|
+
"extension_pages": "script-src 'self' 'wasm-unsafe-eval'; object-src 'self';"
|
|
137
|
+
},
|
|
138
|
+
}
|
|
139
|
+
if cfg.host_permissions:
|
|
140
|
+
m["host_permissions"] = cfg.host_permissions
|
|
141
|
+
if cfg.icon:
|
|
142
|
+
m["icons"] = {"128": cfg.icon}
|
|
143
|
+
return m
|
|
144
|
+
|
|
145
|
+
|
|
146
|
+
def build_extension(target: Path, out: Path | None = None, *, allow_bad: bool = False) -> Path:
|
|
147
|
+
project, cfg = resolve_project(target)
|
|
148
|
+
out = out or (project / "dist" / cfg.slug)
|
|
149
|
+
if out.exists():
|
|
150
|
+
shutil.rmtree(out)
|
|
151
|
+
out.mkdir(parents=True)
|
|
152
|
+
|
|
153
|
+
resources: list[str] = ["overlay.html", "bootstrap.js", "pyodex_runtime.py", "pyodex_natural.py",
|
|
154
|
+
"pyodide/*", "app/*", "wheels/*"]
|
|
155
|
+
|
|
156
|
+
# 1. Pyodide core
|
|
157
|
+
pyo_src = ensure_pyodide(cfg.pyodide_version)
|
|
158
|
+
pyo_dst = out / "pyodide"
|
|
159
|
+
pyo_dst.mkdir()
|
|
160
|
+
for name in PYODIDE_CORE_FILES:
|
|
161
|
+
p = pyo_src / name
|
|
162
|
+
if p.exists():
|
|
163
|
+
shutil.copy2(p, pyo_dst / name)
|
|
164
|
+
|
|
165
|
+
# 1b. Dependencies: PEP 723 block in entry + pyodex.toml extras + HTTP shims.
|
|
166
|
+
# Resolved for wasm32-pyodide via uv, pinned in pyodex.lock, stored once
|
|
167
|
+
# read-only in ~/.cache/pyodex/store and CoW-linked into dist/wheels.
|
|
168
|
+
wheels = out / "wheels"
|
|
169
|
+
wheels.mkdir()
|
|
170
|
+
reqs = list(HTTP_SHIM_PACKAGES) if cfg.http else []
|
|
171
|
+
reqs += [r for r in cfg.pyodide_packages if r not in reqs]
|
|
172
|
+
reqs += [r for r in script_dependencies(project / cfg.entry) if r not in reqs]
|
|
173
|
+
pyodide_lock = json.loads((pyo_src / "pyodide-lock.json").read_text())
|
|
174
|
+
py_ver = pyodide_lock["info"]["python"].rsplit(".", 1)[0] # "3.14.1" -> "3.14"
|
|
175
|
+
lock_path = project / f"{cfg.slug}.pyodex.lock" if cfg.entry != "main.py" else project / "pyodex.lock"
|
|
176
|
+
platform = uv_platform(abi_from_lock(pyodide_lock))
|
|
177
|
+
pins = lock(lock_path, reqs, py_ver, constraints=pyodide_constraints(pyodide_lock), platform=platform)
|
|
178
|
+
from .compat import check_pins
|
|
179
|
+
|
|
180
|
+
check_pins(pins, allow_bad=allow_bad)
|
|
181
|
+
wheel_names, methods, store_paths = [], set(), []
|
|
182
|
+
for pin in pins:
|
|
183
|
+
w = ensure_in_store(pin, pyodide_lock=pyodide_lock, pyodide_version=cfg.pyodide_version)
|
|
184
|
+
store_paths.append(w)
|
|
185
|
+
methods.add(link_cow(w, wheels / w.name))
|
|
186
|
+
wheel_names.append(w.name)
|
|
187
|
+
bad = verify_against_lock(lock_path, store_paths)
|
|
188
|
+
if bad:
|
|
189
|
+
raise RuntimeError("wheel digest mismatch vs lock (delete lock or run --refresh-lock):\n " + "\n ".join(bad))
|
|
190
|
+
record_digests(lock_path, store_paths)
|
|
191
|
+
if pins:
|
|
192
|
+
print(f"packages: {len(pins)} wheels linked ({', '.join(sorted(methods))})")
|
|
193
|
+
# micropip ships with Pyodide; bundle so pip_install() works offline-at-build.
|
|
194
|
+
if cfg.natural:
|
|
195
|
+
mp = pyodide_lock["packages"].get("micropip")
|
|
196
|
+
if mp:
|
|
197
|
+
w = ensure_in_store(Pin("micropip", mp["version"]), pyodide_lock=pyodide_lock, pyodide_version=cfg.pyodide_version)
|
|
198
|
+
methods.add(link_cow(w, wheels / w.name))
|
|
199
|
+
wheel_names.append(w.name)
|
|
200
|
+
(wheels / "index.json").write_text(json.dumps({"wheels": wheel_names, "http": cfg.http, "natural": cfg.natural}))
|
|
201
|
+
|
|
202
|
+
# 2. Vendored URL assets
|
|
203
|
+
for filename, url in cfg.vendor.items():
|
|
204
|
+
shutil.copy2(ensure_url_asset(url, filename), out / filename)
|
|
205
|
+
resources.append(filename)
|
|
206
|
+
|
|
207
|
+
# 3. Python: entry + extra files go under app/
|
|
208
|
+
app = out / "app"
|
|
209
|
+
app.mkdir()
|
|
210
|
+
_copy(project / cfg.entry, app / "main.py")
|
|
211
|
+
for rel in cfg.python_files:
|
|
212
|
+
_copy(project / rel, app / Path(rel).name)
|
|
213
|
+
py_manifest = sorted(str(p.relative_to(app)) for p in app.rglob("*") if p.is_file())
|
|
214
|
+
(app / "files.json").write_text(json.dumps(py_manifest))
|
|
215
|
+
|
|
216
|
+
# 4. Extra assets
|
|
217
|
+
for rel in cfg.assets:
|
|
218
|
+
_copy(project / rel, out / rel)
|
|
219
|
+
resources.append(rel)
|
|
220
|
+
if cfg.icon:
|
|
221
|
+
resources.append(cfg.icon)
|
|
222
|
+
|
|
223
|
+
# 5. Runtime helper (python)
|
|
224
|
+
shutil.copy2(RUNTIME / "pyodex_runtime.py", out / "pyodex_runtime.py")
|
|
225
|
+
shutil.copy2(RUNTIME / "pyodex_natural.py", out / "pyodex_natural.py")
|
|
226
|
+
|
|
227
|
+
# 6. Templates
|
|
228
|
+
body = cfg.overlay_body or ((project / "overlay.body.html").read_text() if (project / "overlay.body.html").exists() else "")
|
|
229
|
+
css = cfg.overlay_css or ((project / "overlay.css").read_text() if (project / "overlay.css").exists() else "")
|
|
230
|
+
script_tags = "\n".join(f' <script src="{s}"></script>' for s in cfg.scripts)
|
|
231
|
+
ctx = {
|
|
232
|
+
"NAME": cfg.name,
|
|
233
|
+
"BODY": body,
|
|
234
|
+
"CSS": css,
|
|
235
|
+
"SCRIPTS": script_tags,
|
|
236
|
+
"URL_FILTER": json.dumps(cfg.url_filter),
|
|
237
|
+
"SLUG": cfg.slug,
|
|
238
|
+
}
|
|
239
|
+
for t in ("overlay.html", "bootstrap.js", "injector.js"):
|
|
240
|
+
(out / t).write_text(_render((TEMPLATES / t).read_text(), ctx))
|
|
241
|
+
|
|
242
|
+
(out / "manifest.json").write_text(json.dumps(_manifest(cfg, resources), indent=2) + "\n")
|
|
243
|
+
return out
|
|
244
|
+
|
|
245
|
+
|
|
246
|
+
def zip_dir(built: Path, out: Path | None = None) -> Path:
|
|
247
|
+
"""Zip an already-built extension dir."""
|
|
248
|
+
out = out or built.with_suffix(".zip")
|
|
249
|
+
with zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED) as zf:
|
|
250
|
+
for p in built.rglob("*"):
|
|
251
|
+
if p.is_file():
|
|
252
|
+
zf.write(p, p.relative_to(built))
|
|
253
|
+
return out
|
|
254
|
+
|
|
255
|
+
|
|
256
|
+
def zip_extension(target: Path, out: Path | None = None) -> Path:
|
|
257
|
+
return zip_dir(build_extension(target), out)
|