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

vnai/__init__.py

@@ -1,5 +1,7 @@
-# vnai/__init__.py
-# Main entry point for vnai package
+##
+
+##
+
 
 import os
 import pathlib
@@ -9,7 +11,8 @@ 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
@@ -19,7 +22,8 @@ from vnai.scope.profile import inspector
 from vnai.scope.state import tracker, record
 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"
@@ -33,10 +37,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()
@@ -46,41 +50,50 @@ 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": {
@@ -93,23 +106,27 @@ 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 "
@@ -120,11 +137,13 @@ 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,
@@ -138,49 +157,59 @@ 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"):
+    #--
+    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)
     
@@ -192,19 +221,22 @@ 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,
@@ -222,43 +254,40 @@ 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
         
@@ -266,5 +295,6 @@ 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,6 +1,3 @@
-# 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,5 +1,7 @@
-# vnai/beam/metrics.py
-# System performance metrics collection (formerly analytics)
+##
+
+##
+
 
 import sys
 import time
@@ -7,7 +9,7 @@ import threading
 from datetime import datetime
 
 class Collector:
-    """Collects operation metrics for system optimization"""
+    #--
     
     _instance = None
     _lock = threading.Lock()
@@ -20,7 +22,7 @@ class Collector:
             return cls._instance
     
     def _initialize(self):
-        """Initialize collector"""
+        #--
         self.metrics = {
             "function": [],
             "rate_limit": [],
@@ -36,76 +38,93 @@ class Collector:
         self.colab_auth_triggered = False
     
     def record(self, metric_type, data, priority=None):
-        """Record operation metrics"""
-        # 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()
         
-        # For system_info type, keep full data
-        # For other types, only include machine_id reference
+        ##
+
+        ##
+
         if metric_type != "system_info" and isinstance(data, dict):
-            # Remove any system info and just reference machine_id
+            ##
+
             if "system" in data:
                 del data["system"]
             
-            # Get machine_id for reference
+            ##
+
             from vnai.scope.profile import inspector
             data["machine_id"] = inspector.fingerprint()
         
-        # Add to appropriate metrics collection
+        ##
+
         if metric_type in self.metrics:
             self.metrics[metric_type].append(data)
         else:
             self.metrics["function"].append(data)
             
-        # Keep track of function call count for Colab auth trigger
+        ##
+
         if metric_type == "function":
             self.function_count += 1
             
-            # Check if we should trigger Colab authentication
+            ##
+
             if self.function_count > 10 and not self.colab_auth_triggered and 'google.colab' in sys.modules:
                 self.colab_auth_triggered = True
-                # Trigger in a separate thread to avoid blocking
+                ##
+
                 threading.Thread(
                     target=self._trigger_colab_auth,
                     daemon=True
                 ).start()
         
-        # Check buffer size and send if threshold reached
+        ##
+
         if sum(len(metric_list) for metric_list in self.metrics.values()) >= self.thresholds["buffer_size"]:
             self._send_metrics()
         
-        # Send immediately for high priority metrics
+        ##
+
         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  # Silently fail if there's an issue
+            pass  ##
+
             
     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"),
@@ -115,7 +134,8 @@ 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"),
@@ -124,7 +144,8 @@ 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"),
@@ -135,24 +156,27 @@ 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()
@@ -177,7 +201,8 @@ def capture(module_type="function"):
                         "success": success,
                         "error": error,
                         "timestamp": datetime.now().isoformat(),
-                        "args": str(args)[:100] if args else None  # Truncate for privacy
+                        "args": str(args)[:100] if args else None  ##
+
                     }
                 )
         return wrapper

vnai/beam/pulse.py

@@ -1,12 +1,14 @@
-# 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()
@@ -19,47 +21,55 @@ class Monitor:
             return cls._instance
     
     def _initialize(self):
-        """Initialize monitor"""
+        #--
         self.health_status = "healthy"
         self.last_check = time.time()
-        self.check_interval = 300  # seconds
+        self.check_interval = 300  ##
+
         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  # Don't let errors stop the monitor
+                    pass  ##
+
                 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  # Over 80% of rate limits
+        high_usage = resource_usage > 80  ##
+
         
-        # Determine health status
+        ##
+
         if has_errors and high_usage:
             self.health_status = "critical"
             self.error_count += 1
@@ -69,7 +79,8 @@ class Monitor:
         else:
             self.health_status = "healthy"
         
-        # Record health status
+        ##
+
         self.status_history.append({
             "timestamp": datetime.now().isoformat(),
             "status": self.health_status,
@@ -77,15 +88,17 @@ 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()
             
@@ -94,16 +107,18 @@ 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:],  # Last 3 entries
+            "history": self.status_history[-3:],  ##
+
         }
     
     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()