vnai 2.1.8__py3-none-any.whl → 2.1.9__py3-none-any.whl

vnai/__init__.py

@@ -1,6 +1,3 @@
-# vnai/__init__.py
-# Main entry point for vnai package
-
 import os
 import pathlib
 import json
@@ -8,8 +5,6 @@ import time
 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,204 +14,139 @@ 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"
-
-TERMS_AND_CONDITIONS = """
+TC_VAR ="ACCEPT_TC"
+TC_VAL ="tôi đồng ý"
+TC_PATH = pathlib.Path.home() /".vnstock" /"id" /"terms_agreement.txt"
+TERMS_AND_CONDITIONS ="""
 Khi tiếp tục sử dụng Vnstock, bạn xác nhận rằng bạn đã đọc, hiểu và đồng ý với Chính sách quyền riêng tư và Điều khoản, điều kiện về giấy phép sử dụng Vnstock.
-
 Chi tiết:
 - Giấy phép sử dụng phần mềm: https://vnstocks.com/docs/tai-lieu/giay-phep-su-dung
 - Chính sách quyền riêng tư: https://vnstocks.com/docs/tai-lieu/chinh-sach-quyen-rieng-tu
 """
 
 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()
         self.home_dir = pathlib.Path.home()
-        self.project_dir = self.home_dir / ".vnstock"
-        self.id_dir = self.project_dir / 'id'
+        self.project_dir = self.home_dir /".vnstock"
+        self.id_dir = self.project_dir /'id'
         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):
-        """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
         from vnai.scope.promo import ContentManager
         manager = ContentManager()
-        # Chỉ hiện ads nếu chắc chắn là free user
-        if manager.is_paid_user is False and getattr(manager, 'license_checked', False):
+        if manager.is_paid_user is False and getattr(manager,'license_checked', False):
             present()
-        
-        # 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": {
-                "commercial": inspector.detect_commercial_usage(),
-                "packages": inspector.scan_packages()
+"type":"system_info",
+"data": {
+"commercial": inspector.detect_commercial_usage(),
+"packages": inspector.scan_packages()
             }
         }, priority="high")
-        
         self.initialized = True
         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 "
-            f"điều khoản & điều kiện sử dụng Vnstock lúc {now}\n"
-            f"---\n\n"
-            f"THÔNG TIN THIẾT BỊ: {json.dumps(system_info, indent=2)}\n\n"
-            f"Đính kèm bản sao nội dung bạn đã đọc, hiểu rõ và đồng ý dưới đây:\n"
-            f"{TERMS_AND_CONDITIONS}"
+f"Người dùng có mã nhận dạng {system_info['machine_id']} đã chấp nhận "
+f"điều khoản & điều kiện sử dụng Vnstock lúc {now}\n"
+f"---\n\n"
+f"THÔNG TIN THIẾT BỊ: {json.dumps(system_info, indent=2)}\n\n"
+f"Đính kèm bản sao nội dung bạn đã đọc, hiểu rõ và đồng ý dưới đây:\n"
+f"{TERMS_AND_CONDITIONS}"
         )
-        
-        # Store the acceptance
-        with open(self.terms_file_path, "w", encoding="utf-8") as f:
+        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_file = self.id_dir /"environment.json"
         env_data = {
-            "accepted_agreement": True,
-            "timestamp": now.isoformat(),
-            "machine_id": system_info['machine_id']
+"accepted_agreement": True,
+"timestamp": now.isoformat(),
+"machine_id": system_info['machine_id']
         }
-        
-        with open(env_file, "w") as f:
+        with open(env_file,"w") as f:
             json.dump(env_data, f)
-        
         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
+"initialized": self.initialized,
+"health": monitor.report(),
+"metrics": tracker.get_metrics()
         }
-    
+
     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():
     return core.initialize()
 
 def setup():
-    """Setup vnai"""
     return core.initialize()
 
 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"
+    terms_file = pathlib.Path.home() /".vnstock" /"id" /"terms_agreement.txt"
     os.makedirs(os.path.dirname(terms_file), exist_ok=True)
-    
-    with open(terms_file, "w", encoding="utf-8") as f:
+    with open(terms_file,"w", encoding="utf-8") as f:
         f.write(f"Terms accepted at {datetime.now().isoformat()}\n")
         f.write(f"System: {json.dumps(system_info)}\n\n")
         f.write(terms_text)
