vnai 2.0.1__tar.gz → 2.0.2__tar.gz

{vnai-2.0.1 → vnai-2.0.2}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: vnai
-Version: 2.0.1
+Version: 2.0.2
 Summary: System optimization and resource management toolkit
 Home-page: https://github.com/yourusername/vnai
 Author: Your Name
 Author-email: your.email@example.com
+License: MIT
 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
@@ -24,6 +24,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license
 Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python

{vnai-2.0.1 → vnai-2.0.2}/setup.py

@@ -7,7 +7,7 @@ long_description = (
 
 setup(
     name="vnai",
-    version='2.0.1',
+    version='2.0.2',
     description="System optimization and resource management toolkit",
     long_description=long_description,
     long_description_content_type="text/markdown",
@@ -17,7 +17,6 @@ setup(
     packages=find_packages(),
     classifiers=[
         "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: MIT License",
         "Operating System :: OS Independent",
         "Development Status :: 4 - Beta",
         "Intended Audience :: Developers",
@@ -34,4 +33,5 @@ setup(
             "black>=21.5b2",
         ],
     },
+    license="MIT",
 )

vnai-2.0.2/vnai/__init__.py

@@ -0,0 +1,81 @@
+_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
+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=_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
+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.2/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.2/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.2/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.2/vnai/beam/quota.py

@@ -0,0 +1,107 @@
+_G='resource_type'
+_F=False
+_E=True
+_D=None
+_C='default'
+_B='hour'
+_A='min'
+import time,functools,threading
+from collections import defaultdict
+from datetime import datetime
+class RateLimitExceeded(Exception):
+	def __init__(A,resource_type,limit_type=_A,current_usage=_D,limit_value=_D,retry_after=_D):
+		D=resource_type;B=retry_after;A.resource_type=D;A.limit_type=limit_type;A.current_usage=current_usage;A.limit_value=limit_value;A.retry_after=B;C=f"Bạn đã gửi quá nhiều request tới {D}. "
+		if B:C+=f"Vui lòng thử lại sau {round(B)} giây."
+		else:C+='Vui lòng thêm thời gian chờ giữa các lần gửi request.'
+		super().__init__(C)
+class Guardian:
+	_instance=_D;_lock=threading.Lock()
+	def __new__(A):
+		with A._lock:
+			if A._instance is _D: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:3000};A.resource_limits['TCBS']={_A:60,_B:3000};A.resource_limits['VCI']={_A:60,_B:3000};A.resource_limits['VCI.ext']={_A:600,_B:36000};A.resource_limits['VND.ext']={_A:600,_B:36000};A.resource_limits['CAF.ext']={_A:600,_B:36000};A.resource_limits['SPL.ext']={_A:600,_B:36000};A.resource_limits['VDS.ext']={_A:600,_B:36000};A.resource_limits['FAD.ext']={_A:600,_B:36000}
+	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;D=time.time();C=B.resource_limits.get(A,B.resource_limits[_C]);N=D-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,{_G:A,J:_A,K:C[_A],L:F,M:_E},priority='high');raise RateLimitExceeded(resource_type=A,limit_type=_A,current_usage=F,limit_value=C[_A],retry_after=60-D%60)
+		P=D-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]);E=H>=C[_B];from vnai.beam.metrics import collector as G;G.record(I,{_G:A,J:_B if E else _A,K:C[_B]if E else C[_A],L:H if E else F,M:E})
+		if E:raise RateLimitExceeded(resource_type=A,limit_type=_B,current_usage=H,limit_value=C[_B],retry_after=3600-D%3600)
+		B.usage_counters[A][_A].append(D);B.usage_counters[A][_B].append(D);return _E
+	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)
+	def get_limit_status(B,resource_type=_C):K='reset_in_seconds';J='remaining';I='percentage';H='limit';G='usage';C=resource_type;D=time.time();A=B.resource_limits.get(C,B.resource_limits[_C]);L=D-60;M=D-3600;E=len([A for A in B.usage_counters[C][_A]if A>L]);F=len([A for A in B.usage_counters[C][_B]if A>M]);return{_G:C,'minute_limit':{G:E,H:A[_A],I:E/A[_A]*100 if A[_A]>0 else 0,J:max(0,A[_A]-E),K:60-D%60},'hour_limit':{G:F,H:A[_B],I:F/A[_B]*100 if A[_B]>0 else 0,J:max(0,A[_B]-F),K:3600-D%3600}}
+guardian=Guardian()
+class CleanErrorContext:
+	_last_message_time=0;_message_cooldown=5
+	def __enter__(A):return A
+	def __exit__(C,exc_type,exc_val,exc_tb):
+		A=exc_val
+		if exc_type is RateLimitExceeded:
+			B=time.time()
+			if B-CleanErrorContext._last_message_time>=CleanErrorContext._message_cooldown:print(f"\n⚠️ {str(A)}\n");CleanErrorContext._last_message_time=B
+			import sys;sys.exit(f"Rate limit exceeded. {str(A)} Process terminated.");return _F
+		return _F
+def optimize(resource_type=_C,loop_threshold=10,time_window=5,ad_cooldown=150,content_trigger_threshold=3,max_retries=2,backoff_factor=2,debug=_F):
+	H=debug;G=ad_cooldown;F=resource_type;E=backoff_factor;D=max_retries;C=content_trigger_threshold;B=time_window;A=loop_threshold
+	if callable(F):I=F;return _create_wrapper(I,_C,A,B,G,C,D,E,H)
+	if A<2:raise ValueError(f"loop_threshold must be at least 2, got {A}")
+	if B<=0:raise ValueError(f"time_window must be positive, got {B}")
+	if C<1:raise ValueError(f"content_trigger_threshold must be at least 1, got {C}")
+	if D<0:raise ValueError(f"max_retries must be non-negative, got {D}")
+	if E<=0:raise ValueError(f"backoff_factor must be positive, got {E}")
+	def J(func):return _create_wrapper(func,F,A,B,G,C,D,E,H)
+	return J
+def _create_wrapper(func,resource_type,loop_threshold,time_window,ad_cooldown,content_trigger_threshold,max_retries,backoff_factor,debug):
+	X=max_retries;W=content_trigger_threshold;P=time_window;K=resource_type;H=debug;A=func;B=[];I=0;E=0;F=_F;Q=time.time();c=1800
+	@functools.wraps(A)
+	def C(*d,**e):
+		b='timestamp';a='environment';V='error';O='function';N='loop';nonlocal I,E,F,Q;C=time.time();R=_F
+		if C-Q>c:F=_F;Q=C
+		G=0
+		while _E:
+			B.append(C)
+			while B and C-B[0]>P:B.pop(0)
+			S=len(B)>=loop_threshold
+			if H and S:print(f"[OPTIMIZE] Đã phát hiện vòng lặp cho {A.__name__}: {len(B)} lần gọi trong {P}s")
+			if S:
+				E+=1
+				if H:print(f"[OPTIMIZE] Số lần phát hiện vòng lặp liên tiếp: {E}/{W}")
+			else:E=0
+			f=E>=W and C-I>=ad_cooldown and not F
+			if f:
+				I=C;E=0;R=_E;F=_E
+				if H:print(f"[OPTIMIZE] Đã kích hoạt nội dung cho {A.__name__}")
+				try:
+					from vnai.scope.promo import manager as J
+					try:from vnai.scope.profile import inspector as T;U=T.examine().get(a,_D);J.present_content(environment=U,context=N)
+					except ImportError:J.present_content(context=N)
+				except ImportError:print(f"Phát hiện vòng lặp: Hàm '{A.__name__}' đang được gọi trong một vòng lặp")
+				except Exception as D:
+					if H:print(f"[OPTIMIZE] Lỗi khi hiển thị nội dung: {str(D)}")
+			try:
+				with CleanErrorContext():guardian.verify(A.__name__,K)
+			except RateLimitExceeded as D:
+				from vnai.beam.metrics import collector as L;L.record(V,{O:A.__name__,V:str(D),'context':'resource_verification',_G:K,'retry_attempt':G},priority='high')
+				if not F:
+					try:
+						from vnai.scope.promo import manager as J
+						try:from vnai.scope.profile import inspector as T;U=T.examine().get(a,_D);J.present_content(environment=U,context=N);F=_E;I=C
+						except ImportError:J.present_content(context=N);F=_E;I=C
+					except Exception:pass
+				if G<X:
+					M=backoff_factor**G;G+=1
+					if hasattr(D,'retry_after')and D.retry_after:M=min(M,D.retry_after)
+					if H:print(f"[OPTIMIZE] Đã đạt giới hạn tốc độ cho {A.__name__}, thử lại sau {M} giây (lần thử {G}/{X})")
+					time.sleep(M);continue
+				else:raise
+			g=time.time();Y=_F;Z=_D
+			try:h=A(*d,**e);Y=_E;return h
+			except Exception as D:Z=str(D);raise
+			finally:
+				i=time.time()-g
+				try:
+					from vnai.beam.metrics import collector as L;L.record(O,{O:A.__name__,_G:K,'execution_time':i,'success':Y,V:Z,'in_loop':S,'loop_depth':len(B),'content_triggered':R,b:datetime.now().isoformat(),'retry_count':G if G>0 else _D})
+					if R:L.record('ad_opportunity',{O:A.__name__,_G:K,'call_frequency':len(B)/P,'consecutive_loops':E,b:datetime.now().isoformat()})
+				except ImportError:pass
+			break
+	return C
+def rate_limit_status(resource_type=_C):return guardian.get_limit_status(resource_type)

vnai-2.0.2/vnai/flow/__init__.py

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

vnai-2.0.2/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.2/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.2/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