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

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/patching.py

@@ -0,0 +1,223 @@
+"""
+Monkey-patch vnstock source methods to apply tier-based period limiting.
+This module patches VCI and KBS Finance methods to automatically apply
+period limits based on user tier, so end users get limited periods
+even when calling vnstock methods directly.
+"""
+from typing import Optional, Callable
+from functools import wraps
+import pandas as pd
+
+def get_max_periods() -> Optional[int]:
+    from vnai.beam.auth import authenticator
+    PERIOD_LIMITS = {
+'guest': 4,
+'free': 8,
+'bronze': None,
+'silver': None,
+'golden': None,
+    }
+    tier = authenticator.get_tier()
+    return PERIOD_LIMITS.get(tier)
+
+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 get_period_limit_notice() -> Optional[str]:
+    from vnai.beam.auth import authenticator
+    tier = authenticator.get_tier()
+    if tier =='guest':
+        return (
+"ℹ️  Phiên bản cộng đồng: Báo cáo tài chính được giới hạn tối đa 4 kỳ để minh hoạ thuật toán. "
+"Để truy cập đầy đủ tất cả các kỳ báo cáo, vui lòng tham gia gói thành viên tài trợ dự án: "
+"https://vnstocks.com/insiders-program"
+        )
+    elif tier =='free':
+        return (
+"ℹ️  Phiên bản cộng đồng: Báo cáo tài chính được giới hạn tối đa 8 kỳ để minh hoạ thuật toán. "
+"Để truy cập đầy đủ tất cả các kỳ báo cáo, vui lòng tham gia gói thành viên tài trợ dự án: "
+"https://vnstocks.com/insiders-program"
+        )
+    return None
+
+def get_period_limit_notice_html() -> Optional[str]:
+    from vnai.beam.auth import authenticator
+    tier = authenticator.get_tier()
+    if tier =='guest':
+        return (
+"<div style='background-color: #e3f2fd; border-left: 4px solid #2196f3; "
+"padding: 12px 16px; margin: 12px 0; border-radius: 4px; font-size: 13px;'>"
+"<strong>ℹ️  Phiên bản cộng đồng</strong><br>"
+"Báo cáo tài chính được giới hạn tối đa <strong>4 kỳ</strong> để minh hoạ thuật toán. "
+"Để truy cập đầy đủ tất cả các kỳ báo cáo, vui lòng "
+"<a href='https://vnstocks.com/insiders-program' target='_blank'>tham gia gói thành viên tài trợ dự án</a>."
+"</div>"
+        )
+    elif tier =='free':
+        return (
+"<div style='background-color: #e3f2fd; border-left: 4px solid #2196f3; "
+"padding: 12px 16px; margin: 12px 0; border-radius: 4px; font-size: 13px;'>"
+"<strong>ℹ️  Phiên bản cộng đồng</strong><br>"
+"Báo cáo tài chính được giới hạn tối đa <strong>8 kỳ</strong> để minh hoạ thuật toán. "
+"Để truy cập đầy đủ tất cả các kỳ báo cáo, vui lòng "
+"<a href='https://vnstocks.com/insiders-program' target='_blank'>tham gia gói thành viên tài trợ dự án</a>."
+"</div>"
+        )
+    return None
+
+def display_period_limit_notice_jupyter() -> None:
+    try:
+        from IPython.display import HTML, display
+        notice_html = get_period_limit_notice_html()
+        if notice_html:
+            display(HTML(notice_html))
+    except ImportError:
+        notice = get_period_limit_notice()
+        if notice:
+            print(f"\n{notice}\n")
+
+def should_show_notice() -> bool:
+    from vnai.beam.auth import authenticator
+    tier = authenticator.get_tier()
+    return tier in ('guest','free')
+
+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
+
+    def parse_period(p):
+        if'-Q' in str(p):
+            year, quarter = str(p).split('-Q')
+            return (int(year), int(quarter))
+        else:
+            return (int(p), 5)
+    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 patch_vci_finance():
+    try:
+        import sys
+        if'vnstock.explorer.vci.financial' not in sys.modules:
+            return False
+        from vnstock.explorer.vci.financial import Finance as VCI_Finance
+        original_balance_sheet = VCI_Finance.balance_sheet
+        original_income_statement = VCI_Finance.income_statement
+        original_cash_flow = VCI_Finance.cash_flow
+        _notice_shown = {'balance_sheet': False,'income_statement': False,'cash_flow': False}
+        @wraps(original_balance_sheet)
+
+        def balance_sheet_with_limit(self, period: Optional[str] = None, lang: Optional[str] ='en',
+                                     dropna: Optional[bool] = True, show_log: Optional[bool] = False) -> pd.DataFrame:
+            df = original_balance_sheet(self, period=period, lang=lang, dropna=dropna, show_log=show_log)
+            df_limited = limit_vci_periods(df, max_periods=get_max_periods())
+            if should_show_notice() and not _notice_shown['balance_sheet']:
+                _notice_shown['balance_sheet'] = True
+                display_period_limit_notice_jupyter()
+            return df_limited
+        @wraps(original_income_statement)
+
+        def income_statement_with_limit(self, period: Optional[str] = None, lang: Optional[str] ='en',
+                                       dropna: Optional[bool] = True, show_log: Optional[bool] = False) -> pd.DataFrame:
+            df = original_income_statement(self, period=period, lang=lang, dropna=dropna, show_log=show_log)
+            df_limited = limit_vci_periods(df, max_periods=get_max_periods())
+            if should_show_notice() and not _notice_shown['income_statement']:
+                _notice_shown['income_statement'] = True
+                display_period_limit_notice_jupyter()
+            return df_limited
+        @wraps(original_cash_flow)
+
+        def cash_flow_with_limit(self, period: Optional[str] = None, lang: Optional[str] ='en',
+                                dropna: Optional[bool] = True, show_log: Optional[bool] = False) -> pd.DataFrame:
+            df = original_cash_flow(self, period=period, lang=lang, dropna=dropna, show_log=show_log)
+            df_limited = limit_vci_periods(df, max_periods=get_max_periods())
+            if should_show_notice() and not _notice_shown['cash_flow']:
+                _notice_shown['cash_flow'] = True
+                display_period_limit_notice_jupyter()
+            return df_limited
+        VCI_Finance.balance_sheet = balance_sheet_with_limit
+        VCI_Finance.income_statement = income_statement_with_limit
+        VCI_Finance.cash_flow = cash_flow_with_limit
+        return True
+    except Exception as e:
+        print(f"Warning: Could not patch VCI Finance: {e}")
+        return False
+
+def patch_kbs_finance():
+    try:
+        from vnstock.explorer.kbs.financial import Finance as KBS_Finance
+        from vnai.beam.fundamental import limit_periods_by_columns
+        original_balance_sheet = KBS_Finance.balance_sheet
+        original_income_statement = KBS_Finance.income_statement
+        original_cash_flow = KBS_Finance.cash_flow
+        _notice_shown = {'balance_sheet': False,'income_statement': False,'cash_flow': False}
+        @wraps(original_balance_sheet)
+
+        def balance_sheet_with_limit(self, period: Optional[str] = None, show_log: Optional[bool] = False) -> pd.DataFrame:
+            df = original_balance_sheet(self, period=period, show_log=show_log)
+            df_limited = limit_periods_by_columns(df, max_periods=get_max_periods())
+            if should_show_notice() and not _notice_shown['balance_sheet']:
+                _notice_shown['balance_sheet'] = True
+                display_period_limit_notice_jupyter()
+            return df_limited
+        @wraps(original_income_statement)
+
+        def income_statement_with_limit(self, period: Optional[str] = None, show_log: Optional[bool] = False) -> pd.DataFrame:
+            df = original_income_statement(self, period=period, show_log=show_log)
+            df_limited = limit_periods_by_columns(df, max_periods=get_max_periods())
+            if should_show_notice() and not _notice_shown['income_statement']:
+                _notice_shown['income_statement'] = True
+                display_period_limit_notice_jupyter()
+            return df_limited
+        @wraps(original_cash_flow)
+
+        def cash_flow_with_limit(self, period: Optional[str] = None, show_log: Optional[bool] = False) -> pd.DataFrame:
+            df = original_cash_flow(self, period=period, show_log=show_log)
+            df_limited = limit_periods_by_columns(df, max_periods=get_max_periods())
+            if should_show_notice() and not _notice_shown['cash_flow']:
+                _notice_shown['cash_flow'] = True
+                display_period_limit_notice_jupyter()
+            return df_limited
+        KBS_Finance.balance_sheet = balance_sheet_with_limit
+        KBS_Finance.income_statement = income_statement_with_limit
+        KBS_Finance.cash_flow = cash_flow_with_limit
+        return True
+    except Exception as e:
+        print(f"Warning: Could not patch KBS Finance: {e}")
+        return False
+_patches_applied = False
+_patches_lock = __import__('threading').Lock()
+
+def apply_all_patches():
+    global _patches_applied
+    with _patches_lock:
+        if _patches_applied:
+            return {'vci': True,'kbs': True}
+        try:
+            vci_patched = patch_vci_finance()
+            kbs_patched = patch_kbs_finance()
+            _patches_applied = True
+            return {
+'vci': vci_patched,
+'kbs': kbs_patched,
+            }
+        except Exception as e:
+            return {'vci': False,'kbs': False}