-    
     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 = home_dir /".vnstock"
     project_dir.mkdir(exist_ok=True)
-    id_dir = project_dir / 'id'
+    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_file = id_dir /"environment.json"
     env_data = {
-        "accepted_agreement": True,
-        "timestamp": datetime.now().isoformat(),
-        "machine_id": system_info['machine_id']
+"accepted_agreement": True,
+"timestamp": datetime.now().isoformat(),
+"machine_id": system_info['machine_id']
     }
-    
     try:
-        with open(env_file, "w") as f:
+        with open(env_file,"w") as f:
             json.dump(env_data, f)
         print("Vnstock terms accepted successfully.")
         return True
@@ -225,16 +155,13 @@ def accept_vnstock_terms():
         return False
 
 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()
+    return inspector.get_or_create_user_id()

vnai/beam/__init__.py

@@ -1,5 +1,3 @@
-# vnai/beam/__init__.py
-
 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,3 @@
-# vnai/beam/metrics.py
-
 import sys
 import time
 import threading
@@ -8,211 +6,162 @@ import hashlib
 import json
 
 class Collector:
-    """Collects operation metrics for system optimization"""
-    
     _instance = None
     _lock = threading.Lock()
-    
+
     def __new__(cls):
         with cls._lock:
             if cls._instance is None:
                 cls._instance = super(Collector, cls).__new__(cls)
                 cls._instance._initialize()
             return cls._instance
-    
+
     def _initialize(self):
-        """Initialize collector"""
-        # Initialize metrics storage
         self.metrics = {
-            "function": [],
-            "rate_limit": [],
-            "request": [],
-            "error": []
+"function": [],
+"rate_limit": [],
+"request": [],
+"error": []
         }
-        # Configuration thresholds
         self.thresholds = {
-            "buffer_size": 50,
-            "error_threshold": 0.1,
-            "performance_threshold": 5.0
+"buffer_size": 50,
+"error_threshold": 0.1,
+"performance_threshold": 5.0
         }
-        # Tracking variables
         self.function_count = 0
         self.colab_auth_triggered = False
-        self.max_metric_length = 200  # Keep only the latest 200 entries
-        self._last_record_time = {}  # Track last record time for throttling
-        self.min_interval_per_type = 0.5  # Min interval between same type records
-        self._recent_hashes = []  # Track recent hashes for deduplication
-        self._sending_metrics = False  # Prevent reentrancy in _send_metrics
-    
-    def record(self, metric_type, data, priority=None):
-        """Record operation metrics with deduplication and throttling"""
+        self.max_metric_length = 200
+        self._last_record_time = {}
+        self.min_interval_per_type = 0.5
+        self._recent_hashes = []
+        self._sending_metrics = False
 
-        # Ensure data is a dictionary
+    def record(self, metric_type, data, priority=None):
         if not isinstance(data, dict):
             data = {"value": str(data)}
-
-        # Add timestamp if not present
-        if "timestamp" not in data:
+        if"timestamp" not in data:
             data["timestamp"] = datetime.now().isoformat()
-
-        # For non-system info, simplify and tag machine
-        if metric_type != "system_info":
+        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
+        if now - last_time < self.min_interval_per_type and priority !="high":
+            return
         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
+        if data_hash in self._recent_hashes and priority !="high":
+            return
         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":
+        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:
+            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()
-
-        # 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  # Silently fail if there's an issue
-            
+            pass
+
     def _send_metrics(self):
-        """Send collected metrics to data relay"""
-        # Prevent reentrancy
         if self._sending_metrics:
             return
-            
         self._sending_metrics = True
         try:
-            # Import here to avoid circular imports
             from vnai.flow.relay import track_function_call, track_rate_limit, track_api_request
         except ImportError:
-            # If relay module is not available, clear metrics and return
             for metric_type in self.metrics:
                 self.metrics[metric_type] = []
             self._sending_metrics = False
             return
