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

vnai/__init__.py

@@ -1,315 +1,327 @@
 import os
 import pathlib
-import importlib.metadata
-import requests
-import psutil
-import platform
-import uuid
-import sys
-import socket
 import json
-import base64
-from cryptography.fernet import Fernet
-
-TC_VAR = "ACCEPT_TC"
-TC_VAL = "tôi đồng ý"
-
-lmt = os.path.sep
-HOME_DIR = pathlib.Path.home()
-PROJECT_DIR = HOME_DIR / ".vnstock"
-ID_DIR = PROJECT_DIR / 'id'
-TG = b'gAAAAABmOPXPmFYXs94INEralMxhR38geFp91TZRLP29C41OoO0k7D7QiXIR2nWl5PCEoQCKECZw8b-Xeek3oqT6LcpcpJsAPyOGOBTX5cw_r5Mv0o8SBLa53jOeuVAwCAhId_BpMtOO'
-TC_PATH = ID_DIR / "terms_agreement.txt"
-
-TERMS_AND_CONDITIONS = """
-    Khi tiếp tục sử dụng Vnstock3, bạn xác nhận rằng bạn đã đọc, hiểu và đồng ý với Chính sách quyền riêng tư và Điều khoản, điều kiện về giấy phép sử dụng Vnstock3.\n
-    Chi tiết:\n
-    - Giấy phép sử dụng phần mềm: https://vnstocks.com/docs/tai-lieu/giay-phep-su-dung
-    - Chính sách quyền riêng tư: https://vnstocks.com/docs/tai-lieu/chinh-sach-quyen-rieng-tu
-    """
-
-class VnstockInitializer:
-    def __init__(self, target, tc=TERMS_AND_CONDITIONS):
-        self.terms_and_conditions = tc
-        self.home_dir = HOME_DIR
-        self.project_dir = PROJECT_DIR
-        self.id_dir = ID_DIR
-        self.terms_file_path = TC_PATH
-        self.env_config = ID_DIR / "environment.json"
-        self.RH = 'asejruyy^&%$#W2vX>NfwrevDRESWR'
-        self.LH = 'YMAnhuytr%$59u90y7j-mjhgvyFTfbiuUYH'
+import time
+import threading
+import functools
+from datetime import datetime
+from typing import Optional
+import pandas as pd
+TC_VAR ="ACCEPT_TC"
+TC_VAL ="tôi đồng ý"
+TC_PATH = pathlib.Path.home() /".vnstock" /"id" /"terms_agreement.txt"
+TERMS_AND_CONDITIONS ="""
+Khi tiếp tục sử dụng Vnstock, bạn xác nhận rằng bạn đã đọc, hiểu và đồng ý với Chính sách quyền riêng tư và Điều khoản, điều kiện về giấy phép sử dụng Vnstock.
+Chi tiết:
+- Giấy phép sử dụng phần mềm: https://vnstocks.com/onboard/giay-phep-su-dung
+- Chính sách quyền riêng tư: https://vnstocks.com/onboard/chinh-sach-quyen-rieng-tu
+"""
 
-        # Create the project directory if it doesn't exist
+class Core:
+    def __init__(self):
+        self.initialized = False
+        self.webhook_url = None
+        self.init_time = datetime.now().isoformat()
+        self.home_dir = pathlib.Path.home()
+        self.project_dir = self.home_dir /".vnstock"
+        self.id_dir = self.project_dir /'id'
+        self.terms_file_path = TC_PATH
+        self.system_info = None
         self.project_dir.mkdir(exist_ok=True)
         self.id_dir.mkdir(exist_ok=True)
-        self.target = target
-
-        kb = (str(self.project_dir).split(lmt)[-1] + str(self.id_dir).split(lmt)[-1] + str(self.terms_file_path).split(lmt)[-1]).ljust(32)[:32].encode('utf-8')
-        kb64 = base64.urlsafe_b64encode(kb)
-        self.cph = Fernet(kb64)
+        self.initialize()
 
