vnai 0.1.4__py3-none-any.whl → 2.0__py3-none-any.whl

vnai/__init__.py

@@ -1,319 +1,79 @@
-import os
-import pathlib
-import importlib.metadata
-import requests
-import psutil
-import platform
-import uuid
-import sys
-import socket
-import json
-import base64
-from cryptography.fernet import Fernet
-
-TC_VAR = "ACCEPT_TC"
-TC_VAL = "tôi đồng ý"
-
-lmt = os.path.sep
-HOME_DIR = pathlib.Path.home()
-PROJECT_DIR = HOME_DIR / ".vnstock"
-ID_DIR = PROJECT_DIR / 'id'
-TG = b'gAAAAABmOPXPmFYXs94INEralMxhR38geFp91TZRLP29C41OoO0k7D7QiXIR2nWl5PCEoQCKECZw8b-Xeek3oqT6LcpcpJsAPyOGOBTX5cw_r5Mv0o8SBLa53jOeuVAwCAhId_BpMtOO'
-TC_PATH = ID_DIR / "terms_agreement.txt"
-
-TERMS_AND_CONDITIONS = """
-    Khi tiếp tục sử dụng Vnstock3, 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 Vnstock3.\n
-    Chi tiết:\n
-    - Giấy phép sử dụng phần mềm: https://vnstocks.com/docs/tai-lieu/giay-phep-su-dung
-    - Chính sách quyền riêng tư: https://vnstocks.com/docs/tai-lieu/chinh-sach-quyen-rieng-tu
-    """
-
-class VnstockInitializer:
-    def __init__(self, target, tc=TERMS_AND_CONDITIONS):
-        self.terms_and_conditions = tc
-        self.home_dir = HOME_DIR
-        self.project_dir = PROJECT_DIR
-        self.id_dir = ID_DIR
-        self.terms_file_path = TC_PATH
-        self.env_config = ID_DIR / "environment.json"
-        self.RH = 'asejruyy^&%$#W2vX>NfwrevDRESWR'
-        self.LH = 'YMAnhuytr%$59u90y7j-mjhgvyFTfbiuUYH'
-
-        # Create the project directory if it doesn't exist
-        self.project_dir.mkdir(exist_ok=True)
-        self.id_dir.mkdir(exist_ok=True)
-        self.target = target
-
-        kb = (str(self.project_dir).split(lmt)[-1] + str(self.id_dir).split(lmt)[-1] + str(self.terms_file_path).split(lmt)[-1]).ljust(32)[:32].encode('utf-8')
-        kb64 = base64.urlsafe_b64encode(kb)
-        self.cph = Fernet(kb64)
-
-    def system_info(self):
-        """
-        Gathers information about the environment and system.
-        """
-        # Generate UUID
-        machine_id = str(uuid.uuid4())
-
-        # Environment (modify to detect your specific frameworks)
-        try:
-            from IPython import get_ipython
-            if 'IPKernelApp' not in get_ipython().config:  # Check if not in IPython kernel
-                if sys.stdout.isatty():
-                    environment = "Terminal"
-                else:
-                    environment = "Other"  # Non-interactive environment (e.g., script executed from an IDE)
-            else:
-                environment = "Jupyter"
-        except (ImportError, AttributeError):
-            # Fallback if IPython isn't installed or other checks fail
-            if sys.stdout.isatty():
-                environment = "Terminal"
-            else:
-                environment = "Other"
-
-        try:
-            if 'google.colab' in sys.modules:
-                hosting_service = "Google Colab"
-            elif 'CODESPACE_NAME' in os.environ:
-                hosting_service = "Github Codespace"
-            elif 'GITPOD_WORKSPACE_CLUSTER_HOST' in os.environ:
-                hosting_service = "Gitpod"
-            elif 'REPLIT_USER' in os.environ:
-                hosting_service = "Replit"
-            elif 'KAGGLE_CONTAINER_NAME' in os.environ:
-                hosting_service = "Kaggle"
-            elif '.hf.space' in os.environ['SPACE_HOST']:
-                hosting_service = "Hugging Face Spaces"
-        except:
-            hosting_service = "Local or Unknown"
-
-        # System information
-        os_info = platform.uname()
-
-        # CPU information
-        cpu_arch = platform.processor()  
-        cpu_logical_cores = psutil.cpu_count(logical=True)
-        cpu_cores = psutil.cpu_count(logical=False)
-
-        # Memory information
-        ram_total = psutil.virtual_memory().total / (1024**3)  # GB
-        ram_available = psutil.virtual_memory().available / (1024**3)  # GB
-
-        try:
-            hostname = socket.gethostname()
-            IPAddr = socket.gethostbyname(hostname)
-        except socket.gaierror:
-            hostname = "unknown"
-            IPAddr = "127.0.0.1"  # Fallback to localhost
-
-        mac = ':'.join(['{:02x}'.format((uuid.getnode() >> elements) & 0xff) for elements in range(0, 2 * 6, 2)])
-
-        # Combine information into a dictionary
-        info = {
-            "uuid": machine_id,
-            "environment": environment,
-            "hosting_service": hosting_service,
-            "python_version": platform.python_version(),
-            "os_name": os_info.system,
-            "os_version": os_info.version,
-            "machine": os_info.machine,
-            "cpu_model": cpu_arch,
-            "cpu_cores": cpu_cores,
-            "cpu_logical_cores": cpu_logical_cores,
-            "ram_total": round(ram_total, 1),
-            "ram_available": round(ram_available, 1),
-            "local_ip": IPAddr,
-            "mac_address": mac,
-        }
-
-        return info
-
-    def show_terms_and_conditions(self):
-        """
-        Displays terms and conditions and asks for acceptance.
-        """
-        print(self.terms_and_conditions)
-        
-        # check if os.environ[TC_VAR] exist and equal to tôi đồng ý
-        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
-
-        from datetime import datetime
-        # get now time in string
-        now = datetime.now()
-        HARDWARE = self.system_info()
-        # VERSION = pkg_resources.get_distribution('vnstock').version
-        
-        VERSION = None
-        try:
-            VERSION = importlib.metadata.version('vnstock')
-        except importlib.metadata.PackageNotFoundError:
-            # print("Package 'vnstock' not found")
-            pass
-
-        # parse HARDWARE to string to store in the file
-        signed_aggreement = f"MÔ TẢ:\nNgười dùng có mã nhận dạng {HARDWARE['uuid']} đã chấp nhận điều khoản & điều kiện sử dụng Vnstock lúc {now}\n---\n\nTHÔNG TIN THIẾT BỊ: {str(HARDWARE)}\n\nĐính kèm bản sao nội dung bạn đã đọc, hiểu rõ và đồng ý dưới đây:\n{self.terms_and_conditions}"
-        
-        # Store the acceptance
-        with open(self.terms_file_path, "w", encoding="utf-8") as f:
-            f.write(signed_aggreement)
-        return True
-
-    def log_analytics_data(self):
-        """
-        Sends analytics data to a webhook.
-        """
-        HARDWARE = self.system_info()
-        EP = 'gAAAAABmOPNX4DJAsImlkzvtcyezBxr4UcK_HpCOgz-GOF9yBDP99tWNFYM_ZjeC22kNqmX3urZa467BC1D2fPLJrUkp6rQizYEMK4m196ZlOzUhwCbfjdvURXesL3LC7DofOgwWjNyltPQ8AnPyB4YUMnnAwnFooQ=='
-        TGE = self.cph.decrypt(self.target).decode('utf-8')
-        WH = f"{self.cph.decrypt(((self.RH+EP+self.RH)[30:-30]).encode()).decode('utf-8')}{TGE}"
-
-        data = {
-            "systems": HARDWARE,
-            "accepted_agreement": True,
-            "installed_packages": self.packages_installed(),
-        }
-
-        # save data to a json file in id folder
-        with open(self.env_config, "w", encoding="utf-8") as f:
-            f.write(json.dumps(data, indent=4))
-
-        try:
-            response = requests.post(WH, json=data)
-        except:
-            raise SystemExit("Không thể gửi dữ liệu phân tích. Vui lòng kiểm tra kết nối mạng và thử lại sau.")
-
-    def check_terms_accepted(self):
-        """
-        Checks if terms and conditions are accepted.
-        """
-        if not self.env_config.exists() or not self.terms_file_path.exists():
-            # If not, ask for acceptance
-            accepted = self.show_terms_and_conditions()
-            if not accepted:
-                raise SystemExit("Điều khoản và điều kiện không được chấp nhận. Không thể tiếp tục.")
-            else:
-                self.log_analytics_data()
-
-    def packages_installed(self):
-        """
-        Checks installed packages and returns a dictionary.
-        """
-        # Define package mapping
-        package_mapping = {
-                    "vnstock_family": [
-                        "vnstock",
-                        "vnstock3",
-                        "vnstock_ezchart",
-                        "vnstock_data_pro"
-                        "vnstock_market_data_pipeline",
-                        "vnstock_ta",
-                        "vnii",
-                        "vnai",
-                    ],
-                    "analytics": [
-                        "openbb",
-                        "pandas_ta"
-                    ],
-                    "static_charts": [
-                        "matplotlib",
-                        "seaborn",
-                        "altair"
-                    ],
-                    "dashboard": [
-                        "streamlit",
-                        "voila",
-                        "panel",
-                        "shiny",
-                        "dash",
-                    ],
-                    "interactive_charts": [
-                        "mplfinance",
-                        "plotly",
-                        "plotline",
-                        "bokeh",
-                        "pyecharts",
-                        "highcharts-core",
-                        "highcharts-stock",
-                        "mplchart",
-                    ],
-                    "datafeed": [
-                        "yfinance",
-                        "alpha_vantage",
-                        "pandas-datareader",
-                        "investpy",
-                    ],
-                    "official_api": [
-                        "ssi-fc-data",
-                        "ssi-fctrading"
-                    ],
-                    "risk_return": [
-                        "pyfolio",
-                        "empyrical",
-                        "quantstats",
-                        "financetoolkit",
-                    ],
-                    "machine_learning": [
-                        "scipy",
-                        "sklearn",
-                        "statsmodels",
-                        "pytorch",
-                        "tensorflow",
-                        "keras",
-                        "xgboost"
-                    ],
-                    "indicators": [
-                        "stochastic",
-                        "talib",
-                        "tqdm",
-                        "finta",
-                        "financetoolkit",
-                        "tulipindicators"
-                    ],
-                    "backtesting": [
-                        "vectorbt",
-                        "backtesting",
-                        "bt",
-                        "zipline",
-                        "pyalgotrade",
-                        "backtrader",
-                        "pybacktest",
-                        "fastquant",
-                        "lean",
-                        "ta",
-                        "finmarketpy",
-                        "qstrader",
-                    ],
-                    "server": [
-                        "fastapi",
-                        "flask",
-                        "uvicorn",
-                        "gunicorn"
-                    ],
-                    "framework": [
-                        "lightgbm",
-                        "catboost",
-                        "django",
-                    ]
-                }
-
-        installed_packages = {}
-
-        for category, packages in package_mapping.items():
-            installed_packages[category] = []
-            for pkg in packages:
-                try:
-                    version = importlib.metadata.version(pkg)
-                    installed_packages[category].append((pkg, version))
-                except importlib.metadata.PackageNotFoundError:
-                    pass
-
-        return installed_packages
-
-def tc_init():
-    vnstock_initializer = VnstockInitializer(TG)
-    vnstock_initializer.check_terms_accepted()
+_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/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/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/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/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/flow/__init__.py

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

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