-        
-        # 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
+                    if metric_type =="function":
                         track_function_call(
-                            function_name=data.get("function", "unknown"),
-                            source=data.get("source", "vnai"),
+                            function_name=data.get("function","unknown"),
+                            source=data.get("source","vnai"),
                             execution_time=data.get("execution_time", 0),
                             success=data.get("success", True),
                             error=data.get("error"),
                             args=data.get("args")
                         )
-                    elif metric_type == "rate_limit":
-                        # Use the track_rate_limit interface
+                    elif metric_type =="rate_limit":
                         track_rate_limit(
-                            source=data.get("source", "vnai"),
-                            limit_type=data.get("limit_type", "unknown"),
+                            source=data.get("source","vnai"),
+                            limit_type=data.get("limit_type","unknown"),
                             limit_value=data.get("limit_value", 0),
                             current_usage=data.get("current_usage", 0),
                             is_exceeded=data.get("is_exceeded", False)
                         )
-                    elif metric_type == "request":
-                        # Use the track_api_request interface
+                    elif metric_type =="request":
                         track_api_request(
-                            endpoint=data.get("endpoint", "unknown"),
-                            source=data.get("source", "vnai"),
-                            method=data.get("method", "GET"),
+                            endpoint=data.get("endpoint","unknown"),
+                            source=data.get("source","vnai"),
+                            method=data.get("method","GET"),
                             status_code=data.get("status_code", 200),
                             execution_time=data.get("execution_time", 0),
                             request_size=data.get("request_size", 0),
                             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] = []
-            
-        # Reset sending flag
         self._sending_metrics = False
-    
+
     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()
             success = False
             error = None
-            
             try:
                 result = func(*args, **kwargs)
                 success = True
                 return result
             except Exception as e:
                 error = str(e)
-                # Log the error to metrics before re-raising
                 collector.record("error", {
-                    "function": func.__name__,
-                    "error": error,
-                    "args": str(args)[:100] if args else None
+"function": func.__name__,
+"error": error,
+"args": str(args)[:100] if args else None
                 })
                 raise
             finally:
                 execution_time = time.time() - start_time
-                
                 collector.record(
                     module_type,
                     {
-                        "function": func.__name__,
-                        "execution_time": execution_time,
-                        "success": success,
-                        "error": error,
-                        "timestamp": datetime.now().isoformat(),
-                        "args": str(args)[:100] if args else None  # Truncate for privacy
+"function": func.__name__,
+"execution_time": execution_time,
+"success": success,
+"error": error,
+"timestamp": datetime.now().isoformat(),
+"args": str(args)[:100] if args else None
                     }
                 )
         return wrapper
-    return decorator
+    return decorator

vnai/beam/pulse.py

@@ -1,108 +1,79 @@
-# vnai/beam/pulse.py
-
 import threading
 import time
 from datetime import datetime
 
 class Monitor:
-    """Monitors system health and performance"""
-    
     _instance = None
     _lock = threading.Lock()
-    
+
     def __new__(cls):
         with cls._lock:
             if cls._instance is None:
                 cls._instance = super(Monitor, cls).__new__(cls)
                 cls._instance._initialize()
             return cls._instance
-    
+
     def _initialize(self):
-        """Initialize monitor"""
-        self.health_status = "healthy"
+        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
-        
-        # Determine health status
+        high_usage = resource_usage > 80
         if has_errors and high_usage:
-            self.health_status = "critical"
+            self.health_status ="critical"
             self.error_count += 1
         elif has_errors or high_usage:
-            self.health_status = "warning"
+            self.health_status ="warning"
             self.warning_count += 1
         else:
-            self.health_status = "healthy"
-        
-        # Record health status
+            self.health_status ="healthy"
         self.status_history.append({
-            "timestamp": datetime.now().isoformat(),
-            "status": self.health_status,
-            "metrics": metrics_summary,
-            "resource_usage": resource_usage
+"timestamp": datetime.now().isoformat(),
+"status": self.health_status,
+"metrics": metrics_summary,
+"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()
-            
         return {
-            "status": self.health_status,
-            "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
+"status": self.health_status,
+"last_check": datetime.fromtimestamp(self.last_check).isoformat(),
+"error_count": self.error_count,
+"warning_count": self.warning_count,
+"history": self.status_history[-3:],
         }
-    
+
     def reset(self):
-        """Reset health monitor"""
-        self.health_status = "healthy"
+        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()
+monitor = Monitor()