vnai 0.1.3__py3-none-any.whl → 2.3.7__py3-none-any.whl

vnai/beam/auth.py

@@ -0,0 +1,312 @@
+"""
+Authentication and tier management.
+Provides tier detection and API key management for rate limiting.
+Includes centralized authentication state manager for deduplication.
+"""
+import os
+import json
+import time
+import logging
+from pathlib import Path
+from typing import Optional, Dict, Any
+from datetime import datetime, timedelta
+import threading
+log = logging.getLogger(__name__)
+
+class AuthStateManager:
+    def __init__(self, state_dir: Path):
+        self.state_dir = state_dir
+        self.state_file = state_dir /"auth_state.json"
+        self.state_dir.mkdir(parents=True, exist_ok=True)
+        self._state = self._load_state()
+
+    def _load_state(self) -> Dict:
+        if self.state_file.exists():
+            try:
+                with open(self.state_file,'r') as f:
+                    return json.load(f)
+            except (json.JSONDecodeError, IOError) as e:
+                log.debug(f"Could not load auth state: {e}")
+                return self._default_state()
+        return self._default_state()
+
+    def _default_state(self) -> Dict:
+        return {
+"session_id": self._generate_session_id(),
+"authenticated": False,
+"user": None,
+"tier": None,
+"auth_time": None,
+"packages_notified": [],
+"cache_ttl_minutes": 60
+        }
+
+    def _generate_session_id(self) -> str:
+        return datetime.now().isoformat()
+
+    def _save_state(self) -> None:
+        try:
+            with open(self.state_file,'w') as f:
+                json.dump(self._state, f, indent=2)
+        except IOError as e:
+            log.warning(f"Could not save auth state: {e}")
+
+    def _is_cache_valid(self) -> bool:
+        if not self._state.get("auth_time"):
+            return False
+        auth_time = datetime.fromisoformat(self._state["auth_time"])
+        ttl_minutes = self._state.get("cache_ttl_minutes", 60)
+        expiry = auth_time + timedelta(minutes=ttl_minutes)
+        return datetime.now() < expiry
+
+    def should_show_message(self, package_name: str) -> bool:
+        if not self._state.get("authenticated") or not self._is_cache_valid():
+            return True
+        packages_notified = self._state.get("packages_notified", [])
+        return len(packages_notified) == 0
+
+    def mark_authenticated(self, license_info: Dict, package_name: str) -> None:
+        self._state["authenticated"] = True
+        self._state["user"] = license_info.get("user","Unknown")
+        self._state["tier"] = license_info.get("tier","free")
+        self._state["auth_time"] = datetime.now().isoformat()
+        packages_notified = self._state.get("packages_notified", [])
+        if package_name not in packages_notified:
+            packages_notified.append(package_name)
+        self._state["packages_notified"] = packages_notified
+        self._save_state()
+
+    def get_cached_info(self) -> Optional[Dict]:
+        if not self._is_cache_valid():
+            return None
+        return {
+"user": self._state.get("user"),
+"tier": self._state.get("tier"),
+"from_cache": True
+        }
+
+    def reset(self) -> None:
+        self._state = self._default_state()
+        self._save_state()
+
+def get_auth_state_manager(project_dir: Path) -> AuthStateManager:
+    return AuthStateManager(project_dir)
+
+class Authenticator:
+    TIER_LIMITS = {
+"guest": {"min": 20,"hour": 1200,"day": 5000},
+"free": {"min": 60,"hour": 3600,"day": 10000},
+"bronze": {"min": 180,"hour": 10800,"day": 50000},
+"silver": {"min": 300,"hour": 18000,"day": 100000},
+"golden": {"min": 600,"hour": 36000,"day": 150000}
+    }
+
+    def __init__(self):
+        self.vnstock_dir = Path.home() /".vnstock"
+        self.api_key_file = self.vnstock_dir /"api_key.json"
+        self._cached_tier = None
+        self._cache_timestamp = 0
+        self._cache_ttl = 300
+
+    def get_tier(self, force_refresh: bool = False) -> str:
+        current_time = time.time()
+        if not force_refresh and self._cached_tier and (current_time - self._cache_timestamp) < self._cache_ttl:
+            return self._cached_tier
+        tier = self._detect_tier()
+        self._cached_tier = tier
+        self._cache_timestamp = current_time
+        log.debug(f"Detected tier: {tier}")
+        return tier
+
+    def _detect_tier(self) -> str:
+        tier_from_vnii = self._check_vnii_tier()
+        if tier_from_vnii:
+            return tier_from_vnii
+        if self._has_api_key():
+            return"free"
+        return"guest"
+
+    def _check_vnii_tier(self) -> Optional[str]:
+        try:
+            import vnii
+            from vnii.auth import authenticate
+            license_info = authenticate(self.vnstock_dir)
+            tier_string = license_info.get('tier','free')
+            log.debug(f"Got tier from vnii: {tier_string}")
+            return tier_string
+        except ImportError:
+            log.debug("vnii not installed")
+            return None
+        except SystemExit:
+            log.debug("vnii authentication failed")
+            return None
+        except Exception as e:
+            log.debug(f"Error checking vnii tier: {e}")
+            return None
+
+    def _has_api_key(self) -> bool:
+        if os.getenv('VNSTOCK_API_KEY'):
+            return True
+        if self.api_key_file.exists():
+            try:
+                with open(self.api_key_file,'r') as f:
+                    data = json.load(f)
+                    api_key = data.get('api_key','').strip()
+                    return bool(api_key)
+            except Exception as e:
+                log.debug(f"Failed to read API key: {e}")
+        return False
+
+    def get_limits(self, tier: Optional[str] = None) -> Dict[str, int]:
+        if tier is None:
+            tier = self.get_tier()
+        return self.TIER_LIMITS.get(tier, self.TIER_LIMITS["guest"])
+
+    def get_tier_info(self) -> Dict:
+        tier = self.get_tier()
+        limits = self.get_limits(tier)
+        descriptions = {
+"guest":"Khách (Guest - chưa đăng ký)",
+"free":"Phiên bản cộng đồng (Community - có API key)",
+"bronze":"Thành viên Bronze (Bronze Member)",
+"silver":"Thành viên Silver (Silver Member)",
+"golden":"Thành viên Golden (Golden Member)"
+        }
+        return {
+"tier": tier,
+"description": descriptions.get(tier,f"Gói {tier.title()}"),
+"limits": {
+"per_minute": limits["min"],
+"per_hour": limits["hour"]
+            }
+        }
+
+    def setup_api_key(self, api_key: str) -> bool:
+        try:
+            self.vnstock_dir.mkdir(exist_ok=True)
+            api_key_data = {"api_key": api_key.strip()}
+            with open(self.api_key_file,'w') as f:
+                json.dump(api_key_data, f, indent=2)
+            print("✓ API key đã được lưu thành công! (API key saved successfully!)")
+            print("Bạn đang sử dụng Phiên bản cộng đồng (60 requests/phút)")
+            print("(You are using Community version - 60 requests/minute)")
+            print("\nĐể tham gia gói thành viên tài trợ (To join sponsor membership):")
+            print("  Truy cập: https://vnstocks.com/insiders-program")
+            log.info("API key setup completed")
+            return True
+        except Exception as e:
+            print(f"✗ Không thể lưu API key (Failed to save API key): {e}")
+            log.error(f"API key setup failed: {e}")
+            return False
+
+    def get_api_key(self) -> Optional[str]:
+        if os.getenv('VNSTOCK_API_KEY'):
+            return os.getenv('VNSTOCK_API_KEY')
+        if self.api_key_file.exists():
+            try:
+                with open(self.api_key_file,'r') as f:
+                    data = json.load(f)
+                    return data.get('api_key')
+            except Exception as e:
+                log.debug(f"Failed to read API key: {e}")
+        return None
+
+    def remove_api_key(self) -> bool:
+        try:
+            if self.api_key_file.exists():
+                self.api_key_file.unlink()
+                print("✓ API key đã được xóa (API key removed)")
+                print("Bạn đang ở chế độ Khách (20 requests/phút) (You are in Guest mode - 20 requests/minute)")
+            else:
+                print("Không tìm thấy API key (No API key found)")
+            log.info("API key removed")
+            return True
+        except Exception as e:
+            print(f"✗ Không thể xóa API key (Failed to remove API key): {e}")
+            log.error(f"API key removal failed: {e}")
+            return False
+
+    def _register_device_to_api(self, api_key: str) -> None:
+        try:
+            import requests
+            import platform
+            from vnai.scope.profile import inspector
+            from vnai.scope.device import IDEDetector
+            system_info = inspector.examine()
+            try:
+                ide_name, ide_info = IDEDetector.detect_ide()
+            except Exception:
+                ide_name ='Unknown'
+                ide_info = {}
+            payload = {
+'api_key': api_key,
+'device_id': system_info['machine_id'],
+'device_name': system_info.get('platform', platform.node()),
+'os_type': system_info['os_name'].lower(),
+'os_version': system_info.get('platform', platform.release()),
+'machine_info': {
+'platform': system_info.get('platform', platform.platform()),
+'machine': platform.machine(),
+'processor': platform.processor(),
+'system': platform.system(),
+'release': platform.release(),
+'python_version': system_info.get('python_version'),
+'environment': system_info.get('environment','unknown'),
+'ide_name': ide_name,
+'ide_detection_method': ide_info.get('detection_method'),
+'ide_frontend': ide_info.get('frontend')
+                }
+            }
+            url ='https://vnstocks.com/api/vnstock/auth/device-register'
+            try:
+                requests.post(url, json=payload, timeout=5)
+                log.debug("Device registered successfully to vnstocks.com")
+            except Exception as req_e:
+                log.debug(f"Device registration request failed: {req_e}")
+        except Exception as e:
+            log.debug(f"Device registration error: {e}")
+
+    def check_api_key_status(self) -> dict:
+        api_key = self.get_api_key()
+        if api_key:
+            preview = api_key[:15] +"..." if len(api_key) > 15 else api_key
+            tier_info = self.get_tier_info()
+            print(f"✓ API key: {preview}")
+            print(f"✓ Tier (Gói): {tier_info['tier']}")
+            print(f"✓ Giới hạn (Limits): {tier_info['limits']}")
+            return {
+'has_api_key': True,
+'api_key_preview': preview,
+'tier': tier_info['tier'],
+'limits': tier_info['limits']
+            }
+        else:
+            return {
+'has_api_key': False,
+'api_key_preview': None,
+'tier': self.get_tier(),
+'limits': self.get_limits()
+            }
+
+    def print_help(self):
+        print("\n" +"="*60)
+        print("VNSTOCK API KEY SETUP (Cài đặt API Key)")
+        print("="*60)
+        print("\n📋 Các gói sử dụng (Available Tiers):")
+        print("  • Khách (Guest): 20 requests/phút. Tối đa 4 kỳ báo cáo tài chính.")
+        print("  • Phiên bản cộng đồng (Community): 60 requests/phút. Tối đa 8 kỳ báo cáo tài chính.")
+        print("  • Thành viên tài trợ (Sponsor): 180-500 requests/phút.")
+        print("\n🔑 Lấy API Key (Get Your API Key):")
+        print("  1. Truy cập: https://vnstocks.com/account")
+        print("  2. Đăng ký hoặc đăng nhập (Sign up or log in)")
+        print("  3. Sao chép API key của bạn (Copy your API key)")
+        print("\n💾 Cài đặt API Key (Setup API Key):")
+        print("  import vnai")
+        print('  vnai.setup_api_key("your_api_key_here")')
+        print("\n📊 Kiểm tra trạng thái (Check Status):")
+        print("  import vnai")
+        print("  vnai.check_api_key_status()")
+        print("\n🤝 Tham gia gói thành viên tài trợ (Join Vnstock Sponsor):")
+        print("  Truy cập: https://vnstocks.com/insiders-program")
+        print("="*60 +"\n")
+authenticator = Authenticator()

vnai/beam/fundamental.py

@@ -0,0 +1,168 @@
+"""
+Fundamental financial reports with tier-based period limiting.
+Provides unified interface for financial reports from multiple sources (VCI, KBS, TCBS)
+with automatic tier-based period limiting:
+- Guest tier: 4 periods max
+- Free tier: 8 periods max
+- Paid tier: Unlimited
+Applies limits intelligently based on data structure:
+- VCI/KBS: Periods in columns (slice columns)
+- TCBS: Periods in index (slice rows)
+"""
+import pandas as pd
+from typing import Optional
+from vnai.beam.auth import authenticator
+PERIOD_LIMITS = {
+'guest': 4,
+'free': 8,
+'bronze': None,
+'silver': None,
+'golden': None,
+}
+
+def get_max_periods() -> Optional[int]:
+    tier = authenticator.get_tier()
+    return PERIOD_LIMITS.get(tier)
+
+def parse_period(period_str: str) -> tuple:
+    if isinstance(period_str, str):
+        if'-Q' in period_str:
+            year, quarter = period_str.split('-Q')
+            return (int(year), int(quarter))
+        elif period_str.isdigit():
+            return (int(period_str), 5)
+    return (0, 0)
+
+def limit_periods_by_columns(df: pd.DataFrame, max_periods: Optional[int] = None) -> pd.DataFrame:
+    if max_periods is None:
+        return df
+    metadata_cols = [
+'ticker','yearReport','lengthReport',
+'item','item_en','item_id','unit','levels','row_number'
+    ]
+    period_cols = []
+    for col in df.columns:
+        if isinstance(col, str) and col not in metadata_cols:
+            if col.isdigit() or (len(col) > 4 and'-Q' in col):
+                period_cols.append(col)
+    if not period_cols:
+        return df
+    period_cols_sorted = sorted(period_cols, key=parse_period, reverse=True)
+    keep_periods = period_cols_sorted[:max_periods]
+    metadata_cols_present = [col for col in metadata_cols if col in df.columns]
+    financial_cols = [col for col in df.columns if col not in metadata_cols and col not in period_cols]
+    final_cols = metadata_cols_present + financial_cols + keep_periods
+    return df[final_cols]
+
+def limit_periods_by_index(df: pd.DataFrame, max_periods: Optional[int] = None) -> pd.DataFrame:
+    if max_periods is None:
+        return df
+    periods = df.index.tolist()
+    periods_sorted = sorted(periods, key=parse_period, reverse=True)
+    keep_periods = periods_sorted[:max_periods]
+    return df.loc[keep_periods]
+
+def limit_vci_periods(df: pd.DataFrame, max_periods: Optional[int] = None) -> pd.DataFrame:
+    if max_periods is None or df.empty or'yearReport' not in df.columns:
+        return df
+    df_limited = df.head(max_periods).copy()
+    df_limited = df_limited.reset_index(drop=True)
+    return df_limited
+
+def apply_period_limit(df: pd.DataFrame, by_index: bool = False, source: str ='default') -> pd.DataFrame:
+    max_periods = get_max_periods()
+    if source =='vci' and'yearReport' in df.columns:
+        return limit_vci_periods(df, max_periods)
+    elif by_index:
+        return limit_periods_by_index(df, max_periods)
+    else:
+        return limit_periods_by_columns(df, max_periods)
+
+class FinancialReports:
+    def __init__(self, symbol: str, source: str ='vci', show_log: bool = False):
+        self.symbol = symbol
+        self.source = source.lower()
+        self.show_log = show_log
+        if self.source =='vci':
+            from vnstock.explorer.vci import Finance as VCI_Finance
+            self.finance = VCI_Finance(symbol=symbol, show_log=show_log)
+            self.by_index = False
+        elif self.source =='kbs':
+            from vnstock.explorer.kbs import Finance as KBS_Finance
+            self.finance = KBS_Finance(symbol=symbol, show_log=show_log)
+            self.by_index = False
+        elif self.source =='tcbs':
+            from vnstock.explorer.tcbs import Finance as TCBS_Finance
+            self.finance = TCBS_Finance(symbol=symbol, show_log=show_log)
+            self.by_index = True
+        else:
+            raise ValueError(f"Unsupported source: {source}. Must be 'vci', 'kbs', or 'tcbs'.")
+
+    def balance_sheet(self, period: str ='year', lang: Optional[str] ='en',
+                     show_log: Optional[bool] = False) -> pd.DataFrame:
+        if self.source =='vci':
+            df = self.finance.balance_sheet(period=period, lang=lang, show_log=show_log)
+        elif self.source =='kbs':
+            df = self.finance.balance_sheet(period=period, show_log=show_log)
+        elif self.source =='tcbs':
+            df = self.finance.balance_sheet(period=period, show_log=show_log)
+        df = apply_period_limit(df, by_index=self.by_index, source=self.source)
+        if not hasattr(self,'_notice_shown'):
+            self._notice_shown = False
+        if not self._notice_shown:
+            from vnai.beam.patching import should_show_notice, display_period_limit_notice_jupyter
+            if should_show_notice():
+                self._notice_shown = True
+                display_period_limit_notice_jupyter()
+        return df
+
+    def income_statement(self, period: str ='year', lang: Optional[str] ='en',
+                        show_log: Optional[bool] = False) -> pd.DataFrame:
+        if self.source =='vci':
+            df = self.finance.income_statement(period=period, lang=lang, show_log=show_log)
+        elif self.source =='kbs':
+            df = self.finance.income_statement(period=period, show_log=show_log)
+        elif self.source =='tcbs':
+            df = self.finance.income_statement(period=period, show_log=show_log)
+        df = apply_period_limit(df, by_index=self.by_index, source=self.source)
+        if not hasattr(self,'_notice_shown'):
+            self._notice_shown = False
+        if not self._notice_shown:
+            from vnai.beam.patching import should_show_notice, display_period_limit_notice_jupyter
+            if should_show_notice():
+                self._notice_shown = True
+                display_period_limit_notice_jupyter()
+        return df
+
+    def cash_flow(self, period: str ='year', lang: Optional[str] ='en',
+                 show_log: Optional[bool] = False) -> pd.DataFrame:
+        if self.source =='vci':
+            df = self.finance.cash_flow(period=period, lang=lang, show_log=show_log)
+        elif self.source =='kbs':
+            df = self.finance.cash_flow(period=period, show_log=show_log)
+        elif self.source =='tcbs':
+            df = self.finance.cash_flow(period=period, show_log=show_log)
+        df = apply_period_limit(df, by_index=self.by_index, source=self.source)
+        if not hasattr(self,'_notice_shown'):
+            self._notice_shown = False
+        if not self._notice_shown:
+            from vnai.beam.patching import should_show_notice, display_period_limit_notice_jupyter
+            if should_show_notice():
+                self._notice_shown = True
+                display_period_limit_notice_jupyter()
+        return df
+
+def balance_sheet(symbol: str, source: str ='vci', period: str ='year',
+                 lang: Optional[str] ='en', show_log: bool = False) -> pd.DataFrame:
+    reports = FinancialReports(symbol=symbol, source=source, show_log=show_log)
+    return reports.balance_sheet(period=period, lang=lang, show_log=show_log)
+
+def income_statement(symbol: str, source: str ='vci', period: str ='year',
+                    lang: Optional[str] ='en', show_log: bool = False) -> pd.DataFrame:
+    reports = FinancialReports(symbol=symbol, source=source, show_log=show_log)
+    return reports.income_statement(period=period, lang=lang, show_log=show_log)
+
+def cash_flow(symbol: str, source: str ='vci', period: str ='year',
+             lang: Optional[str] ='en', show_log: bool = False) -> pd.DataFrame:
+    reports = FinancialReports(symbol=symbol, source=source, show_log=show_log)
+    return reports.cash_flow(period=period, lang=lang, show_log=show_log)