vnai/beam/quota.py

@@ -5,17 +5,72 @@ from collections import defaultdict
 from datetime import datetime
 
 class RateLimitExceeded(Exception):
-    def __init__(self, resource_type, limit_type="min", current_usage=None, limit_value=None, retry_after=None):
+    def __init__(self, resource_type, limit_type="min", current_usage=None, limit_value=None, retry_after=None, tier=None):
         self.resource_type = resource_type
         self.limit_type = limit_type
         self.current_usage = current_usage
         self.limit_value = limit_value
         self.retry_after = retry_after
-        message =f"Bạn đã gửi quá nhiều request tới {resource_type}. "
+        self.tier = tier
+        promotional_message =""
+        try:
+            from vnai.scope.promo import (
+                should_show_promotional_for_rate_limit,
+                mark_promotional_shown,
+                get_promotional_message
+            )
+            if should_show_promotional_for_rate_limit(tier):
+                promotional_message = get_promotional_message() +"\n"
+                mark_promotional_shown()
+        except Exception as e:
+            pass
+        message =f"\n{'='*60}\n"
+        message +=f"⚠️  GIỚI HẠN API ĐÃ ĐẠT TỐI ĐA (Rate Limit Exceeded)\n"
+        message +=f"{'='*60}\n\n"
+        scope_names = {
+'min':'phút (minute)',
+'hour':'giờ (hour)',
+'day':'ngày (day)'
+        }
+        scope_display = scope_names.get(limit_type, limit_type)
+        message +=f"📌 Bạn đã đạt giới hạn tối đa số lượt yêu cầu API trong 1 {scope_display}.\n"
+        message +=f"   (You have reached the maximum API request limit for this period)\n\n"
+        message +=f"📊 Chi tiết (Details):\n"
+        if tier:
+            tier_names = {
+'guest':'Khách (Guest)',
+'free':'Phiên bản cộng đồng (Community)',
+'bronze':'Thành viên Bronze (Bronze Member)',
+'silver':'Thành viên Silver (Silver Member)',
+'golden':'Thành viên Golden (Golden Member)'
+            }
+            tier_display = tier_names.get(tier,f"Thành viên {tier.title()}")
+            message +=f"   • Gói hiện tại: {tier_display}\n"
+        message +=f"   • Giới hạn: {limit_value} requests/{scope_display.split()[0]}\n"
+        message +=f"   • Đã sử dụng: {current_usage}/{limit_value}\n"
         if retry_after:
-            message +=f"Vui lòng thử lại sau {round(retry_after)} giây."
+            message +=f"   • Chờ {round(retry_after)} giây để tiếp tục (Wait to retry)\n"
+        message +=f"\n💡 Giải pháp (Solutions):\n"
+        message +=f"   1️⃣ Chờ {round(retry_after) if retry_after else 'một lúc'} giây rồi thử lại\n"
+        message +=f"      (Wait and retry)\n"
+        message +=f"   2️⃣ Tham gia gói thành viên tài trợ để sử dụng không bị gián đoạn\n"
+        message +=f"      (Join sponsor membership for uninterrupted access)\n"
+        if tier =='guest':
+            message +=f"\n🚀 Nâng cấp (Upgrade):\n"
+            message +=f"   • Phiên bản cộng đồng (60 request/phút - Community):\n"
+            message +=f"     Đăng ký API key miễn phí: https://vnstocks.com/login\n"
+            message +=f"   • Gói thành viên tài trợ (180-600 request/phút - Sponsor):\n"
+            message +=f"     Tham gia: https://vnstocks.com/insiders-program\n"
+        elif tier =='free':
+            message +=f"\n🚀 Nâng cấp (Upgrade):\n"
+            message +=f"   • Gói thành viên tài trợ (180-600 request/phút - Sponsor):\n"
+            message +=f"     Tham gia: https://vnstocks.com/insiders-program\n"
         else:
-            message +="Vui lòng thêm thời gian chờ giữa các lần gửi request."
+            message +=f"\n🚀 Nâng cấp (Upgrade):\n"
+            message +=f"   • Gói cao hơn (Higher tier): https://vnstocks.com/insiders-program\n"
+        message +=f"\n{'='*60}\n"
+        if promotional_message:
+            message += promotional_message
         super().__init__(message)
 
 class Guardian:
@@ -30,24 +85,47 @@ class Guardian:
             return cls._instance
 
     def _initialize(self):
-        self.resource_limits = defaultdict(lambda: defaultdict(int))
         self.usage_counters = defaultdict(lambda: defaultdict(list))
-        self.resource_limits["default"] = {"min": 60,"hour": 3000}
-        self.resource_limits["TCBS"] = {"min": 60,"hour": 3000}
-        self.resource_limits["VCI"] = {"min": 60,"hour": 3000}
-        self.resource_limits["MBK"] = {"min": 600,"hour": 36000}
-        self.resource_limits["MAS.ext"] = {"min": 600,"hour": 36000}
-        self.resource_limits["VCI.ext"] = {"min": 600,"hour": 36000}
-        self.resource_limits["FMK.ext"] = {"min": 600,"hour": 36000}
-        self.resource_limits["VND.ext"] = {"min": 600,"hour": 36000}
-        self.resource_limits["CAF.ext"] = {"min": 600,"hour": 36000}
-        self.resource_limits["SPL.ext"] = {"min": 600,"hour": 36000}
-        self.resource_limits["VDS.ext"] = {"min": 600,"hour": 36000}
-        self.resource_limits["FAD.ext"] = {"min": 600,"hour": 36000}
+        self.quota_manager = None
+
+    def _get_quota_manager(self):
+        if self.quota_manager is None:
+            try:
+                from vnai.beam.quota_manager import quota_manager
+                self.quota_manager = quota_manager
+            except ImportError:
+                return None
+        return self.quota_manager
+
+    def _get_tier_limits(self):
+        try:
+            from vnai.beam.auth import authenticator
+            return authenticator.get_limits()
+        except Exception as e:
+            return {"min": 20,"hour": 1200,"day": 28800}
 
-    def verify(self, operation_id, resource_type="default"):
+    def _get_current_tier(self):
+        try:
+            from vnai.beam.auth import authenticator
+            return authenticator.get_tier()
+        except Exception:
+            return None
+
+    def verify(self, operation_id, resource_type="default", api_key=None):
         current_time = time.time()
-        limits = self.resource_limits.get(resource_type, self.resource_limits["default"])
+        limits = self._get_tier_limits()
+        if api_key:
+            qm = self._get_quota_manager()
+            if qm:
+                quota_check = qm.check_quota(api_key)
+                if not quota_check.get("allowed"):
+                    raise RateLimitExceeded(
+                        resource_type=resource_type,
+                        limit_type=quota_check.get("reason","unknown"),
+                        current_usage=quota_check.get("usage"),
+                        limit_value=quota_check.get("limit"),
+                        retry_after=quota_check.get("reset_in_seconds")
+                    )
         minute_cutoff = current_time - 60
         self.usage_counters[resource_type]["min"] = [
             t for t in self.usage_counters[resource_type]["min"]
@@ -68,12 +146,14 @@ class Guardian:
                 },
                 priority="high"
             )
+            current_tier = self._get_current_tier()
             raise RateLimitExceeded(
                 resource_type=resource_type,
                 limit_type="min",
                 current_usage=minute_usage,
                 limit_value=limits["min"],
-                retry_after=60 - (current_time % 60)
+                retry_after=60 - (current_time % 60),
+                tier=current_tier
             )
         hour_cutoff = current_time - 3600
         self.usage_counters[resource_type]["hour"] = [
@@ -94,12 +174,14 @@ class Guardian:
             }
         )
         if hour_exceeded:
+            current_tier = self._get_current_tier()
             raise RateLimitExceeded(
                 resource_type=resource_type,
                 limit_type="hour",
                 current_usage=hour_usage,
                 limit_value=limits["hour"],
-                retry_after=3600 - (current_time % 3600)
+                retry_after=3600 - (current_time % 3600),
+                tier=current_tier
             )
         self.usage_counters[resource_type]["min"].append(current_time)
         self.usage_counters[resource_type]["hour"].append(current_time)
@@ -107,7 +189,7 @@ class Guardian:
 
     def usage(self, resource_type="default"):
         current_time = time.time()
