unitlab 2.3.0__py3-none-any.whl → 2.3.3__py3-none-any.whl

unitlab/client.py

@@ -3,16 +3,30 @@ import glob
 import logging
 import os
 import urllib.parse
-
 import aiofiles
 import aiohttp
 import requests
 import tqdm
-
+import socket
+import subprocess
+import signal
+import re
+import time
+import threading
+import psutil
+from datetime import datetime, timezone
+from .tunnel_config import CloudflareTunnel
 from .utils import get_api_url, handle_exceptions
 
-logger = logging.getLogger(__name__)
 
+try:
+    import GPUtil
+    HAS_GPU = True
+except ImportError:
+    HAS_GPU = False
+
+
+logger = logging.getLogger(__name__)
 
 class UnitlabClient:
     """A client with a connection to the Unitlab.ai platform.
@@ -54,6 +68,20 @@ class UnitlabClient:
         adapter = requests.adapters.HTTPAdapter(max_retries=3)
         self.api_session.mount("http://", adapter)
         self.api_session.mount("https://", adapter)
+        
+        # Device agent attributes (initialized when needed)
+        self.device_id = None
+        self.base_domain = None
+        self.server_url = None
+        self.hostname = socket.gethostname()
+        self.tunnel_manager = None
+        self.jupyter_url = None
+        self.ssh_url = None
+        self.jupyter_proc = None
+        self.tunnel_proc = None
+        self.jupyter_port = None
+        self.running = True
+        self.metrics_thread = None
 
     def close(self) -> None:
         """Close :class:`UnitlabClient` connections.
@@ -234,3 +262,372 @@ class UnitlabClient:
                         pbar.update(await f)
 
         asyncio.run(main())
+    
+    def initialize_device_agent(self, server_url: str, device_id: str, base_domain: str):
+        """Initialize device agent configuration"""
+        self.server_url = server_url.rstrip('/')
+        self.device_id = device_id
+        self.base_domain = base_domain
+        
+        # Initialize tunnel manager if available
+        if CloudflareTunnel:
+            self.tunnel_manager = CloudflareTunnel(base_domain, device_id)
+            self.jupyter_url = self.tunnel_manager.jupyter_url
+            self.ssh_url = self.tunnel_manager.ssh_url
+        else:
+            self.tunnel_manager = None
+            self.jupyter_url = f"https://jupyter-{device_id}.{base_domain}"
+            self.ssh_url = f"https://ssh-{device_id}.{base_domain}"
+        
+        # Setup signal handlers
+        signal.signal(signal.SIGINT, self._handle_shutdown)
+        signal.signal(signal.SIGTERM, self._handle_shutdown)
+    
+    def _handle_shutdown(self, signum, frame):
+        """Handle shutdown signals"""
+        _ = frame  # Unused but required by signal handler signature
+        logger.info(f"Received signal {signum}, shutting down...")
+        self.running = False
+    
+    def _get_device_headers(self):
+        """Get headers for device agent API requests"""
+        headers = {
+            'Content-Type': 'application/json',
+            'User-Agent': f'UnitlabDeviceAgent/{self.device_id}'
+        }
+        
+        # Add API key if provided
+        if self.api_key:
+            headers['Authorization'] = f'Api-Key {self.api_key}'
+        
+        return headers
+    
+    def _post_device(self, endpoint, data=None):
+        """Make authenticated POST request for device agent"""
+        full_url = urllib.parse.urljoin(self.server_url, endpoint)
+        logger.debug(f"Posting to {full_url} with data: {data}")
+        
+        try:
+            response = self.api_session.post(
+                full_url,
+                json=data or {},
+                headers=self._get_device_headers(),
+            )
+            logger.debug(f"Response status: {response.status_code}, Response: {response.text}")
+            response.raise_for_status()
+            return response
+        except Exception as e:
+            logger.error(f"POST request failed to {full_url}: {e}")
+            raise
+    
+    def start_jupyter(self) -> bool:
+        """Start Jupyter notebook server"""
+        try:
+            logger.info("Starting Jupyter notebook...")
+            
+            cmd = [
+                "jupyter", "notebook",
+                "--no-browser",
+                "--ServerApp.token=''",
+                "--ServerApp.password=''",
+                "--ServerApp.allow_origin='*'",
+                "--ServerApp.ip='0.0.0.0'"
+            ]
+            
+            self.jupyter_proc = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True
+            )
+            
+            # Wait for Jupyter to start and get the port
+            start_time = time.time()
+            while time.time() - start_time < 30:
+                line = self.jupyter_proc.stdout.readline()
+                if not line:
+                    break
+                
+                # Look for the port in the output
+                match = re.search(r'http://.*:(\d+)/', line)
+                if match:
+                    self.jupyter_port = match.group(1)
+                    logger.info(f"✅ Jupyter started on port {self.jupyter_port}")
+                    return True
+            
+            raise Exception("Timeout waiting for Jupyter to start")
+            
+        except Exception as e:
+            logger.error(f"Failed to start Jupyter: {e}")
+            if self.jupyter_proc:
+                self.jupyter_proc.terminate()
+                self.jupyter_proc = None
+            return False
+    
+    def setup_tunnels(self) -> bool:
+        """Setup Cloudflare tunnels"""
+        try:
+            if not self.jupyter_port:
+                logger.error("Jupyter port not available")
+                return False
+            
+            if not self.tunnel_manager:
+                logger.warning("CloudflareTunnel not available, skipping tunnel setup")
+                return True
+            
+            logger.info("Setting up Cloudflare tunnels...")
+            self.tunnel_proc = self.tunnel_manager.setup(self.jupyter_port)
+            
+            if self.tunnel_proc:
+                logger.info("✅ Tunnels established")
+                self.report_services()
+                return True
+            
+            return False
+            
+        except Exception as e:
+            logger.error(f"Tunnel setup failed: {e}")
+            return False
+    
+    def check_ssh(self) -> bool:
+        """Check if SSH service is available"""
+        try:
+            # Check if SSH is running
+            result = subprocess.run(
+                ["systemctl", "is-active", "ssh"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            
+            if result.stdout.strip() == "active":
+                logger.info("✅ SSH service is active")
+                return True
+            else:
+                logger.warning("SSH service is not active")
+                # Try to start SSH
+                subprocess.run(["sudo", "systemctl", "start", "ssh"], timeout=10)
+                time.sleep(2)
+                return False
+                
+        except Exception as e:
+            logger.error(f"SSH check failed: {e}")
+            return False
+    
+    def report_services(self):
+        """Report services to the server"""
+        try:
+            # Report Jupyter service
+            jupyter_data = {
+                'service_type': 'jupyter',
+                'service_name': f'jupyter-{self.device_id}',
+                'local_port': int(self.jupyter_port) if self.jupyter_port else 8888,
+                'tunnel_url': self.jupyter_url,
+                'status': 'online'
+            }
+            
+            logger.info(f"Reporting Jupyter service with URL: {self.jupyter_url}")
+            jupyter_response = self._post_device(
+                f"/api/tunnel/agent/jupyter/{self.device_id}/", 
+                jupyter_data
+            )
+            logger.info(f"Reported Jupyter service: {jupyter_response.status_code if hasattr(jupyter_response, 'status_code') else jupyter_response}")
+            
+            # Report SSH service (always report, even if SSH is not running locally)
+            # Remove https:// prefix for SSH hostname
+            ssh_hostname = self.ssh_url.replace('https://', '')
+            
+            # Get current system username
+            import getpass
+            current_user = getpass.getuser()
+            
+            # Create SSH connection command
+            ssh_connection_cmd = f"ssh -o ProxyCommand='cloudflared access ssh --hostname {ssh_hostname}' {current_user}@{ssh_hostname}"
+            
+            # Check if SSH is available
+            ssh_available = self.check_ssh()
+            
+            ssh_data = {
+                'service_type': 'ssh',
+                'service_name': f'ssh-{self.device_id}',
+                'local_port': 22,
+                'tunnel_url': ssh_connection_cmd,  # Send the SSH command instead of URL
+                'status': 'online' if ssh_available else 'offline'
+            }
+            
+            logger.info(f"Reporting SSH service with command: {ssh_connection_cmd}")
+            ssh_response = self._post_device(
+                f"/api/tunnel/agent/ssh/{self.device_id}/",
+                ssh_data
+            )
+            logger.info(f"Reported SSH service: {ssh_response.status_code if hasattr(ssh_response, 'status_code') else ssh_response}")
+            
+        except Exception as e:
+            logger.error(f"Failed to report services: {e}", exc_info=True)
+    
+    def collect_metrics(self) -> dict:
+        """Collect system metrics"""
+        metrics = {}
+        
+        # CPU metrics
+        metrics['cpu'] = {
+            'percent': psutil.cpu_percent(interval=1),
+            'count': psutil.cpu_count(),
+            'timestamp': datetime.now(timezone.utc).isoformat()
+        }
+        
+        # Memory metrics
+        mem = psutil.virtual_memory()
+        metrics['ram'] = {
+            'total': mem.total,
+            'used': mem.used,
+            'available': mem.available,
+            'percent': mem.percent,
+            'timestamp': datetime.now(timezone.utc).isoformat()
+        }
+        
+        # GPU metrics (if available)
+        if HAS_GPU:
+            try:
+                gpus = GPUtil.getGPUs()
+                if gpus:
+                    gpu = gpus[0]
+                    metrics['gpu'] = {
+                        'name': gpu.name,
+                        'load': gpu.load * 100,
+                        'memory_used': gpu.memoryUsed,
+                        'memory_total': gpu.memoryTotal,
+                        'temperature': gpu.temperature,
+                        'timestamp': datetime.now(timezone.utc).isoformat()
+                    }
+            except Exception as e:
+                logger.debug(f"GPU metrics unavailable: {e}")
+        
+        return metrics
+    
+    def send_metrics(self):
+        """Send metrics to server"""
+        try:
+            metrics = self.collect_metrics()
+            
+            # Send CPU metrics
+            if 'cpu' in metrics:
+                self._post_device(f"/api/tunnel/agent/cpu/{self.device_id}/", metrics['cpu'])
+            
+            # Send RAM metrics  
+            if 'ram' in metrics:
+                self._post_device(f"/api/tunnel/agent/ram/{self.device_id}/", metrics['ram'])
+            
+            # Send GPU metrics if available
+            if 'gpu' in metrics and metrics['gpu']:
+                self._post_device(f"/api/tunnel/agent/gpu/{self.device_id}/", metrics['gpu'])
+            
+            logger.debug(f"Metrics sent - CPU: {metrics['cpu']['percent']:.1f}%, RAM: {metrics['ram']['percent']:.1f}%")
+            
+        except Exception as e:
+            logger.error(f"Failed to send metrics: {e}")
+    
+    def metrics_loop(self):
+        """Background thread for sending metrics"""
+        logger.info("Starting metrics thread")
+        
+        while self.running:
+            try:
+                self.send_metrics()
+                
+                # Check if processes are still running
+                if self.jupyter_proc and self.jupyter_proc.poll() is not None:
+                    logger.warning("Jupyter process died")
+                    self.jupyter_proc = None
+                
+                if self.tunnel_proc and self.tunnel_proc.poll() is not None:
+                    logger.warning("Tunnel process died")
+                    self.tunnel_proc = None
+                
+            except Exception as e:
+                logger.error(f"Metrics loop error: {e}")
+            
+            # Wait for next interval (default 5 seconds)
+            for _ in range(3):
+                if not self.running:
+                    break
+                time.sleep(1)
+        
+        logger.info("Metrics thread stopped")
+    
+    def run_device_agent(self):
+        """Main run method for device agent"""
+        logger.info("=" * 50)
+        logger.info("Starting Device Agent")
+        logger.info(f"Device ID: {self.device_id}")
+        logger.info(f"Server: {self.server_url}")
+        logger.info(f"Domain: {self.base_domain}")
+        logger.info("=" * 50)
+        
+        # Check SSH
+        self.check_ssh()
+        
+        # Start Jupyter
+        if not self.start_jupyter():
+            logger.error("Failed to start Jupyter")
+            return
+        
+        # Wait a moment for Jupyter to fully initialize
+        time.sleep(1)
+        
+        # Setup tunnels
+        if not self.setup_tunnels():
+            logger.error("Failed to setup tunnels")
+            self.cleanup_device_agent()
+            return
+        
+        # Print access information
+        logger.info("=" * 50)
+        logger.info("🎉 All services started successfully!")
+        logger.info(f"📔 Jupyter: {self.jupyter_url}")
+        logger.info(f"🔐 SSH: {self.ssh_url}")
+        # Remove https:// prefix for SSH command display
+        ssh_hostname = self.ssh_url.replace('https://', '')
+        import getpass
+        current_user = getpass.getuser()
+        logger.info(f"🔐 SSH Command: ssh -o ProxyCommand='cloudflared access ssh --hostname {ssh_hostname}' {current_user}@{ssh_hostname}")
+        logger.info("=" * 50)
+        
+        # Start metrics thread
+        self.metrics_thread = threading.Thread(target=self.metrics_loop, daemon=True)
+        self.metrics_thread.start()
+        
+        # Main loop
+        try:
+            while self.running:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            logger.info("Interrupted by user")
+        
+        self.cleanup_device_agent()
+    
+    def cleanup_device_agent(self):
+        """Clean up device agent resources"""
+        logger.info("Cleaning up...")
+        
+        self.running = False
+        
+        # Stop Jupyter
+        if self.jupyter_proc:
+            logger.info("Stopping Jupyter...")
+            self.jupyter_proc.terminate()
+            try:
+                self.jupyter_proc.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.jupyter_proc.kill()
+        
+        # Stop tunnel
+        if self.tunnel_proc:
+            logger.info("Stopping tunnel...")
+            self.tunnel_proc.terminate()
+            try:
+                self.tunnel_proc.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.tunnel_proc.kill()
+        
+        logger.info("Cleanup complete")

unitlab/main.py

@@ -1,6 +1,8 @@
 from enum import Enum
 from pathlib import Path
 from uuid import UUID
+import logging
+import os
 
 import typer
 import validators
@@ -9,12 +11,16 @@ from typing_extensions import Annotated
 from . import utils
 from .client import UnitlabClient
 
+
 app = typer.Typer()
 project_app = typer.Typer()
 dataset_app = typer.Typer()
+agent_app = typer.Typer()
+
 
 app.add_typer(project_app, name="project", help="Project commands")
 app.add_typer(dataset_app, name="dataset", help="Dataset commands")
+app.add_typer(agent_app, name="agent", help="Agent commands")
 
 
 API_KEY = Annotated[
@@ -42,7 +48,7 @@ class AnnotationType(str, Enum):
 @app.command(help="Configure the credentials")
 def configure(
     api_key: Annotated[str, typer.Option(help="The api-key obtained from unitlab.ai")],
-    api_url: Annotated[str, typer.Option()] = "https://api.unitlab.ai",
+    api_url: Annotated[str, typer.Option()] = "https://localhost/",
 ):
     if not validators.url(api_url, simple_host=True):
         raise typer.BadParameter("Invalid api url")
@@ -105,5 +111,65 @@ def dataset_download(
     get_client(api_key).dataset_download_files(pk)
 
 
+def send_metrics_to_server(server_url: str, device_id: str, metrics: dict):
+    """Standalone function to send metrics to server using client"""
+    client = UnitlabClient(api_key="dummy")  # API key not needed for metrics
+    return client.send_metrics_to_server(server_url, device_id, metrics)
+
+
+def send_metrics_into_server():
+    """Standalone function to collect system metrics using client"""
+    client = UnitlabClient(api_key="dummy")  # API key not needed for metrics
+    return client.collect_system_metrics()
+
+
+@agent_app.command(name="run", help="Run the device agent with Jupyter, SSH tunnels and metrics")
+def run_agent(
+    api_key: str,
+    device_id: Annotated[str, typer.Option(help="Device ID")] = None,
+    base_domain: Annotated[str, typer.Option(help="Base domain for tunnels")] = "1scan.uz",
+  
+):
+    """Run the full device agent with Jupyter, SSH tunnels and metrics reporting"""
+    
+    # Setup logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(levelname)s - %(message)s',
+        handlers=[logging.StreamHandler()]
+    )
+
+    # Get server URL from environment or use default
+    server_url = 'https://api-dev.unitlab.ai/'
+    
+    # Generate unique device ID if not provided
+    if not device_id:
+        import uuid
+        import platform
+        # Try environment variable first
+        device_id = os.getenv('DEVICE_ID')
+        if not device_id:
+            # Generate a unique ID based on hostname and random UUID
+            hostname = platform.node().replace('.', '-').replace(' ', '-')[:20]
+            random_suffix = str(uuid.uuid4())[:8]
+            device_id = f"{hostname}-{random_suffix}"
+          
+    
+    # Create client and initialize device agent
+    client = UnitlabClient(api_key=api_key)
+    client.initialize_device_agent(
+        server_url=server_url,
+        device_id=device_id,
+        base_domain=base_domain
+    )
+    
+    try:
+        client.run_device_agent()
+    except Exception as e:
+        logging.error(f"Fatal error: {e}")
+        client.cleanup_device_agent()
+        raise typer.Exit(1)
+
+
 if __name__ == "__main__":
     app()

unitlab/tunnel_config.py

@@ -0,0 +1,238 @@
+"""
+Cloudflare Tunnel Configuration for persistent subdomains
+"""
+
+import json
+import subprocess
+import socket
+import time
+import yaml
+from pathlib import Path
+
+
+class CloudflareTunnel:
+    def __init__(self, base_domain, device_id):
+        # Hardcode the base domain here
+        self.base_domain = "1scan.uz"  # HARDCODED - ignore the passed base_domain
+        self.device_id = device_id
+        self.hostname = socket.gethostname()
+        self.tunnel_name = f"device-{device_id}"
+        self.config_dir = Path.home() / ".cloudflared"
+        self.config_dir.mkdir(exist_ok=True)
+        
+        # Subdomain names
+        self.jupyter_subdomain = f"jupyter-{device_id}"
+        self.ssh_subdomain = f"ssh-{device_id}"
+        
+        # Full URLs - using hardcoded base_domain
+        self.jupyter_url = f"https://{self.jupyter_subdomain}.{self.base_domain}"
+        self.ssh_url = f"https://{self.ssh_subdomain}.{self.base_domain}"
+        
+        self.tunnel_uuid = None
+        self.credentials_file = None
+
+    def login(self):
+        """Login to Cloudflare (one-time setup)"""
+        try:
+            print("🔐 Checking Cloudflare authentication...")
+            result = subprocess.run(
+                ["cloudflared", "tunnel", "login"],
+                capture_output=True,
+                text=True
+            )
+            if result.returncode == 0:
+                print("✅ Cloudflare authentication successful")
+                return True
+            else:
+                print("❌ Cloudflare authentication failed")
+                return False
+        except Exception as e:
+            print(f"❌ Error during Cloudflare login: {e}")
+            return False
+
+    def create_tunnel(self):
+        """Create a named tunnel"""
+        try:
+            print(f"🚇 Creating tunnel: {self.tunnel_name}")
+            
+            # Check if tunnel already exists
+            list_result = subprocess.run(
+                ["cloudflared", "tunnel", "list", "--output", "json"],
+                capture_output=True,
+                text=True
+            )
+            
+            if list_result.returncode == 0:
+                tunnels = json.loads(list_result.stdout)
+                for tunnel in tunnels:
+                    if tunnel.get("name") == self.tunnel_name:
+                        self.tunnel_uuid = tunnel.get("id")
+                        print(f"✅ Tunnel already exists with ID: {self.tunnel_uuid}")
+                        self.credentials_file = self.config_dir / f"{self.tunnel_uuid}.json"
+                        return True
+            
+            # Create new tunnel
+            result = subprocess.run(
+                ["cloudflared", "tunnel", "create", self.tunnel_name],
+                capture_output=True,
+                text=True
+            )
+            
+            if result.returncode == 0:
+                for line in result.stdout.split('\n'):
+                    if "Created tunnel" in line and "with id" in line:
+                        self.tunnel_uuid = line.split("with id")[1].strip()
+                        break
+                
+                if not self.tunnel_uuid:
+                    list_result = subprocess.run(
+                        ["cloudflared", "tunnel", "list", "--output", "json"],
+                        capture_output=True,
+                        text=True
+                    )
+                    if list_result.returncode == 0:
+                        tunnels = json.loads(list_result.stdout)
+                        for tunnel in tunnels:
+                            if tunnel.get("name") == self.tunnel_name:
+                                self.tunnel_uuid = tunnel.get("id")
+                                break
+                
+                if self.tunnel_uuid:
+                    self.credentials_file = self.config_dir / f"{self.tunnel_uuid}.json"
+                    print(f"✅ Tunnel created with ID: {self.tunnel_uuid}")
+                    return True
+                    
+            print(f"❌ Failed to create tunnel: {result.stderr}")
+            return False
+            
+        except Exception as e:
+            print(f"❌ Error creating tunnel: {e}")
+            return False
+
+    def configure_dns(self):
+        """Configure DNS routes for the tunnel"""
+        try:
+            print("🌐 Configuring DNS routes...")
+            
+            # Route for Jupyter
+            jupyter_result = subprocess.run(
+                ["cloudflared", "tunnel", "route", "dns", 
+                 self.tunnel_name, f"{self.jupyter_subdomain}.{self.base_domain}"],
+                capture_output=True,
+                text=True
+            )
+            
+            if jupyter_result.returncode == 0:
+                print(f"✅ Jupyter route configured: {self.jupyter_url}")
+            else:
+                print(f"⚠️  Jupyter route may already exist or failed: {jupyter_result.stderr}")
+            
+            # Route for SSH
+            ssh_result = subprocess.run(
+                ["cloudflared", "tunnel", "route", "dns",
+                 self.tunnel_name, f"{self.ssh_subdomain}.{self.base_domain}"],
+                capture_output=True,
+                text=True
+            )
+            
+            if ssh_result.returncode == 0:
+                print(f"✅ SSH route configured: {self.ssh_url}")
+            else:
+                print(f"⚠️  SSH route may already exist or failed: {ssh_result.stderr}")
+                
+            return True
+            
+        except Exception as e:
+            print(f"❌ Error configuring DNS: {e}")
+            return False
+
+    def create_config_file(self, jupyter_port):
+        """Create tunnel configuration file"""
+        config = {
+            "tunnel": self.tunnel_uuid,
+            "credentials-file": str(self.credentials_file),
+            "ingress": [
+                {
+                    "hostname": f"{self.jupyter_subdomain}.{self.base_domain}",
+                    "service": f"http://localhost:{jupyter_port}",
+                    "originRequest": {
+                        "noTLSVerify": True
+                    }
+                },
+                {
+                    "hostname": f"{self.ssh_subdomain}.{self.base_domain}",
+                    "service": "ssh://localhost:22",
+                    "originRequest": {
+                        "noTLSVerify": True
+                    }
+                },
+                {
+                    "service": "http_status:404"
+                }
+            ]
+        }
+        
+        config_file = self.config_dir / f"config-{self.device_id}.yml"
+        with open(config_file, 'w') as f:
+            yaml.dump(config, f, default_flow_style=False)
+        
+        print(f"📝 Configuration saved to: {config_file}")
+        return config_file
+
+    def start_tunnel(self, config_file):
+        """Start the tunnel with the configuration"""
+        try:
+            print("🚀 Starting Cloudflare tunnel...")
+            
+            cmd = ["cloudflared", "tunnel", "--config", str(config_file), "run"]
+            
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1
+            )
+            
+            # Wait for tunnel to establish
+            time.sleep(5)
+            
+            if process.poll() is None:
+                print("✅ Tunnel is running")
+                return process
+            else:
+                print("❌ Tunnel failed to start")
+                return None
+                
+        except Exception as e:
+            print(f"❌ Error starting tunnel: {e}")
+            return None
+
+    def setup(self, jupyter_port):
+        """Complete setup process"""
+        # Check if we need to login
+        if not (self.config_dir / "cert.pem").exists():
+            if not self.login():
+                return None
+        
+        # Create tunnel
+        if not self.create_tunnel():
+            return None
+        
+        # Configure DNS
+        if not self.configure_dns():
+            return None
+        
+        # Create config file
+        config_file = self.create_config_file(jupyter_port)
+        
+        # Start tunnel
+        tunnel_process = self.start_tunnel(config_file)
+        
+        if tunnel_process:
+            print("\n✅ Tunnel setup complete!")
+            print(f"📌 Jupyter URL: {self.jupyter_url}")
+            print(f"📌 SSH URL: {self.ssh_url}")
+            return tunnel_process
+        
+        return None

unitlab/utils.py

@@ -1,6 +1,8 @@
 import logging
 from configparser import ConfigParser
 from pathlib import Path
+import logging
+import requests
 
 import requests
 
@@ -63,3 +65,4 @@ def get_api_url() -> str:
         return config.get("default", "api_url")
     except Exception:
         return "https://api.unitlab.ai"
+

{unitlab-2.3.0.dist-info → unitlab-2.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: unitlab
-Version: 2.3.0
+Version: 2.3.3
 Home-page: https://github.com/teamunitlab/unitlab-sdk
 Author: Unitlab Inc.
 Author-email: team@unitlab.ai
@@ -21,11 +21,6 @@ Requires-Dist: requests
 Requires-Dist: tqdm
 Requires-Dist: typer
 Requires-Dist: validators
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: home-page
-Dynamic: keywords
-Dynamic: license
-Dynamic: license-file
-Dynamic: requires-dist
+Requires-Dist: psutil
+Requires-Dist: pyyaml
+

unitlab-2.3.3.dist-info/RECORD

@@ -0,0 +1,13 @@
+unitlab/__init__.py,sha256=Wtk5kQ_MTlxtd3mxJIn2qHVK5URrVcasMMPjD3BtrVM,214
+unitlab/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
+unitlab/client.py,sha256=LGbjto3jisF5LojlYjJyLKRc55wxfZTO_tkoipZBKd4,22910
+unitlab/exceptions.py,sha256=68Tr6LreEzjQ3Vns8HAaWdtewtkNUJOvPazbf6NSnXU,950
+unitlab/main.py,sha256=XD8PF_EJ1gAKqHcRT_bWy62LWrODGWMx2roKoaQaoY4,5253
+unitlab/tunnel_config.py,sha256=lfWXKTPKlhHOxECUA0_HhynrKfOZ345nLo0qA7XtfbE,8571
+unitlab/utils.py,sha256=83ekAxxfXecFTg76Z62BGDybC_skKJHYoLyawCD9wGM,1920
+unitlab-2.3.3.dist-info/LICENSE.md,sha256=Gn7RRvByorAcAaM-WbyUpsgi5ED1-bKFFshbWfYYz2Y,1069
+unitlab-2.3.3.dist-info/METADATA,sha256=pO2UGvjS3FoVgAXZKlHUeBONoWAnLgVkZ2I55UyiSGs,791
+unitlab-2.3.3.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+unitlab-2.3.3.dist-info/entry_points.txt,sha256=ig-PjKEqSCj3UTdyANgEi4tsAU84DyXdaOJ02NHX4bY,45
+unitlab-2.3.3.dist-info/top_level.txt,sha256=Al4ZlTYE3fTJK2o6YLCDMH5_DjuQkffRBMxgmWbKaqQ,8
+unitlab-2.3.3.dist-info/RECORD,,

{unitlab-2.3.0.dist-info → unitlab-2.3.3.dist-info}/WHEEL

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

unitlab-2.3.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-unitlab/__init__.py,sha256=Wtk5kQ_MTlxtd3mxJIn2qHVK5URrVcasMMPjD3BtrVM,214
-unitlab/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
-unitlab/client.py,sha256=j8m0An4Bt3ARA1ps7P2o-NLcfWFPoaXG_PxIdBDAEpQ,8374
-unitlab/exceptions.py,sha256=68Tr6LreEzjQ3Vns8HAaWdtewtkNUJOvPazbf6NSnXU,950
-unitlab/main.py,sha256=3_awGLQ39dOA4WpOLkngzTK1X9ttOs9avh4PvJFlH34,3039
-unitlab/utils.py,sha256=U95JqeUvKP0p5Ka0KIar0e8Uqe_4TZmZ7N68UdEGfpk,1888
-unitlab-2.3.0.dist-info/licenses/LICENSE.md,sha256=Gn7RRvByorAcAaM-WbyUpsgi5ED1-bKFFshbWfYYz2Y,1069
-unitlab-2.3.0.dist-info/METADATA,sha256=9gk8MoNLgV1jPR9TdT_NSvM8wqAqxU10isgBNjQzgNY,903
-unitlab-2.3.0.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-unitlab-2.3.0.dist-info/entry_points.txt,sha256=ig-PjKEqSCj3UTdyANgEi4tsAU84DyXdaOJ02NHX4bY,45
-unitlab-2.3.0.dist-info/top_level.txt,sha256=Al4ZlTYE3fTJK2o6YLCDMH5_DjuQkffRBMxgmWbKaqQ,8
-unitlab-2.3.0.dist-info/RECORD,,