-    def system_info(self):
-        """
-        Gathers information about the environment and system.
-        """
-        # Generate UUID
-        machine_id = str(uuid.uuid4())
-
-        # Environment (modify to detect your specific frameworks)
+    def initialize(self):
+        if self.initialized:
+            return True
+        if not self._check_terms():
+            self._accept_terms()
+        from vnai.scope.profile import inspector
+        inspector.setup_vnstock_environment()
         try:
-            from IPython import get_ipython
-            if 'IPKernelApp' not in get_ipython().config:  # Check if not in IPython kernel
-                if sys.stdout.isatty():
-                    environment = "Terminal"
-                else:
-                    environment = "Other"  # Non-interactive environment (e.g., script executed from an IDE)
-            else:
-                environment = "Jupyter"
-        except (ImportError, AttributeError):
-            # Fallback if IPython isn't installed or other checks fail
-            if sys.stdout.isatty():
-                environment = "Terminal"
+            from vnai.scope.device import device_registry
+            vnstock_version = getattr(__import__('vnstock'),
+'__version__','0.0.1')
+            if device_registry.needs_reregistration(vnstock_version):
+                system_info = inspector.examine()
+                device_registry.register(system_info, vnstock_version)
+                self.system_info = system_info
             else:
-                environment = "Other"
-
-        try:
-            if 'google.colab' in sys.modules:
-                hosting_service = "Google Colab"
-            elif 'CODESPACE_NAME' in os.environ:
-                hosting_service = "Github Codespace"
-            elif 'GITPOD_WORKSPACE_CLUSTER_HOST' in os.environ:
-                hosting_service = "Gitpod"
-            elif 'REPLIT_USER' in os.environ:
-                hosting_service = "Replit"
-            elif 'KAGGLE_CONTAINER_NAME' in os.environ:
-                hosting_service = "Kaggle"
-            elif '.hf.space' in os.environ['SPACE_HOST']:
-                hosting_service = "Hugging Face Spaces"
-        except:
-            hosting_service = "Local or Unknown"
-
-        # System information
-        os_info = platform.uname()
-
-        # CPU information
-        cpu_arch = platform.processor()  
-        cpu_logical_cores = psutil.cpu_count(logical=True)
-        cpu_cores = psutil.cpu_count(logical=False)
-
-        # Memory information
-        ram_total = psutil.virtual_memory().total / (1024**3)  # GB
-        ram_available = psutil.virtual_memory().available / (1024**3)  # GB
-
-        hostname = socket.gethostname()
-        IPAddr = socket.gethostbyname(hostname)
-
-        mac = ':'.join(['{:02x}'.format((uuid.getnode() >> elements) & 0xff) for elements in range(0, 2 * 6, 2)])
-
-        # Combine information into a dictionary
-        info = {
-            "uuid": machine_id,
-            "environment": environment,
-            "hosting_service": hosting_service,
-            "python_version": platform.python_version(),
-            "os_name": os_info.system,
-            "os_version": os_info.version,
-            "machine": os_info.machine,
-            "cpu_model": cpu_arch,
-            "cpu_cores": cpu_cores,
-            "cpu_logical_cores": cpu_logical_cores,
-            "ram_total": round(ram_total, 1),
-            "ram_available": round(ram_available, 1),
-            "local_ip": IPAddr,
-            "mac_address": mac,
-        }
+                self.system_info = device_registry.get_registry()
+        except Exception as e:
+            import logging
+            logger = logging.getLogger(__name__)
+            msg =f"Device registration failed: {e}. Using fallback."
+            logger.warning(msg)
+            self.system_info = inspector.examine()
+        from vnai.scope.promo import ContentManager
+        manager = ContentManager()
+        if manager.is_paid_user is not True:
+            from vnai.scope.promo import present
+            present()
+        from vnai.scope.state import record
+        record("initialization", {"timestamp": datetime.now().isoformat()})
+        from vnai.flow.relay import conduit
+        conduit.queue({
+"type":"system_info",
+"data": {
+"commercial": inspector.detect_commercial_usage(),
+"packages": inspector.scan_packages()
+            }
+        }, priority="high")
+        self.initialized = True
+        _trigger_patching_after_init()
+        return True
 
