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

{unitlab-2.3.33.dist-info → unitlab-2.3.34.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: unitlab
-Version: 2.3.33
+Version: 2.3.34
 Home-page: https://github.com/teamunitlab/unitlab-sdk
 Author: Unitlab Inc.
 Author-email: team@unitlab.ai
@@ -25,4 +25,13 @@ Requires-Dist: psutil
 Requires-Dist: pyyaml
 Requires-Dist: jupyter
 Requires-Dist: python-dotenv
-
+Requires-Dist: uvicorn
+Requires-Dist: fastapi
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist

unitlab-2.3.34.dist-info/RECORD

@@ -0,0 +1,13 @@
+unitlab/__init__.py,sha256=Wtk5kQ_MTlxtd3mxJIn2qHVK5URrVcasMMPjD3BtrVM,214
+unitlab/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
+unitlab/client.py,sha256=LMZ7HFjRxzPV2IrCXlP2GETlY0vWvAxP0RrjSXOn_Jk,26015
+unitlab/exceptions.py,sha256=68Tr6LreEzjQ3Vns8HAaWdtewtkNUJOvPazbf6NSnXU,950
+unitlab/main.py,sha256=EbQNO-Z5drNQjDXJp_sIs5a3WgPoqxaXxpdFGzMWm6k,4416
+unitlab/persistent_tunnel.py,sha256=XDJo2PPq4EjEtI4vT68LIGUUq7WV4m0bnXYKPfY51cY,21180
+unitlab/utils.py,sha256=9gPRu-d6pbhSoVdll1GXe4eoz_uFYOSbYArFDQdlUZs,1922
+unitlab-2.3.34.dist-info/licenses/LICENSE.md,sha256=Gn7RRvByorAcAaM-WbyUpsgi5ED1-bKFFshbWfYYz2Y,1069
+unitlab-2.3.34.dist-info/METADATA,sha256=ctnyV_ZT0vuOzGMoH0N09v0nalsR79WQCGdi_D-ncw0,1046
+unitlab-2.3.34.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+unitlab-2.3.34.dist-info/entry_points.txt,sha256=ig-PjKEqSCj3UTdyANgEi4tsAU84DyXdaOJ02NHX4bY,45
+unitlab-2.3.34.dist-info/top_level.txt,sha256=Al4ZlTYE3fTJK2o6YLCDMH5_DjuQkffRBMxgmWbKaqQ,8
+unitlab-2.3.34.dist-info/RECORD,,

{unitlab-2.3.33.dist-info → unitlab-2.3.34.dist-info}/WHEEL

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

unitlab/api_tunnel.py

@@ -1,238 +0,0 @@
-#!/usr/bin/env python3
-"""
-Simple API-based Dynamic Tunnel - Each device gets deviceid.1scan.uz
-"""
-
-import subprocess
-import requests
-import json
-import time
-import os
-
-class APITunnel:
-    def __init__(self, device_id=None):
-        """Initialize with device ID"""
-        # Hardcoded Cloudflare credentials for simplicity
-        self.cf_email = "muminovbobur93@gmail.com"
-        self.cf_api_key = "1ae47782b5e2e639fb088ee73e17b74db4b4e"  # Global API Key
-        self.cf_account_id = "c91192ae20a5d43f65e087550d8dc89b"
-        self.cf_zone_id = "06ebea0ee0b228c186f97fe9a0a7c83e"  # for 1scan.uz
-        
-        # Clean device ID for subdomain
-        if device_id:
-            self.device_id = device_id.replace('-', '').replace('_', '').replace('.', '').lower()[:20]
-        else:
-            import uuid
-            self.device_id = str(uuid.uuid4())[:8]
-        
-        self.tunnel_name = "agent-{}".format(self.device_id)
-        self.subdomain = self.device_id
-        self.jupyter_url = "https://{}.1scan.uz".format(self.subdomain)
-        
-        self.tunnel_id = None
-        self.tunnel_token = None
-        self.jupyter_process = None
-        self.tunnel_process = None
-    
-    def create_tunnel_via_cli(self):
-        """Create tunnel using cloudflared CLI (simpler than API)"""
-        print("🔧 Creating tunnel: {}...".format(self.tunnel_name))
-        
-        cloudflared = self.get_cloudflared_path()
-        
-        # Login with cert (one-time if not logged in)
-        # This uses the cert.pem file if it exists
-        cert_path = os.path.expanduser("~/.cloudflared/cert.pem")
-        if not os.path.exists(cert_path):
-            print("📝 First time setup - logging in to Cloudflare...")
-            # Use service token instead of interactive login
-            # Or use the API to create tunnel
-        
-        # Create tunnel using CLI
-        cmd = [cloudflared, "tunnel", "create", self.tunnel_name]
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        
-        if result.returncode == 0:
-            # Extract tunnel ID from output
-            import re
-            match = re.search(r'Created tunnel .* with id ([a-f0-9-]+)', result.stdout)
-            if match:
-                self.tunnel_id = match.group(1)
-                print("✅ Tunnel created: {}".format(self.tunnel_id))
-                
-                # Get the tunnel token
-                token_cmd = [cloudflared, "tunnel", "token", self.tunnel_name]
-                token_result = subprocess.run(token_cmd, capture_output=True, text=True)
-                if token_result.returncode == 0:
-                    self.tunnel_token = token_result.stdout.strip()
-                    return True
-        
-        print("⚠️  Could not create tunnel via CLI, using quick tunnel instead")
-        return False
-    
-    def create_dns_record(self):
-        """Add DNS record for subdomain"""
-        if not self.tunnel_id:
-            return False
-            
-        print("🔧 Creating DNS: {}.1scan.uz...".format(self.subdomain))
-        
-        url = "https://api.cloudflare.com/client/v4/zones/{}/dns_records".format(self.cf_zone_id)
-        
-        headers = {
-            "X-Auth-Email": self.cf_email,
-            "X-Auth-Key": self.cf_api_key,
-            "Content-Type": "application/json"
-        }
-        
-        data = {
-            "type": "CNAME",
-            "name": self.subdomain,
-            "content": "{}.cfargotunnel.com".format(self.tunnel_id),
-            "proxied": True
-        }
-        
-        response = requests.post(url, headers=headers, json=data)
-        if response.status_code in [200, 409]:  # 409 = already exists
-            print("✅ DNS configured")
-            return True
-        
-        print("⚠️  DNS setup failed: {}".format(response.text[:100]))
-        return False
-    
-    def get_cloudflared_path(self):
-        """Get or download cloudflared"""
-        import shutil
-        if shutil.which("cloudflared"):
-            return "cloudflared"
-        
-        local_bin = os.path.expanduser("~/.local/bin/cloudflared")
-        if os.path.exists(local_bin):
-            return local_bin
-        
-        # Download
-        print("📦 Downloading cloudflared...")
-        import platform
-        system = platform.system().lower()
-        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.dirname(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)
-        return local_bin
-    
-    def start_jupyter(self):
-        """Start Jupyter"""
-        print("🚀 Starting Jupyter...")
-        
-        cmd = [
-            "jupyter", "notebook",
-            "--port", "8888",
-            "--no-browser",
-            "--ip", "0.0.0.0",
-            "--NotebookApp.token=''",
-            "--NotebookApp.password=''"
-        ]
-        
-        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 - try with token first, fallback to quick tunnel"""
-        cloudflared = self.get_cloudflared_path()
-        
-        if self.tunnel_token:
-            # Use token-based tunnel
-            print("🔧 Starting tunnel with token...")
-            cmd = [cloudflared, "tunnel", "run", "--token", self.tunnel_token]
-        elif self.tunnel_id:
-            # Use tunnel ID
-            print("🔧 Starting tunnel with ID...")
-            cmd = [cloudflared, "tunnel", "run", "--url", "http://localhost:8888", self.tunnel_id]
-        else:
-            # Fallback to quick tunnel
-            print("🔧 Starting quick tunnel (random URL)...")
-            cmd = [cloudflared, "tunnel", "--url", "http://localhost:8888"]
-            self.jupyter_url = "Check terminal output for URL"
-        
-        self.tunnel_process = subprocess.Popen(
-            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
-        )
-        
-        time.sleep(5)
-        print("✅ Tunnel running")
-        return True
-    
-    def start(self):
-        """Main entry point"""
-        try:
-            print("="*50)
-            print("🌐 API-Based Dynamic Tunnel")
-            print("Device: {}".format(self.device_id))
-            print("="*50)
-            
-            # Try to create named tunnel
-            tunnel_created = self.create_tunnel_via_cli()
-            
-            if tunnel_created:
-                # Add DNS record
-                self.create_dns_record()
-            
-            # Start services
-            self.start_jupyter()
-            self.start_tunnel()
-            
-            print("\n" + "="*50)
-            print("🎉 SUCCESS!")
-            if tunnel_created:
-                print("📍 Your permanent URL: {}".format(self.jupyter_url))
-            else:
-                print("📍 Using quick tunnel - check output for URL")
-            print("="*50)
-            
-            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()
-
-
-def main():
-    """Test the API tunnel"""
-    import platform
-    import uuid
-    
-    hostname = platform.node().replace('.', '-')[:20]
-    device_id = "{}-{}".format(hostname, str(uuid.uuid4())[:8])
-    
-    tunnel = APITunnel(device_id=device_id)
-    tunnel.run()
-
-
-if __name__ == "__main__":
-    main()

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
-        
-            
-