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

vnai/scope/profile.py

@@ -1,767 +1,223 @@
-# 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
+_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:
-    """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()
+	_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()