vnai 2.0.2__py3-none-any.whl → 2.0.4__py3-none-any.whl

vnai/__init__.py

@@ -1,81 +1,274 @@
-_L='default'
-_K='standard'
-_J='accepted_agreement'
-_I='environment.json'
-_H='terms_agreement.txt'
-_G='timestamp'
-_F=False
-_E='id'
-_D='.vnstock'
-_C='machine_id'
-_B=None
-_A=True
-import os,pathlib,json,time,threading,functools
+# vnai/__init__.py
+# Main entry point for vnai package
+
+import os
+import pathlib
+import json
+import time
+import threading
+import functools
 from datetime import datetime
-from vnai.beam.quota import guardian,optimize
-from vnai.beam.metrics import collector,capture
+
+# Import core functionality
+from vnai.beam.quota import guardian, optimize
+from vnai.beam.metrics import collector, capture
 from vnai.beam.pulse import monitor
-from vnai.flow.relay import conduit,configure
+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
+from vnai.scope.state import tracker, record
 from vnai.scope.promo import present
-TC_VAR='ACCEPT_TC'
-TC_VAL='tôi đồng ý'
-TC_PATH=pathlib.Path.home()/_D/_E/_H
-TERMS_AND_CONDITIONS='\nKhi 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.\n\nChi tiết:\n- Giấy phép sử dụng phần mềm: https://vnstocks.com/docs/tai-lieu/giay-phep-su-dung\n- Chính sách quyền riêng tư: https://vnstocks.com/docs/tai-lieu/chinh-sach-quyen-rieng-tu\n'
+
+# 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 = """
+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:
-	def __init__(A):A.initialized=_F;A.webhook_url=_B;A.init_time=datetime.now().isoformat();A.home_dir=pathlib.Path.home();A.project_dir=A.home_dir/_D;A.id_dir=A.project_dir/_E;A.terms_file_path=TC_PATH;A.system_info=_B;A.project_dir.mkdir(exist_ok=_A);A.id_dir.mkdir(exist_ok=_A);A.initialize()
-	def initialize(A,webhook_url=_B):
-		C=webhook_url
-		if A.initialized:return _A
-		if not A._check_terms():A._accept_terms()
-		from vnai.scope.profile import inspector as B;B.setup_vnstock_environment();present()
-		if C:A.webhook_url=C;configure(C)
-		record('initialization',{_G:datetime.now().isoformat()});A.system_info=B.examine();conduit.queue({'type':'system_info','data':{'commercial':B.detect_commercial_usage(),'packages':B.scan_packages()}},priority='high');A.initialized=_A;return _A
-	def _check_terms(A):return os.path.exists(A.terms_file_path)
-	def _accept_terms(C):
-		A=inspector.examine()
-		if TC_VAR in os.environ and os.environ[TC_VAR]==TC_VAL:E=TC_VAL
-		else:E=TC_VAL;os.environ[TC_VAR]=TC_VAL
-		D=datetime.now();F=f"""Người dùng có mã nhận dạng {A[_C]} đã chấp nhận điều khoản & điều kiện sử dụng Vnstock lúc {D}
----
-
-THÔNG TIN THIẾT BỊ: {json.dumps(A,indent=2)}
-
-Đính kèm bản sao nội dung bạn đã đọc, hiểu rõ và đồng ý dưới đây:
-{TERMS_AND_CONDITIONS}"""
-		with open(C.terms_file_path,'w',encoding='utf-8')as B:B.write(F)
-		G=C.id_dir/_I;H={_J:_A,_G:D.isoformat(),_C:A[_C]}
-		with open(G,'w')as B:json.dump(H,B)
-		return _A
-	def status(A):return{'initialized':A.initialized,'health':monitor.report(),'metrics':tracker.get_metrics()}
-	def configure_privacy(B,level=_K):from vnai.scope.state import tracker as A;return A.setup_privacy(level)
-core=Core()
-def tc_init(webhook_url=_B):return core.initialize(webhook_url)
-def setup(webhook_url=_B):return core.initialize(webhook_url)
-def optimize_execution(resource_type=_L):return optimize(resource_type)
-def agg_execution(resource_type=_L):return optimize(resource_type,ad_cooldown=1500,content_trigger_threshold=100000)
-def measure_performance(module_type='function'):return capture(module_type)
-def accept_license_terms(terms_text=_B):
-	A=terms_text
-	if A is _B:A=TERMS_AND_CONDITIONS
-	D=inspector.examine();C=pathlib.Path.home()/_D/_E/_H;os.makedirs(os.path.dirname(C),exist_ok=_A)
-	with open(C,'w',encoding='utf-8')as B:B.write(f"Terms accepted at {datetime.now().isoformat()}\n");B.write(f"System: {json.dumps(D)}\n\n");B.write(A)
-	return _A
+    """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.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": {
+                "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}"
+        )
+        
+        # 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,
+            "timestamp": now.isoformat(),
+            "machine_id": system_info['machine_id']
+        }
+        
+        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
+        }
+    
+    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)
+    
+    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():
-	from vnai.scope.profile import inspector as C;D=C.examine();E=pathlib.Path.home();A=E/_D;A.mkdir(exist_ok=_A);B=A/_E;B.mkdir(exist_ok=_A);F=B/_I;G={_J:_A,_G:datetime.now().isoformat(),_C:D[_C]}
-	try:
-		with open(F,'w')as H:json.dump(G,H)
-		print('Vnstock terms accepted successfully.');return _A
-	except Exception as I:print(f"Error accepting terms: {I}");return _F
-def setup_for_colab():from vnai.scope.profile import inspector as A;A.detect_colab_with_delayed_auth(immediate=_A);A.setup_vnstock_environment();return'Environment set up for Google Colab'
-def display_content():return present()
-def configure_privacy(level=_K):from vnai.scope.state import tracker as A;return A.setup_privacy(level)
-def check_commercial_usage():from vnai.scope.profile import inspector as A;return A.detect_commercial_usage()
-def authenticate_for_persistence():from vnai.scope.profile import inspector as A;return A.get_or_create_user_id()
+    """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,
+        "timestamp": datetime.now().isoformat(),
+        "machine_id": system_info['machine_id']
+    }
+    
+    try:
+        with open(env_file, "w") as f:
+            json.dump(env_data, f)
+        print("Vnstock terms accepted successfully.")
+        return True
+    except Exception as e:
+        print(f"Error accepting terms: {e}")
+        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'):
-	A=webhook_id
-	if not A:return _F
-	from vnai.flow.relay import configure as B;C=f"https://botbuilder.larksuite.com/api/trigger-webhook/{A}";return B(C)
+    """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
+        
+    from vnai.flow.relay import configure
+    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 @@
-from vnai.beam.quota import guardian,optimize
-from vnai.beam.metrics import collector,capture
+# 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,59 +1,184 @@
-_K='success'
-_J='buffer_size'
-_I='request'
-_H='rate_limit'
-_G='execution_time'
-_F='timestamp'
-_E=False
-_D=True
-_C='error'
-_B=None
-_A='function'
-import sys,time,threading
+# vnai/beam/metrics.py
+# System performance metrics collection (formerly analytics)
+
+import sys
+import time
+import threading
 from datetime import datetime
+
 class Collector:
-	_instance=_B;_lock=threading.Lock()
-	def __new__(A):
-		with A._lock:
-			if A._instance is _B:A._instance=super(Collector,A).__new__(A);A._instance._initialize()
-			return A._instance
-	def _initialize(A):A.metrics={_A:[],_H:[],_I:[],_C:[]};A.thresholds={_J:50,'error_threshold':.1,'performance_threshold':5.};A.function_count=0;A.colab_auth_triggered=_E
-	def record(A,metric_type,data,priority=_B):
-		D='system';C=metric_type;B=data
-		if not isinstance(B,dict):B={'value':str(B)}
-		if _F not in B:B[_F]=datetime.now().isoformat()
-		if C!='system_info'and isinstance(B,dict):
-			if D in B:del B[D]
-			from vnai.scope.profile import inspector as E;B['machine_id']=E.fingerprint()
-		if C in A.metrics:A.metrics[C].append(B)
-		else:A.metrics[_A].append(B)
-		if C==_A:
-			A.function_count+=1
-			if A.function_count>10 and not A.colab_auth_triggered and'google.colab'in sys.modules:A.colab_auth_triggered=_D;threading.Thread(target=A._trigger_colab_auth,daemon=_D).start()
-		if sum(len(A)for A in A.metrics.values())>=A.thresholds[_J]:A._send_metrics()
-		if priority=='high'or C==_C:A._send_metrics()
-	def _trigger_colab_auth(B):
-		try:from vnai.scope.profile import inspector as A;A.get_or_create_user_id()
-		except:pass
-	def _send_metrics(F):
-		E='vnai';D='source';C='unknown';from vnai.flow.relay import track_function_call as H,track_rate_limit as I,track_api_request as J
-		for(B,G)in F.metrics.items():
-			if not G:continue
-			for A in G:
-				try:
-					if B==_A:H(function_name=A.get(_A,C),source=A.get(D,E),execution_time=A.get(_G,0),success=A.get(_K,_D),error=A.get(_C),args=A.get('args'))
-					elif B==_H:I(source=A.get(D,E),limit_type=A.get('limit_type',C),limit_value=A.get('limit_value',0),current_usage=A.get('current_usage',0),is_exceeded=A.get('is_exceeded',_E))
-					elif B==_I:J(endpoint=A.get('endpoint',C),source=A.get(D,E),method=A.get('method','GET'),status_code=A.get('status_code',200),execution_time=A.get(_G,0),request_size=A.get('request_size',0),response_size=A.get('response_size',0))
-				except Exception as K:continue
-			F.metrics[B]=[]
-	def get_metrics_summary(A):return{A:len(B)for(A,B)in A.metrics.items()}
-collector=Collector()
-def capture(module_type=_A):
-	def A(func):
-		def A(*A,**D):
-			E=time.time();B=_E;C=_B
-			try:F=func(*A,**D);B=_D;return F
-			except Exception as G:C=str(G);raise
-			finally:H=time.time()-E;collector.record(module_type,{_A:func.__name__,_G:H,_K:B,_C:C,_F:datetime.now().isoformat(),'args':str(A)[:100]if A else _B})
-		return A
-	return A
+    """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"""
+        self.metrics = {
+            "function": [],
+            "rate_limit": [],
+            "request": [],
+            "error": []
+        }
+        self.thresholds = {
+            "buffer_size": 50,
+            "error_threshold": 0.1,
+            "performance_threshold": 5.0
+        }
+        self.function_count = 0
+        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
+            
+    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"),
+                            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
+                        track_rate_limit(
+                            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
+                        track_api_request(
+                            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] = []
+    
+    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)
+                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
+                    }
+                )
+        return wrapper
+    return decorator