Repository navigation
Expand file tree
/
Copy pathmanage.py
More file actions
467 lines (392 loc) · 19.3 KB
/
Copy pathmanage.py
File metadata and controls
467 lines (392 loc) · 19.3 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
#!/usr/bin/env python3
"""One place for the project's add-ons, themes and switches: what each is, its screenshot, what is on the TV,
and installing, updating or removing it the way its creator wrote it down. Nothing is downloaded: everything comes
from this checkout of the repo, and every install runs the creator's own script (an add-on's install.sh or
build-and-install.sh, or the steps in addons/README.md; tools/theme.sh for themes).
tools/venv/bin/python -I tools/manage.py list [addons|themes|switches]
tools/venv/bin/python -I tools/manage.py show <add-on, theme or switch>
TV_HOST=<tv ip> tools/venv/bin/python -I tools/manage.py status
TV_HOST=<tv ip> tools/venv/bin/python -I tools/manage.py install <add-on or theme> [script arguments]
TV_HOST=<tv ip> tools/venv/bin/python -I tools/manage.py remove <add-on>
TV_HOST=<tv ip> tools/venv/bin/python -I tools/manage.py set <switch> <json value> --theme <your theme folder>
install on an installed add-on updates it (pm install -r). set writes the key into a theme folder of your own and
pushes it with tools/theme.sh, as themes/README.md describes; it never edits a folder in this checkout, so pointing
--theme at the project's themes/ or examples/ is refused before anything is written. set reads the value the way
the key's own type in the Keys table needs - true or false for a bool, a JSON list, object or number where the
table says so, the text itself for a string - and refuses one the launcher would ignore or a number outside the
range the table states. A theme's config.json is hand-edited, so one that cannot be read, is not JSON, or is not a
JSON object is named before the key is written, and a write it cannot make says so instead of ending in a traceback.
"""
import json
import math
import os
import re
import subprocess
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parent.parent
TOOLS = ROOT / "tools"
LAUNCHER_PKG = "com.gathin.tvhome"
# ---------------------------------------------------------------- reading the repo
def table_rows(text, header_start):
"""Rows of the first Markdown table whose header starts with header_start, as lists of cell strings."""
rows, inside = [], False
for line in text.splitlines():
if line.startswith(header_start):
inside = True
continue
if inside:
if not line.startswith("|"):
if rows:
break
continue
if re.match(r"^\|[\s:|-]+\|$", line):
continue
rows.append([c.strip() for c in line.strip().strip("|").split(" | ")])
return rows
def img_src(cell):
m = re.search(r'<img src="([^"]+)"', cell or "")
return m.group(1) if m else None
def plain(cell):
"""A Markdown cell as text: links to their words, code marks dropped."""
s = re.sub(r"\[([^\]]+)\]\([^)]*\)", r"\1", cell or "")
return s.replace("`", "").strip()
def addons(root=ROOT):
text = (root / "addons" / "README.md").read_text(encoding="utf-8")
out = []
for c in table_rows(text, "| Add-on |"):
m = re.match(r"\[([^\]]+)\]\(([^)/]+)/\)", c[0])
if not m:
continue
name, folder = m.group(1), m.group(2)
d = root / "addons" / folder
shot = img_src(c[5]) if len(c) > 5 else None
out.append({
"kind": "add-on", "name": name, "id": folder, "what": plain(c[1]), "author": plain(c[2]),
"tested": plain(c[3]), "permissions": plain(c[4]),
"screenshot": str(root / "addons" / shot) if shot else None,
"package": package(d), "script": script(d),
})
return out
def package(folder):
for name in ("build.gradle", "build.gradle.kts"):
f = folder / "app" / name
if f.is_file():
m = re.search(r"applicationId\s*=?\s*['\"]([^'\"]+)['\"]", f.read_text(encoding="utf-8"))
if m:
return m.group(1)
return None
def script(folder):
"""The creator's own installer, if the add-on has one."""
for name in ("install.sh", "build-and-install.sh"):
if (folder / name).is_file():
return name
return None
def themes(root=ROOT):
text = (root / "themes" / "README.md").read_text(encoding="utf-8")
out = []
for c in table_rows(text, "| Theme |"):
folder = plain(c[0]).strip("/")
if not folder:
continue
shot = img_src(c[2]) if len(c) > 2 else None
out.append({"kind": "theme", "name": folder, "id": folder, "what": plain(c[1]),
"screenshot": str(root / "themes" / shot) if shot else None})
return out
def switches(root=ROOT):
text = (root / "themes" / "README.md").read_text(encoding="utf-8")
keys_part = text[text.index("## Keys"):] if "## Keys" in text else text
shots = {}
sw = root / "docs" / "switches.md"
if sw.is_file():
for c in table_rows(sw.read_text(encoding="utf-8"), "| Key |"):
src = img_src(c[1]) if len(c) > 1 else None
if src:
for k in re.findall(r"`([a-z_]+)`", c[0]):
shots[k] = str((sw.parent / src).resolve())
out = []
for c in table_rows(keys_part, "| Key |"):
for k in re.findall(r"`([a-z_]+)`", c[0]):
out.append({"kind": "switch", "name": k, "id": k, "type": plain(c[1]) if len(c) > 1 else "",
"what": plain(c[2]) if len(c) > 2 else "", "screenshot": shots.get(k)})
return out
def find(name, root=ROOT):
n = name.strip().strip("/").lower()
for item in addons(root) + themes(root) + switches(root):
if n in (item["id"].lower(), item["name"].lower()):
return item
return None
# ---------------------------------------------------------------- a switch's value
def declared_kind(item):
"""How the launcher reads a switch, from the type column of the Keys table in themes/README.md.
Every reader in Config.java is strict about the JSON type - bool() takes a Boolean and nothing else,
string() a String, integer() a Number in its range, the list readers an array - and a value of another type
is not an error there: the built-in default comes back, so the key silently does nothing on the TV while set
reports it as written. The table states the type of every key, so set reads the value the way that type needs
and refuses one the launcher would drop.
"""
cell = (item.get("type") or "").strip()
if "config.xml only" in cell:
return "config-only"
if cell == "bool":
return "bool"
if cell.startswith("list"):
return "list"
if cell == "object":
return "object"
if declared_range(cell) != (None, None):
return "number"
return "string" if cell else None
def declared_range(cell):
"""The (low, high) of a range cell such as '1 to 8', or (None, None) when the cell is not a range."""
m = re.fullmatch(r"(-?\d+) to (-?\d+)", cell or "")
return (int(m.group(1)), int(m.group(2))) if m else (None, None)
def number_in_range(key, item, parsed, text):
"""An int the launcher's integer() would keep: truncated like Number.intValue(), inside the table's range.
integer() is `int i = ((Number) v).intValue(); return i < min || i > max ? fallback : i;`, so a float is
truncated on the TV and anything outside the range is silently the default. The range comes from the Keys
table, so the value set writes is one the launcher reads back. (lunar_utc_offset's floor in Config.java is
-1, the "by locale" sentinel the table's Meaning column calls Unset rather than a number to pass.)
"""
cell = (item.get("type") or "").strip()
low, high = declared_range(cell)
if low is None or high is None:
# declared_kind() only sends a range cell here; a cell whose shape changed must not pass unchecked.
sys.exit(f"{key} has no range in the Keys table, so there is nothing to check {text} against")
# json.loads accepts NaN and Infinity; int() has no answer for them and integer() keeps the default.
if isinstance(parsed, float) and not math.isfinite(parsed):
sys.exit(f"{key} takes {cell}, so pass a finite number, not {text}")
value = int(parsed)
if not low <= value <= high:
sys.exit(f"{key} takes {cell}, so {text} is out of range and the launcher would keep the default")
return value
def value_as(key, item, text):
"""The argument read the way the key's type needs, or a refusal naming what the key takes."""
kind = declared_kind(item)
if kind == "config-only":
sys.exit(f"{key} is only read from config.xml, not from a theme, so a theme push cannot set it")
if kind == "bool":
if text.strip().lower() not in ("true", "false"):
sys.exit(f"{key} is a bool, so pass true or false, not {text}")
return text.strip().lower() == "true"
if kind in (None, "string"):
try:
parsed = json.loads(text)
except ValueError:
return text
# A string key is read as a String only, so `set greeting_name 42` means the text 42, not a number.
return parsed if isinstance(parsed, str) else text
try:
parsed = json.loads(text)
except ValueError:
parsed = None
wanted = {"list": list, "object": dict, "number": (int, float)}[kind]
# A Python bool is an int, so it would pass the number test while the launcher's integer() drops it.
if not isinstance(parsed, wanted) or isinstance(parsed, bool):
example = {"list": '["a", "b"]', "object": '{"key": "value"}', "number": "6"}[kind]
sys.exit(f"{key} takes {item.get('type')}, so pass {example}, not {text}")
if kind == "number":
return number_in_range(key, item, parsed, text)
return parsed
# ---------------------------------------------------------------- the theme folder set writes into
# Both folders hold config.json files this checkout ships and its tests hold to the launcher's readers
# (tests/test_shipped_config_values.py): a theme author who pointed --theme at one would rewrite a tracked
# file, and the edit would ride along in their next pull request.
PROJECT_FOLDERS = ("themes", "examples")
def reason(error):
"""The short reason from an OSError or a decoding error, without the errno prefix Python repeats."""
return getattr(error, "strerror", None) or str(error)
def json_kind(value):
"""What a parsed JSON value is, in the words a reader would use."""
for kind, name in ((bool, "a boolean"), (list, "an array"), (str, "a string"), (int, "a number"),
(float, "a number"), (type(None), "null")):
if isinstance(value, kind):
return name
return type(value).__name__
def own_folder_problem(folder):
"""Why set may not write into `folder`, or None: it is one of the folders this checkout ships, or a file."""
for name in PROJECT_FOLDERS:
project = ROOT / name
if folder == project or project in folder.parents:
return (f"{folder} is inside this checkout's {name}/: set writes into a theme folder of your own, "
f"so copy one somewhere else first. Nothing was written or pushed.")
if folder.exists() and not folder.is_dir():
return f"{folder} is a file, not a folder: --theme takes a theme folder of your own."
return None
def theme_config(folder):
"""(data, problem): the theme folder's config.json as an object, or why set cannot use it.
The file is the owner's own, hand-edited and pushed by tools/theme.sh, so the ways it can be unreadable are
the owner's next problem to fix: a comma left after the last key, a list where the launcher reads an object,
a file saved in another encoding. Each is named with its path before the key is written, and nothing is
pushed, rather than a JSONDecodeError traceback from halfway through the command.
"""
path = folder / "config.json"
if not path.is_file():
return {}, None # a folder of their own with no config.json yet: set starts the file
try:
text = path.read_text(encoding="utf-8")
except (OSError, UnicodeDecodeError) as e:
return {}, f"cannot read {path}: {reason(e)}. Nothing was written or pushed."
try:
data = json.loads(text)
except ValueError as e:
return {}, (f"{path} is not valid JSON ({e}); fix it, then run set again. "
f"Nothing was written or pushed.")
if not isinstance(data, dict):
return {}, (f"{path} holds {json_kind(data)}, not a JSON object, and a theme's config.json is an object "
f"of keys. Nothing was written or pushed.")
return data, None
# ---------------------------------------------------------------- the TV
def tv_python():
for p in (TOOLS / "venv" / "bin" / "python", TOOLS / "venv" / "Scripts" / "python.exe"):
if p.is_file():
return str(p)
sys.exit("run: python3 -m venv tools/venv && tools/venv/bin/pip install -r tools/requirements.txt")
def tv(command):
if not os.environ.get("TV_HOST"):
sys.exit("set TV_HOST to the TV IP address")
r = subprocess.run([tv_python(), "-I", str(TOOLS / "tv.py"), command], capture_output=True, text=True)
# A failed read is unknown, not empty: never report "not installed" for a TV that didn't answer.
if r.returncode:
sys.exit(r.stderr.strip() or r.stdout.strip() or f"tv.py exited with status {r.returncode}")
return r.stdout
def installed_packages():
return {line.split(":", 1)[1].strip() for line in tv("pm list packages").splitlines() if line.startswith("package:")}
def run(cmd, cwd):
print("$ " + " ".join(cmd), flush=True)
return subprocess.run(cmd, cwd=cwd).returncode
def install_addon(item, extra):
folder = ROOT / "addons" / item["id"]
if item["script"]:
# The creator's own script, as their README says to run it.
return run(["bash", str(folder / item["script"])] + extra, ROOT)
# No script: the steps addons/README.md gives for every add-on.
# Windows resolves a relative program against this process's directory, not cwd, so give the full path.
gradlew = str(folder / "gradlew.bat") if os.name == "nt" else "./gradlew"
code = run([gradlew, "assembleRelease"], folder)
if code:
return code
apk = folder / "app" / "build" / "outputs" / "apk" / "release" / "app-release.apk"
py = tv_python()
code = run([py, "-I", str(TOOLS / "tv.py"), "--push", str(apk), "/data/local/tmp/addon.apk"], ROOT)
if code:
return code
out = tv("pm install -r /data/local/tmp/addon.apk; rm -f /data/local/tmp/addon.apk")
print(out.strip())
return 0 if "Success" in out else 1
# ---------------------------------------------------------------- commands
def show_line(item, installed=None):
mark = ""
if installed is not None and item["kind"] == "add-on":
mark = " [on the TV]" if item["package"] in installed else ""
return f" {item['id']:<24} {item['what'][:90]}{mark}"
def cmd_list(what):
groups = {"addons": addons, "themes": themes, "switches": switches}
for g in ([what] if what else ["addons", "themes", "switches"]):
if g not in groups:
sys.exit("list addons, themes or switches")
items = groups[g]()
print(f"{g} ({len(items)})")
for item in items:
print(show_line(item))
return 0
def cmd_show(name):
item = find(name)
8000
if not item:
sys.exit(f"no add-on, theme or switch called {name}")
for k in ("kind", "name", "what", "type", "author", "tested", "permissions", "package", "screenshot"):
if item.get(k):
print(f"{k:>12}: {item[k]}")
if item["kind"] == "add-on":
how = item["script"] or "the steps in addons/README.md"
print(f"{'install':>12}: TV_HOST=<tv ip> tools/venv/bin/python -I tools/manage.py install {item['id']} (runs {how})")
elif item["kind"] == "theme":
print(f"{'install':>12}: TV_HOST=<tv ip> tools/theme.sh themes/{item['id']}")
else:
print(f"{'set':>12}: TV_HOST=<tv ip> tools/venv/bin/python -I tools/manage.py set {item['id']} <value> --theme <your theme folder>")
return 0
def cmd_status():
have = installed_packages()
print(f"launcher: {'installed' if LAUNCHER_PKG in have else 'not installed'}")
print("add-ons on the TV:")
for item in addons():
if item["package"] in have:
print(f" {item['id']}")
config = tv(f"cat /sdcard/Android/data/{LAUNCHER_PKG}/files/config.json 2>/dev/null")
match = None
if config.strip():
try:
pushed = json.loads(config)
for t in themes():
f = ROOT / "themes" / t["id"] / "config.json"
if f.is_file() and json.loads(f.read_text(encoding="utf-8")) == pushed:
match = t["id"]
except ValueError:
pass
print(f"theme: {match or ('your own' if config.strip() else 'none (the built-in config.xml)')}")
return 0
def cmd_install(name, extra):
item = find(name)
if not item or item["kind"] == "switch":
sys.exit(f"no add-on or theme called {name}")
if item["kind"] == "theme":
return run(["bash", str(TOOLS / "theme.sh"), str(ROOT / "themes" / item["id"])] + extra, ROOT)
return install_addon(item, extra)
def cmd_remove(name):
item = find(name)
if not item or item["kind"] != "add-on" or not item["package"]:
sys.exit(f"no add-on called {name}")
out = tv(f"pm uninstall {item['package']}")
print(out.strip())
return 0 if "Success" in out else 1
def cmd_set(key, value, theme_folder):
item = find(key)
if not item or item["kind"] != "switch":
sys.exit(f"no switch called {key}")
folder = Path(theme_folder).resolve()
problem = own_folder_problem(folder)
if problem:
sys.exit(problem)
data, problem = theme_config(folder)
if problem:
sys.exit(problem)
parsed = value_as(key, item, value) # before the file is written or anything is pushed
data[key] = parsed
f = folder / "config.json"
try:
folder.mkdir(parents=True, exist_ok=True)
f.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
except OSError as e:
# A folder that is read-only, a path with a file in the middle of it, a full disk: the key is not
# written and the theme on the TV is untouched, so say which file and why rather than a traceback.
sys.exit(f"cannot write {f}: {reason(e)}. Nothing was pushed.")
print(f"{key} = {json.dumps(parsed)} in {f}")
return run(["bash", str(TOOLS / "theme.sh"), str(folder)], ROOT)
def main(argv):
if not argv or argv[0] in ("-h", "--help", "help"):
print(__doc__)
return 0
c, args = argv[0], argv[1:]
if c == "list":
return cmd_list(args[0] if args else None)
if c == "show" and args:
return cmd_show(" ".join(args))
if c == "status":
return cmd_status()
if c == "install" and args:
return cmd_install(args[0], args[1:])
if c == "remove" and args:
return cmd_remove(args[0])
if c == "set" and len(args) >= 2:
theme = None
if "--theme" in args:
i = args.index("--theme")
theme = args[i + 1] if i + 1 < len(args) else None
args = args[:i] + args[i + 2:]
if not theme:
sys.exit("set needs --theme <your theme folder>")
return cmd_set(args[0], args[1], theme)
print(__doc__)
return 2
if __name__ == "__main__":
sys.exit(main(sys.argv[1:]))