vnai/scope/profile.py

@@ -0,0 +1,223 @@
+_W='type_confidence'
+_V='detected_type'
+_U='commercial_app'
+_T='version'
+_S='django'
+_R='fastapi'
+_Q='streamlit'
+_P='indicators'
+_O='commercial_indicators'
+_N='likely_commercial'
+_M='KAGGLE_KERNEL_RUN_TYPE'
+_L='machine_id'
+_K='domain'
+_J='.git'
+_I='backtesting'
+_H='commercial_probability'
+_G='timestamp'
+_F='business_hours_usage'
+_E='google.colab'
+_D='unknown'
+_C=False
+_B=None
+_A=True
+import os,sys,platform,uuid,hashlib,psutil,threading,time,importlib.metadata
+from datetime import datetime
+import subprocess
+from pathlib import Path
+class Inspector:
+	_instance=_B;_lock=_B
+	def __new__(cls):
+		import threading
+		if cls._lock is _B:cls._lock=threading.Lock()
+		with cls._lock:
+			if cls._instance is _B:cls._instance=super(Inspector,cls).__new__(cls);cls._instance._initialize()
+			return cls._instance
+	def _initialize(self):self.cache={};self.cache_ttl=3600;self.last_examination=0;self.machine_id=_B;self._colab_auth_triggered=_C;self.home_dir=Path.home();self.project_dir=self.home_dir/'.vnstock';self.project_dir.mkdir(exist_ok=_A);self.id_dir=self.project_dir/'id';self.id_dir.mkdir(exist_ok=_A);self.machine_id_path=self.id_dir/'machine_id.txt';self.examine()
+	def examine(self,force_refresh=_C):
+		D='script';C='terminal';B='hosting_service';A='environment';current_time=time.time()
+		if not force_refresh and current_time-self.last_examination<self.cache_ttl:return self.cache
+		info={_G:datetime.now().isoformat(),'python_version':platform.python_version(),'os_name':platform.system(),'platform':platform.platform()};info[_L]=self.fingerprint()
+		try:
+			import importlib.util;ipython_spec=importlib.util.find_spec('IPython')
+			if ipython_spec:
+				from IPython import get_ipython;ipython=get_ipython()
+				if ipython is not _B:
+					info[A]='jupyter'
+					if _E in sys.modules:info[B]='colab'
+					elif _M in os.environ:info[B]='kaggle'
+					else:info[B]='local_jupyter'
+				elif sys.stdout.isatty():info[A]=C
+				else:info[A]=D
+			elif sys.stdout.isatty():info[A]=C
+			else:info[A]=D
+		except:info[A]=_D
+		try:info['cpu_count']=os.cpu_count();info['memory_gb']=round(psutil.virtual_memory().total/1024**3,1)
+		except:pass
+		is_colab=_E in sys.modules
+		if is_colab:info['is_colab']=_A;self.detect_colab_with_delayed_auth()
+		try:info['commercial_usage']=self.enhanced_commercial_detection();info['project_context']=self.analyze_project_structure();info['git_info']=self.analyze_git_info();info['usage_pattern']=self.detect_usage_pattern();info['dependencies']=self.analyze_dependencies()
+		except Exception as e:info['detection_error']=str(e)
+		self.cache=info;self.last_examination=current_time;return info
+	def fingerprint(self):
+		if self.machine_id:return self.machine_id
+		if self.machine_id_path.exists():
+			try:
+				with open(self.machine_id_path,'r')as f:self.machine_id=f.read().strip();return self.machine_id
+			except:pass
+		is_colab=self.detect_colab_with_delayed_auth()
+		try:system_info=platform.node()+platform.platform()+platform.machine();self.machine_id=hashlib.md5(system_info.encode()).hexdigest()
+		except:self.machine_id=str(uuid.uuid4())
+		try:
+			with open(self.machine_id_path,'w')as f:f.write(self.machine_id)
+		except:pass
+		return self.machine_id
+	def detect_hosting(self):
+		A='Google Colab';hosting_markers={'COLAB_GPU':A,_M:'Kaggle','BINDER_SERVICE_HOST':'Binder','CODESPACE_NAME':'GitHub Codespaces','STREAMLIT_SERVER_HEADLESS':'Streamlit Cloud','CLOUD_SHELL':'Cloud Shell'}
+		for(env_var,host_name)in hosting_markers.items():
+			if env_var in os.environ:return host_name
+		if _E in sys.modules:return A
+		return'local'
+	def detect_commercial_usage(self):
+		F='client';E='enterprise';D='dir_patterns';C='env_vars';B='file_patterns';A='env_domains';commercial_indicators={A:['.com','.io','.co',E,'corp','inc'],B:['invoice','payment','customer',F,'product','sale'],C:['COMPANY','BUSINESS','ENTERPRISE','CORPORATE'],D:['company','business',E,'corporate',F]};env_values=' '.join(os.environ.values()).lower();domain_match=any(domain in env_values for domain in commercial_indicators[A]);env_var_match=any(var in os.environ for var in commercial_indicators[C]);current_dir=os.getcwd().lower();dir_match=any(pattern in current_dir for pattern in commercial_indicators[D])
+		try:files=[f.lower()for f in os.listdir()if os.path.isfile(f)];file_match=any(any(pattern in f for pattern in commercial_indicators[B])for f in files)
+		except:file_match=_C
+		indicators=[domain_match,env_var_match,dir_match,file_match];commercial_probability=sum(indicators)/len(indicators);return{_N:commercial_probability>.3,_H:commercial_probability,_O:{'domain_match':domain_match,'env_var_match':env_var_match,'dir_match':dir_match,'file_match':file_match}}
+	def scan_packages(self):
+		A='financetoolkit';package_groups={'vnstock_family':['vnstock','vnstock3','vnstock_ezchart','vnstock_data_pro','vnstock_market_data_pipeline','vnstock_ta','vnii','vnai'],'analytics':['openbb','pandas_ta'],'static_charts':['matplotlib','seaborn','altair'],'dashboard':[_Q,'voila','panel','shiny','dash'],'interactive_charts':['mplfinance','plotly','plotline','bokeh','pyecharts','highcharts-core','highcharts-stock','mplchart'],'datafeed':['yfinance','alpha_vantage','pandas-datareader','investpy'],'official_api':['ssi-fc-data','ssi-fctrading'],'risk_return':['pyfolio','empyrical','quantstats',A],'machine_learning':['scipy','sklearn','statsmodels','pytorch','tensorflow','keras','xgboost'],_P:['stochastic','talib','tqdm','finta',A,'tulipindicators'],_I:['vectorbt',_I,'bt','zipline','pyalgotrade','backtrader','pybacktest','fastquant','lean','ta','finmarketpy','qstrader'],'server':[_R,'flask','uvicorn','gunicorn'],'framework':['lightgbm','catboost',_S]};installed={}
+		for(category,packages)in package_groups.items():
+			installed[category]=[]
+			for pkg in packages:
+				try:version=importlib.metadata.version(pkg);installed[category].append({'name':pkg,_T:version})
+				except:pass
+		return installed
+	def setup_vnstock_environment(self):
+		env_file=self.id_dir/'environment.json';env_data={'accepted_agreement':_A,_G:datetime.now().isoformat(),_L:self.fingerprint()}
+		try:
+			with open(env_file,'w')as f:import json;json.dump(env_data,f)
+			return _A
+		except Exception as e:print(f"Failed to set up vnstock environment: {e}");return _C
+	def detect_colab_with_delayed_auth(self,immediate=_C):
+		is_colab=_E in sys.modules
+		if is_colab and not self._colab_auth_triggered:
+			if immediate:
+				self._colab_auth_triggered=_A;user_id=self.get_or_create_user_id()
+				if user_id and user_id!=self.machine_id:
+					self.machine_id=user_id
+					try:
+						with open(self.machine_id_path,'w')as f:f.write(user_id)
+					except:pass
+			else:
+				def delayed_auth():
+					time.sleep(300);user_id=self.get_or_create_user_id()
+					if user_id and user_id!=self.machine_id:
+						self.machine_id=user_id
+						try:
+							with open(self.machine_id_path,'w')as f:f.write(user_id)
+						except:pass
+				thread=threading.Thread(target=delayed_auth,daemon=_A);thread.start()
+		return is_colab
+	def get_or_create_user_id(self):
+		if self._colab_auth_triggered:return self.machine_id
+		try:
+			from google.colab import drive;print('\n📋 Authenticating to save your settings. This helps maintain your preferences across sessions.');print('This is a one-time setup for better experience with vnstock.\n');self._colab_auth_triggered=_A;drive.mount('/content/drive');id_path='/content/drive/MyDrive/.vnstock/user_id.txt'
+			if os.path.exists(id_path):
+				with open(id_path,'r')as f:return f.read().strip()
+			else:
+				user_id=str(uuid.uuid4());os.makedirs(os.path.dirname(id_path),exist_ok=_A)
+				with open(id_path,'w')as f:f.write(user_id)
+				return user_id
+		except Exception as e:return self.machine_id
+	def analyze_project_structure(self):
+		E='root_dirs';D='manage.py';C='wsgi.py';B='data_science';A='app.py';current_dir=os.getcwd();project_indicators={_U:['app','services','products','customers','billing'],'financial_tool':['portfolio',_I,'trading','strategy'],B:['models','notebooks','datasets','visualization'],'educational':['examples','lectures','assignments','slides']};project_type={}
+		for(category,markers)in project_indicators.items():
+			match_count=0
+			for marker in markers:
+				if os.path.exists(os.path.join(current_dir,marker)):match_count+=1
+			if len(markers)>0:project_type[category]=match_count/len(markers)
+		try:
+			root_files=[f for f in os.listdir(current_dir)if os.path.isfile(os.path.join(current_dir,f))];root_dirs=[d for d in os.listdir(current_dir)if os.path.isdir(os.path.join(current_dir,d))];file_markers={'python_project':['setup.py','pyproject.toml','requirements.txt'],B:['notebook.ipynb','.ipynb_checkpoints'],'web_app':[A,C,D,'server.py'],'finance_app':['portfolio.py','trading.py','backtest.py']};file_project_type=_D
+			for(ptype,markers)in file_markers.items():
+				if any(marker in root_files for marker in markers):file_project_type=ptype;break
+			frameworks=[];framework_markers={_S:[D,'settings.py'],'flask':[A,C],_Q:['streamlit_app.py',A],_R:['main.py',A]}
+			for(framework,markers)in framework_markers.items():
+				if any(marker in root_files for marker in markers):frameworks.append(framework)
+		except Exception as e:root_files=[];root_dirs=[];file_project_type=_D;frameworks=[]
+		return{'project_dir':current_dir,_V:max(project_type.items(),key=lambda x:x[1])[0]if project_type else _D,'file_type':file_project_type,'is_git_repo':_J in(root_dirs if E in locals()else[]),'frameworks':frameworks,'file_count':len(root_files)if'root_files'in locals()else 0,'directory_count':len(root_dirs)if E in locals()else 0,_W:project_type}
+	def analyze_git_info(self):
+		I='license_type';H='has_license';G='repo_path';F='rev-parse';E='/';D='has_git';C=':';B='git';A='@'
+		try:
+			result=subprocess.run([B,F,'--is-inside-work-tree'],capture_output=_A,text=_A)
+			if result.returncode!=0:return{D:_C}
+			repo_root=subprocess.run([B,F,'--show-toplevel'],capture_output=_A,text=_A);repo_path=repo_root.stdout.strip()if repo_root.stdout else _B;repo_name=os.path.basename(repo_path)if repo_path else _B;has_license=_C;license_type=_D
+			if repo_path:
+				license_files=[os.path.join(repo_path,'LICENSE'),os.path.join(repo_path,'LICENSE.txt'),os.path.join(repo_path,'LICENSE.md')]
+				for license_file in license_files:
+					if os.path.exists(license_file):
+						has_license=_A
+						try:
+							with open(license_file,'r')as f:
+								content=f.read().lower()
+								if'mit license'in content:license_type='MIT'
+								elif'apache license'in content:license_type='Apache'
+								elif'gnu general public'in content:license_type='GPL'
+								elif'bsd 'in content:license_type='BSD'
+						except:pass
+						break
+			remote=subprocess.run([B,'config','--get','remote.origin.url'],capture_output=_A,text=_A);remote_url=remote.stdout.strip()if remote.stdout else _B
+			if remote_url:
+				remote_url=remote_url.strip();domain=_B
+				if remote_url:
+					if remote_url.startswith('git@')or A in remote_url and C in remote_url.split(A)[1]:domain=remote_url.split(A)[1].split(C)[0]
+					elif remote_url.startswith('http'):
+						url_parts=remote_url.split('//')
+						if len(url_parts)>1:
+							auth_and_domain=url_parts[1].split(E,1)[0]
+							if A in auth_and_domain:domain=auth_and_domain.split(A)[-1]
+							else:domain=auth_and_domain
+					else:
+						import re;domain_match=re.search('@([^:/]+)|https?://(?:[^@/]+@)?([^/]+)',remote_url)
+						if domain_match:domain=domain_match.group(1)or domain_match.group(2)
+				owner=_B;repo_name=_B
+				if domain:
+					if'github'in domain:
+						if C in remote_url and A in remote_url:
+							parts=remote_url.split(C)[-1].split(E)
+							if len(parts)>=2:owner=parts[0];repo_name=parts[1].replace(_J,'')
+						else:
+							url_parts=remote_url.split('//')
+							if len(url_parts)>1:
+								path_parts=url_parts[1].split(E)
+								if len(path_parts)>=3:
+									domain_part=path_parts[0]
+									if A in domain_part:owner_index=1
+									else:owner_index=1
+									if len(path_parts)>owner_index:owner=path_parts[owner_index]
+									if len(path_parts)>owner_index+1:repo_name=path_parts[owner_index+1].replace(_J,'')
+				commit_count=subprocess.run([B,'rev-list','--count','HEAD'],capture_output=_A,text=_A);branch_count=subprocess.run([B,'branch','--list'],capture_output=_A,text=_A);branch_count=len(branch_count.stdout.strip().split('\n'))if branch_count.stdout else 0;return{_K:domain,'owner':owner,'commit_count':int(commit_count.stdout.strip())if commit_count.stdout else 0,'branch_count':branch_count,D:_A,G:repo_path if G in locals()else _B,'repo_name':repo_name,H:has_license if H in locals()else _C,I:license_type if I in locals()else _D}
+		except Exception as e:pass
+		return{D:_C}
+	def detect_usage_pattern(self):current_time=datetime.now();is_weekday=current_time.weekday()<5;hour=current_time.hour;is_business_hours=9<=hour<=18;return{_F:is_weekday and is_business_hours,'weekday':is_weekday,'hour':hour,_G:current_time.isoformat()}
+	def enhanced_commercial_detection(self):
+		basic=self.detect_commercial_usage()
+		try:
+			project_files=os.listdir(os.getcwd());commercial_frameworks=['django-oscar','opencart','magento','saleor','odoo','shopify','woocommerce'];framework_match=_C
+			for framework in commercial_frameworks:
+				if any(framework in f for f in project_files):framework_match=_A;break
+			db_files=[f for f in project_files if'database'in f.lower()or'db_config'in f.lower()or f.endswith('.db')];has_database=len(db_files)>0
+		except:framework_match=_C;has_database=_C
+		domain_check=self.analyze_git_info();domain_is_commercial=_C
+		if domain_check and domain_check.get(_K):commercial_tlds=['.com','.io','.co','.org','.net'];domain_is_commercial=any(tld in domain_check[_K]for tld in commercial_tlds)
+		project_structure=self.analyze_project_structure();indicators=[basic[_H],framework_match,has_database,domain_is_commercial,project_structure.get(_W,{}).get(_U,0),self.detect_usage_pattern()[_F]];indicators=[i for i in indicators if i is not _B]
+		if indicators:score=sum(1. if isinstance(i,bool)and i else i if isinstance(i,(int,float))else 0 for i in indicators)/len(indicators)
+		else:score=0
+		return{_H:score,_N:score>.4,_P:{'basic_indicators':basic[_O],'framework_match':framework_match,'has_database':has_database,'domain_is_commercial':domain_is_commercial,'project_structure':project_structure.get(_V),_F:self.detect_usage_pattern()[_F]}}
+	def analyze_dependencies(self):
+		A='has_commercial_deps'
+		try:
+			import pkg_resources;enterprise_packages=['snowflake-connector-python','databricks','azure','aws','google-cloud','stripe','atlassian','salesforce','bigquery','tableau','sap'];commercial_deps=[]
+			for pkg in pkg_resources.working_set:
+				if any(ent in pkg.key for ent in enterprise_packages):commercial_deps.append({'name':pkg.key,_T:pkg.version})
+			return{A:len(commercial_deps)>0,'commercial_deps_count':len(commercial_deps),'commercial_deps':commercial_deps}
+		except:return{A:_C}
+inspector=Inspector()

vnai/scope/promo.py

@@ -0,0 +1,56 @@
+_A=None
+import requests
+from datetime import datetime
+import random,threading,time
+class ContentManager:
+	_instance=_A;_lock=threading.Lock()
+	def __new__(A):
+		with A._lock:
+			if A._instance is _A:A._instance=super(ContentManager,A).__new__(A);A._instance._initialize()
+			return A._instance
+	def _initialize(A):A.last_display=0;A.display_interval=86400;A.content_url='https://vnstocks.com/files/package_ads.html';A.target_url='https://vnstocks.com/lp-khoa-hoc-python-chung-khoan';A.image_url='https://course.learn-anything.vn/wp-content/uploads/2025/03/cta-python-chung-khoan-k10-simple.jpg';A._start_periodic_display()
+	def _start_periodic_display(A):
+		def B():
+			while True:
+				B=random.randint(7200,21600);time.sleep(B);C=time.time()
+				if C-A.last_display>=A.display_interval:A.present_content()
+		C=threading.Thread(target=B,daemon=True);C.start()
+	def fetch_remote_content(B):
+		try:
+			A=requests.get(B.content_url,timeout=3)
+			if A.status_code==200:return A.text
+			return
+		except:return
+	def present_content(A,environment=_A):
+		B=environment;A.last_display=time.time()
+		if B is _A:from vnai.scope.profile import inspector as F;B=F.examine().get('environment','unknown')
+		D=A.fetch_remote_content();G=f'''
+        <a href="{A.target_url}">
+            <img src="{A.image_url}" 
+            alt="Khóa học Python Chứng khoán" style="max-width: 100%; border-radius: 4px;">
+        </a>
+        ''';H=f"[![Khóa học Python Chứng khoán]({A.image_url})]({A.target_url})";I=f"""
+        ╔══════════════════════════════════════════════════════════╗
+        ║                                                          ║
+        ║  🚀 Phân tích dữ liệu & tạo bot chứng khoán K10          ║
+        ║                                                          ║
+        ║  ✓ Khai giảng khóa mới từ 23/3/2025                      ║
+        ║  ✓ Tạo bot python đầu tư từ số 0                         ║
+        ║  ✓ Học 10 buổi chiều Chủ Nhật                            ║
+        ║                                                          ║
+        ║  → Đăng ký ngay: {A.target_url} ║
+        ║                                                          ║
+        ╚══════════════════════════════════════════════════════════╝
+        """
+		if B=='jupyter':
+			try:
+				from IPython.display import display as C,HTML as E,Markdown as J
+				if D:C(E(D))
+				else:
+					try:C(J(H))
+					except:C(E(G))
+			except:pass
+		elif B=='terminal':print(I)
+		else:print(f"🚀 Phân tích dữ liệu & tạo bot chứng khoán K10 - Đăng ký: {A.target_url}")
+manager=ContentManager()
+def present():return manager.present_content()

vnai/scope/state.py

@@ -0,0 +1,74 @@
+_L='minimal'
+_K='warnings'
+_J='api_requests'
+_I='last_error_time'
+_H='startup_time'
+_G='standard'
+_F='function_calls'
+_E='peak_memory'
+_D='errors'
+_C=True
+_B=None
+_A='execution_times'
+import time,threading,json,os
+from datetime import datetime
+from pathlib import Path
+class Tracker:
+	_instance=_B;_lock=threading.Lock()
+	def __new__(A):
+		with A._lock:
+			if A._instance is _B:A._instance=super(Tracker,A).__new__(A);A._instance._initialize()
+			return A._instance
+	def _initialize(A):A.metrics={_H:datetime.now().isoformat(),_F:0,_J:0,_D:0,_K:0};A.performance_metrics={_A:[],_I:_B,_E:0};A.privacy_level=_G;A.home_dir=Path.home();A.project_dir=A.home_dir/'.vnstock';A.project_dir.mkdir(exist_ok=_C);A.data_dir=A.project_dir/'data';A.data_dir.mkdir(exist_ok=_C);A.metrics_path=A.data_dir/'usage_metrics.json';A.privacy_config_path=A.project_dir/'config'/'privacy.json';os.makedirs(os.path.dirname(A.privacy_config_path),exist_ok=_C);A._load_metrics();A._load_privacy_settings();A._start_background_collector()
+	def _load_metrics(A):
+		if A.metrics_path.exists():
+			try:
+				with open(A.metrics_path,'r')as C:D=json.load(C)
+				for(B,E)in D.items():
+					if B in A.metrics:A.metrics[B]=E
+			except:pass
+	def _save_metrics(A):
+		try:
+			with open(A.metrics_path,'w')as B:json.dump(A.metrics,B)
+		except:pass
+	def _load_privacy_settings(A):
+		if A.privacy_config_path.exists():
+			try:
+				with open(A.privacy_config_path,'r')as B:C=json.load(B);A.privacy_level=C.get('level',_G)
+			except:pass
+	def setup_privacy(B,level=_B):
+		A=level;C={_L:'Essential system data only',_G:'Performance metrics and errors','enhanced':'Detailed operation analytics'}
+		if A is _B:A=_G
+		if A not in C:raise ValueError(f"Invalid privacy level: {A}. Choose from {', '.join(C.keys())}")
+		B.privacy_level=A
+		with open(B.privacy_config_path,'w')as D:json.dump({'level':A},D)
+		return A
+	def get_privacy_level(A):return A.privacy_level
+	def _start_background_collector(A):
+		def B():
+			while _C:
+				try:
+					import psutil as C;D=C.Process();E=D.memory_info();B=E.rss/1048576
+					if B>A.performance_metrics[_E]:A.performance_metrics[_E]=B
+					A._save_metrics()
+				except:pass
+				time.sleep(300)
+		C=threading.Thread(target=B,daemon=_C);C.start()
+	def record(A,event_type,data=_B):
+		D='execution_time';C=data;B=event_type
+		if A.privacy_level==_L and B!=_D:return _C
+		if B in A.metrics:A.metrics[B]+=1
+		else:A.metrics[B]=1
+		if B==_D:A.performance_metrics[_I]=datetime.now().isoformat()
+		if B==_F and C and D in C:
+			A.performance_metrics[_A].append(C[D])
+			if len(A.performance_metrics[_A])>100:A.performance_metrics[_A]=A.performance_metrics[_A][-100:]
+		if A.metrics[_F]%100==0 or B==_D:A._save_metrics()
+		return _C
+	def get_metrics(A):
+		B=0
+		if A.performance_metrics[_A]:B=sum(A.performance_metrics[_A])/len(A.performance_metrics[_A])
+		C=A.metrics.copy();C.update({'avg_execution_time':B,'peak_memory_mb':A.performance_metrics[_E],'uptime':(datetime.now()-datetime.fromisoformat(A.metrics[_H])).total_seconds(),'privacy_level':A.privacy_level});return C
+	def reset(A):A.metrics={_H:datetime.now().isoformat(),_F:0,_J:0,_D:0,_K:0};A.performance_metrics={_A:[],_I:_B,_E:0};A._save_metrics();return _C
+tracker=Tracker()
+def record(event_type,data=_B):return tracker.record(event_type,data)

vnai-2.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,16 @@
+vnai/__init__.py,sha256=htWSy730Vm-viAxYTJ2tsq4J7_-jOJsJ9dEl1r8AtFI,4668
+vnai/beam/__init__.py,sha256=MG_4FkhQZyuKeaoQQh-KaULhxcGu370lGR6FVV5blU4,129
+vnai/beam/metrics.py,sha256=nVKoe0SJg0TNCPvAOaE99ZyBJ9Tw5WSRydyAObH8FrA,2709
+vnai/beam/pulse.py,sha256=5e21Ky6rVKD57bf8BzSA2lGzwHhohansoQzggrnEpIE,1580
+vnai/beam/quota.py,sha256=arII5Dl0hLpAfvThpOHJNRFAJnMbtEmfAMJOLemBiKg,2345
+vnai/flow/__init__.py,sha256=BURTo8cXicmqqTbeB0qfXwVole0oGDVp_UxRSeh4qfA,80
+vnai/flow/queue.py,sha256=pvC_HSjctR62Uzt4b3h3EANJXmrkKBm3iiNVIrlTnJA,1912
+vnai/flow/relay.py,sha256=RU-paE3HVkgodPmNlAI8fAoVUcwufegY1WmsGL-sWpY,6676
+vnai/scope/__init__.py,sha256=o7N7JjgSqIfQeDojgnxzV9gthEWL3YxxljnvRO9AXkQ,196
+vnai/scope/profile.py,sha256=Oi8kZ_7wnSAyW7MkU2NZuw5cxzSRrRv8v61SkgX0zrc,14941
+vnai/scope/promo.py,sha256=eOySqZ4XnxLbRyD6uKhYnJFSIwaDJ7T8hbJynuqvfho,2958
+vnai/scope/state.py,sha256=JkVwJv8l_-ef201I_O1PHqFyp8KJ3VWyfmZnCltH18c,3283
+vnai-2.0.dist-info/METADATA,sha256=ibGNnz6wpZ9xoGw0T45707a5_WWGpz6uCA3hieYlbCM,947
+vnai-2.0.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+vnai-2.0.dist-info/top_level.txt,sha256=4zI0qZHePCwvgSqXl4420sBcd0VzZn4MEcRsAIFae3k,5
+vnai-2.0.dist-info/RECORD,,

{vnai-0.1.4.dist-info → vnai-2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

vnai-0.1.4.dist-info/METADATA

@@ -1,19 +0,0 @@
-Metadata-Version: 2.1
-Name: vnai
-Version: 0.1.4
-Summary: :))
-Author: Vnstock HQ
-Author-email: support@vnstock.site
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
-Requires-Dist: requests
-Requires-Dist: cryptography
-Requires-Dist: psutil
-Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: pytest-cov; extra == "dev"

vnai-0.1.4.dist-info/RECORD

@@ -1,5 +0,0 @@
-vnai/__init__.py,sha256=k6Qn1-1DeiTMHs0TZk4tLwLzAb35qxcjhjg4fJQ046A,12245
-vnai-0.1.4.dist-info/METADATA,sha256=tosZBcT5xYtgGkkKCyPf77H9LsqA0ja04vg-zByIcrQ,631
-vnai-0.1.4.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-vnai-0.1.4.dist-info/top_level.txt,sha256=4zI0qZHePCwvgSqXl4420sBcd0VzZn4MEcRsAIFae3k,5
-vnai-0.1.4.dist-info/RECORD,,