vnai 2.0.7__tar.gz → 2.0.9__tar.gz

{vnai-2.0.7 → vnai-2.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vnai
-Version: 2.0.7
+Version: 2.0.9
 Summary: System optimization and resource management toolkit
 Author-email: Vnstock HQ <support@vnstocks.com>
 License: MIT

{vnai-2.0.7 → vnai-2.0.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vnai"
-version = "2.0.7"
+version = "2.0.9"
 description = "System optimization and resource management toolkit"
 readme = "README.md"
 requires-python = ">=3.7"

vnai-2.0.9/vnai/__init__.py

@@ -0,0 +1,79 @@
+_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
+import vnai.scope.promo
+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__(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():
+	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'):
+	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-2.0.9/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.9/vnai/beam/metrics.py

@@ -0,0 +1,64 @@
+_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:
+	_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;self._last_record_time={}
+	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

vnai-2.0.9/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__(cls):
+		with cls._lock:
+			if cls._instance is None:cls._instance=super(Monitor,cls).__new__(cls);cls._instance._initialize()
+			return cls._instance
+	def _initialize(self):self.health_status=_A;self.last_check=time.time();self.check_interval=300;self.error_count=0;self.warning_count=0;self.status_history=[];self._start_background_check()
+	def _start_background_check(self):
+		def check_health():
+			while True:
+				try:self.check_health()
+				except:pass
+				time.sleep(self.check_interval)
+		thread=threading.Thread(target=check_health,daemon=True);thread.start()
+	def check_health(self):
+		from vnai.beam.metrics import collector;from vnai.beam.quota import guardian;self.last_check=time.time();metrics_summary=collector.get_metrics_summary();has_errors=metrics_summary.get('error',0)>0;resource_usage=guardian.usage();high_usage=resource_usage>80
+		if has_errors and high_usage:self.health_status='critical';self.error_count+=1
+		elif has_errors or high_usage:self.health_status='warning';self.warning_count+=1
+		else:self.health_status=_A
+		self.status_history.append({'timestamp':datetime.now().isoformat(),_B:self.health_status,'metrics':metrics_summary,'resource_usage':resource_usage})
+		if len(self.status_history)>10:self.status_history=self.status_history[-10:]
+		return self.health_status
+	def report(self):
+		if time.time()-self.last_check>self.check_interval:self.check_health()
+		return{_B:self.health_status,'last_check':datetime.fromtimestamp(self.last_check).isoformat(),'error_count':self.error_count,'warning_count':self.warning_count,'history':self.status_history[-3:]}
+	def reset(self):self.health_status=_A;self.error_count=0;self.warning_count=0;self.status_history=[];self.last_check=time.time()
+monitor=Monitor()

vnai-2.0.9/vnai/beam/quota.py

@@ -0,0 +1,105 @@
+_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__(self,resource_type,limit_type=_A,current_usage=_D,limit_value=_D,retry_after=_D):
+		self.resource_type=resource_type;self.limit_type=limit_type;self.current_usage=current_usage;self.limit_value=limit_value;self.retry_after=retry_after;message=f"Bạn đã gửi quá nhiều request tới {resource_type}. "
+		if retry_after:message+=f"Vui lòng thử lại sau {round(retry_after)} giây."
+		else:message+='Vui lòng thêm thời gian chờ giữa các lần gửi request.'
+		super().__init__(message)
+class Guardian:
+	_instance=_D;_lock=threading.Lock()
+	def __new__(cls):
+		with cls._lock:
+			if cls._instance is _D:cls._instance=super(Guardian,cls).__new__(cls);cls._instance._initialize()
+			return cls._instance
+	def _initialize(self):self.resource_limits=defaultdict(lambda:defaultdict(int));self.usage_counters=defaultdict(lambda:defaultdict(list));self.resource_limits[_C]={_A:60,_B:3000};self.resource_limits['TCBS']={_A:60,_B:3000};self.resource_limits['VCI']={_A:60,_B:3000};self.resource_limits['MBK']={_A:600,_B:36000};self.resource_limits['MAS.ext']={_A:600,_B:36000};self.resource_limits['VCI.ext']={_A:600,_B:36000};self.resource_limits['FMK.ext']={_A:600,_B:36000};self.resource_limits['VND.ext']={_A:600,_B:36000};self.resource_limits['CAF.ext']={_A:600,_B:36000};self.resource_limits['SPL.ext']={_A:600,_B:36000};self.resource_limits['VDS.ext']={_A:600,_B:36000};self.resource_limits['FAD.ext']={_A:600,_B:36000}
+	def verify(self,operation_id,resource_type=_C):
+		E='is_exceeded';D='current_usage';C='limit_value';B='limit_type';A='rate_limit';current_time=time.time();limits=self.resource_limits.get(resource_type,self.resource_limits[_C]);minute_cutoff=current_time-60;self.usage_counters[resource_type][_A]=[t for t in self.usage_counters[resource_type][_A]if t>minute_cutoff];minute_usage=len(self.usage_counters[resource_type][_A]);minute_exceeded=minute_usage>=limits[_A]
+		if minute_exceeded:from vnai.beam.metrics import collector;collector.record(A,{_G:resource_type,B:_A,C:limits[_A],D:minute_usage,E:_E},priority='high');raise RateLimitExceeded(resource_type=resource_type,limit_type=_A,current_usage=minute_usage,limit_value=limits[_A],retry_after=60-current_time%60)
+		hour_cutoff=current_time-3600;self.usage_counters[resource_type][_B]=[t for t in self.usage_counters[resource_type][_B]if t>hour_cutoff];hour_usage=len(self.usage_counters[resource_type][_B]);hour_exceeded=hour_usage>=limits[_B];from vnai.beam.metrics import collector;collector.record(A,{_G:resource_type,B:_B if hour_exceeded else _A,C:limits[_B]if hour_exceeded else limits[_A],D:hour_usage if hour_exceeded else minute_usage,E:hour_exceeded})
+		if hour_exceeded:raise RateLimitExceeded(resource_type=resource_type,limit_type=_B,current_usage=hour_usage,limit_value=limits[_B],retry_after=3600-current_time%3600)
+		self.usage_counters[resource_type][_A].append(current_time);self.usage_counters[resource_type][_B].append(current_time);return _E
+	def usage(self,resource_type=_C):current_time=time.time();limits=self.resource_limits.get(resource_type,self.resource_limits[_C]);minute_cutoff=current_time-60;hour_cutoff=current_time-3600;self.usage_counters[resource_type][_A]=[t for t in self.usage_counters[resource_type][_A]if t>minute_cutoff];self.usage_counters[resource_type][_B]=[t for t in self.usage_counters[resource_type][_B]if t>hour_cutoff];minute_usage=len(self.usage_counters[resource_type][_A]);hour_usage=len(self.usage_counters[resource_type][_B]);minute_percentage=minute_usage/limits[_A]*100 if limits[_A]>0 else 0;hour_percentage=hour_usage/limits[_B]*100 if limits[_B]>0 else 0;return max(minute_percentage,hour_percentage)
+	def get_limit_status(self,resource_type=_C):E='reset_in_seconds';D='remaining';C='percentage';B='limit';A='usage';current_time=time.time();limits=self.resource_limits.get(resource_type,self.resource_limits[_C]);minute_cutoff=current_time-60;hour_cutoff=current_time-3600;minute_usage=len([t for t in self.usage_counters[resource_type][_A]if t>minute_cutoff]);hour_usage=len([t for t in self.usage_counters[resource_type][_B]if t>hour_cutoff]);return{_G:resource_type,'minute_limit':{A:minute_usage,B:limits[_A],C:minute_usage/limits[_A]*100 if limits[_A]>0 else 0,D:max(0,limits[_A]-minute_usage),E:60-current_time%60},'hour_limit':{A:hour_usage,B:limits[_B],C:hour_usage/limits[_B]*100 if limits[_B]>0 else 0,D:max(0,limits[_B]-hour_usage),E:3600-current_time%3600}}
+guardian=Guardian()
+class CleanErrorContext:
+	_last_message_time=0;_message_cooldown=5
+	def __enter__(self):return self
+	def __exit__(self,exc_type,exc_val,exc_tb):
+		if exc_type is RateLimitExceeded:
+			current_time=time.time()
+			if current_time-CleanErrorContext._last_message_time>=CleanErrorContext._message_cooldown:print(f"\n⚠️ {str(exc_val)}\n");CleanErrorContext._last_message_time=current_time
+			import sys;sys.exit(f"Rate limit exceeded. {str(exc_val)} 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):
+	if callable(resource_type):func=resource_type;return _create_wrapper(func,_C,loop_threshold,time_window,ad_cooldown,content_trigger_threshold,max_retries,backoff_factor,debug)
+	if loop_threshold<2:raise ValueError(f"loop_threshold must be at least 2, got {loop_threshold}")
+	if time_window<=0:raise ValueError(f"time_window must be positive, got {time_window}")
+	if content_trigger_threshold<1:raise ValueError(f"content_trigger_threshold must be at least 1, got {content_trigger_threshold}")
+	if max_retries<0:raise ValueError(f"max_retries must be non-negative, got {max_retries}")
+	if backoff_factor<=0:raise ValueError(f"backoff_factor must be positive, got {backoff_factor}")
+	def decorator(func):return _create_wrapper(func,resource_type,loop_threshold,time_window,ad_cooldown,content_trigger_threshold,max_retries,backoff_factor,debug)
+	return decorator
+def _create_wrapper(func,resource_type,loop_threshold,time_window,ad_cooldown,content_trigger_threshold,max_retries,backoff_factor,debug):
+	call_history=[];last_ad_time=0;consecutive_loop_detections=0;session_displayed=_F;session_start_time=time.time();session_timeout=1800
+	@functools.wraps(func)
+	def wrapper(*args,**kwargs):
+		E='timestamp';D='environment';C='error';B='function';A='loop';nonlocal last_ad_time,consecutive_loop_detections,session_displayed,session_start_time;current_time=time.time();content_triggered=_F
+		if current_time-session_start_time>session_timeout:session_displayed=_F;session_start_time=current_time
+		retries=0
+		while _E:
+			call_history.append(current_time)
+			while call_history and current_time-call_history[0]>time_window:call_history.pop(0)
+			loop_detected=len(call_history)>=loop_threshold
+			if debug and loop_detected:print(f"[OPTIMIZE] Đã phát hiện vòng lặp cho {func.__name__}: {len(call_history)} lần gọi trong {time_window}s")
+			if loop_detected:
+				consecutive_loop_detections+=1
+				if debug:print(f"[OPTIMIZE] Số lần phát hiện vòng lặp liên tiếp: {consecutive_loop_detections}/{content_trigger_threshold}")
+			else:consecutive_loop_detections=0
+			should_show_content=consecutive_loop_detections>=content_trigger_threshold and current_time-last_ad_time>=ad_cooldown and not session_displayed
+			if should_show_content:
+				last_ad_time=current_time;consecutive_loop_detections=0;content_triggered=_E;session_displayed=_E
+				if debug:print(f"[OPTIMIZE] Đã kích hoạt nội dung cho {func.__name__}")
+				try:
+					from vnai.scope.promo import manager
+					try:from vnai.scope.profile import inspector;environment=inspector.examine().get(D,_D);manager.present_content(environment=environment,context=A)
+					except ImportError:manager.present_content(context=A)
+				except ImportError:print(f"Phát hiện vòng lặp: Hàm '{func.__name__}' đang được gọi trong một vòng lặp")
+				except Exception as e:
+					if debug:print(f"[OPTIMIZE] Lỗi khi hiển thị nội dung: {str(e)}")
+			try:
+				with CleanErrorContext():guardian.verify(func.__name__,resource_type)
+			except RateLimitExceeded as e:
+				from vnai.beam.metrics import collector;collector.record(C,{B:func.__name__,C:str(e),'context':'resource_verification',_G:resource_type,'retry_attempt':retries},priority='high')
+				if not session_displayed:
+					try:
+						from vnai.scope.promo import manager
+						try:from vnai.scope.profile import inspector;environment=inspector.examine().get(D,_D);manager.present_content(environment=environment,context=A);session_displayed=_E;last_ad_time=current_time
+						except ImportError:manager.present_content(context=A);session_displayed=_E;last_ad_time=current_time
+					except Exception:pass
+				if retries<max_retries:
+					wait_time=backoff_factor**retries;retries+=1
+					if hasattr(e,'retry_after')and e.retry_after:wait_time=min(wait_time,e.retry_after)
+					if debug:print(f"[OPTIMIZE] Đã đạt giới hạn tốc độ cho {func.__name__}, thử lại sau {wait_time} giây (lần thử {retries}/{max_retries})")
+					time.sleep(wait_time);continue
+				else:raise
+			start_time=time.time();success=_F;error=_D
+			try:result=func(*args,**kwargs);success=_E;return result
+			except Exception as e:error=str(e);raise
+			finally:
+				execution_time=time.time()-start_time
+				try:
+					from vnai.beam.metrics import collector;collector.record(B,{B:func.__name__,_G:resource_type,'execution_time':execution_time,'success':success,C:error,'in_loop':loop_detected,'loop_depth':len(call_history),'content_triggered':content_triggered,E:datetime.now().isoformat(),'retry_count':retries if retries>0 else _D})
+					if content_triggered:collector.record('ad_opportunity',{B:func.__name__,_G:resource_type,'call_frequency':len(call_history)/time_window,'consecutive_loops':consecutive_loop_detections,E:datetime.now().isoformat()})
+				except ImportError:pass
+			break
+	return wrapper
+def rate_limit_status(resource_type=_C):return guardian.get_limit_status(resource_type)

vnai-2.0.9/vnai/flow/__init__.py

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

vnai-2.0.9/vnai/flow/queue.py

@@ -0,0 +1,55 @@
+_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__(cls):
+		with cls._lock:
+			if cls._instance is _A:cls._instance=super(Buffer,cls).__new__(cls);cls._instance._initialize()
+			return cls._instance
+	def _initialize(self):self.data=[];self.lock=threading.Lock();self.max_size=1000;self.backup_interval=300;self.home_dir=Path.home();self.project_dir=self.home_dir/'.vnstock';self.project_dir.mkdir(exist_ok=_B);self.data_dir=self.project_dir/'data';self.data_dir.mkdir(exist_ok=_B);self.backup_path=self.data_dir/'buffer_backup.json';self._load_from_backup();self._start_backup_thread()
+	def _load_from_backup(self):
+		if self.backup_path.exists():
+			try:
+				with open(self.backup_path,'r')as f:backup_data=json.load(f)
+				with self.lock:self.data=backup_data
+			except:pass
+	def _save_to_backup(self):
+		with self.lock:
+			if not self.data:return
+			try:
+				with open(self.backup_path,'w')as f:json.dump(self.data,f)
+			except:pass
+	def _start_backup_thread(self):
+		def backup_task():
+			while _B:time.sleep(self.backup_interval);self._save_to_backup()
+		backup_thread=threading.Thread(target=backup_task,daemon=_B);backup_thread.start()
+	def add(self,item,category=_A):
+		A='timestamp'
+		with self.lock:
+			if isinstance(item,dict):
+				if A not in item:item[A]=datetime.now().isoformat()
+				if category:item[_C]=category
+			self.data.append(item)
+			if len(self.data)>self.max_size:self.data=self.data[-self.max_size:]
+			if len(self.data)%100==0:self._save_to_backup()
+			return len(self.data)
+	def get(self,count=_A,category=_A):
+		with self.lock:
+			if category:filtered_data=[item for item in self.data if item.get(_C)==category]
+			else:filtered_data=self.data.copy()
+			if count:return filtered_data[:count]
+			else:return filtered_data
+	def clear(self,category=_A):
+		with self.lock:
+			if category:self.data=[item for item in self.data if item.get(_C)!=category]
+			else:self.data=[]
+			self._save_to_backup();return len(self.data)
+	def size(self,category=_A):
+		with self.lock:
+			if category:return len([item for item in self.data if item.get(_C)==category])
+			else:return len(self.data)
+buffer=Buffer()

vnai-2.0.9/vnai/flow/relay.py

@@ -0,0 +1,161 @@
+_U='execution_time'
+_T='manual'
+_S='success'
+_R='is_exceeded'
+_Q='source'
+_P='function'
+_O='last_sync_time'
+_N='sync_interval'
+_M='buffer_size'
+_L='webhook_url'
+_K='value'
+_J='sync_count'
+_I='machine_id'
+_H='data'
+_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__(cls,webhook_url=_F,buffer_size=50,sync_interval=300):
+		with cls._lock:
+			if cls._instance is _F:cls._instance=super(Conduit,cls).__new__(cls);cls._instance._initialize(webhook_url,buffer_size,sync_interval)
+			return cls._instance
+	def _initialize(self,webhook_url,buffer_size,sync_interval):
+		self.webhook_url=webhook_url;self.buffer_size=buffer_size;self.sync_interval=sync_interval;self.buffer={_B:[],_D:[],_C:[]};self.lock=threading.Lock();self.last_sync_time=time.time();self.sync_count=0;self.failed_queue=[];self.home_dir=Path.home();self.project_dir=self.home_dir/'.vnstock';self.project_dir.mkdir(exist_ok=_A);self.data_dir=self.project_dir/_H;self.data_dir.mkdir(exist_ok=_A);self.config_path=self.data_dir/'relay_config.json'
+		try:from vnai.scope.profile import inspector;self.machine_id=inspector.fingerprint()
+		except:self.machine_id=self._generate_fallback_id()
+		self._load_config();self._start_periodic_sync()
+	def _generate_fallback_id(self)->str:
+		try:import platform,hashlib,uuid;system_info=platform.node()+platform.platform()+platform.processor();return hashlib.md5(system_info.encode()).hexdigest()
+		except:import uuid;return str(uuid.uuid4())
+	def _load_config(self):
+		if self.config_path.exists():
+			try:
+				with open(self.config_path,'r')as f:config=json.load(f)
+				if not self.webhook_url and _L in config:self.webhook_url=config[_L]
+				if _M in config:self.buffer_size=config[_M]
+				if _N in config:self.sync_interval=config[_N]
+				if _O in config:self.last_sync_time=config[_O]
+				if _J in config:self.sync_count=config[_J]
+			except:pass
+	def _save_config(self):
+		config={_L:self.webhook_url,_M:self.buffer_size,_N:self.sync_interval,_O:self.last_sync_time,_J:self.sync_count}
+		try:
+			with open(self.config_path,'w')as f:json.dump(config,f)
+		except:pass
+	def _start_periodic_sync(self):
+		def periodic_sync():
+			while _A:time.sleep(self.sync_interval);self.dispatch('periodic')
+		sync_thread=threading.Thread(target=periodic_sync,daemon=_A);sync_thread.start()
+	def add_function_call(self,record):
+		if not isinstance(record,dict):record={_K:str(record)}
+		with self.lock:self.buffer[_B].append(record);self._check_triggers(_B)
+	def add_api_request(self,record):
+		if not isinstance(record,dict):record={_K:str(record)}
+		with self.lock:self.buffer[_D].append(record);self._check_triggers(_D)
+	def add_rate_limit(self,record):
+		if not isinstance(record,dict):record={_K:str(record)}
+		with self.lock:self.buffer[_C].append(record);self._check_triggers(_C)
+	def _check_triggers(self,record_type:str):
+		current_time=time.time();should_trigger=_G;trigger_reason=_F;total_records=sum(len(buffer)for buffer in self.buffer.values())
+		if total_records>=self.buffer_size:should_trigger=_A;trigger_reason='buffer_full'
+		elif record_type==_C and self.buffer[_C]and any(item.get(_R)for item in self.buffer[_C]if isinstance(item,dict)):should_trigger=_A;trigger_reason='rate_limit_exceeded'
+		elif record_type==_B and self.buffer[_B]and any(not item.get(_S)for item in self.buffer[_B]if isinstance(item,dict)):should_trigger=_A;trigger_reason='function_error'
+		else:
+			time_factor=min(1.,(current_time-self.last_sync_time)/(self.sync_interval/2))
+			if random.random()<.05*time_factor:should_trigger=_A;trigger_reason='random_time_weighted'
+		if should_trigger:threading.Thread(target=self.dispatch,args=(trigger_reason,),daemon=_A).start()
+	def queue(self,package,priority=_F):
+		H='packages';G='commercial';F='system_info';E='rate_limit';D='free';C='system';B='type';A='segment'
+		try:from vnai.scope.promo import ContentManager;is_paid=ContentManager().is_paid_user;segment_val='paid'if is_paid else D
+		except Exception:segment_val=D
+		def ensure_segment(d):
+			if not isinstance(d,dict):return d
+			d=dict(d)
+			if A not in d:d[A]=segment_val
+			return d
+		if isinstance(package,dict)and A not in package:package[A]=segment_val
+		if isinstance(package,dict)and isinstance(package.get(_H),dict):
+			if A not in package[_H]:package[_H][A]=segment_val
+		if not package:return _G
+		if not isinstance(package,dict):self.add_function_call(ensure_segment({'message':str(package)}));return _A
+		if _E not in package:package[_E]=datetime.now().isoformat()
+		if B in package:
+			package_type=package[B];data=package.get(_H,{})
+			if isinstance(data,dict)and C in data:
+				machine_id=data[C].get(_I);data.pop(C)
+				if machine_id:data[_I]=machine_id
+			if package_type==_P:self.add_function_call(ensure_segment(data))
+			elif package_type=='api_request':self.add_api_request(ensure_segment(data))
+			elif package_type==E:self.add_rate_limit(ensure_segment(data))
+			elif package_type==F:self.add_function_call({B:F,G:data.get(G),H:data.get(H),_E:package.get(_E)})
+			elif package_type=='metrics':
+				metrics_data=data
+				for(metric_type,metrics_list)in metrics_data.items():
+					if isinstance(metrics_list,list):
+						if metric_type==_P:
+							for item in metrics_list:self.add_function_call(ensure_segment(item))
+						elif metric_type==E:
+							for item in metrics_list:self.add_rate_limit(ensure_segment(item))
+						elif metric_type=='request':
+							for item in metrics_list:self.add_api_request(ensure_segment(item))
+			elif isinstance(data,dict)and data is not package:self.add_function_call(ensure_segment(data))
+			else:self.add_function_call(ensure_segment(package))
+		else:self.add_function_call(ensure_segment(package))
+		if priority=='high':self.dispatch('high_priority')
+		return _A
+	def dispatch(self,reason=_T):
+		if not self.webhook_url:return _G
+		with self.lock:
+			if all(len(records)==0 for records in self.buffer.values()):return _G
+			data_to_send={_B:self.buffer[_B].copy(),_D:self.buffer[_D].copy(),_C:self.buffer[_C].copy()};self.buffer={_B:[],_D:[],_C:[]};self.last_sync_time=time.time();self.sync_count+=1;self._save_config()
+		try:from vnai.scope.profile import inspector;environment_info=inspector.examine();machine_id=environment_info.get(_I,self.machine_id)
+		except:environment_info={_I:self.machine_id};machine_id=self.machine_id
+		payload={'analytics_data':data_to_send,'metadata':{_E:datetime.now().isoformat(),_I:machine_id,_J:self.sync_count,'trigger_reason':reason,'environment':environment_info,'data_counts':{_B:len(data_to_send[_B]),_D:len(data_to_send[_D]),_C:len(data_to_send[_C])}}};success=self._send_data(payload)
+		if not success:
+			with self.lock:
+				self.failed_queue.append(payload)
+				if len(self.failed_queue)>10:self.failed_queue=self.failed_queue[-10:]
+		return success
+	def _send_data(self,payload):
+		if not self.webhook_url:return _G
+		try:response=requests.post(self.webhook_url,json=payload,timeout=5);return response.status_code==200
+		except:return _G
+	def retry_failed(self):
+		if not self.failed_queue:return 0
+		with self.lock:to_retry=self.failed_queue.copy();self.failed_queue=[]
+		success_count=0
+		for payload in to_retry:
+			if self._send_data(payload):success_count+=1
+			else:
+				with self.lock:self.failed_queue.append(payload)
+		return success_count
+	def configure(self,webhook_url):
+		with self.lock:self.webhook_url=webhook_url;self._save_config();return _A
+conduit=Conduit()
+def track_function_call(function_name,source,execution_time,success=_A,error=_F,args=_F):
+	record={_P:function_name,_Q:source,_U:execution_time,_E:datetime.now().isoformat(),_S:success}
+	if error:record['error']=error
+	if args:
+		sanitized_args={}
+		if isinstance(args,dict):
+			for(key,value)in args.items():
+				if isinstance(value,(str,int,float,bool)):sanitized_args[key]=value
+				else:sanitized_args[key]=str(type(value))
+		else:sanitized_args={_K:str(args)}
+		record['args']=sanitized_args
+	conduit.add_function_call(record)
+def track_rate_limit(source,limit_type,limit_value,current_usage,is_exceeded):record={_Q:source,'limit_type':limit_type,'limit_value':limit_value,'current_usage':current_usage,_R:is_exceeded,_E:datetime.now().isoformat(),'usage_percentage':current_usage/limit_value*100 if limit_value>0 else 0};conduit.add_rate_limit(record)
+def track_api_request(endpoint,source,method,status_code,execution_time,request_size=0,response_size=0):record={'endpoint':endpoint,_Q:source,'method':method,'status_code':status_code,_U:execution_time,_E:datetime.now().isoformat(),'request_size':request_size,'response_size':response_size};conduit.add_api_request(record)
+def configure(webhook_url):return conduit.configure(webhook_url)
+def sync_now():return conduit.dispatch(_T)
+def retry_failed():return conduit.retry_failed()

vnai-2.0.9/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