vnai/beam/metrics.py

@@ -0,0 +1,167 @@
+import sys
+import time
+import threading
+from datetime import datetime
+import hashlib
+import json
+
+class Collector:
+    _instance = None
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super(Collector, cls).__new__(cls)
+                cls._instance._initialize()
+            return cls._instance
+
+    def _initialize(self):
+        self.metrics = {
+"function": [],
+"rate_limit": [],
+"request": [],
+"error": []
+        }
+        self.thresholds = {
+"buffer_size": 50,
+"error_threshold": 0.1,
+"performance_threshold": 5.0
+        }
+        self.function_count = 0
+        self.colab_auth_triggered = False
+        self.max_metric_length = 200
+        self._last_record_time = {}
+        self.min_interval_per_type = 0.5
+        self._recent_hashes = []
+        self._sending_metrics = False
+
+    def record(self, metric_type, data, priority=None):
+        if not isinstance(data, dict):
+            data = {"value": str(data)}
+        if"timestamp" not in data:
+            data["timestamp"] = datetime.now().isoformat()
+        if metric_type !="system_info":
+            data.pop("system", None)
+            from vnai.scope.profile import inspector
+            data["machine_id"] = inspector.fingerprint()
+        now = time.time()
+        last_time = self._last_record_time.get(metric_type, 0)
+        if now - last_time < self.min_interval_per_type and priority !="high":
+            return
+        self._last_record_time[metric_type] = now
+        data_hash = hashlib.md5(json.dumps(data, sort_keys=True).encode()).hexdigest()
+        if data_hash in self._recent_hashes and priority !="high":
+            return
+        self._recent_hashes.append(data_hash)
+        if metric_type in self.metrics:
+            self.metrics[metric_type].append(data)
+            if len(self.metrics[metric_type]) > self.max_metric_length:
+                self.metrics[metric_type] = self.metrics[metric_type][-self.max_metric_length:]
+        else:
+            self.metrics["function"].append(data)
+        if metric_type =="function":
+            self.function_count += 1
+            if self.function_count > 10 and not self.colab_auth_triggered and'google.colab' in sys.modules:
+                self.colab_auth_triggered = True
+                threading.Thread(target=self._trigger_colab_auth, daemon=True).start()
+        if sum(len(metric_list) for metric_list in self.metrics.values()) >= self.thresholds["buffer_size"]:
+            self._send_metrics()
+        if priority =="high" or metric_type =="error":
+            self._send_metrics()
+
+    def _trigger_colab_auth(self):
+        try:
+            from vnai.scope.profile import inspector
+            inspector.get_or_create_user_id()
+        except:
+            pass
+
+    def _send_metrics(self):
+        if self._sending_metrics:
+            return
+        self._sending_metrics = True
+        try:
+            from vnai.flow.relay import track_function_call, track_rate_limit, track_api_request
+        except ImportError:
+            for metric_type in self.metrics:
+                self.metrics[metric_type] = []
+            self._sending_metrics = False
+            return
+        for metric_type, data_list in self.metrics.items():
+            if not data_list:
+                continue
+            for data in data_list:
+                try:
+                    if metric_type =="function":
+                        track_function_call(
+                            function_name=data.get("function","unknown"),
+                            source=data.get("source","vnai"),
+                            execution_time=data.get("execution_time", 0),
+                            success=data.get("success", True),
+                            error=data.get("error"),
+                            args=data.get("args")
+                        )
+                    elif metric_type =="rate_limit":
+                        track_rate_limit(
+                            source=data.get("source","vnai"),
+                            limit_type=data.get("limit_type","unknown"),
+                            limit_value=data.get("limit_value", 0),
+                            current_usage=data.get("current_usage", 0),
+                            is_exceeded=data.get("is_exceeded", False)
+                        )
+                    elif metric_type =="request":
+                        track_api_request(
+                            endpoint=data.get("endpoint","unknown"),
+                            source=data.get("source","vnai"),
+                            method=data.get("method","GET"),
+                            status_code=data.get("status_code", 200),
+                            execution_time=data.get("execution_time", 0),
+                            request_size=data.get("request_size", 0),
+                            response_size=data.get("response_size", 0)
+                        )
+                except Exception as e:
+                    continue
+            self.metrics[metric_type] = []
+        self._sending_metrics = False
+
+    def get_metrics_summary(self):
+        return {
+            metric_type: len(data_list)
+            for metric_type, data_list in self.metrics.items()
+        }
+collector = Collector()
+
+def capture(module_type="function"):
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            start_time = time.time()
+            success = False
+            error = None
+            try:
+                result = func(*args, **kwargs)
+                success = True
+                return result
+            except Exception as e:
+                error = str(e)
+                collector.record("error", {
+"function": func.__name__,
+"error": error,
+"args": str(args)[:100] if args else None
+                })
+                raise
+            finally:
+                execution_time = time.time() - start_time
+                collector.record(
+                    module_type,
+                    {
+"function": func.__name__,
+"execution_time": execution_time,
+"success": success,
+"error": error,
+"timestamp": datetime.now().isoformat(),
+"args": str(args)[:100] if args else None
+                    }
+                )
+        return wrapper
+    return decorator