-        return info
+    def _check_terms(self):
+        return os.path.exists(self.terms_file_path)
 
-    def show_terms_and_conditions(self):
-        """
-        Displays terms and conditions and asks for acceptance.
-        """
-        print(self.terms_and_conditions)
-        
-        # check if os.environ[TC_VAR] exist and equal to tôi đồng ý
+    def _accept_terms(self):
+        from vnai.scope.profile import inspector
+        system_info = inspector.examine()
         if TC_VAR in os.environ and os.environ[TC_VAR] == TC_VAL:
-            response = TC_VAL
+            os.environ[TC_VAR] = TC_VAL
         else:
-            response = TC_VAL
             os.environ[TC_VAR] = TC_VAL
+        now = datetime.now()
+        machine_id = system_info['machine_id']
+        signed_agreement = (
+f"Người dùng có mã nhận dạng {machine_id} "
+f"đã chấp nhận điều khoản & điều kiện sử dụng Vnstock "
+f"lúc {now.isoformat()}\n\n"
+f"{TERMS_AND_CONDITIONS}"
+        )
+        with open(self.terms_file_path,"w", encoding="utf-8") as f:
+            f.write(signed_agreement)
+        env_file = self.id_dir /"environment.json"
+        env_data = {
+"accepted_agreement": True,
+"timestamp": now.isoformat(),
+"machine_id": machine_id
+        }
+        with open(env_file,"w") as f:
+            json.dump(env_data, f)
+        return True
+
+    def status(self):
+        from vnai.beam.pulse import monitor
+        from vnai.scope.state import tracker
+        return {
+"initialized": self.initialized,
+"health": monitor.report(),
+"metrics": tracker.get_metrics()
+        }
+
+    def configure_privacy(self, level="standard"):
+        from vnai.scope.state import tracker
+        return tracker.setup_privacy(level)
+_core_instance = None
+_core_lock = threading.Lock()
+
+def _get_core():
+    global _core_instance
+    if _core_instance is None:
+        with _core_lock:
+            if _core_instance is None:
+                _core_instance = Core()
+    return _core_instance
+
+def tc_init():
+    return _get_core().initialize()
+
+def setup():
+    return _get_core().initialize()
+
+def optimize_execution(resource_type="default"):
+    def decorator(func):
+        _optimized_func = [None]
+        @functools.wraps(func)
+
+        def wrapper(*args, **kwargs):
+            if _optimized_func[0] is None:
+                from vnai.beam.quota import optimize
+                actual_decorator = optimize(resource_type)
+                _optimized_func[0] = actual_decorator(func)
+            return _optimized_func[0](*args, **kwargs)
+        return wrapper
+    return decorator
+
+def agg_execution(resource_type="default"):
+    def decorator(func):
+        _optimized_func = [None]
+        @functools.wraps(func)
+
+        def wrapper(*args, **kwargs):
+            if _optimized_func[0] is None:
+                from vnai.beam.quota import optimize
+                actual_decorator = optimize(resource_type, ad_cooldown=1500,
+                                          content_trigger_threshold=100000)
+                _optimized_func[0] = actual_decorator(func)
+            return _optimized_func[0](*args, **kwargs)
+        return wrapper
+    return decorator
 
-        from datetime import datetime
-        # get now time in string
+def measure_performance(module_type="function"):
+    def decorator(func):
+        _captured_func = [None]
+        @functools.wraps(func)
+
+        def wrapper(*args, **kwargs):
+            if _captured_func[0] is None:
+                from vnai.beam.metrics import capture
+                actual_decorator = capture(module_type)
+                _captured_func[0] = actual_decorator(func)
+            return _captured_func[0](*args, **kwargs)
+        return wrapper
+    return decorator
+
+def accept_license_terms(terms_text=None):
+    if terms_text is None:
+        terms_text = TERMS_AND_CONDITIONS
+    from vnai.scope.profile import inspector
+    system_info = inspector.examine()
+    terms_file_path = (
+        pathlib.Path.home() /".vnstock" /"id" /
+"terms_agreement.txt"
+    )
+    os.makedirs(os.path.dirname(terms_file_path), exist_ok=True)
+    now = datetime.now()
+    machine_id = system_info['machine_id']
+    with open(terms_file_path,"w", encoding="utf-8") as f:
+        f.write(f"Người dùng có mã nhận dạng {machine_id} "
+f"đã chấp nhận lúc {now.isoformat()}\n\n")
+        f.write(terms_text)
+    return True
+
+def accept_vnstock_terms():
+    from vnai.scope.profile import inspector
+    system_info = inspector.examine()
+    home_dir = pathlib.Path.home()
+    project_dir = home_dir /".vnstock"
+    project_dir.mkdir(exist_ok=True)
+    id_dir = project_dir /'id'
+    id_dir.mkdir(exist_ok=True)
+    env_file = id_dir /"environment.json"
+    env_data = {
+"accepted_agreement": True,
+"timestamp": datetime.now().isoformat(),
+"machine_id": system_info['machine_id']
+    }
+    try:
+        with open(env_file,"w") as f:
+            json.dump(env_data, f)
+        terms_file = id_dir /"terms_agreement.txt"
         now = datetime.now()
-        HARDWARE = self.system_info()
-        # VERSION = pkg_resources.get_distribution('vnstock').version
-        
-        VERSION = None
-        try:
-            VERSION = importlib.metadata.version('vnstock')
-        except importlib.metadata.PackageNotFoundError:
-            # print("Package 'vnstock' not found")
-            pass
-
-        # parse HARDWARE to string to store in the file
-        signed_aggreement = f"MÔ TẢ:\nNgười dùng có mã nhận dạng {HARDWARE['uuid']} đã chấp nhận điều khoản & điều kiện sử dụng Vnstock lúc {now}\n---\n\nTHÔNG TIN THIẾT BỊ: {str(HARDWARE)}\n\nĐính kèm bản sao nội dung bạn đã đọc, hiểu rõ và đồng ý dưới đây:\n{self.terms_and_conditions}"
-        
-        # Store the acceptance
-        with open(self.terms_file_path, "w", encoding="utf-8") as f:
-            f.write(signed_aggreement)
+        machine_id = system_info['machine_id']
+        with open(terms_file,"w", encoding="utf-8") as f:
+            f.write(f"Người dùng có mã nhận dạng {machine_id} "
+f"đã chấp nhận lúc {now.isoformat()}\n\n")
+            f.write(TERMS_AND_CONDITIONS)
+        print("Vnstock terms accepted successfully.")
         return True
+    except Exception as e:
+        print(f"Error accepting terms: {e}")
+        return False
+
+def configure_privacy(level="standard"):
+    from vnai.scope.state import tracker
+    return tracker.setup_privacy(level)
+
+def check_commercial_usage():
+    from vnai.scope.profile import inspector
+    return inspector.detect_commercial_usage()
 
-    def log_analytics_data(self):
-        """
-        Sends analytics data to a webhook.
-        """
-        HARDWARE = self.system_info()
-        EP = 'gAAAAABmOPNX4DJAsImlkzvtcyezBxr4UcK_HpCOgz-GOF9yBDP99tWNFYM_ZjeC22kNqmX3urZa467BC1D2fPLJrUkp6rQizYEMK4m196ZlOzUhwCbfjdvURXesL3LC7DofOgwWjNyltPQ8AnPyB4YUMnnAwnFooQ=='
-        TGE = self.cph.decrypt(self.target).decode('utf-8')
-        WH = f"{self.cph.decrypt(((self.RH+EP+self.RH)[30:-30]).encode()).decode('utf-8')}{TGE}"
-
-        data = {
-            "systems": HARDWARE,
-            "accepted_agreement": True,
-            "installed_packages": self.packages_installed(),
+def authenticate_for_persistence():
+    from vnai.scope.profile import inspector
+    return inspector.get_or_create_user_id()
+
+def get_user_tier():
+    try:
+        from vnai.beam.auth import authenticator
+        return authenticator.get_tier_info()
+    except Exception as e:
+        return {
+"tier":"guest",
+"description":"Khách (không có API key)",
+"limits": {"per_minute": 20,"per_hour": 1200},
+"error": str(e)
         }
 
-        # save data to a json file in id folder
-        with open(self.env_config, "w", encoding="utf-8") as f:
-            f.write(json.dumps(data, indent=4))
+def refresh_tier_cache():
+    try:
+        from vnai.beam.auth import authenticator
+        authenticator.get_tier(force_refresh=True)
+        return True
+    except Exception:
+        return False
+
+def setup_api_key(api_key):
+    from vnai.beam.auth import authenticator
+    return authenticator.setup_api_key(api_key)
+
+def get_api_key():
+    from vnai.beam.auth import authenticator
+    return authenticator.get_api_key()
+
+def remove_api_key():
+    from vnai.beam.auth import authenticator
+    return authenticator.remove_api_key()
+
+def check_api_key_status():
+    from vnai.beam.auth import authenticator
+    return authenticator.check_api_key_status()
 
+def print_api_key_help():
+    from vnai.beam.auth import authenticator
+    return authenticator.print_help()
+
+def get_quota_status(api_key):
+    from vnai.beam.quota_endpoint import quota_endpoint
+    return quota_endpoint.get_quota_status(api_key)
+
+def get_tier_info():
+    from vnai.beam.quota_endpoint import quota_endpoint
+    return quota_endpoint.get_tier_info()
+
+def check_quota_available(api_key):
+    from vnai.beam.quota_endpoint import quota_endpoint
+    return quota_endpoint.check_quota(api_key)
+
+def get_quota_metadata(api_key):
+    from vnai.beam.quota_endpoint import quota_endpoint
+    return quota_endpoint.get_metadata(api_key)
+
+def record_api_usage(api_key, amount=1):
+    from vnai.beam.quota_endpoint import quota_endpoint
+    return quota_endpoint.record_usage(api_key, amount)
+
+def balance_sheet(symbol: str, source: str ='vci', period: str ='year',
+                 lang: Optional[str] ='en', show_log: bool = False) -> pd.DataFrame:
+    _ensure_patches_applied()
+    from vnai.beam.fundamental import balance_sheet as get_balance_sheet
+    return get_balance_sheet(symbol, source=source, 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:
+    _ensure_patches_applied()
+    from vnai.beam.fundamental import income_statement as get_income_statement
+    return get_income_statement(symbol, source=source, period=period, lang=lang, show_log=show_log)
+
+def cash_flow(symbol, source='vci', period='year', lang='en', show_log=False):
+    _ensure_patches_applied()
+    from vnai.beam.fundamental import cash_flow as get_cash_flow
+    return get_cash_flow(symbol, source=source, period=period, lang=lang, show_log=show_log)
+_patches_initialized = False
+
+def _ensure_patches_applied():
+    global _patches_initialized
+    if not _patches_initialized:
         try:
-            response = requests.post(WH, json=data)
-        except:
-            raise SystemExit("Không thể gửi dữ liệu phân tích. Vui lòng kiểm tra kết nối mạng và thử lại sau.")
-
-    def check_terms_accepted(self):
-        """
-        Checks if terms and conditions are accepted.
-        """
-        if not self.env_config.exists() or not self.terms_file_path.exists():
-            # If not, ask for acceptance
-            accepted = self.show_terms_and_conditions()
-            if not accepted:
-                raise SystemExit("Điều khoản và điều kiện không được chấp nhận. Không thể tiếp tục.")
-            else:
-                self.log_analytics_data()
-
-    def packages_installed(self):
-        """
-        Checks installed packages and returns a dictionary.
-        """
-        # Define package mapping
-        package_mapping = {
-                    "vnstock_family": [
-                        "vnstock",
-                        "vnstock3",
-                        "vnstock_ezchart",
-                        "vnstock_data_pro"
-                        "vnstock_market_data_pipeline",
-                        "vnstock_ta",
-                        "vnii",
-                        "vnai",
-                    ],
-                    "analytics": [
-                        "openbb",
-                        "pandas_ta"
-                    ],
-                    "static_charts": [
-                        "matplotlib",
-                        "seaborn",
-                        "altair"
-                    ],
-                    "dashboard": [
-                        "streamlit",
-                        "voila",
-                        "panel",
-                        "shiny",
-                        "dash",
-                    ],
-                    "interactive_charts": [
-                        "mplfinance",
-                        "plotly",
-                        "plotline",
-                        "bokeh",
-                        "pyecharts",
-                        "highcharts-core",
-                        "highcharts-stock",
-                        "mplchart",
-                    ],
-                    "datafeed": [
-                        "yfinance",
-                        "alpha_vantage",
-                        "pandas-datareader",
-                        "investpy",
-                    ],
-                    "official_api": [
-                        "ssi-fc-data",
-                        "ssi-fctrading"
-                    ],
-                    "risk_return": [
-                        "pyfolio",
-                        "empyrical",
-                        "quantstats",
-                        "financetoolkit",
-                    ],
-                    "machine_learning": [
-                        "scipy",
-                        "sklearn",
-                        "statsmodels",
-                        "pytorch",
-                        "tensorflow",
-                        "keras",
-                        "xgboost"
-                    ],
-                    "indicators": [
-                        "stochastic",
-                        "talib",
-                        "tqdm",
-                        "finta",
-                        "financetoolkit",
-                        "tulipindicators"
-                    ],
-                    "backtesting": [
-                        "vectorbt",
-                        "backtesting",
-                        "bt",
-                        "zipline",
-                        "pyalgotrade",
-                        "backtrader",
-                        "pybacktest",
-                        "fastquant",
-                        "lean",
-                        "ta",
-                        "finmarketpy",
-                        "qstrader",
-                    ],
-                    "server": [
-                        "fastapi",
-                        "flask",
-                        "uvicorn",
-                        "gunicorn"
-                    ],
-                    "framework": [
-                        "lightgbm",
-                        "catboost",
-                        "django",
-                    ]
-                }
-
-        installed_packages = {}
-
-        for category, packages in package_mapping.items():
-            installed_packages[category] = []
-            for pkg in packages:
-                try:
-                    version = importlib.metadata.version(pkg)
-                    installed_packages[category].append((pkg, version))
-                except importlib.metadata.PackageNotFoundError:
-                    pass
-
-        return installed_packages
+            from vnai.beam.patching import apply_all_patches
+            apply_all_patches()
+            _patches_initialized = True
+        except Exception:
+            _patches_initialized = True
 
-def tc_init():
-    vnstock_initializer = VnstockInitializer(TG)
-    vnstock_initializer.check_terms_accepted()
+def _trigger_patching_after_init():
+    _ensure_patches_applied()

vnai/beam/__init__.py

@@ -0,0 +1,26 @@
+def __getattr__(name):
+    if name =='guardian':
+        from vnai.beam.quota import guardian
+        return guardian
+    elif name =='optimize':
+        from vnai.beam.quota import optimize
+        return optimize
+    elif name =='collector':
+        from vnai.beam.metrics import collector
+        return collector
+    elif name =='capture':
+        from vnai.beam.metrics import capture
+        return capture
+    elif name =='monitor':
+        from vnai.beam.pulse import monitor
+        return monitor
+    elif name =='get_auth_state_manager':
+        from vnai.beam.auth import get_auth_state_manager
+        return get_auth_state_manager
+    elif name =='AuthStateManager':
+        from vnai.beam.auth import AuthStateManager
+        return AuthStateManager
+    elif name =='authenticator':
+        from vnai.beam.auth import authenticator
+        return authenticator
+    raise AttributeError(f"module 'vnai.beam' has no attribute '{name}'")