vnai 2.0.7__py3-none-any.whl → 2.0.8__py3-none-any.whl

vnai/__init__.py

@@ -1,275 +1,79 @@
-# vnai/__init__.py
-# Main entry point for vnai package
-
-import os
-import pathlib
-import json
-import time
-import threading
-import functools
+_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
 from datetime import datetime
-
-# Import core functionality
-from vnai.beam.quota import guardian, optimize
-from vnai.beam.metrics import collector, capture
+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
 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 = """
-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
-"""
-
+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'
 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.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 __init__(self):self.initialized=_F;self.webhook_url=_B;self.init_time=datetime.now().isoformat();self.home_dir=pathlib.Path.home();self.project_dir=self.home_dir/_D;self.id_dir=self.project_dir/_E;self.terms_file_path=TC_PATH;self.system_info=_B;self.project_dir.mkdir(exist_ok=_A);self.id_dir.mkdir(exist_ok=_A);self.initialize()
+	def initialize(self,webhook_url=_B):
+		if self.initialized:return _A
+		if not self._check_terms():self._accept_terms()
+		from vnai.scope.profile import inspector;inspector.setup_vnstock_environment();present()
+		if webhook_url:self.webhook_url=webhook_url;configure(webhook_url)
+		record('initialization',{_G:datetime.now().isoformat()});self.system_info=inspector.examine();conduit.queue({'type':'system_info','data':{'commercial':inspector.detect_commercial_usage(),'packages':inspector.scan_packages()}},priority='high');self.initialized=_A;return _A
+	def _check_terms(self):return os.path.exists(self.terms_file_path)
+	def _accept_terms(self):
+		system_info=inspector.examine()
+		if TC_VAR in os.environ and os.environ[TC_VAR]==TC_VAL:response=TC_VAL
+		else:response=TC_VAL;os.environ[TC_VAR]=TC_VAL
+		now=datetime.now();signed_agreement=f"""Người dùng có mã nhận dạng {system_info[_C]} đã chấp nhận điều khoản & điều kiện sử dụng Vnstock lúc {now}
+---
+
+THÔNG TIN THIẾT BỊ: {json.dumps(system_info,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(self.terms_file_path,'w',encoding='utf-8')as f:f.write(signed_agreement)
+		env_file=self.id_dir/_I;env_data={_J:_A,_G:now.isoformat(),_C:system_info[_C]}
+		with open(env_file,'w')as f:json.dump(env_data,f)
+		return _A
+	def status(self):return{'initialized':self.initialized,'health':monitor.report(),'metrics':tracker.get_metrics()}
+	def configure_privacy(self,level=_K):from vnai.scope.state import tracker;return tracker.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):
+	if terms_text is _B:terms_text=TERMS_AND_CONDITIONS
+	system_info=inspector.examine();terms_file=pathlib.Path.home()/_D/_E/_H;os.makedirs(os.path.dirname(terms_file),exist_ok=_A)
+	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 _A
 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,
-        "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()
-
+	from vnai.scope.profile import inspector;system_info=inspector.examine();home_dir=pathlib.Path.home();project_dir=home_dir/_D;project_dir.mkdir(exist_ok=_A);id_dir=project_dir/_E;id_dir.mkdir(exist_ok=_A);env_file=id_dir/_I;env_data={_J:_A,_G:datetime.now().isoformat(),_C:system_info[_C]}
+	try:
+		with open(env_file,'w')as f:json.dump(env_data,f)
+		print('Vnstock terms accepted successfully.');return _A
+	except Exception as e:print(f"Error accepting terms: {e}");return _F
+def setup_for_colab():from vnai.scope.profile import inspector;inspector.detect_colab_with_delayed_auth(immediate=_A);inspector.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;return tracker.setup_privacy(level)
+def check_commercial_usage():from vnai.scope.profile import inspector;return inspector.detect_commercial_usage()
+def authenticate_for_persistence():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
-        
-    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
+	if not webhook_id:return _F
+	from vnai.flow.relay import configure;webhook_url=f"https://botbuilder.larksuite.com/api/trigger-webhook/{webhook_id}";return configure(webhook_url)
 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.quota import guardian,optimize
+from vnai.beam.metrics import collector,capture
 from vnai.beam.pulse import monitor

vnai/beam/metrics.py

@@ -1,189 +1,64 @@
-# vnai/beam/metrics.py
-# System performance metrics collection (formerly analytics)
-
-import sys
-import time
-import threading
+_K='success'
+_J='buffer_size'
+_I='request'
+_H='rate_limit'
+_G='execution_time'
+_F='timestamp'
+_E=False
+_D='error'
+_C=True
+_B=None
+_A='function'
+import sys,time,threading
 from datetime import datetime
-
 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"""
-        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
-        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()
-
-        # 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()
-
-        # 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":
-            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
+	_instance=_B;_lock=threading.Lock()
+	def __new__(cls):
+		with cls._lock:
+			if cls._instance is _B:cls._instance=super(Collector,cls).__new__(cls);cls._instance._initialize()
+			return cls._instance
+	def _initialize(self):self.metrics={_A:[],_H:[],_I:[],_D:[]};self.thresholds={_J:50,'error_threshold':.1,'performance_threshold':5.};self.function_count=0;self.colab_auth_triggered=_E;self.max_metric_length=200
+	def record(self,metric_type,data,priority=_B):
+		A='high'
+		if not isinstance(data,dict):data={'value':str(data)}
+		if _F not in data:data[_F]=datetime.now().isoformat()
+		if metric_type!='system_info':data.pop('system',_B);from vnai.scope.profile import inspector;data['machine_id']=inspector.fingerprint()
+		now=time.time();last_time=self._last_record_time.get(metric_type,0)
+		if now-last_time<self.min_interval_per_type and priority!=A:return
+		self._last_record_time[metric_type]=now;data_hash=hashlib.md5(json.dumps(data,sort_keys=_C).encode()).hexdigest()
+		if data_hash in self._recent_hashes and priority!=A:return
+		self._recent_hashes.append(data_hash)
+		if metric_type in self.metrics:
+			self.metrics[metric_type].append(data)
+			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[_A].append(data)
+		if metric_type==_A:
+			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=_C;threading.Thread(target=self._trigger_colab_auth,daemon=_C).start()
+		if sum(len(metric_list)for metric_list in self.metrics.values())>=self.thresholds[_J]:self._send_metrics()
+		if priority==A or metric_type==_D:self._send_metrics()
+	def _trigger_colab_auth(self):
+		try:from vnai.scope.profile import inspector;inspector.get_or_create_user_id()
+		except:pass
+	def _send_metrics(self):
+		C='vnai';B='source';A='unknown';from vnai.flow.relay import track_function_call,track_rate_limit,track_api_request
+		for(metric_type,data_list)in self.metrics.items():
+			if not data_list:continue
+			for data in data_list:
+				try:
+					if metric_type==_A:track_function_call(function_name=data.get(_A,A),source=data.get(B,C),execution_time=data.get(_G,0),success=data.get(_K,_C),error=data.get(_D),args=data.get('args'))
+					elif metric_type==_H:track_rate_limit(source=data.get(B,C),limit_type=data.get('limit_type',A),limit_value=data.get('limit_value',0),current_usage=data.get('current_usage',0),is_exceeded=data.get('is_exceeded',_E))
+					elif metric_type==_I:track_api_request(endpoint=data.get('endpoint',A),source=data.get(B,C),method=data.get('method','GET'),status_code=data.get('status_code',200),execution_time=data.get(_G,0),request_size=data.get('request_size',0),response_size=data.get('response_size',0))
+				except Exception as e:continue
+			self.metrics[metric_type]=[]
+	def get_metrics_summary(self):return{metric_type:len(data_list)for(metric_type,data_list)in self.metrics.items()}
+collector=Collector()
+def capture(module_type=_A):
+	def decorator(func):
+		def wrapper(*args,**kwargs):
+			start_time=time.time();success=_E;error=_B
+			try:result=func(*args,**kwargs);success=_C;return result
+			except Exception as e:error=str(e);raise
+			finally:execution_time=time.time()-start_time;collector.record(module_type,{_A:func.__name__,_G:execution_time,_K:success,_D:error,_F:datetime.now().isoformat(),'args':str(args)[:100]if args else _B})
+		return wrapper
+	return decorator