unitlab 2.3.33__py3-none-any.whl → 2.3.35__py3-none-any.whl

unitlab/auto_tunnel.py

@@ -1,174 +0,0 @@
-#!/usr/bin/env python3
-"""
-Automatic Tunnel Creation - Simplest approach using cloudflared's built-in quick tunnel
-No API tokens needed!
-"""
-
-import subprocess
-import time
-import re
-import os
-
-class AutoTunnel:
-    def __init__(self, device_id=None):
-        """
-        Initialize auto tunnel - no credentials needed!
-        """
-        self.device_id = device_id or "device"
-        self.jupyter_process = None
-        self.tunnel_process = None
-        self.tunnel_url = None
-        
-    def get_cloudflared_path(self):
-        """Get or download cloudflared binary"""
-        import platform
-        
-        # Check if exists in system
-        import shutil
-        if shutil.which("cloudflared"):
-            return "cloudflared"
-        
-        # Check local
-        local_bin = os.path.expanduser("~/.local/bin/cloudflared")
-        if os.path.exists(local_bin):
-            return local_bin
-        
-        # Download it
-        print("📦 Downloading cloudflared...")
-        system = platform.system().lower()
-        if system == "linux":
-            arch = "amd64" if "x86" in platform.machine() else "arm64"
-            url = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-{}".format(arch)
-            
-            os.makedirs(os.path.expanduser("~/.local/bin"), exist_ok=True)
-            subprocess.run("curl -L {} -o {}".format(url, local_bin), shell=True, capture_output=True)
-            subprocess.run("chmod +x {}".format(local_bin), shell=True)
-            print("✅ cloudflared downloaded")
-            return local_bin
-        
-        return "cloudflared"
-    
-    def start_jupyter(self):
-        """Start Jupyter notebook"""
-        print("🚀 Starting Jupyter on port 8888...")
-        
-        cmd = [
-            "jupyter", "notebook",
-            "--port", "8888",
-            "--no-browser",
-            "--ip", "0.0.0.0",
-            "--NotebookApp.token=''",
-            "--NotebookApp.password=''",
-            "--NotebookApp.allow_origin='*'"
-        ]
-        
-        self.jupyter_process = subprocess.Popen(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE
-        )
-        
-        time.sleep(3)
-        print("✅ Jupyter started")
-        return True
-    
-    def start_tunnel(self):
-        """Start tunnel using cloudflared quick tunnel - no auth needed!"""
-        print("🔧 Starting automatic tunnel (no credentials needed)...")
-        
-        cloudflared = self.get_cloudflared_path()
-        
-        # Use cloudflared's quick tunnel feature - generates random URL
-        cmd = [
-            cloudflared,
-            "tunnel",
-            "--url", "http://localhost:8888"
-        ]
-        
-        self.tunnel_process = subprocess.Popen(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            text=True,
-            bufsize=1
-        )
-        
-        # Read output to get the tunnel URL
-        print("⏳ Waiting for tunnel URL...")
-        for _ in range(30):  # Wait up to 30 seconds
-            line = self.tunnel_process.stdout.readline()
-            if line:
-                # Look for the tunnel URL in output
-                match = re.search(r'https://[a-zA-Z0-9-]+\.trycloudflare\.com', line)
-                if match:
-                    self.tunnel_url = match.group(0)
-                    print("✅ Tunnel created: {}".format(self.tunnel_url))
-                    return True
-            time.sleep(1)
-        
-        print("❌ Failed to get tunnel URL")
-        return False
-    
-    def start(self):
-        """Start everything - super simple!"""
-        try:
-            print("="*50)
-            print("🌐 Automatic Cloudflare Tunnel (No Auth Needed!)")
-            print("Device: {}".format(self.device_id))
-            print("="*50)
-            
-            # 1. Start Jupyter
-            if not self.start_jupyter():
-                raise Exception("Failed to start Jupyter")
-            
-            # 2. Start tunnel (automatic, no credentials)
-            if not self.start_tunnel():
-                raise Exception("Failed to start tunnel")
-            
-            print("\n" + "="*50)
-            print("🎉 SUCCESS! Your Jupyter is accessible at:")
-            print("   {}".format(self.tunnel_url))
-            print("="*50)
-            print("\n⚠️  Note: This URL is temporary and random")
-            print("For persistent URLs, use Cloudflare API approach")
-            
-            return True
-            
-        except Exception as e:
-            print("❌ Error: {}".format(e))
-            self.stop()
-            return False
-    
-    def stop(self):
-        """Stop everything"""
-        if self.jupyter_process:
-            self.jupyter_process.terminate()
-        if self.tunnel_process:
-            self.tunnel_process.terminate()
-    
-    def run(self):
-        """Run and keep alive"""
-        try:
-            if self.start():
-                print("\nPress Ctrl+C to stop...")
-                while True:
-                    time.sleep(1)
-        except KeyboardInterrupt:
-            print("\n⏹️  Shutting down...")
-            self.stop()
-            print("👋 Goodbye!")
-
-
-def main():
-    """Test automatic tunnel"""
-    import platform
-    device_id = platform.node()
-    
-    print("Starting auto tunnel for: {}".format(device_id))
-    
-    tunnel = AutoTunnel(device_id=device_id)
-    tunnel.run()
-
-
-if __name__ == "__main__":
-    main()

