globalhost 0.1.0__py3-none-any.whl

globalhost/__init__.py

@@ -0,0 +1,4 @@
+from .core import GlobalHostApp
+
+__version__ = "0.1.0"
+__all__ = ["GlobalHostApp"]

globalhost/core.py

@@ -0,0 +1,73 @@
+import sys
+import os
+import subprocess
+import logging
+from .tunnel import TunnelManager
+
+# Root logger configuration for the globalhost package
+logger = logging.getLogger("globalhost")
+
+class GlobalHostApp:
+    def __init__(self):
+        self.tunnel = TunnelManager()
+        self.url = None
+
+    def launch(self, framework: str, app: str, port: int = 8000):
+        framework = framework.lower()
+
+        try:
+            # 1. Start tunnel and grab URL
+            self.url = self.tunnel.start(port=port)
+
+            logger.info(f"\n🚀 GLOBALHOST IS LIVE!\n👉 YOUR PUBLIC URL: {self.url} 👈\n")
+
+            # 2. Spin up framework
+            if framework == "fastapi":
+                logger.info(f"Launching FastAPI backend via Uvicorn on port {port}...")
+
+                # Get the directory of the currently running script
+                script_dir = os.path.dirname(os.path.abspath(sys.argv[0]))
+
+                subprocess.run(
+                    [sys.executable, "-m", "uvicorn", app, "--host", "127.0.0.1", "--port", str(port)],
+                    cwd=script_dir  # 👈 Run Uvicorn from the script's directory
+                )
+            elif framework == "django":
+                logger.info(f"Launching Django server on port {port}...")
+
+                if os.path.exists("manage.py"):
+                    subprocess.run([sys.executable, "manage.py", "runserver", f"127.0.0.1:{port}"])
+                else:
+                    logger.info("No manage.py detected. Booting Django in standalone mode...")
+
+                    # Clean up file paths or standard dot notation signatures
+                    clean_app = app.replace("\\", "/").rstrip(".py")
+
+                    if "/" in clean_app:
+                        module_dir = os.path.dirname(os.path.abspath(clean_app))
+                        module_name = os.path.basename(clean_app)
+                    else:
+                        module_dir = os.getcwd()
+                        module_name = clean_app
+
+                    # Inject the target example directory directly into the python process environment map
+                    env = os.environ.copy()
+                    env["PYTHONPATH"] = module_dir + os.pathsep + env.get("PYTHONPATH", "")
+
+                    subprocess.run([
+                        sys.executable, "-m", "django",
+                        "runserver", f"127.0.0.1:{port}",
+                        f"--settings={module_name}"
+                    ], env=env)
+            else:
+                logger.error(f"Unknown framework '{framework}'")
+                self.tunnel.stop()
+                sys.exit(1)
+
+        except KeyboardInterrupt:
+            self.tunnel.stop()
+            logger.info("GlobalHost safely shut down.")
+        except Exception as e:
+            self.tunnel.stop()
+            logger.error(f"GlobalHost unexpected crash: {e}")
+            sys.exit(1)

globalhost/tunnel.py

