vnai 2.0.3__py3-none-any.whl → 2.0.5__py3-none-any.whl

vnai/__init__.py

@@ -1,7 +1,5 @@
-##
-
-##
-
+# vnai/__init__.py
+# Main entry point for vnai package
 
 import os
 import pathlib
@@ -11,8 +9,7 @@ import threading
 import functools
 from datetime import datetime
 
-##
-
+# Import core functionality
 from vnai.beam.quota import guardian, optimize
 from vnai.beam.metrics import collector, capture
 from vnai.beam.pulse import monitor
@@ -20,10 +17,10 @@ from vnai.flow.relay import conduit, configure
 from vnai.flow.queue import buffer
 from vnai.scope.profile import inspector
 from vnai.scope.state import tracker, record
+import vnai.scope.promo
 from vnai.scope.promo import present
 
-##
-
+# Constants for terms and conditions
 TC_VAR = "ACCEPT_TC"
 TC_VAL = "tôi đồng ý"
 TC_PATH = pathlib.Path.home() / ".vnstock" / "id" / "terms_agreement.txt"
@@ -37,10 +34,10 @@ Chi tiết:
 """
 
 class Core:
-    #--
+    """Core functionality for system optimization"""
     
     def __init__(self):
-        #--
+        """Initialize core"""
         self.initialized = False
         self.webhook_url = None
         self.init_time = datetime.now().isoformat()
@@ -50,50 +47,41 @@ class Core:
         self.terms_file_path = TC_PATH
         self.system_info = None
         
-        ##
-
+        # Create necessary directories
         self.project_dir.mkdir(exist_ok=True)
         self.id_dir.mkdir(exist_ok=True)
         
-        ##
-
+        # Auto-initialize
         self.initialize()
 
     def initialize(self, webhook_url=None):
-        #--
+        """Initialize the system"""
         if self.initialized:
             return True
             
-        ##
-
+        # Check terms acceptance
         if not self._check_terms():
             self._accept_terms()
             
-        ##
-
+        # Set up vnstock environment
         from vnai.scope.profile import inspector
         inspector.setup_vnstock_environment()
         
-        ##
-
+        # Display content during initialization
         present()
         
-        ##
-
+        # Configure webhook if provided
         if webhook_url:
             self.webhook_url = webhook_url
             configure(webhook_url)
             
-        ##
-
+        # Record initialization
         record("initialization", {"timestamp": datetime.now().isoformat()})
         
-        ##
-
+        # Get system information ONCE and store it in the class
         self.system_info = inspector.examine()
         
-        ##
-
+        # Queue system data with optimal structure
         conduit.queue({
             "type": "system_info",
             "data": {
@@ -106,27 +94,23 @@ class Core:
         return True
 
     def _check_terms(self):
-        #--
+        """Check if terms have been accepted"""
         return os.path.exists(self.terms_file_path)
 
     def _accept_terms(self):
-        #--
-        ##
-
+        """Record terms acceptance"""
+        # Get system information
         system_info = inspector.examine()
         
-        ##
-
+        # Auto-accept terms
         if TC_VAR in os.environ and os.environ[TC_VAR] == TC_VAL:
             response = TC_VAL
         else:
-            ##
-
+            # For non-interactive environments, accept by default
             response = TC_VAL
             os.environ[TC_VAR] = TC_VAL
         
-        ##
-
+        # Store the acceptance with hardware info
         now = datetime.now()
         signed_agreement = (
             f"Người dùng có mã nhận dạng {system_info['machine_id']} đã chấp nhận "
@@ -137,13 +121,11 @@ class Core:
             f"{TERMS_AND_CONDITIONS}"
         )
         
-        ##
-
+        # Store the acceptance
         with open(self.terms_file_path, "w", encoding="utf-8") as f:
             f.write(signed_agreement)
         
-        ##
-
+        # Create the environment.json file that vnstock expects
         env_file = self.id_dir / "environment.json"
         env_data = {
             "accepted_agreement": True,
@@ -157,59 +139,53 @@ class Core:
         return True
 
     def status(self):
-        #--
+        """Get system status"""
         return {
             "initialized": self.initialized,
             "health": monitor.report(),
             "metrics": tracker.get_metrics()
-            ##
-
+            # Environment information available via self.system_info
         }
     
     def configure_privacy(self, level="standard"):
-        #--
+        """Configure privacy settings"""
         from vnai.scope.state import tracker
         return tracker.setup_privacy(level)
 
 
-##
-
+# Create singleton instance
 core = Core()
 
-##
-
+# Backward support
 def tc_init(webhook_url=None):
     return core.initialize(webhook_url)
 
-##
-
+# Public API
 def setup(webhook_url=None):
-    #--
+    """Setup vnai with optional webhook URL"""
     return core.initialize(webhook_url)
 
 def optimize_execution(resource_type="default"):
-    #--
+    """Decorator for optimizing function execution"""
     return optimize(resource_type)
 
 def agg_execution(resource_type="default"):
-    #--
+    """Decorator for aggregating function execution"""
     return optimize(resource_type, ad_cooldown=1500, content_trigger_threshold=100000)
 
 def measure_performance(module_type="function"):
-    #--
+    """Decorator for measuring function performance"""
     return capture(module_type)
 
 def accept_license_terms(terms_text=None):
-    #--
+    """Accept license terms and conditions"""
     if terms_text is None:
         terms_text = TERMS_AND_CONDITIONS
     
-    ##
-
+    # Get system information
     system_info = inspector.examine()
     
-    ##
-
+    # Record acceptance
     terms_file = pathlib.Path.home() / ".vnstock" / "id" / "terms_agreement.txt"
     os.makedirs(os.path.dirname(terms_file), exist_ok=True)
     
@@ -221,22 +197,19 @@ def accept_license_terms(terms_text=None):
     return True
 
 def accept_vnstock_terms():
-    #--
-    ##
-
+    """Accept vnstock terms and create necessary files"""
+    # Get system information
     from vnai.scope.profile import inspector
     system_info = inspector.examine()
     
-    ##
-
+    # Create necessary directories
     home_dir = pathlib.Path.home()
     project_dir = home_dir / ".vnstock"
     project_dir.mkdir(exist_ok=True)
     id_dir = project_dir / 'id'
     id_dir.mkdir(exist_ok=True)
     
-    ##
-
+    # Create environment.json file that vnstock looks for
     env_file = id_dir / "environment.json"
     env_data = {
         "accepted_agreement": True,
@@ -254,40 +227,43 @@ def accept_vnstock_terms():
         return False
 
 def setup_for_colab():
-    #--
+    """Special setup for Google Colab environments"""
     from vnai.scope.profile import inspector
     
-    ##
-
+    # Immediate authentication for Colab
     inspector.detect_colab_with_delayed_auth(immediate=True)
     
-    ##
-
+    # Setup vnstock environment
     inspector.setup_vnstock_environment()
     
     return "Environment set up for Google Colab"
 
 def display_content():
-    #--
+    """Display promotional content appropriate for the current environment"""
     return present()
 
 def configure_privacy(level="standard"):
-    #--
+    """Configure privacy level for analytics data"""
     from vnai.scope.state import tracker
     return tracker.setup_privacy(level)
 
 def check_commercial_usage():
-    #--
+    """Check if running in commercial environment"""
     from vnai.scope.profile import inspector
     return inspector.detect_commercial_usage()
 
 def authenticate_for_persistence():
-    #--
+    """Authenticate to Google Drive for persistent settings (Colab only)"""
     from vnai.scope.profile import inspector
     return inspector.get_or_create_user_id()
 
 def configure_webhook(webhook_id='80b8832b694a75c8ddc811ac7882a3de'):
-    #--
+    """Configure webhook URL for analytics data transmission
+    
+    This method should be called once during application initialization
+    to set up the analytics endpoint. For security reasons, the URL should
+    not be hardcoded in user-facing code.
+    """
     if not webhook_id:
         return False
         
@@ -295,6 +271,5 @@ def configure_webhook(webhook_id='80b8832b694a75c8ddc811ac7882a3de'):
     webhook_url = f'https://botbuilder.larksuite.com/api/trigger-webhook/{webhook_id}'
     return configure(webhook_url)
 
-##
-
+# Set the webhook
 configure_webhook()

vnai/beam/__init__.py

@@ -1,3 +1,6 @@
+# vnai/beam/__init__.py
+# System monitoring and resource management
+
 from vnai.beam.quota import guardian, optimize
 from vnai.beam.metrics import collector, capture
 from vnai.beam.pulse import monitor

vnai/beam/metrics.py

@@ -1,7 +1,5 @@
-##
-
-##
-
+# vnai/beam/metrics.py
+# System performance metrics collection (formerly analytics)
 
 import sys
 import time
@@ -9,7 +7,7 @@ import threading
 from datetime import datetime
 
 class Collector:
-    #--
+    """Collects operation metrics for system optimization"""
     
     _instance = None
     _lock = threading.Lock()
@@ -22,7 +20,7 @@ class Collector:
             return cls._instance
     
     def _initialize(self):
-        #--
+        """Initialize collector"""
         self.metrics = {
             "function": [],
             "rate_limit": [],
@@ -36,95 +34,83 @@ class Collector:
         }
         self.function_count = 0
         self.colab_auth_triggered = False
+        self.max_metric_length = 200  # Keep only the latest 200 entries
     
     def record(self, metric_type, data, priority=None):
-        #--
-        ##
+        """Record operation metrics with deduplication and throttling"""
 
+        # Ensure data is a dictionary
         if not isinstance(data, dict):
             data = {"value": str(data)}
-            
-        ##
 
+        # Add timestamp if not present
         if "timestamp" not in data:
             data["timestamp"] = datetime.now().isoformat()
-        
-        ##
-
-        ##
-
-        if metric_type != "system_info" and isinstance(data, dict):
-            ##
-
-            if "system" in data:
-                del data["system"]
-            
-            ##
 
+        # For non-system info, simplify and tag machine
+        if metric_type != "system_info":
+            data.pop("system", None)
             from vnai.scope.profile import inspector
             data["machine_id"] = inspector.fingerprint()
-        
-        ##
 
+        # ==== THROTTLING ====
+        now = time.time()
+        last_time = self._last_record_time.get(metric_type, 0)
+        if now - last_time < self.min_interval_per_type and priority != "high":
+            return  # Skip due to interval limit
+        self._last_record_time[metric_type] = now
+
+        # ==== DEDUPLICATION ====
+        data_hash = hashlib.md5(json.dumps(data, sort_keys=True).encode()).hexdigest()
+        if data_hash in self._recent_hashes and priority != "high":
+            return  # Skip duplicate
+        self._recent_hashes.append(data_hash)
+
+        # ==== RECORD LOGIC ====
         if metric_type in self.metrics:
             self.metrics[metric_type].append(data)
+            # Prune oldest if too long
+            if len(self.metrics[metric_type]) > self.max_metric_length:
+                self.metrics[metric_type] = self.metrics[metric_type][-self.max_metric_length:]
         else:
             self.metrics["function"].append(data)
-            
-        ##
 
+        # Function metric tracking (Colab trigger)
         if metric_type == "function":
             self.function_count += 1
-            
-            ##
-
             if self.function_count > 10 and not self.colab_auth_triggered and 'google.colab' in sys.modules:
                 self.colab_auth_triggered = True
-                ##
-
-                threading.Thread(
-                    target=self._trigger_colab_auth,
-                    daemon=True
-                ).start()
-        
-        ##
+                threading.Thread(target=self._trigger_colab_auth, daemon=True).start()
 
+        # Auto-send triggers
         if sum(len(metric_list) for metric_list in self.metrics.values()) >= self.thresholds["buffer_size"]:
             self._send_metrics()
-        
-        ##
-
-        if priority == "high" or (metric_type == "error"):
+        if priority == "high" or metric_type == "error":
             self._send_metrics()
     
     def _trigger_colab_auth(self):
-        #--
+        """Trigger Google Colab authentication in a background thread"""
         try:
             from vnai.scope.profile import inspector
             inspector.get_or_create_user_id()
         except:
-            pass  ##
-
+            pass  # Silently fail if there's an issue
             
     def _send_metrics(self):
-        #--
-        ##
-
+        """Send collected metrics to data relay"""
+        # Import here to avoid circular imports
         from vnai.flow.relay import track_function_call, track_rate_limit, track_api_request
         
-        ##
-
+        # Process and send each type of metric using the appropriate tracking function
         for metric_type, data_list in self.metrics.items():
             if not data_list:
                 continue
                 
-            ##
-
+            # Process each metric by type
             for data in data_list:
                 try:
                     if metric_type == "function":
-                        ##
-
+                        # Use the track_function_call interface
                         track_function_call(
                             function_name=data.get("function", "unknown"),
                             source=data.get("source", "vnai"),
@@ -134,8 +120,7 @@ class Collector:
                             args=data.get("args")
                         )
                     elif metric_type == "rate_limit":
-                        ##
-
+                        # Use the track_rate_limit interface
                         track_rate_limit(
                             source=data.get("source", "vnai"),
                             limit_type=data.get("limit_type", "unknown"),
@@ -144,8 +129,7 @@ class Collector:
                             is_exceeded=data.get("is_exceeded", False)
                         )
                     elif metric_type == "request":
-                        ##
-
+                        # Use the track_api_request interface
                         track_api_request(
                             endpoint=data.get("endpoint", "unknown"),
                             source=data.get("source", "vnai"),
@@ -156,27 +140,24 @@ class Collector:
                             response_size=data.get("response_size", 0)
                         )
                 except Exception as e:
-                    ##
-
+                    # If tracking fails, just continue with the next item
                     continue
             
-            ##
-
+            # Clear the processed metrics
             self.metrics[metric_type] = []
     
     def get_metrics_summary(self):
-        #--
+        """Get summary of collected metrics"""
         return {
             metric_type: len(data_list)
             for metric_type, data_list in self.metrics.items()
         }
 
-##
-
+# Create singleton instance
 collector = Collector()
 
 def capture(module_type="function"):
-    #--
+    """Decorator to capture metrics for any function"""
     def decorator(func):
         def wrapper(*args, **kwargs):
             start_time = time.time()
@@ -201,8 +182,7 @@ def capture(module_type="function"):
                         "success": success,
                         "error": error,
                         "timestamp": datetime.now().isoformat(),
-                        "args": str(args)[:100] if args else None  ##
-
+                        "args": str(args)[:100] if args else None  # Truncate for privacy
                     }
                 )
         return wrapper

vnai/beam/pulse.py

@@ -1,14 +1,12 @@
-##
-
-##
-
+# vnai/beam/pulse.py
+# System health and performance monitoring
 
 import threading
 import time
 from datetime import datetime
 
 class Monitor:
-    #--
+    """Monitors system health and performance"""
     
     _instance = None
     _lock = threading.Lock()
@@ -21,55 +19,47 @@ class Monitor:
             return cls._instance
     
     def _initialize(self):
-        #--
+        """Initialize monitor"""
         self.health_status = "healthy"
         self.last_check = time.time()
-        self.check_interval = 300  ##
-
+        self.check_interval = 300  # seconds
         self.error_count = 0
         self.warning_count = 0
         self.status_history = []
         
-        ##
-
+        # Start background health check thread
         self._start_background_check()
     
     def _start_background_check(self):
-        #--
+        """Start background health check thread"""
         def check_health():
             while True:
                 try:
                     self.check_health()
                 except:
-                    pass  ##
-
+                    pass  # Don't let errors stop the monitor
                 time.sleep(self.check_interval)
         
         thread = threading.Thread(target=check_health, daemon=True)
         thread.start()
     
     def check_health(self):
-        #--
+        """Check system health status"""
         from vnai.beam.metrics import collector
         from vnai.beam.quota import guardian
         
-        ##
-
+        # Record check time
         self.last_check = time.time()
         
-        ##
-
+        # Check metrics collector health
         metrics_summary = collector.get_metrics_summary()
         has_errors = metrics_summary.get("error", 0) > 0
         
-        ##
-
+        # Check resource usage
         resource_usage = guardian.usage()
-        high_usage = resource_usage > 80  ##
-
+        high_usage = resource_usage > 80  # Over 80% of rate limits
         
-        ##
-
+        # Determine health status
         if has_errors and high_usage:
             self.health_status = "critical"
             self.error_count += 1
@@ -79,8 +69,7 @@ class Monitor:
         else:
             self.health_status = "healthy"
         
-        ##
-
+        # Record health status
         self.status_history.append({
             "timestamp": datetime.now().isoformat(),
             "status": self.health_status,
@@ -88,17 +77,15 @@ class Monitor:
             "resource_usage": resource_usage
         })
         
-        ##
-
+        # Keep history limited to last 10 entries
         if len(self.status_history) > 10:
             self.status_history = self.status_history[-10:]
         
         return self.health_status
     
     def report(self):
-        #--
-        ##
-
+        """Get health report"""
+        # Ensure we have a fresh check if last one is old
         if time.time() - self.last_check > self.check_interval:
             self.check_health()
             
@@ -107,18 +94,16 @@ class Monitor:
             "last_check": datetime.fromtimestamp(self.last_check).isoformat(),
             "error_count": self.error_count,
             "warning_count": self.warning_count,
-            "history": self.status_history[-3:],  ##
-
+            "history": self.status_history[-3:],  # Last 3 entries
         }
     
     def reset(self):
-        #--
+        """Reset health monitor"""
         self.health_status = "healthy"
         self.error_count = 0
         self.warning_count = 0
         self.status_history = []
         self.last_check = time.time()
 
-##
-
+# Create singleton instance
 monitor = Monitor()