unitlab 2.3.33__py3-none-any.whl → 2.3.35__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,33 @@ 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 +467,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 +506,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 +565,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 +627,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 +649,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 = 'https://api-dev/unitlab-ai.com/'
     
-    # 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: