vnai 2.0.2__py3-none-any.whl → 2.0.4__py3-none-any.whl

vnai/scope/profile.py

@@ -1,223 +1,766 @@
-_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
+# vnai/scope/profile.py
+# System environment detection
+
+import os
+import sys
+import platform
+import uuid
+import hashlib
+import psutil
+import threading
+import time
+import 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📋 Kết nối tài khoản Google Drive để lưu các thiết lập của dự án.');print('Dữ liệu phiên làm việc với Colab của bạn sẽ bị xóa nếu không lưu trữ vào Google Drive.\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()
+    """Inspects execution environment"""
+    
+    _instance = None
+    _lock = None
+    
+    def __new__(cls):
+        import threading
+        if cls._lock is None:
+            cls._lock = threading.Lock()
+            
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super(Inspector, cls).__new__(cls)
+                cls._instance._initialize()
+            return cls._instance
+    
+    def _initialize(self):
+        """Initialize inspector"""
+        self.cache = {}
+        self.cache_ttl = 3600  # 1 hour cache validity
+        self.last_examination = 0
+        self.machine_id = None
+        self._colab_auth_triggered = False
+        
+        # Paths
+        self.home_dir = Path.home()
+        self.project_dir = self.home_dir / ".vnstock"
+        self.project_dir.mkdir(exist_ok=True)
+        self.id_dir = self.project_dir / 'id'
+        self.id_dir.mkdir(exist_ok=True)
+        self.machine_id_path = self.id_dir / "machine_id.txt"
+        
+        # Perform initial examination
+        self.examine()
+    
+    def examine(self, force_refresh=False):
+        """Examine current execution context"""
+        current_time = time.time()
+        
+        # Return cached data if it's fresh enough and we're not forcing a refresh
+        if not force_refresh and (current_time - self.last_examination) < self.cache_ttl:
+            return self.cache
+            
+        # Start with basic information
+        info = {
+            "timestamp": datetime.now().isoformat(),
+            "python_version": platform.python_version(),
+            "os_name": platform.system(),
+            "platform": platform.platform()
+        }
+        
+        # Machine identifier
+        info["machine_id"] = self.fingerprint()
+        
+        # Environment detection
+        try:
+            # Check for Jupyter/IPython
+            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 None:
+                    info["environment"] = "jupyter"
+                    # Check for hosted notebooks
+                    if 'google.colab' in sys.modules:
+                        info["hosting_service"] = "colab"
+                    elif 'KAGGLE_KERNEL_RUN_TYPE' in os.environ:
+                        info["hosting_service"] = "kaggle"
+                    else:
+                        info["hosting_service"] = "local_jupyter"
+                elif sys.stdout.isatty():
+                    info["environment"] = "terminal"
+                else:
+                    info["environment"] = "script"
+            elif sys.stdout.isatty():
+                info["environment"] = "terminal"
+            else:
+                info["environment"] = "script"
+        except:
+            info["environment"] = "unknown"
+        
+        # System resources
+        try:
+            info["cpu_count"] = os.cpu_count()
+            info["memory_gb"] = round(psutil.virtual_memory().total / (1024**3), 1)
+        except:
+            pass
+        
+        # Check if in Google Colab
+        is_colab = 'google.colab' in sys.modules
+        if is_colab:
+            info["is_colab"] = True
+            # Setup delayed authentication if not already triggered
+            self.detect_colab_with_delayed_auth()
+        
+        # Enhanced context information
+        try:
+            # Commercial usage detection
+            info["commercial_usage"] = self.enhanced_commercial_detection()
+            
+            # Project context
+            info["project_context"] = self.analyze_project_structure()
+            
+            # Git info
+            info["git_info"] = self.analyze_git_info()
+            
+            # Working hours pattern
+            info["usage_pattern"] = self.detect_usage_pattern()
+            
+            # Dependency analysis
+            info["dependencies"] = self.analyze_dependencies()
+        except Exception as e:
+            # Don't let enhanced detection failure stop basic functionality
+            info["detection_error"] = str(e)
+        
+        # Update cache
+        self.cache = info
+        self.last_examination = current_time
+        
+        return info
+    
+    def fingerprint(self):
+        """Generate unique environment fingerprint"""
+        # Always return cached machine_id if it exists
+        if self.machine_id:
+            return self.machine_id
+                
+        # Try to load from file first
+        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
+        
+        # Check for Colab and setup delayed authentication
+        is_colab = self.detect_colab_with_delayed_auth()
+                    
+        # Generate a new machine ID only if necessary
+        try:
+            # Use consistent system information
+            system_info = platform.node() + platform.platform() + platform.machine()
+            self.machine_id = hashlib.md5(system_info.encode()).hexdigest()
+        except:
+            # Fallback to UUID but only as last resort
+            self.machine_id = str(uuid.uuid4())
+                
+        # Save to ensure consistency across calls
+        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):
+        """Detect if running in a hosted environment"""
+        # Check common environment variables for hosted environments
+        hosting_markers = {
+            "COLAB_GPU": "Google Colab",
+            "KAGGLE_KERNEL_RUN_TYPE": "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
+                
+        # Check for Google Colab module
+        if 'google.colab' in sys.modules:
+            return "Google Colab"
+            
+        return "local"
+    
+    def detect_commercial_usage(self):
+        """Detect if running in commercial environment"""
+        commercial_indicators = {
+            "env_domains": [".com", ".io", ".co", "enterprise", "corp", "inc"],
+            "file_patterns": ["invoice", "payment", "customer", "client", "product", "sale"],
+            "env_vars": ["COMPANY", "BUSINESS", "ENTERPRISE", "CORPORATE"],
+            "dir_patterns": ["company", "business", "enterprise", "corporate", "client"]
+        }
+        
+        # Check environment variables for commercial domains
+        env_values = " ".join(os.environ.values()).lower()
+        domain_match = any(domain in env_values for domain in commercial_indicators["env_domains"])
+        
+        # Check if commercial-related environment variables exist
+        env_var_match = any(var in os.environ for var in commercial_indicators["env_vars"])
+        
+        # Check current directory for commercial indicators
+        current_dir = os.getcwd().lower()
+        dir_match = any(pattern in current_dir for pattern in commercial_indicators["dir_patterns"])
+        
+        # Check files in current directory for commercial patterns
+        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["file_patterns"]) for f in files)
+        except:
+            file_match = False
+        
+        # Calculate probability
+        indicators = [domain_match, env_var_match, dir_match, file_match]
+        commercial_probability = sum(indicators) / len(indicators)
+        
+        return {
+            "likely_commercial": commercial_probability > 0.3,
+            "commercial_probability": commercial_probability,
+            "commercial_indicators": {
+                "domain_match": domain_match,
+                "env_var_match": env_var_match,
+                "dir_match": dir_match,
+                "file_match": file_match
+            }
+        }
+    
+    def scan_packages(self):
+        """Scan for installed packages by category"""
+        package_groups = {
+            "vnstock_family": [
+                "vnstock", 
+                "vnstock3", 
+                "vnstock_ezchart", 
+                "vnstock_data_pro",  # Fixed missing comma here
+                "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 = {}
+        
+        for category, packages in package_groups.items():
+            installed[category] = []
+            for pkg in packages:
+                try:
+                    version = importlib.metadata.version(pkg)
+                    installed[category].append({"name": pkg, "version": version})
+                except:
+                    pass
+        
+        return installed
+    
+    def setup_vnstock_environment(self):
+        """Set up environment for vnstock library"""
+        # Create environment.json file
+        env_file = self.id_dir / "environment.json"
+        env_data = {
+            "accepted_agreement": True,
+            "timestamp": datetime.now().isoformat(),
+            "machine_id": self.fingerprint()
+        }
+        
+        try:
+            with open(env_file, "w") as f:
+                import json
+                json.dump(env_data, f)
+            return True
+        except Exception as e:
+            print(f"Failed to set up vnstock environment: {e}")
+            return False
+
+    # Update detect_colab_with_delayed_auth method in Inspector class
+    def detect_colab_with_delayed_auth(self, immediate=False):
+        """Detect if running in Google Colab and setup authentication"""
+        # Check if we're in Colab without mounting drive yet
+        is_colab = 'google.colab' in sys.modules
+        
+        if is_colab and not self._colab_auth_triggered:
+            if immediate:
+                # Immediate authentication
+                self._colab_auth_triggered = True
+                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:
+                # Start a delayed thread to trigger authentication after user is already using the package
+                def delayed_auth():
+                    # Wait for some time (e.g., 5 minutes) before attempting auth
+                    time.sleep(300)
+                    # Try to get authenticated user ID
+                    user_id = self.get_or_create_user_id()
+                    # Update machine ID with the authenticated one
+                    if user_id and user_id != self.machine_id:
+                        self.machine_id = user_id
+                        # Save to the machine_id_path
+                        try:
+                            with open(self.machine_id_path, "w") as f:
+                                f.write(user_id)
+                        except:
+                            pass
+                
+                # Start the delayed authentication thread
+                thread = threading.Thread(target=delayed_auth, daemon=True)
+                thread.start()
+        
+        return is_colab
+
+    def get_or_create_user_id(self):
+        """Get existing user ID from Google Drive or create new one"""
+        if self._colab_auth_triggered:
+            return self.machine_id  # Avoid triggering multiple times
+            
+        try:
+            from google.colab import drive
+            print("\n📋 Kết nối tài khoản Google Drive để lưu các thiết lập của dự án.")
+            print("Dữ liệu phiên làm việc với Colab của bạn sẽ bị xóa nếu không lưu trữ vào Google Drive.\n")
+            
+            # Mark that we've triggered the auth
+            self._colab_auth_triggered = True
+            
+            # Mount Google Drive
+            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=True)
+                with open(id_path, 'w') as f:
+                    f.write(user_id)
+                return user_id
+        except Exception as e:
+            # Silently fail and return the existing machine ID
+            return self.machine_id
+    
+    # Enhanced methods for project context collection
+    
+    def analyze_project_structure(self):
+        """Analyze project directory structure for context"""
+        current_dir = os.getcwd()
+        project_indicators = {
+            "commercial_app": ["app", "services", "products", "customers", "billing"],
+            "financial_tool": ["portfolio", "backtesting", "trading", "strategy"],
+            "data_science": ["models", "notebooks", "datasets", "visualization"],
+            "educational": ["examples", "lectures", "assignments", "slides"]
+        }
+        
+        # Look for key directories up to 2 levels deep (limited for privacy)
+        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)
+        
+        # Scan for direct child files and directories (limited depth for privacy)
+        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))]
+            
+            # Detect project type
+            file_markers = {
+                "python_project": ["setup.py", "pyproject.toml", "requirements.txt"],
+                "data_science": ["notebook.ipynb", ".ipynb_checkpoints"],
+                "web_app": ["app.py", "wsgi.py", "manage.py", "server.py"],
+                "finance_app": ["portfolio.py", "trading.py", "backtest.py"],
+            }
+            
+            file_project_type = "unknown"
+            for ptype, markers in file_markers.items():
+                if any(marker in root_files for marker in markers):
+                    file_project_type = ptype
+                    break
+                    
+            # Scan for specific frameworks
+            frameworks = []
+            framework_markers = {
+                "django": ["manage.py", "settings.py"],
+                "flask": ["app.py", "wsgi.py"],
+                "streamlit": ["streamlit_app.py", "app.py"],
+                "fastapi": ["main.py", "app.py"],
+            }
+            
+            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 = "unknown"
+            frameworks = []
+        
+        return {
+            "project_dir": current_dir,
+            "detected_type": max(project_type.items(), key=lambda x: x[1])[0] if project_type else "unknown",
+            "file_type": file_project_type,
+            "is_git_repo": ".git" in (root_dirs if 'root_dirs' in locals() else []),
+            "frameworks": frameworks,
+            "file_count": len(root_files) if 'root_files' in locals() else 0,
+            "directory_count": len(root_dirs) if 'root_dirs' in locals() else 0,
+            "type_confidence": project_type
+        }
+
+    def analyze_git_info(self):
+        """Extract non-sensitive git repository information"""
+        try:
+            # Check if it's a git repository
+            result = subprocess.run(["git", "rev-parse", "--is-inside-work-tree"], 
+                                capture_output=True, text=True)
+            
+            if result.returncode != 0:
+                return {"has_git": False}
+            
+            # Get repository root path - ADD THIS CODE
+            repo_root = subprocess.run(["git", "rev-parse", "--show-toplevel"], 
+                                    capture_output=True, text=True)
+            repo_path = repo_root.stdout.strip() if repo_root.stdout else None
+            
+            # Extract repository name from path - ADD THIS CODE
+            repo_name = os.path.basename(repo_path) if repo_path else None
+            
+            # Check for license file - ADD THIS CODE
+            has_license = False
+            license_type = "unknown"
+            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 = True
+                        # Try to determine license type by scanning content
+                        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"
+                                # Add more license type detection as needed
+                        except:
+                            pass
+                        break
+                
+            # Get remote URL (only domain, not full URL)
+            remote = subprocess.run(["git", "config", "--get", "remote.origin.url"], 
+                                capture_output=True, text=True)
+            
+            remote_url = remote.stdout.strip() if remote.stdout else None
+            
+            if remote_url:
+                # Clean the remote URL string
+                remote_url = remote_url.strip()
+                
+                # Properly extract domain without authentication information
+                domain = None
+                if remote_url:
+                    # For SSH URLs (git@github.com:user/repo.git)
+                    if remote_url.startswith('git@') or '@' in remote_url and ':' in remote_url.split('@')[1]:
+                        domain = remote_url.split('@')[1].split(':')[0]
+                    # For HTTPS URLs with or without authentication
+                    elif remote_url.startswith('http'):
+                        # Remove authentication part if present
+                        url_parts = remote_url.split('//')
+                        if len(url_parts) > 1:
+                            auth_and_domain = url_parts[1].split('/', 1)[0]
+                            # If auth info exists (contains @), take only domain part
+                            if '@' in auth_and_domain:
+                                domain = auth_and_domain.split('@')[-1]
+                            else:
+                                domain = auth_and_domain
+                    # Handle other URL formats
+                    else:
+                        # Try a general regex as fallback for unusual formats
+                        import re
+                        domain_match = re.search(r'@([^:/]+)|https?://(?:[^@/]+@)?([^/]+)', remote_url)
+                        if domain_match:
+                            domain = domain_match.group(1) or domain_match.group(2)
+                
+                # Extract owner and repo info securely
+                owner = None
+                repo_name = None
+                
+                if domain:
+                    # For GitHub repositories
+                    if "github" in domain:
+                        # SSH format: git@github.com:username/repo.git
+                        if ':' in remote_url and '@' in remote_url:
+                            parts = remote_url.split(':')[-1].split('/')
+                            if len(parts) >= 2:
+                                owner = parts[0]
+                                repo_name = parts[1].replace('.git', '')
+                        # HTTPS format
+                        else:
+                            url_parts = remote_url.split('//')
+                            if len(url_parts) > 1:
+                                path_parts = url_parts[1].split('/')
+                                if len(path_parts) >= 3:
+                                    # Skip domain and authentication part
+                                    domain_part = path_parts[0]
+                                    if '@' in domain_part:
+                                        # Path starts after domain
+                                        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('.git', '')
+                
+                # Get commit count
+                commit_count = subprocess.run(["git", "rev-list", "--count", "HEAD"], 
+                                        capture_output=True, text=True)
+                
+                # Get branch count
+                branch_count = subprocess.run(["git", "branch", "--list"], 
+                                        capture_output=True, text=True)
+                branch_count = len(branch_count.stdout.strip().split('\n')) if branch_count.stdout else 0
+                                        
+                return {
+                    "domain": domain,  # Only domain, not full URL
+                    "owner": owner,    # Repository owner (for GitHub)
+                    "commit_count": int(commit_count.stdout.strip()) if commit_count.stdout else 0,
+                    "branch_count": branch_count,
+                    "has_git": True,
+                    "repo_path": repo_path if 'repo_path' in locals() else None,
+                    "repo_name": repo_name,
+                    "has_license": has_license if 'has_license' in locals() else False,
+                    "license_type": license_type if 'license_type' in locals() else "unknown"
+                }
+
+        except Exception as e:
+            # Optionally log the exception for debugging
+            pass
+        return {"has_git": False}
+
+    def detect_usage_pattern(self):
+        """Detect usage patterns that indicate commercial use"""
+        current_time = datetime.now()
+        
+        # Check if using during business hours
+        is_weekday = current_time.weekday() < 5  # 0-4 are Monday to Friday
+        hour = current_time.hour
+        is_business_hours = 9 <= hour <= 18
+        
+        return {
+            "business_hours_usage": is_weekday and is_business_hours,
+            "weekday": is_weekday,
+            "hour": hour,
+            "timestamp": current_time.isoformat()
+        }
+
+    def enhanced_commercial_detection(self):
+        """More thorough commercial usage detection"""
+        basic = self.detect_commercial_usage()
+        
+        # Additional commercial indicators
+        try:
+            project_files = os.listdir(os.getcwd())
+            
+            # Look for commercial frameworks
+            commercial_frameworks = ["django-oscar", "opencart", "magento", 
+                                   "saleor", "odoo", "shopify", "woocommerce"]
+            
+            framework_match = False
+            for framework in commercial_frameworks:
+                if any(framework in f for f in project_files):
+                    framework_match = True
+                    break
+            
+            # Check for database connections
+            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 = False
+            has_database = False
+        
+        # Domain name registration check
+        domain_check = self.analyze_git_info()
+        domain_is_commercial = False
+        if domain_check and domain_check.get("domain"):
+            commercial_tlds = [".com", ".io", ".co", ".org", ".net"]
+            domain_is_commercial = any(tld in domain_check["domain"] for tld in commercial_tlds)
+        
+        # Check project structure
+        project_structure = self.analyze_project_structure()
+        
+        # Calculate enhanced commercial score
+        indicators = [
+            basic["commercial_probability"],
+            framework_match,
+            has_database,
+            domain_is_commercial,
+            project_structure.get("type_confidence", {}).get("commercial_app", 0),
+            self.detect_usage_pattern()["business_hours_usage"]
+        ]
+        
+        # Filter out None values
+        indicators = [i for i in indicators if i is not None]
+        
+        # Calculate score - convert booleans to 1.0 and average
+        if indicators:
+            score = sum(1.0 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 {
+            "commercial_probability": score,
+            "likely_commercial": score > 0.4,
+            "indicators": {
+                "basic_indicators": basic["commercial_indicators"],
+                "framework_match": framework_match,
+                "has_database": has_database,
+                "domain_is_commercial": domain_is_commercial,
+                "project_structure": project_structure.get("detected_type"),
+                "business_hours_usage": self.detect_usage_pattern()["business_hours_usage"]
+            }
+        }
+
+    def analyze_dependencies(self):
+        """Analyze package dependencies for commercial patterns"""
+        try:
+            import pkg_resources
+            
+            # Commercial/enterprise package indicators
+            enterprise_packages = [
+                "snowflake-connector-python", "databricks", "azure", 
+                "aws", "google-cloud", "stripe", "atlassian",
+                "salesforce", "bigquery", "tableau", "sap"
+            ]
+            
+            # Find installed packages that match enterprise indicators
+            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, "version": pkg.version})
+            
+            return {
+                "has_commercial_deps": len(commercial_deps) > 0,
+                "commercial_deps_count": len(commercial_deps),
+                "commercial_deps": commercial_deps
+            }
+        except:
+            return {"has_commercial_deps": False}
+
+# Create singleton instance
+inspector = Inspector()