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

vnai/flow/relay.py

@@ -1,7 +1,5 @@
-##
-
-##
-
+# vnai/flow/relay.py
+# Data transmission system (formerly sync)
 
 import time
 import threading
@@ -13,7 +11,7 @@ from pathlib import Path
 from typing import Dict, List, Any, Optional
 
 class Conduit:
-    #--
+    """Handles system telemetry flow"""
     
     _instance = None
     _lock = threading.Lock()
@@ -26,13 +24,12 @@ class Conduit:
             return cls._instance
     
     def _initialize(self, webhook_url, buffer_size, sync_interval):
-        #--
+        """Initialize conduit"""
         self.webhook_url = webhook_url
         self.buffer_size = buffer_size
         self.sync_interval = sync_interval
         
-        ##
-
+        # Separate buffers for different data types
         self.buffer = {
             "function_calls": [],
             "api_requests": [],
@@ -44,8 +41,7 @@ class Conduit:
         self.sync_count = 0
         self.failed_queue = []
         
-        ##
-
+        # Home directory setup
         self.home_dir = Path.home()
         self.project_dir = self.home_dir / ".vnstock"
         self.project_dir.mkdir(exist_ok=True)
@@ -53,31 +49,27 @@ class Conduit:
         self.data_dir.mkdir(exist_ok=True)
         self.config_path = self.data_dir / "relay_config.json"
         
-        ##
-
+        # Get machine identifier from system profile
         try:
             from vnai.scope.profile import inspector
             self.machine_id = inspector.fingerprint()
         except:
             self.machine_id = self._generate_fallback_id()
         
-        ##
-
+        # Load config if exists
         self._load_config()
         
-        ##
-
+        # Start periodic sync
         self._start_periodic_sync()
     
     def _generate_fallback_id(self) -> str:
-        #--
+        """Generate a fallback machine identifier if profile is unavailable"""
         try:
             import platform
             import hashlib
             import uuid
             
-            ##
-
+            # Try to get machine-specific information
             system_info = platform.node() + platform.platform() + platform.processor()
             return hashlib.md5(system_info.encode()).hexdigest()
         except:
@@ -85,7 +77,7 @@ class Conduit:
             return str(uuid.uuid4())
     
     def _load_config(self):
-        #--
+        """Load configuration from file"""
         if self.config_path.exists():
             try:
                 with open(self.config_path, 'r') as f:
@@ -105,7 +97,7 @@ class Conduit:
                 pass
     
     def _save_config(self):
-        #--
+        """Save configuration to file"""
         config = {
             'webhook_url': self.webhook_url,
             'buffer_size': self.buffer_size,
@@ -121,7 +113,7 @@ class Conduit:
             pass
     
     def _start_periodic_sync(self):
-        #--
+        """Start periodic sync thread"""
         def periodic_sync():
             while True:
                 time.sleep(self.sync_interval)
@@ -131,9 +123,8 @@ class Conduit:
         sync_thread.start()
     
     def add_function_call(self, record):
-        #--
-        ##
-
+        """Add function call record"""
+        # Ensure record is a dictionary
         if not isinstance(record, dict):
             record = {"value": str(record)}
             
@@ -142,9 +133,8 @@ class Conduit:
             self._check_triggers("function_calls")
     
     def add_api_request(self, record):
-        #--
-        ##
-
+        """Add API request record"""
+        # Ensure record is a dictionary
         if not isinstance(record, dict):
             record = {"value": str(record)}
             
@@ -153,9 +143,8 @@ class Conduit:
             self._check_triggers("api_requests")
     
     def add_rate_limit(self, record):
-        #--
-        ##
-
+        """Add rate limit record"""
+        # Ensure record is a dictionary
         if not isinstance(record, dict):
             record = {"value": str(record)}
             
@@ -164,36 +153,33 @@ class Conduit:
             self._check_triggers("rate_limits")
     
     def _check_triggers(self, record_type: str):
-        #--
+        """Check if any sync triggers are met"""
         current_time = time.time()
         should_trigger = False
         trigger_reason = None
         
-        ##
-
+        # Get total buffer size
         total_records = sum(len(buffer) for buffer in self.buffer.values())
         
-        ##
-
+        # SIZE TRIGGER: Buffer size threshold reached
         if total_records >= self.buffer_size:
             should_trigger = True
             trigger_reason = "buffer_full"
         
-        ##
-
-        elif record_type == "rate_limits" and self.buffer["rate_limits"] and             any(item.get("is_exceeded") for item in self.buffer["rate_limits"] if isinstance(item, dict)):
+        # EVENT TRIGGER: Critical events (errors, rate limit warnings)
+        elif record_type == "rate_limits" and self.buffer["rate_limits"] and \
+             any(item.get("is_exceeded") for item in self.buffer["rate_limits"] if isinstance(item, dict)):
             should_trigger = True
             trigger_reason = "rate_limit_exceeded"
-        elif record_type == "function_calls" and self.buffer["function_calls"] and             any(not item.get("success") for item in self.buffer["function_calls"] if isinstance(item, dict)):
+        elif record_type == "function_calls" and self.buffer["function_calls"] and \
+             any(not item.get("success") for item in self.buffer["function_calls"] if isinstance(item, dict)):
             should_trigger = True
             trigger_reason = "function_error"
         
-        ##
-
+        # TIME-WEIGHTED RANDOM TRIGGER: More likely as time since last sync increases
         else:
             time_factor = min(1.0, (current_time - self.last_sync_time) / (self.sync_interval / 2))
-            if random.random() < 0.05 * time_factor:  ##
-
+            if random.random() < 0.05 * time_factor:  # 0-5% chance based on time
                 should_trigger = True
                 trigger_reason = "random_time_weighted"
         
@@ -205,48 +191,64 @@ class Conduit:
             ).start()
     
     def queue(self, package, priority=None):
-        #--
+        # --- Auto add 'segment' field to every payload ---
+        try:
+            from vnai.scope.promo import ContentManager
+            is_paid = ContentManager().is_paid_user
+            segment_val = "paid" if is_paid else "free"
+        except Exception:
+            segment_val = "free"
+
+        def ensure_segment(d):
+            if not isinstance(d, dict):
+                return d
+            d = dict(d)  # tạo bản sao để không ảnh hưởng dict gốc
+            if "segment" not in d:
+                d["segment"] = segment_val
+            return d
+        # Add segment to package if not present
+        if isinstance(package, dict) and "segment" not in package:
+            package["segment"] = segment_val
+        # Add segment to data if exists and is dict
+        if isinstance(package, dict) and isinstance(package.get("data"), dict):
+            if "segment" not in package["data"]:
+                package["data"]["segment"] = segment_val
+        # --- End auto segment ---
+
+        """Queue data package"""
         if not package:
             return False
             
-        ##
-
+        # Handle non-dictionary packages
         if not isinstance(package, dict):
-            self.add_function_call({"message": str(package)})
+            self.add_function_call(ensure_segment({"message": str(package)}))
             return True
             
-        ##
-
+        # Add timestamp if not present
         if "timestamp" not in package:
             package["timestamp"] = datetime.now().isoformat()
         
-        ##
-
+        # Route based on package type
         if "type" in package:
             package_type = package["type"]
             data = package.get("data", {})
             
-            ##
-
+            # Remove system info if present to avoid duplication
             if isinstance(data, dict) and "system" in data:
-                ##
-
+                # Get machine_id for reference but don't duplicate the whole system info
                 machine_id = data["system"].get("machine_id")
                 data.pop("system")
                 if machine_id:
                     data["machine_id"] = machine_id
-                    
             if package_type == "function":
-                self.add_function_call(data)
+                self.add_function_call(ensure_segment(data))
             elif package_type == "api_request":
-                self.add_api_request(data)
+                self.add_api_request(ensure_segment(data))
             elif package_type == "rate_limit":
-                self.add_rate_limit(data)
+                self.add_rate_limit(ensure_segment(data))
             elif package_type == "system_info":
-                ##
-
-                ##
-
+                # For system info, we'll add it as a special function call
+                # but remove duplicated data
                 self.add_function_call({
                     "type": "system_info",
                     "commercial": data.get("commercial"),
@@ -254,83 +256,75 @@ class Conduit:
                     "timestamp": package.get("timestamp")
                 })
             elif package_type == "metrics":
-                ##
-
+                # Handle metrics package with multiple categories
                 metrics_data = data
                 for metric_type, metrics_list in metrics_data.items():
                     if isinstance(metrics_list, list):
                         if metric_type == "function":
                             for item in metrics_list:
-                                self.add_function_call(item)
+                                self.add_function_call(ensure_segment(item))
                         elif metric_type == "rate_limit":
                             for item in metrics_list:
-                                self.add_rate_limit(item)
+                                self.add_rate_limit(ensure_segment(item))
                         elif metric_type == "request":
                             for item in metrics_list:
-                                self.add_api_request(item)
+                                self.add_api_request(ensure_segment(item))
             else:
-                ##
-
-                self.add_function_call(data)
+                # Default to function calls
+                if isinstance(data, dict) and data is not package:
+                    self.add_function_call(ensure_segment(data))
+                else:
+                    self.add_function_call(ensure_segment(package))
         else:
-            ##
-
-            self.add_function_call(package)
+            # No type specified, default to function call
+            self.add_function_call(ensure_segment(package))
             
-        ##
-
+        # Handle high priority items
         if priority == "high":
             self.dispatch("high_priority")
             
         return True
     
     def dispatch(self, reason="manual"):
-        #--
+        """Send queued data"""
         if not self.webhook_url:
             return False
             
         with self.lock:
-            ##
-
+            # Check if all buffers are empty
             if all(len(records) == 0 for records in self.buffer.values()):
                 return False
                 
-            ##
-
+            # Create a copy of the buffer for sending
             data_to_send = {
                 "function_calls": self.buffer["function_calls"].copy(),
                 "api_requests": self.buffer["api_requests"].copy(),
                 "rate_limits": self.buffer["rate_limits"].copy()
             }
             
-            ##
-
+            # Clear buffer
             self.buffer = {
                 "function_calls": [],
                 "api_requests": [],
                 "rate_limits": []
             }
             
-            ##
-
+            # Update sync time and count
             self.last_sync_time = time.time()
             self.sync_count += 1
             self._save_config()
         
-        ##
-
+        # Get environment information ONCE
         try:
             from vnai.scope.profile import inspector
             environment_info = inspector.examine()
             machine_id = environment_info.get("machine_id", self.machine_id)
         except:
-            ##
-
+            # Fallback if environment info isn't available
             environment_info = {"machine_id": self.machine_id}
             machine_id = self.machine_id
         
-        ##
-
+        # Create payload with environment info only in metadata
         payload = {
             "analytics_data": data_to_send,
             "metadata": {
@@ -347,8 +341,7 @@ class Conduit:
             }
         }
         
-        ##
-
+        # Send data
         success = self._send_data(payload)
         
         if not success:
@@ -360,7 +353,7 @@ class Conduit:
         return success
     
     def _send_data(self, payload):
-        #--
+        """Send data to webhook"""
         if not self.webhook_url:
             return False
             
@@ -368,8 +361,7 @@ class Conduit:
             response = requests.post(
                 self.webhook_url,
                 json=payload,
-                timeout=5  ##
-
+                timeout=5  # 5 second timeout
             )
             
             return response.status_code == 200
@@ -377,7 +369,7 @@ class Conduit:
             return False
     
     def retry_failed(self):
-        #--
+        """Retry sending failed data"""
         if not self.failed_queue:
             return 0
             
@@ -396,20 +388,18 @@ class Conduit:
         return success_count
     
     def configure(self, webhook_url):
-        #--
+        """Configure webhook URL"""
         with self.lock:
             self.webhook_url = webhook_url
             self._save_config()
             return True
 
-##
-
+# Create singleton instance
 conduit = Conduit()
 
-##
-
+# Exposed functions that match sync.py naming pattern
 def track_function_call(function_name, source, execution_time, success=True, error=None, args=None):
-    #--
+    """Track function call (bridge to add_function_call)"""
     record = {
         "function": function_name,
         "source": source,
@@ -422,8 +412,7 @@ def track_function_call(function_name, source, execution_time, success=True, err
         record["error"] = error
         
     if args:
-        ##
-
+        # Sanitize arguments
         sanitized_args = {}
         if isinstance(args, dict):
             for key, value in args.items():
@@ -438,7 +427,7 @@ def track_function_call(function_name, source, execution_time, success=True, err
     conduit.add_function_call(record)
 
 def track_rate_limit(source, limit_type, limit_value, current_usage, is_exceeded):
-    #--
+    """Track rate limit checks (bridge to add_rate_limit)"""
     record = {
         "source": source,
         "limit_type": limit_type,
@@ -452,7 +441,7 @@ def track_rate_limit(source, limit_type, limit_value, current_usage, is_exceeded
     conduit.add_rate_limit(record)
 
 def track_api_request(endpoint, source, method, status_code, execution_time, request_size=0, response_size=0):
-    #--
+    """Track API requests (bridge to add_api_request)"""
     record = {
         "endpoint": endpoint,
         "source": source,
@@ -467,13 +456,13 @@ def track_api_request(endpoint, source, method, status_code, execution_time, req
     conduit.add_api_request(record)
 
 def configure(webhook_url):
-    #--
+    """Configure webhook URL"""
     return conduit.configure(webhook_url)
 
 def sync_now():
-    #--
+    """Manually trigger synchronization"""
     return conduit.dispatch("manual")
 
 def retry_failed():
-    #--
+    """Retry failed synchronizations"""
     return conduit.retry_failed()

vnai/scope/__init__.py

@@ -1,7 +1,5 @@
-##
-
-##
-
+# vnai/scope/__init__.py
+# Environment detection and state tracking
 
 from vnai.scope.profile import inspector
 from vnai.scope.state import tracker, record