unitlab/binary_manager.py

@@ -1,154 +0,0 @@
-import os
-import platform
-import hashlib
-import urllib.request
-from pathlib import Path
-import stat
-import json
-
-class CloudflaredBinaryManager:
-    """
-    Manages cloudflared binary automatically
-    - Downloads on first use
-    - Caches for future use  
-    - Verifies integrity
-    - Zero user configuration
-    """
-
-    # Binary URLs and checksums
-    BINARIES = {
-        'linux-amd64': {
-            'url': 'https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64',
-            'checksum': 'sha256:...',  # Add real checksums
-            'filename': 'cloudflared'
-        },
-        'linux-arm64': {
-            'url': 'https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-arm64',
-            'checksum': 'sha256:...',
-            'filename': 'cloudflared'
-        },
-        'darwin-amd64': {
-            'url': 'https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-darwin-amd64.tgz',
-            'checksum': 'sha256:...',
-            'filename': 'cloudflared',
-            'compressed': True
-        },
-        'windows-amd64': {
-            'url': 'https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-amd64.exe',
-            'checksum': 'sha256:...',
-            'filename': 'cloudflared.exe'
-        }
-    }
-
-    def __init__(self):
-        # User's home directory - works on all platforms
-        self.cache_dir = Path.home() / '.unitlab' / 'bin'
-        self.cache_dir.mkdir(parents=True, exist_ok=True)
-
-        # Detect platform once
-        self.platform_key = self._detect_platform()
-
-    def _detect_platform(self):
-        """Detect OS and architecture"""
-        system = platform.system().lower()
-        machine = platform.machine().lower()
-
-        if system == 'linux':
-            if machine in ['x86_64', 'amd64']:
-                return 'linux-amd64'
-            elif machine in ['aarch64', 'arm64']:
-                return 'linux-arm64'
-
-        elif system == 'darwin':  # macOS
-            # Check if ARM (M1/M2) or Intel
-            if machine == 'arm64':
-                return 'darwin-arm64'
-            return 'darwin-amd64'
-
-        elif system == 'windows':
-            return 'windows-amd64'
-
-        raise RuntimeError(f"Unsupported platform: {system} {machine}")
-
-    def get_binary_path(self):
-        """Get path to cloudflared binary, downloading if needed"""
-
-        binary_info = self.BINARIES[self.platform_key]
-        binary_path = self.cache_dir / binary_info['filename']
-
-        # Check if already downloaded
-        if binary_path.exists():
-            print("✓ Using cached cloudflared")
-            return str(binary_path)
-
-        # Download for first time
-        print("🔄 First time setup - downloading cloudflared...")
-        self._download_binary(binary_info, binary_path)
-
-        return str(binary_path)
-
-    def _download_binary(self, info, target_path):
-        """Download and verify binary"""
-        
-        # Create SSL context to handle certificate issues
-        import ssl
-        ssl_context = ssl.create_default_context()
-        ssl_context.check_hostname = False
-        ssl_context.verify_mode = ssl.CERT_NONE
-
-        # Download with progress bar
-        def download_progress(block_num, block_size, total_size):
-            downloaded = block_num * block_size
-            if total_size > 0:
-                percent = min(downloaded * 100 / total_size, 100)
-                print(f"Downloading: {percent:.0f}%", end='\r')
-            else:
-                print(f"Downloading: {downloaded} bytes", end='\r')
-
-        temp_file = target_path.with_suffix('.tmp')
-
-        try:
-            # Download file with SSL context
-            req = urllib.request.Request(info['url'], headers={'User-Agent': 'Mozilla/5.0'})
-            with urllib.request.urlopen(req, context=ssl_context) as response:
-                total_size = int(response.headers.get('Content-Length', 0))
-                
-                with open(temp_file, 'wb') as f:
-                    downloaded = 0
-                    block_size = 8192
-                    while True:
-                        chunk = response.read(block_size)
-                        if not chunk:
-                            break
-                        f.write(chunk)
-                        downloaded += len(chunk)
-                        if total_size > 0:
-                            percent = min(downloaded * 100 / total_size, 100)
-                            print(f"Downloading: {percent:.0f}%", end='\r')
-            print("\n✓ Download complete")
-
-            # Handle compressed files (macOS .tgz)
-            if info.get('compressed'):
-                import tarfile
-                with tarfile.open(temp_file, 'r:gz') as tar:
-                    # Extract just the cloudflared binary
-                    tar.extract('cloudflared', self.cache_dir)
-                temp_file.unlink()
-            else:
-                # Move to final location
-                temp_file.rename(target_path)
-
-            # Make executable on Unix systems
-            if platform.system() != 'Windows':
-                target_path.chmod(target_path.stat().st_mode | stat.S_IEXEC)
-
-            print("✓ Cloudflared ready!")
-
-        except Exception as e:
-            print(f"❌ Download failed: {e}")
-            if temp_file.exists():
-                temp_file.unlink()
-            raise
-        
-            
-