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

unitlab/client.py

@@ -12,12 +12,8 @@ import subprocess
 import signal
 import re
 import time
-import threading
 import psutil
 from datetime import datetime, timezone
-from .tunnel_config import CloudflareTunnel
-from .cloudflare_api_tunnel import CloudflareAPITunnel
-from .simple_tunnel import SimpleTunnel
 from .utils import get_api_url, handle_exceptions
 from pathlib import Path
 
@@ -29,15 +25,6 @@ except ImportError:
     HAS_GPU = False
 
 
-try:
-    from dotenv import load_dotenv
-    env_path = Path(__file__).parent.parent.parent / '.env'
-    if env_path.exists():
-        load_dotenv(env_path)
-except ImportError:
-    pass  # dotenv not installed, use system env vars only
-
-
 logger = logging.getLogger(__name__)
 
 class UnitlabClient:
@@ -88,6 +75,7 @@ class UnitlabClient:
         self.hostname = socket.gethostname()
         self.tunnel_manager = None
         self.jupyter_url = None
+        self.api_expose_url = None
         self.ssh_url = None
         self.jupyter_proc = None
         self.tunnel_proc = None
@@ -289,6 +277,8 @@ class UnitlabClient:
             # Don't call run() here - it has infinite loop. Call start() in setup_tunnels()
             self.jupyter_url = None
             self.ssh_url = None
+            self.api_url = None
+
             
         except ImportError as e:
             logger.warning(f"Could not import PersistentTunnel: {e}")
@@ -399,26 +389,34 @@ class UnitlabClient:
             
             logger.info("Setting up Cloudflare tunnel...")
             
-            # Both SimpleTunnel and AutoTunnel handle Jupyter internally
+            
             if self.tunnel_manager.start():
-                # Store the processes for monitoring
+                
                 self.jupyter_proc = self.tunnel_manager.jupyter_process
-                # Update URLs after tunnel starts successfully
+                
                 self.jupyter_url = self.tunnel_manager.jupyter_url
-                self.ssh_url = self.tunnel_manager.jupyter_url
+                self.api_expose_url = self.tunnel_manager.api_expose_url
                 logger.info(f"Tunnel started successfully at {self.jupyter_url}")
                 self.tunnel_proc = self.tunnel_manager.tunnel_process
                 self.jupyter_port = "8888"  # Both use fixed port
                 
-                # Get the URL (AutoTunnel generates it dynamically)
+              
+                if hasattr(self.tunnel_manager, 'ssh_url'):
+                    self.ssh_url = self.tunnel_manager.ssh_url
+                else:
+                    
+                    self.ssh_url = self.jupyter_url
+                
+               
                 if hasattr(self.tunnel_manager, 'tunnel_url') and self.tunnel_manager.tunnel_url:
                     self.jupyter_url = self.tunnel_manager.tunnel_url
-                    self.ssh_url = self.tunnel_manager.tunnel_url
+                    if not hasattr(self.tunnel_manager, 'ssh_url'):
+                        self.ssh_url = self.tunnel_manager.tunnel_url
                 elif hasattr(self.tunnel_manager, 'jupyter_url'):
                     self.jupyter_url = self.tunnel_manager.jupyter_url
-                    self.ssh_url = self.tunnel_manager.jupyter_url
+                    if not hasattr(self.tunnel_manager, 'ssh_url'):
+                        self.ssh_url = self.tunnel_manager.jupyter_url
                 
-                # The tunnel is now running
                 logger.info("✅ Tunnel and Jupyter established")
                 logger.info("URL: {}".format(self.jupyter_url))
                 self.report_services()
@@ -470,12 +468,15 @@ class UnitlabClient:
             
             logger.info(f"Reporting Jupyter service with URL: {self.jupyter_url}")
             logger.debug(f"API key present: {bool(self.api_key)}")
+
             if self.api_key:
                 logger.debug(f"API key value: {self.api_key[:8]}...")
+
             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)
