flashstudio 0.2.2__tar.gz → 0.2.3__tar.gz

{flashstudio-0.2.2/flashstudio.egg-info → flashstudio-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flashstudio
-Version: 0.2.2
+Version: 0.2.3
 Summary: Interactive Training & Inference UI for FlashDet — runs on Google Colab
 Author: FlashVision
 License-Expression: Apache-2.0

{flashstudio-0.2.2 → flashstudio-0.2.3}/flashstudio/__init__.py

@@ -1,5 +1,5 @@
 """FlashStudio — Interactive Training & Inference UI for FlashDet."""
 
-__version__ = "0.2.2"
+__version__ = "0.2.3"
 
 from flashstudio.launcher import launch  # noqa: F401

{flashstudio-0.2.2 → flashstudio-0.2.3}/flashstudio/launcher.py

@@ -1,9 +1,12 @@
 """Launch FlashStudio UI — works locally and inside Google Colab."""
 
+import atexit
+import platform
 import subprocess
 import sys
 import os
 import re
+import tempfile
 import time as _time
 from pathlib import Path
 
@@ -69,59 +72,115 @@ def launch(port: int = 8501, share: bool = True, ngrok_token: str | None = None)
 # Tunnel helpers
 # ---------------------------------------------------------------------------
 
-def _start_cloudflared_tunnel(port: int) -> str | None:
-    """Start a free Cloudflare tunnel (no sign-up required).
+# Keep tunnel processes referenced for the lifetime of the session. If these
+# are garbage collected or terminated, the trycloudflare.com hostname starts
+# returning Cloudflare error 1033 ("tunnel cannot resolve").
+_LIVE_TUNNELS: list = []
+
+
+def _shutdown_tunnels():
+    for proc in list(_LIVE_TUNNELS):
+        try:
+            if proc.poll() is None:
+                proc.terminate()
+        except OSError:
+            pass
+
+
+atexit.register(_shutdown_tunnels)
+
+
+def _cloudflared_binary() -> str | None:
+    """Return a usable cloudflared binary path, downloading it if needed."""
+    import shutil
+
+    existing = shutil.which("cloudflared")
+    if existing:
+        return existing
 
-    Returns the public https URL or None on failure.
-    """
     binary = "/usr/local/bin/cloudflared"
-    if not os.path.isfile(binary):
+    if os.path.isfile(binary):
+        return binary
+
+    machine = platform.machine().lower()
+    arch = "arm64" if machine in ("aarch64", "arm64") else "amd64"
+    url = ("https://github.com/cloudflare/cloudflared/releases/latest/download/"
+           f"cloudflared-linux-{arch}")
+
+    try:
+        subprocess.check_call(
+            ["wget", "-q", url, "-O", binary],
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+        )
+    except Exception:
         try:
-            subprocess.check_call(
-                ["wget", "-q",
-                 "https://github.com/cloudflare/cloudflared/releases/latest"
-                 "/download/cloudflared-linux-amd64",
-                 "-O", binary],
-                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
-            )
-            os.chmod(binary, 0o755)
+            import urllib.request
+            urllib.request.urlretrieve(url, binary)
         except Exception:
             return None
 
     try:
-        tunnel_proc = subprocess.Popen(
-            [binary, "tunnel", "--url", f"http://localhost:{port}"],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-        )
+        os.chmod(binary, 0o755)
     except OSError:
         return None
+    return binary
 
-    url_re = re.compile(r"https://[a-z0-9-]+\.trycloudflare\.com")
-    deadline = _time.monotonic() + 20
+
+def _start_cloudflared_tunnel(port: int) -> str | None:
+    """Start a free Cloudflare quick tunnel (no sign-up required).
+
+    The tunnel process is kept alive for the rest of the session so the URL
+    stays usable. Returns the public https URL or None on failure.
+    """
+    binary = _cloudflared_binary()
+    if not binary:
+        return None
+
+    fd, log_name = tempfile.mkstemp(prefix="flashstudio-cloudflared-",
+                                    suffix=".log")
+    os.close(fd)
+    log_path = Path(log_name)
     try:
-        import select
-        while _time.monotonic() < deadline:
-            ready, _, _ = select.select([tunnel_proc.stderr], [], [], 0.5)
-            if not ready:
-                if tunnel_proc.poll() is not None:
-                    return None
-                continue
-            line = tunnel_proc.stderr.readline().decode("utf-8", errors="replace")
-            if not line:
-                if tunnel_proc.poll() is not None:
-                    return None
-                continue
-            match = url_re.search(line)
-            if match:
-                return match.group(0)
-    finally:
-        if tunnel_proc.poll() is None:
-            try:
-                tunnel_proc.terminate()
-            except OSError:
-                pass
+        with open(log_path, "wb") as log_file:
+            proc = subprocess.Popen(
+                [binary, "tunnel", "--no-autoupdate", "--protocol", "http2",
+                 "--url", f"http://127.0.0.1:{port}"],
+                stdout=log_file,
+                stderr=subprocess.STDOUT,
+            )
+    except OSError:
+        log_path.unlink(missing_ok=True)
+        return None
 
+    _LIVE_TUNNELS.append(proc)
+
+    url_re = re.compile(r"https://[a-z0-9-]+\.trycloudflare\.com")
+    deadline = _time.monotonic() + 30
+    while _time.monotonic() < deadline:
+        if proc.poll() is not None:
+            break
+        try:
+            output = log_path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            output = ""
+        match = url_re.search(output)
+        if match:
+            return match.group(0)
+        _time.sleep(0.5)
+
+    # Timed out or cloudflared exited — clean up so we don't leak a dead tunnel.
+    if proc.poll() is None:
+        try:
+            proc.terminate()
+            proc.wait(timeout=5)
+        except Exception:
+            proc.kill()
+    if proc in _LIVE_TUNNELS:
+        _LIVE_TUNNELS.remove(proc)
+    try:
+        log_path.unlink(missing_ok=True)
+    except OSError:
+        pass
     return None
 
 
@@ -226,9 +285,8 @@ def _launch_colab(app_path: str, port: int, share: bool, ngrok_token: str | None
             print(" Skipped (using Colab proxy)")
 
     # 3) Colab's built-in proxy (fallback — desktop browser only)
-    colab_proxy_url = _get_colab_proxy_url(port)
     if not public_url:
-        public_url = colab_proxy_url
+        public_url = _get_colab_proxy_url(port)
 
     # --- Display results ---
     print(f"\n{'=' * 60}")

{flashstudio-0.2.2 → flashstudio-0.2.3/flashstudio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flashstudio
-Version: 0.2.2
+Version: 0.2.3
 Summary: Interactive Training & Inference UI for FlashDet — runs on Google Colab
 Author: FlashVision
 License-Expression: Apache-2.0

{flashstudio-0.2.2 → flashstudio-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flashstudio"
-version = "0.2.2"
+version = "0.2.3"
 description = "Interactive Training & Inference UI for FlashDet — runs on Google Colab"
 readme = "README_PYPI.md"
 license = "Apache-2.0"

{flashstudio-0.2.2 → flashstudio-0.2.3}/tests/test_launcher.py

@@ -58,3 +58,50 @@ class TestLaunchFunction:
     def test_import(self):
         from flashstudio.launcher import launch
         assert callable(launch)
+
+
+class TestCloudflaredTunnel:
+    def test_tunnel_process_is_kept_alive(self):
+        """The tunnel must stay running, otherwise trycloudflare returns 1033."""
+        from flashstudio import launcher
+
+        class FakeProc:
+            def __init__(self):
+                self.returncode = None
+
+            def poll(self):
+                return self.returncode
+
+            def terminate(self):
+                self.returncode = -15
+
+            def wait(self, timeout=None):
+                return self.returncode
+
+            def kill(self):
+                self.returncode = -9
+
+        fake_proc = FakeProc()
+
+        def fake_popen(cmd, stdout=None, stderr=None):
+            stdout.write(b"Your quick Tunnel: https://unit-test-tunnel.trycloudflare.com\n")
+            stdout.flush()
+            return fake_proc
+
+        launcher._LIVE_TUNNELS.clear()
+        try:
+            with patch.object(launcher, "_cloudflared_binary", return_value="/usr/bin/cloudflared"), \
+                 patch.object(launcher.subprocess, "Popen", side_effect=fake_popen):
+                url = launcher._start_cloudflared_tunnel(8501)
+
+            assert url == "https://unit-test-tunnel.trycloudflare.com"
+            assert fake_proc.poll() is None
+            assert fake_proc in launcher._LIVE_TUNNELS
+        finally:
+            launcher._LIVE_TUNNELS.clear()
+
+    def test_missing_binary_returns_none(self):
+        from flashstudio import launcher
+
+        with patch.object(launcher, "_cloudflared_binary", return_value=None):
+            assert launcher._start_cloudflared_tunnel(8501) is None