Debloat any Android or Google TV over Wi-Fi and get an Apple TV-style home.
Python adbadblockandroid-tvandroid-tv-launcherapple-tvbloatware-removalclaude-codedebloatfire-tvgoogle-tvlauncherprivacysmart-tvsony-braviatclvibe-codingxiaomi
"""tools/b64push.py: a client that is not installed is refused, not a traceback.
The script is started both ways, like the other tools: every add-on install script and
`tools/theme.sh` run it as `tools/venv/bin/python -I tools/b64push.py`, and a reader who has just
cloned the repository types `python3 tools/b64push.py app.apk /data/local/tmp/app.apk`. That second
run ended in a ModuleNotFoundError out of `import tv` - a traceback with exit 1, the code this file
keeps for a transfer that failed, although nothing had been sent and no TV had been opened - and it
named neither tools/requirements.txt nor the venv sitting next to it.
b64push.py is the fourth place the client is imported. tools/privacy.py's and tools/recovery.py's
connect() stop with the line that builds the venv, tools/bench.py and tools/trace.py start again
under it, and tools/tv.py does the same when it is the script that was started; this file now answers
with that line and exits 2, which is what its own exit status reserves for a run that sent nothing.
The first run below copies the real tools/tv.py beside a copy of the script and starts it with -S, so
the interpreter cannot import adb_shell whatever it is installed into: that is the shape a fresh clone
gives. The second puts a stand-in tv.py there instead, and shows the handler is entered only when the
import fails: a client that loads is used as it was.
Run from the repository root: python3 -m unittest discover -s tests -v
"""
import os
from pathlib import Path
import shutil
import subprocess
import sys
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
# A tools/tv.py that records being opened, so a run that gets past the import leaves a file behind.
FAKE_TV = r'''import os
open(os.environ["FAKE_CONNECTED"], "w").write("connected")
class Device:
max_chunk_size = 4096
def shell(self, command, read_timeout_s=None):
return ""
def close(self):
pass
def connect():
return Device()
'''
class MissingClientTest(unittest.TestCase):
def setUp(self):
self.base = Path(tempfile.mkdtemp())
self.addCleanup(shutil.rmtree, self.base, ignore_errors=True)
tools = self.base / "tools"
tools.mkdir()
shutil.copy2(ROOT / "tools" / "b64push.py", tools / "b64push.py")
shutil.copy2(ROOT / "tools" / "tv.py", tools / "tv.py")
self.script = tools / "b64push.py"
self.connected = self.base / "connected"
self.local = self.base / "app.apk"
self.local.write_bytes(b"an apk")
def run_b64push(self, *args, isolated=False):
"""The script, with no TV_HOST in the environment and adb_shell unavailable under -S."""
env = {k: v for k, v in os.environ.items() if k not in ("TV_HOST", "TV_PORT")}
env["FAKE_CONNECTED"] = str(self.connected)
command = [sys.executable] + (["-S"] if isolated else []) + [str(self.script), *args]
return subprocess.run(command, env=env, capture_output=True, text=True, timeout=60)
def assert_client_refused(self, result):
self.assertEqual(result.returncode, 2, result.stdout + result.stderr)
self.assertIn("cannot load tools/tv.py", result.stderr)
self.assertIn("tools/venv", result.stderr, "the message names the venv to install the packages into")
self.assertIn("tools/requirements.txt", result.stderr, "and the file the packages are listed in")
self.assertNotIn("Traceback", result.stderr)
self.assertEqual(result.stdout, "", "nothing is reported as transferred")
self.assertFalse(self.connected.exists(), "the TV is not opened")
def test_a_run_without_the_packages_is_refused(self):
self.assert_client_refused(self.run_b64push(str(self.local), "/data/local/tmp/app.apk",
isolated=True))
def test_the_refusal_comes_before_the_tv_host_check(self):
# tv.py reads TV_HOST at import time, so a run with no TV_HOST and no packages has to answer
# about the packages: that is the thing the reader can fix.
result = self.run_b64push(str(self.local), "/data/local/tmp/app.apk", isolated=True)
self.assertNotIn("Set TV_HOST", result.stderr)
self.assertIn("adb_shell", result.stderr, "the missing package is named")
def test_a_word_count_that_is_wrong_still_gets_the_usage_line(self):
# The usage message is written before the client is imported, so this refusal is unchanged.
result = self.run_b64push(str(self.local), isolated=True)
self.assertEqual(result.returncode, 2, result.stderr)
self.assertIn("usage: b64push.py", result.stderr)
self.assertNotIn("cannot load", result.stderr)
def test_a_client_that_loads_is_used_as_before(self):
(self.base / "tools" / "tv.py").write_text(FAKE_TV, encoding="utf-8")
result = self.run_b64push(str(self.local), "/data/local/tmp/app.apk")
self.assertNotIn("cannot load tools/tv.py", result.stderr,
"the handler is for a failed import, not for every run")
self.assertTrue(self.connected.exists(), "the client beside the copy was imported and used")
if __name__ == "__main__":
unittest.main()