@@ -506,7 +507,22 @@ class UnitlabClient:
                 ssh_data
             )
             logger.info(f"Reported SSH service: {ssh_response.status_code if hasattr(ssh_response, 'status_code') else ssh_response}")
+            logger.info("Reporting  API endpoint:")
             
+            api_expose_data = {
+                "service_type": "api",
+                "service_name": f"api-{self.device_id}",
+                'local_port': None,
+                'tunnel_url': self.api_expose_url,
+                'status': 'online'
+            }
+
+            api_expose_response = self._post_device(
+                f"/api/tunnel/agent/api-url/{self.device_id}/",
+                api_expose_data
+            )
+            logger.info(f"Reported Api service: {api_expose_response.status_code if hasattr(api_expose_response, 'status_code') else api_expose_response}")
+
         except Exception as e:
             logger.error(f"Failed to report services: {e}", exc_info=True)
     
@@ -550,55 +566,55 @@ class UnitlabClient:
         
         return metrics
     
-    def send_metrics(self):
-        """Send metrics to server"""
-        try:
-            metrics = self.collect_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 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 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'])
+    #         # 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}%")
+    #         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}")
+    #     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")
+    # def metrics_loop(self):
+    #     """Background thread for sending metrics"""
+    #     logger.info("Starting metrics thread")
         
-        while self.running:
-            try:
-                self.send_metrics()
+    #     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
+    #             # 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
+    #             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}")
+    #         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)
+    #         # Wait for next interval (default 5 seconds)
+    #         for _ in range(3):
+    #             if not self.running:
+    #                 break
+    #             time.sleep(1)
         
-        logger.info("Metrics thread stopped")
+    #     logger.info("Metrics thread stopped")
     
     def run_device_agent(self):
         """Main run method for device agent"""
@@ -612,17 +628,16 @@ class UnitlabClient:
         # Check SSH
         self.check_ssh()
         
-        # SimpleTunnel handles Jupyter internally, so we don't start it separately
-        # Just setup the tunnels which will also start Jupyter
+        
         logger.info("Starting integrated Jupyter and tunnel...")
         
-        # 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}")
@@ -635,8 +650,8 @@ class UnitlabClient:
         logger.info("=" * 50)
         
         # Start metrics thread
-        self.metrics_thread = threading.Thread(target=self.metrics_loop, daemon=True)
-        self.metrics_thread.start()
+        # self.metrics_thread = threading.Thread(target=self.metrics_loop, daemon=True)
+        # self.metrics_thread.start()
         
         # Main loop
         try:

unitlab/main.py

@@ -2,16 +2,21 @@ from enum import Enum
 from pathlib import Path
 from uuid import UUID
 import logging
-import os
+import threading
 
 import typer
 import validators
 from typing_extensions import Annotated
+import psutil
+import uvicorn 
+from fastapi import FastAPI,Response
+
 
 from . import utils
 from .client import UnitlabClient
 
 
+
 app = typer.Typer()
 project_app = typer.Typer()
 dataset_app = typer.Typer()
@@ -45,6 +50,8 @@ class AnnotationType(str, Enum):
     IMG_POINT = "img_point"
 
 
+
+
 @app.command(help="Configure the credentials")
 def configure(
     api_key: Annotated[str, typer.Option(help="The api-key obtained from unitlab.ai")],
@@ -111,18 +118,6 @@ 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: API_KEY,
@@ -130,42 +125,32 @@ def run_agent(
     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/'
+    server_url = 'http://localhost:8000/'
     
-    # Generate unique device ID if not provided
     if not device_id:
         import uuid
         import platform
-        from pathlib import Path
-        
-        # Try environment variable first
-        device_id = os.getenv('DEVICE_ID')
-        if not device_id:
-            # Always generate a unique device ID (no saving/reusing)
-            hostname = platform.node().replace('.', '-').replace(' ', '-')[:20]
-            random_suffix = str(uuid.uuid4())[:8]
-            device_id = f"{hostname}-{random_suffix}"
-            print(f"📝 Generated unique device ID: {device_id}")
+
+        hostname = platform.node().replace('.', '-').replace(' ', '-')[:20]
+        random_suffix = str(uuid.uuid4())[:8]
+        device_id = f"{hostname}-{random_suffix}"
+        print(f"📝 Generated unique device ID: {device_id}")
           
-    
-    # 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:

unitlab/persistent_tunnel.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Persistent Tunnel - Each device gets deviceid.1scan.uz
+Persistent Tunnel - Each device gets deviceid.unitlab-ai.com
 Uses Cloudflare API to create named tunnels
 """
 
@@ -10,18 +10,32 @@ import json
 import time
 import os
 import base64
+from fastapi import FastAPI
+import uvicorn
+import threading
+import psutil
+
+
+api = FastAPI()
+
+@api.get("/api-agent/")
+def get_cpu_info():
+    cpu_usage_percent = psutil.cpu_percent(interval=1)
+    ram = psutil.virtual_memory()
+    return  {"cpu_percentage": cpu_usage_percent, 'cpu_count': psutil.cpu_count(), 'ram_usage': ram.used }
+
 
 class PersistentTunnel:
     def __init__(self, device_id=None):
         """Initialize with device ID"""
         
         # Cloudflare credentials (hardcoded for simplicity)
-        self.cf_email = "uone2323@gmail.com"
-        self.cf_api_key = "1c634bd17ca6ade0eb91966323589fd98c72e"  # Global API Key
+        
+        self.cf_api_key = "RoIAn1t9rMqcGK7_Xja216pxbRTyFafC1jeRKIO3"  
         
         # Account and Zone IDs
-        self.cf_account_id = "c91192ae20a5d43f65e087550d8dc89b"  # Your account ID
-        self.cf_zone_id = "78182c3883adad79d8f1026851a68176"  # Zone ID for 1scan.uz
+        self.cf_account_id = "29df28cf48a30be3b1aa344b840400e6"  # Your account ID
+        self.cf_zone_id = "eae80a730730b3b218a80dace996535a"  # Zone ID for unitlab-ai.com
         
         # Clean device ID for subdomain
         if device_id:
@@ -32,16 +46,19 @@ class PersistentTunnel:
         
         self.tunnel_name = "agent-{}".format(self.device_id)
         self.subdomain = self.device_id
-        self.domain = "1scan.uz"
+        self.domain = "unitlab-ai.com"
         self.jupyter_url = "https://{}.{}".format(self.subdomain, self.domain)
-        
+        self.api_expose_url = "https://{}.{}/api-agent/".format(self.subdomain, self.domain)
+        self.ssh_subdomain = "s{}".format(self.device_id)  # Shorter SSH subdomain to avoid length issues
+        self.ssh_url = "{}.{}".format(self.ssh_subdomain, self.domain)  # SSH on s{deviceid}.unitlab-ai.com
+
         self.tunnel_id = None
         self.tunnel_credentials = None
         self.jupyter_process = None
         self.tunnel_process = None
     
     def get_zone_id(self):
-        """Get Zone ID for 1scan.uz"""
+        """Get Zone ID for unitlab-ai.com"""
         print("🔍 Getting Zone ID for {}...".format(self.domain))
         
         url = "https://api.cloudflare.com/client/v4/zones"
@@ -61,11 +78,12 @@ class PersistentTunnel:
     
     def _get_headers(self):
         """Get API headers for Global API Key"""
-        return {
-            "X-Auth-Email": self.cf_email,
-            "X-Auth-Key": self.cf_api_key,
-            "Content-Type": "application/json"
-        }
+     
+    
+        return { 
+            "Authorization":  f"Bearer {self.cf_api_key}",                                                                                                                                                         
+            "Content-Type": "application/json"                                                                                          
+        } 
     
     def get_or_create_tunnel(self):
         """Get existing tunnel or create a new one"""
@@ -133,15 +151,15 @@ class PersistentTunnel:
             print("✅ Tunnel created: {}".format(self.tunnel_id))
             return cred_file
         else:
-            print("❌ Failed to create tunnel: {}".format(response.text[:200]))
+            print("❌ Failed to create tunnel: {}".format(response.text))
             return None
     
     def create_dns_record(self):
-        """Create DNS CNAME record"""
+        """Create DNS CNAME records for main domain and SSH subdomain"""
         if not self.tunnel_id:
             return False
         
-        print("🔧 Creating DNS record: {}.{}...".format(self.subdomain, self.domain))
+        print("🔧 Creating DNS records...")
         
         # Get zone ID if we don't have it
         if self.cf_zone_id == "NEED_ZONE_ID_FOR_1SCAN_UZ":
@@ -150,6 +168,7 @@ class PersistentTunnel:
         url = "https://api.cloudflare.com/client/v4/zones/{}/dns_records".format(self.cf_zone_id)
         headers = self._get_headers()
         
+        # Create main subdomain record for Jupyter and API
         data = {
             "type": "CNAME",
             "name": self.subdomain,
@@ -161,14 +180,33 @@ class PersistentTunnel:
         response = requests.post(url, headers=headers, json=data)
         
         if response.status_code in [200, 201]:
-            print("✅ DNS record created")
-            return True
+            print("✅ Main DNS record created: {}.{}".format(self.subdomain, self.domain))
         elif "already exists" in response.text:
-            print("⚠️  DNS record already exists")
-            return True
+            print("⚠️  Main DNS record already exists: {}.{}".format(self.subdomain, self.domain))
         else:
-            print("❌ Failed to create DNS: {}".format(response.text[:200]))
+            print("❌ Failed to create main DNS: {}".format(response.text[:200]))
             return False
+        
+        # Create SSH subdomain record (s{deviceid}.unitlab-ai.com)
+        ssh_data = {
+            "type": "CNAME",
+            "name": self.ssh_subdomain,
+            "content": "{}.cfargotunnel.com".format(self.tunnel_id),
+            "proxied": True,
+            "ttl": 1
+        }
+        
+        ssh_response = requests.post(url, headers=headers, json=ssh_data)
+        
+        if ssh_response.status_code in [200, 201]:
+            print("✅ SSH DNS record created: {}.{}".format(self.ssh_subdomain, self.domain))
+        elif "already exists" in ssh_response.text:
+            print("⚠️  SSH DNS record already exists: {}.{}".format(self.ssh_subdomain, self.domain))
+        else:
+            print("⚠️  Could not create SSH DNS: {}".format(ssh_response.text[:200]))
+            # SSH is optional, so we continue even if SSH DNS fails
+        
+        return True
     
     def create_tunnel_config(self, cred_file):
         """Create tunnel config file"""
@@ -177,11 +215,24 @@ class PersistentTunnel:
             f.write("tunnel: {}\n".format(self.tunnel_id))
             f.write("credentials-file: {}\n\n".format(cred_file))
             f.write("ingress:\n")
+
+            # SSH service on dedicated subdomain (s{deviceid}.unitlab-ai.com)
+            f.write("  - hostname: {}.{}\n".format(self.ssh_subdomain, self.domain))
+            f.write("    service: ssh://localhost:22\n")
+
+            # API (more specific path goes first)
+            f.write("  - hostname: {}.{}\n".format(self.subdomain, self.domain))
+            f.write("    path: /api-agent/*\n")
+            f.write("    service: http://localhost:8001\n")
+
+            # Jupyter (general hostname for HTTP)
             f.write("  - hostname: {}.{}\n".format(self.subdomain, self.domain))
             f.write("    service: http://localhost:8888\n")
+
+            # Catch-all 404 (MUST be last!)
             f.write("  - service: http_status:404\n")
-        
-        return config_file
+        return config_file 
+
     
     def get_cloudflared_path(self):
         """Get or download cloudflared for any platform"""
@@ -255,6 +306,9 @@ class PersistentTunnel:
         print("✅ cloudflared downloaded successfully")
         return local_bin
     
+   
+
+    
     def start_jupyter(self):
         """Start Jupyter"""
         print("🚀 Starting Jupyter...")
@@ -274,31 +328,59 @@ class PersistentTunnel:
         self.jupyter_process = subprocess.Popen(
             cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
         )
-        
+
         time.sleep(3)
         print("✅ Jupyter started")
         return True
     
-    def start_tunnel(self, config_file):
-        """Start tunnel with config"""
-        print("🔧 Starting tunnel...")
-        
-        cloudflared = self.get_cloudflared_path()
-        
-        cmd = [
-            cloudflared,
-            "tunnel",
-            "--config", config_file,
-            "run"
-        ]
-        
-        self.tunnel_process = subprocess.Popen(
-            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
-        )
-        
-        time.sleep(5)
-        print("✅ Tunnel running at {}".format(self.jupyter_url))
-        return True
+    def start_api(self):
+        def run_api():
+            uvicorn.run(
+                api,
+                port=8001
+            )
+        
+        api_thread = threading.Thread(target=run_api, daemon=True)
+        api_thread.start()
+        print('API is started')
+
+    def start_tunnel(self, config_file):                                                         
+        """Start tunnel with config"""                                                           
+        print("🔧 Starting tunnel...")                                                           
+                                                                                                
+        cloudflared = self.get_cloudflared_path()                                                
+                                                                                                
+        cmd = [                                                                                  
+            cloudflared,                                                                         
+            "tunnel",                                                                            
+            "--config", config_file,                                                             
+            "run"                                                                                
+        ]                                                                                        
+                                                                                                
+        self.tunnel_process = subprocess.Popen(                                                  
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE                                  
+        )                                                                                        
+                                                                                                
+        time.sleep(2)                                                                            
+                                                                                                
+        # Check if process is still running                                                      
+        if self.tunnel_process.poll() is not None:                                               
+            print("❌ Tunnel process died!")                                                      
+            # Try to read error output                                                           
+            try:                                                                                 
+                stdout, stderr = self.tunnel_process.communicate(timeout=1)                      
+                if stderr:                                                                       
+                    print(f"Error: {stderr.decode()}")                                           
+                if stdout:                                                                       
+                    print(f"Output: {stdout.decode()}")                                          
+            except:                                                                              
+                pass                                                                             
+            return False                                                                         
+                                                                                                
+        print("✅ Tunnel running at {}".format(self.jupyter_url))                                 
+        print("✅ API running at {}".format(self.api_expose_url))
+        print("✅ SSH available at {}".format(self.ssh_url))                                        
+        return True        
     
     def start(self):
         """Main entry point"""
@@ -313,9 +395,7 @@ class PersistentTunnel:
             
             # 1. Get existing or create new tunnel via API
             cred_file = self.get_or_create_tunnel()
-            if not cred_file:
-                print("⚠️  Falling back to quick tunnel")
-                return self.start_quick_tunnel()
+        
             
             # 2. Create DNS record
             self.create_dns_record()
@@ -325,13 +405,24 @@ class PersistentTunnel:
             
             # 4. Start services
             self.start_jupyter()
+            self.start_api()
             self.start_tunnel(config_file)
             
             print("\n" + "="*50)
-            print("🎉 SUCCESS! Persistent URL created:")
-            print("   {}".format(self.jupyter_url))
-            print("   Tunnel ID: {}".format(self.tunnel_id))
+            print("🎉 SUCCESS! Persistent URLs created:")
+            print("📔 Jupyter:   {}".format(self.jupyter_url))
+            print("🔧 API:       {}".format(self.api_expose_url))
+            print("🔐 SSH:       {}".format(self.ssh_url))
+            print("")
+            print("SSH Connection Command:")
+            import getpass
+            current_user = getpass.getuser()
+            print("ssh -o ProxyCommand='cloudflared access ssh --hostname {}' {}@{}".format(
+                self.ssh_url, current_user, self.ssh_url))
+            print("")
+            print("Tunnel ID: {}".format(self.tunnel_id))
             print("="*50)
+  
             
             return True
             

unitlab/utils.py

@@ -66,3 +66,5 @@ def get_api_url() -> str:
     except Exception:
         return "https://api.unitlab.ai"
 
+
+