@@ -0,0 +1,101 @@
+import os
+import platform
+import subprocess
+import time
+import sys
+import urllib.request
+import logging
+
+# Set up a named logger for this module
+logger = logging.getLogger("globalhost.tunnel")
+
+class TunnelManager:
+    def __init__(self):
+        self.system = platform.system().lower()
+        self.machine = platform.machine().lower()
+        self.process = None
+        self.public_url = None
+
+    def _get_binary_config(self):
+        base_url = "https://github.com/cloudflare/cloudflared/releases/latest/download/"
+        if "windows" in self.system:
+            filename = "cloudflared-windows-amd64.exe"
+            return filename, base_url + filename
+        elif "linux" in self.system:
+            filename = "cloudflared-linux-arm64" if "arm" in self.machine or "aarch64" in self.machine else "cloudflared-linux-amd64"
+            return filename, base_url + filename
+        elif "darwin" in self.system:
+            filename = "cloudflared-darwin-arm64.tgz" if "arm" in self.machine else "cloudflared-darwin-amd64.tgz"
+            return filename, base_url + filename
+        else:
+            raise RuntimeError(f"GlobalHost doesn't support your OS yet: {self.system}")
+
+    def _ensure_binary_exists(self) -> str:
+        base_dir = os.path.dirname(__file__)
+        bin_dir = os.path.join(base_dir, "bin")
+        os.makedirs(bin_dir, exist_ok=True)
+
+        filename, download_url = self._get_binary_config()
+        binary_path = os.path.join(bin_dir, filename)
+
+        if filename.endswith(".tgz"):
+            binary_path = os.path.join(bin_dir, "cloudflared")
+
+        if not os.path.exists(binary_path):
+            logger.info("Core networking module missing. Downloading from Cloudflare network...")
+            logger.debug(f"Downloading from URL: {download_url}")
+            try:
+                temp_download = os.path.join(bin_dir, filename)
+                urllib.request.urlretrieve(download_url, temp_download)
+                if filename.endswith(".tgz"):
+                    import tarfile
+                    with tarfile.open(temp_download, "r:gz") as tar:
+                        tar.extractall(path=bin_dir)
+                    os.remove(temp_download)
+                logger.info("Download complete.")
+            except Exception as e:
+                logger.error(f"Failed to download network binary: {e}")
+                sys.exit(1)
+
+        if "windows" not in self.system:
+            os.chmod(binary_path, 0o755)
+
+        return binary_path
+
+    def start(self, port: int) -> str:
+        binary = self._ensure_binary_exists()
+
+        logger.info(f"Establishing secure edge network tunnel to port {port}...")
+
+        self.process = subprocess.Popen(
+            [binary, "tunnel", "--url", f"http://localhost:{port}"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1
+        )
+
+        start_time = time.time()
+        while time.time() - start_time < 10:
+            line = self.process.stdout.readline()
+            if not line:
+                break
+
+            if ".trycloudflare.com" in line:
+                for word in line.split():
+                    if "trycloudflare.com" in word:
+                        url = word.strip()
+                        if url.startswith("https://"):
+                            self.public_url = url
+                        else:
+                            self.public_url = f"https://{url}"
+                        break
+                break
+
+        return self.public_url
+
+    def stop(self):
+        if self.process:
+            logger.info("Collapsing tunnel, removing machine from public routing...")
+            self.process.terminate()
+            self.process.wait()

globalhost-0.1.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: globalhost
+Version: 0.1.0
+Summary: Turn any machine into a public server instantly with automated zero-config tunnels.
+Author-email: Joel Opoku <joelclouds@gmail.com>
+Project-URL: Homepage, https://github.com/joelclouds/globalhost
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: uvicorn>=0.22.0
+
+# GlobalHost 🛰️
+
+Turn any machine running your code into a publicly accessible, secure SaaS backend instantly. No `localhost`, no router configuration, and zero cloud deployment setup needed during development.
+
+## Features
+* **Zero-Config Public Ingress:** Automatically spawns a secure, temporary public HTTPS tunnel (`.trycloudflare.com`) on startup.
+* **Framework Agnostic:** Works flawlessly out-of-the-box with **FastAPI**, **Django**, Flask, or raw Python scripts.
+* **Self-Contained & Lightweight:** Auto-provisions the exact native binary for your OS (Mac/Win/Lin) on the fly. No `brew`, `apt`, or manual downloads required, and keeps the pip package tiny.
+
+---
+
+## Architecture
+
+```text
+[ Any PC Running Your Code ] ──(Outbound Tunnel)──> [ Global Edge Network ] ──> [ Public Internet URL ]
+```
+
+---
+
+## Quick Start
+
+### 1. Installation
+
+```bash
+pip install globalhost
+```
+
+### 2. Basic Usage (Zero-Config)
+
+Drop this into your project entrypoint. This automatically boots the tunnel and wraps your web framework.
+
+```python
+from globalhost import GlobalHostApp
+from fastapi import FastAPI
+
+app = FastAPI()
+
+@app.get("/my-algo")
+def run_algo():
+    return {"status": "Your golden algo is live globally!"}
+
+if __name__ == "__main__":
+    # Boots tunnel and starts the server
+    GlobalHostApp.launch(framework="fastapi", app="main:app", port=8000)
+```
+
+### 3. Programmatic Usage (Advanced)
+
+Need to inject the live public URL into a database, webhook, or frontend config at runtime? Use the programmatic API:
+
+```python
+from globalhost import GlobalHostApp
+
+gh = GlobalHostApp()
+
+# Start the tunnel and grab the endpoint string
+public_endpoint = gh.tunnel.start(port=9000)
+
+print(f"🔗 Live Hyperlink: {public_endpoint}")
+print(f"📦 Stored Attribute: {gh.tunnel.public_url}")
+
+# Keep tunnel alive while your app runs...
+```
+
+---
+
+## How It Works Under the Hood
+
+1. **OS Detection:** On execution, the module identifies the hosting machine's operating system and architecture.
+2. **Auto-Provisioning:** It silently downloads and caches the exact lightweight network binary required for that specific system.
+3. **Reverse Tunnel Routing:** It executes the binary to establish a secure outbound connection to a global edge router, bypassing local firewalls and printing your public production-ready endpoint straight to the console.
+
+---
+
+## Examples
+
+Ready-to-run implementations are available in the `examples/` directory:
+* **FastAPI:** `examples/fastapi/01_json_api.py` & `02_webpage.py`
+* **Django:** `examples/django/01_json_api.py` & `02_webpage.py`
+* **Runtime URL Extraction:** `examples/runtime_url.py`
+
+---
+
+## Author
+
+**Joel Opoku**
+📧 [joelclouds@gmail.com](mailto:joelclouds@gmail.com)
+🌐 [joelclouds.pythonanywhere.com](https://joelclouds.pythonanywhere.com)
+🐙 [github.com/joelclouds/globalhost](https://github.com/joelclouds/globalhost)
+
+## License
+
+Distributed under the MIT License. See `LICENSE` for more information.

globalhost-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+globalhost/__init__.py,sha256=oTz_h5NEmfEtHDY66QWrSD7P71EMmMPf7LxiR1DLaWA,83
+globalhost/core.py,sha256=A2mX7_5Vn-LxeyavJTRFkub8OL-Us4ssLrY11-E9pq4,2885
+globalhost/tunnel.py,sha256=LZK_CpxDxMzp8UJKKj2UyNoSDV4lZGLoIaM6TZN0Nvk,3741
+globalhost-0.1.0.dist-info/METADATA,sha256=A-Hr_JV_W5wDNXMO59T1BX6JCvHb739yPidwP1D9fUE,3470
+globalhost-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+globalhost-0.1.0.dist-info/top_level.txt,sha256=c4InFFLegEgznGRj3zG1ksGe_1lYpWJb25ZsX_W4jOA,11
+globalhost-0.1.0.dist-info/RECORD,,

globalhost-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

globalhost-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+globalhost