-        limits = self.resource_limits.get(resource_type, self.resource_limits["default"])
+        limits = self._get_tier_limits()
         minute_cutoff = current_time - 60
         hour_cutoff = current_time - 3600
         self.usage_counters[resource_type]["min"] = [
@@ -126,7 +208,7 @@ class Guardian:
 
     def get_limit_status(self, resource_type="default"):
         current_time = time.time()
-        limits = self.resource_limits.get(resource_type, self.resource_limits["default"])
+        limits = self._get_tier_limits()
         minute_cutoff = current_time - 60
         hour_cutoff = current_time - 3600
         minute_usage = len([t for t in self.usage_counters[resource_type]["min"] if t > minute_cutoff])
@@ -214,11 +296,11 @@ def _create_wrapper(func, resource_type, loop_threshold, time_window, ad_cooldow
                 call_history.pop(0)
             loop_detected = len(call_history) >= loop_threshold
             if debug and loop_detected:
-                print(f"[OPTIMIZE] Đã phát hiện vòng lặp cho {func.__name__}: {len(call_history)} lần gọi trong {time_window}s")
+                print(f"Đã phát hiện vòng lặp cho {func.__name__}: {len(call_history)} lần gọi trong {time_window}s")
             if loop_detected:
                 consecutive_loop_detections += 1
                 if debug:
-                    print(f"[OPTIMIZE] Số lần phát hiện vòng lặp liên tiếp: {consecutive_loop_detections}/{content_trigger_threshold}")
+                    print(f"Số lần phát hiện vòng lặp liên tiếp: {consecutive_loop_detections}/{content_trigger_threshold}")
             else:
                 consecutive_loop_detections = 0
             should_show_content = (consecutive_loop_detections >= content_trigger_threshold) and                                 (current_time - last_ad_time >= ad_cooldown) and                                 not session_displayed
@@ -228,20 +310,15 @@ def _create_wrapper(func, resource_type, loop_threshold, time_window, ad_cooldow
                 content_triggered = True
                 session_displayed = True
                 if debug:
-                    print(f"[OPTIMIZE] Đã kích hoạt nội dung cho {func.__name__}")
+                    print(f"Đã kích hoạt nội dung cho {func.__name__}")
                 try:
                     from vnai.scope.promo import manager
-                    try:
-                        from vnai.scope.profile import inspector
-                        environment = inspector.examine().get("environment", None)
-                        manager.present_content(environment=environment, context="loop")
-                    except ImportError:
-                        manager.present_content(context="loop")
+                    manager.present_content(context="loop")
                 except ImportError:
                     print(f"Phát hiện vòng lặp: Hàm '{func.__name__}' đang được gọi trong một vòng lặp")
                 except Exception as e:
                     if debug:
-                        print(f"[OPTIMIZE] Lỗi khi hiển thị nội dung: {str(e)}")
+                        print(f"Lỗi khi hiển thị nội dung: {str(e)}")
             try:
                 with CleanErrorContext():
                     guardian.verify(func.__name__, resource_type)
@@ -261,16 +338,9 @@ def _create_wrapper(func, resource_type, loop_threshold, time_window, ad_cooldow
                 if not session_displayed:
                     try:
                         from vnai.scope.promo import manager
-                        try:
-                            from vnai.scope.profile import inspector
-                            environment = inspector.examine().get("environment", None)
-                            manager.present_content(environment=environment, context="loop")
-                            session_displayed = True
-                            last_ad_time = current_time
-                        except ImportError:
-                            manager.present_content(context="loop")
-                            session_displayed = True
-                            last_ad_time = current_time
+                        manager.present_content(context="loop")
+                        session_displayed = True
+                        last_ad_time = current_time
                     except Exception:
                         pass
                 if retries < max_retries:
@@ -279,7 +349,7 @@ def _create_wrapper(func, resource_type, loop_threshold, time_window, ad_cooldow
                     if hasattr(e,"retry_after") and e.retry_after:
                         wait_time = min(wait_time, e.retry_after)
                     if debug:
-                        print(f"[OPTIMIZE] Đã đạt giới hạn tốc độ cho {func.__name__}, thử lại sau {wait_time} giây (lần thử {retries}/{max_retries})")
+                        print(f"Đã đạt giới hạn tốc độ cho {func.__name__}, thử lại sau {wait_time} giây (lần thử {retries}/{max_retries})")
                     time.sleep(wait_time)
                     continue
                 else: