vnai 2.0.3__py3-none-any.whl → 2.0.5__py3-none-any.whl

vnai/scope/promo.py

@@ -1,3 +1,7 @@
+"""
+Promo module for vnai: fetches and presents promotional content periodically or on demand,
+using logging instead of printing to avoid polluting stdout for AI tools.
+"""
 import logging
 import requests
 from datetime import datetime
@@ -6,18 +10,49 @@ import threading
 import time
 import urllib.parse
 
+# Enum AdCategory (tương thích với vnii)
+class AdCategory:
+    FREE = 0
+    MANDATORY = 1
+    ANNOUNCEMENT = 2
+    REFERRAL = 3
+    FEATURE = 4
+    GUIDE = 5
+    SURVEY = 6
+    PROMOTION = 7
+    SECURITY = 8
+    MAINTENANCE = 9
+    WARNING = 10
+
+# Thêm import kiểm tra license từ vnii
+try:
+    from vnii import lc_init
+except ImportError:
+    lc_init = None  # Nếu không có vnii, luôn coi là free user
+
+# Module-level logger setup
 logger = logging.getLogger(__name__)
 if not logger.hasHandlers():
+    # Add a simple stream handler that only outputs the message text
     handler = logging.StreamHandler()
     handler.setFormatter(logging.Formatter('%(message)s'))
     logger.addHandler(handler)
     logger.setLevel(logging.INFO)
 
 class ContentManager:
+    """
+    Singleton manager to fetch remote or fallback promotional content and
+    present it in different environments (Jupyter, terminal, other).
+
+    Displays content automatically at randomized intervals via a background thread.
+    """
     _instance = None
     _lock = threading.Lock()
 
     def __new__(cls):
+        """
+        Ensure only one instance of ContentManager is created (thread-safe).
+        """
         with cls._lock:
             if cls._instance is None:
                 cls._instance = super(ContentManager, cls).__new__(cls)
@@ -25,94 +60,218 @@ class ContentManager:
             return cls._instance
 
     def _initialize(self):
+        """
+        Internal initializer: sets up display timing, URLs, and starts the periodic display thread.
+        """
+        global _vnii_check_attempted
+        if _vnii_check_attempted:
+            # Đã kiểm tra/cài đặt vnii trước đó, không làm lại nữa
+            return
+        _vnii_check_attempted = True
+        # Nếu máy đã từng cài vnii, luôn cài lại bản mới nhất; nếu chưa từng cài thì coi là free user
+        import sys
+        import importlib
+        try:
+            import importlib.metadata
+            try:
+                old_version = importlib.metadata.version("vnii")
+                # Nếu đã từng cài, luôn force cài bản mới nhất
+                VNII_LATEST_VERSION = "0.0.9"
+                VNII_URL = f"https://github.com/vnstock-hq/licensing/releases/download/vnii-{VNII_LATEST_VERSION}/vnii-{VNII_LATEST_VERSION}.tar.gz"
+                logger.debug(f"Đã phát hiện vnii version {old_version}. Đang cập nhật lên bản mới nhất...")
+                import subprocess
+                subprocess.check_call([sys.executable, "-m", "pip", "install", f"vnii@{VNII_URL}"])
+                importlib.invalidate_caches()
+                if "vnii" in sys.modules:
+                    importlib.reload(sys.modules["vnii"])
+                else:
+                    import vnii
+                new_version = importlib.metadata.version("vnii")
+                logger.debug(f"Đã cập nhật vnii lên version {new_version}")
+            except importlib.metadata.PackageNotFoundError:
+                # Nếu chưa từng cài, không cài, luôn coi là free user
+                logger.debug("Không phát hiện vnii trên hệ thống. Luôn coi là free user, không kiểm tra license.")
+                self.is_paid_user = False
+                return
+        except Exception as e:
+            logger.warning(f"Lỗi khi kiểm tra/cài đặt vnii: {e}")
+            user_msg = (
+                "Không thể tự động cài đặt/cập nhật vnii. "
+                "Vui lòng liên hệ admin hoặc hỗ trợ kỹ thuật của Vnstock để được trợ giúp. "
+                f"Chi tiết lỗi: {e}"
+            )
+            logger.error(user_msg)
+            try:
+                print(user_msg)
+            except Exception:
+                pass
+            self.is_paid_user = False
+            return
+
+        # Kiểm tra trạng thái paid user (sponsor) và cache lại
+        self.is_paid_user = False
+        logger.debug("[promo] Bắt đầu kiểm tra trạng thái paid user với vnii...")
+        if lc_init is not None:
+            try:
+                license_info = lc_init(repo_name='vnstock')
+                logger.debug(f"[promo] license_info trả về: {license_info}")
+                status = license_info.get('status', '').lower()
+                if 'recognized and verified' in status:
+                    self.is_paid_user = True
+                    logger.debug("[promo] Đã xác nhận paid user từ vnii. Sẽ không hiện quảng cáo.")
+                else:
+                    logger.debug(f"[promo] Không xác nhận được paid user từ vnii. Status: {status}")
+            except Exception as e:
+                logger.warning(f"[promo] Không thể kiểm tra trạng thái sponsor: {e}. Sẽ coi là free user và hiện quảng cáo.")
+        else:
+            logger.debug("[promo] Không tìm thấy module vnii. Luôn coi là free user và hiện quảng cáo.")
+
+        # Timestamp of last content display (epoch seconds)
         self.last_display = 0
+        # Minimum interval between displays (24 hours)
         self.display_interval = 24 * 3600
 
-        self.content_base_url = (
-            "https://vnstock-beam.hf.space/content-delivery"
-        )
-        self.target_url = (
-            "https://vnstocks.com/lp-khoa-hoc-python-chung-khoan"
-        )
+        # Base endpoints for fetching remote content and linking
+        self.content_base_url = "https://hq.vnstocks.com/static"
+        self.target_url = "https://vnstocks.com/lp-khoa-hoc-python-chung-khoan"
         self.image_url = (
             "https://vnstocks.com/img/trang-chu-vnstock-python-api-phan-tich-giao-dich-chung-khoan.jpg"
         )
 
+        # Launch the background thread to periodically present content
+        logger.debug(f"[promo] is_paid_user = {self.is_paid_user}")
         self._start_periodic_display()
 
     def _start_periodic_display(self):
+        """
+        Launch a daemon thread that sleeps a random duration between 2–6 hours,
+        then checks if the display interval has elapsed and calls present_content.
+        """
+        logger.debug("[promo] Khởi tạo thread hiển thị quảng cáo định kỳ...")
         def periodic_display():
+            logger.debug("[promo] Thread quảng cáo bắt đầu chạy.")
             while True:
+                # Nếu là paid user thì không bao giờ hiện ads
+                if self.is_paid_user:
+                    logger.debug("[promo] Đang là paid user trong thread. Không hiện quảng cáo, dừng thread.")
+                    break
+                # Randomize sleep to avoid synchronized requests across instances
                 sleep_time = random.randint(2 * 3600, 6 * 3600)
+                logger.debug(f"[promo] Thread quảng cáo sẽ ngủ {sleep_time//3600} giờ...")
                 time.sleep(sleep_time)
 
+                # Present content if enough time has passed since last_display
                 current_time = time.time()
+                logger.debug(f"[promo] Kiểm tra điều kiện hiện quảng cáo: time since last_display = {current_time - self.last_display}s")
                 if current_time - self.last_display >= self.display_interval:
+                    logger.debug("[promo] Đã đủ thời gian, sẽ gọi present_content(context='periodic')")
                     self.present_content(context="periodic")
+                else:
+                    logger.debug("[promo] Chưa đủ thời gian, chưa hiện quảng cáo.")
 
         thread = threading.Thread(target=periodic_display, daemon=True)
         thread.start()
 
-    def fetch_remote_content(self, context="init", html=True):
+    def fetch_remote_content(self, context: str = "init", html: bool = True) -> str:
+        if self.is_paid_user:
+            logger.debug("Paid user detected. Skip fetching remote content (ads).")
+            return ""
+
+        """
+        Fetch promotional content from remote service with context and format flag.
+
+        Args:
+            context: usage context (e.g., "init", "periodic", "loop").
+            html: if True, request HTML; otherwise plain text.
+
+        Returns:
+            The content string on HTTP 200, or None on failure.
+        """
         try:
+            # Build query params and URL
             params = {"context": context, "html": "true" if html else "false"}
             url = f"{self.content_base_url}?{urllib.parse.urlencode(params)}"
 
             response = requests.get(url, timeout=3)
             if response.status_code == 200:
                 return response.text
+            # Log non-200 responses at debug level
             logger.debug(f"Non-200 response fetching content: {response.status_code}")
             return None
         except Exception as e:
+            # Log exceptions without interrupting user code
             logger.debug(f"Failed to fetch remote content: {e}")
             return None
 
-    def present_content(self, environment=None, context="init"):
+    def present_content(self, context: str = "init", ad_category: int = AdCategory.FREE) -> None:
+        environment = None
+        logger.debug(f"[promo] Gọi present_content(context={context}, ad_category={ad_category}). is_paid_user = {getattr(self, 'is_paid_user', None)}")
+        """
+        Display promotional content in the appropriate environment.
+        ad_category: Loại quảng cáo (FREE, ANNOUNCEMENT, ...)
+        """
+        # Nếu là paid user và ad_category là FREE thì skip, còn lại vẫn hiện
+        if getattr(self, 'is_paid_user', False) and ad_category == AdCategory.FREE:
+            logger.debug("[promo] Đang là paid user và ad_category là FREE. Không hiện quảng cáo.")
+            return
+
+        # Chỉ hiện log này nếu debug mode
+        if logger.level <= logging.DEBUG:
+            logger.debug(f"[promo] Sẽ hiển thị quảng cáo với context={context}, ad_category={ad_category}")
+        # Update last display timestamp
         self.last_display = time.time()
 
+        # Auto-detect environment if not provided
         if environment is None:
             try:
                 from vnai.scope.profile import inspector
-
-                environment = (
-                    inspector.examine().get("environment", "unknown")
-                )
-            except Exception:
+                environment = inspector.examine().get("environment", "unknown")
+                logger.debug(f"[promo] Đã detect environment: {environment}")
+            except Exception as e:
+                logger.debug(f"[promo] Không detect được environment: {e}")
                 environment = "unknown"
 
-        if environment == "jupyter":
-            remote_content = self.fetch_remote_content(
-                context=context, html=True
-            )
-        else:
-            remote_content = self.fetch_remote_content(
-                context=context, html=False
-            )
-
-        fallback_content = self._generate_fallback_content(context)
+        # Retrieve remote or HTML/text content based on environment
+        remote_content = self.fetch_remote_content(
+            context=context, html=(environment == "jupyter")
+        )
+        logger.debug(f"[promo] remote_content = {bool(remote_content)} (None -> False, có nội dung -> True)")
+        # Generate fallback messages if remote fetch fails
+        fallback = self._generate_fallback_content(context)
+        logger.debug(f"[promo] fallback keys: {list(fallback.keys())}")
 
         if environment == "jupyter":
+            logger.debug("[promo] Đang ở môi trường Jupyter, sẽ thử display HTML/Markdown.")
             try:
                 from IPython.display import display, HTML, Markdown
 
                 if remote_content:
+                    logger.debug("[promo] Hiển thị quảng cáo bằng HTML từ remote_content.")
                     display(HTML(remote_content))
                 else:
+                    logger.debug("[promo] Không có remote_content, thử display fallback Markdown/HTML.")
                     try:
-                        display(Markdown(fallback_content["markdown"]))
-                    except Exception:
-                        display(HTML(fallback_content["html"]))
+                        display(Markdown(fallback["markdown"]))
+                    except Exception as e:
+                        logger.debug(f"[promo] Lỗi khi display Markdown: {e}, fallback HTML.")
+                        display(HTML(fallback["html"]))
             except Exception as e:
-                logger.debug(f"Jupyter display failed: {e}")
+                logger.debug(f"[promo] Jupyter display failed: {e}")
 
         elif environment == "terminal":
+            logger.debug("[promo] Đang ở môi trường terminal, sẽ log quảng cáo ra logger.")
+            # Log terminal-friendly or raw content via logger
             if remote_content:
-                logger.info(remote_content)
+                logger.debug("[promo] Hiển thị quảng cáo bằng remote_content cho terminal.")
+                logger.debug(remote_content)
             else:
-                logger.info(fallback_content["terminal"])
+                logger.debug("[promo] Không có remote_content, hiển thị fallback terminal.")
+                logger.debug(fallback["terminal"])
 
         else:
-            logger.info(fallback_content["simple"])
+            logger.debug(f"[promo] Môi trường khác ({environment}), hiển thị fallback simple.")
+            # Generic simple message for other environments
+            logger.debug(fallback["simple"])
 
     def _generate_fallback_content(self, context):
         fallback = {"html": "", "markdown": "", "terminal": "", "simple": ""}
@@ -180,39 +339,51 @@ class ContentManager:
 
 Cảm ơn bạn đã sử dụng package phân tích chứng khoán #1 tại Việt Nam
 
-* Tài liệu: [Sổ tay hướng dẫn](https://vnstocks.com/docs/category/s%E1%BB%95-tay-h%C6%B0%E1%BB%9Bng-d%E1%BA%ABn)
-* Cộng đồng: [Nhóm Facebook](https://www.facebook.com/groups/vnstock.official)
+* Tài liệu: [Sổ tay hướng dẫn](https://vnstocks.com/docs)
+* Cộng đồng: [Nhóm Facebook](https://facebook.com/groups/vnstock.official)
 
 Khám phá các tính năng mới nhất và tham gia cộng đồng để nhận hỗ trợ.
                 """
             )
             fallback["terminal"] = (
                 """
-╔══════════════════════════════════════════════════════════╗
-║                                                          ║
-║  👋 Chào mừng bạn đến với Vnstock!                       ║
-║                                                          ║
-║  Cảm ơn bạn đã sử dụng package phân tích                 ║
-║  chứng khoán #1 tại Việt Nam                             ║
-║                                                          ║
-║  ✓ Tài liệu: https://vnstocks.com/docs/category/s%E1%BB%95-tay-h%C6%B0%E1%BB%9Bng-d%E1%BA%ABn             ║
-║  ✓ Cộng đồng: https://www.facebook.com/groups/vnstock.official             ║
-║                                                          ║
-║  Khám phá các tính năng mới nhất và tham gia             ║
-║  cộng đồng để nhận hỗ trợ.                               ║
-║                                                          ║
-╚══════════════════════════════════════════════════════════╝
+╔════════════════════════════════════════════════════════════╗
+║                                                            ║
+║  👋 Chào mừng bạn đến với Vnstock!                         ║
+║                                                            ║
+║  Cảm ơn bạn đã sử dụng package phân tích                   ║
+║  chứng khoán #1 tại Việt Nam                               ║
+║                                                            ║
+║  ✓ Tài liệu: https://vnstocks.com/docs                     ║
+║  ✓ Cộng đồng: https://facebook.com/groups/vnstock.official ║
+║                                                            ║
+║  Khám phá các tính năng mới nhất và tham gia               ║
+║  cộng đồng để nhận hỗ trợ.                                 ║
+║                                                            ║
+╚════════════════════════════════════════════════════════════╝
                 """
             )
             fallback["simple"] = (
                 "👋 Chào mừng bạn đến với Vnstock! "
-                "Tài liệu: https://vnstocks.com/docs/tai-lieu/huong-dan-nhanh | "
-                "Cộng đồng: https://www.facebook.com/groups/vnstock.official"
+                "Tài liệu: https://vnstocks.com/onboard | "
+                "Cộng đồng: https://facebook.com/groups/vnstock.official"
             )
         return fallback
 
-# Singleton instance
+# Singleton instance for module-level use
 manager = ContentManager()
 
-def present(context="init"):  # module-level shortcut
-    return manager.present_content(context=context)
+# Ép buộc hiện quảng cáo ngay khi import nếu là free user
+if not getattr(manager, 'is_paid_user', False):
+    manager.present_content(context="auto_import")
+
+
+def present(context: str = "init", ad_category: int = AdCategory.FREE) -> None:
+    """
+    Shortcut to ContentManager.present_content for external callers.
+
+    Args:
+        context: propagate context string to ContentManager.
+        ad_category: loại quảng cáo (FREE, ANNOUNCEMENT, ...)
+    """
+    manager.present_content(context=context, ad_category=ad_category)

vnai/scope/state.py

@@ -1,7 +1,5 @@
-##
-
-##
-
+# vnai/scope/state.py
+# System state tracking
 
 import time
 import threading
@@ -11,7 +9,7 @@ from datetime import datetime
 from pathlib import Path
 
 class Tracker:
-    #--
+    """Tracks system state and performance metrics"""
     
     _instance = None
     _lock = threading.Lock()
@@ -24,7 +22,7 @@ class Tracker:
             return cls._instance
     
     def _initialize(self):
-        #--
+        """Initialize tracker"""
         self.metrics = {
             "startup_time": datetime.now().isoformat(),
             "function_calls": 0,
@@ -41,8 +39,7 @@ class Tracker:
         
         self.privacy_level = "standard"
         
-        ##
-
+        # Setup data directory
         self.home_dir = Path.home()
         self.project_dir = self.home_dir / ".vnstock"
         self.project_dir.mkdir(exist_ok=True)
@@ -51,31 +48,26 @@ class Tracker:
         self.metrics_path = self.data_dir / "usage_metrics.json"
         self.privacy_config_path = self.project_dir / 'config' / "privacy.json"
         
-        ##
-
+        # Create config directory if it doesn't exist
         os.makedirs(os.path.dirname(self.privacy_config_path), exist_ok=True)
         
-        ##
-
+        # Load existing metrics
         self._load_metrics()
         
-        ##
-
+        # Load privacy settings
         self._load_privacy_settings()
         
-        ##
-
+        # Start background metrics collector
         self._start_background_collector()
     
     def _load_metrics(self):
-        #--
+        """Load metrics from file"""
         if self.metrics_path.exists():
             try:
                 with open(self.metrics_path, 'r') as f:
                     stored_metrics = json.load(f)
                     
-                ##
-
+                # Update metrics with stored values
                 for key, value in stored_metrics.items():
                     if key in self.metrics:
                         self.metrics[key] = value
@@ -83,7 +75,7 @@ class Tracker:
                 pass
     
     def _save_metrics(self):
-        #--
+        """Save metrics to file"""
         try:
             with open(self.metrics_path, 'w') as f:
                 json.dump(self.metrics, f)
@@ -91,7 +83,7 @@ class Tracker:
             pass
     
     def _load_privacy_settings(self):
-        #--
+        """Load privacy settings"""
         if self.privacy_config_path.exists():
             try:
                 with open(self.privacy_config_path, 'r') as f:
@@ -101,7 +93,7 @@ class Tracker:
                 pass
     
     def setup_privacy(self, level=None):
-        #--
+        """Configure privacy level for data collection"""
         privacy_levels = {
             "minimal": "Essential system data only",
             "standard": "Performance metrics and errors",
@@ -109,107 +101,90 @@ class Tracker:
         }
         
         if level is None:
-            ##
-
+            # Default level
             level = "standard"
         
         if level not in privacy_levels:
             raise ValueError(f"Invalid privacy level: {level}. Choose from {', '.join(privacy_levels.keys())}")
         
-        ##
-
+        # Store preference
         self.privacy_level = level
         
-        ##
-
+        # Store in configuration file
         with open(self.privacy_config_path, "w") as f:
             json.dump({"level": level}, f)
         
         return level
     
     def get_privacy_level(self):
-        #--
+        """Get current privacy level"""
         return self.privacy_level
     
     def _start_background_collector(self):
-        #--
+        """Start background metrics collection"""
         def collect_metrics():
             while True:
                 try:
                     import psutil
                     
-                    ##
-
+                    # Update peak memory
                     current_process = psutil.Process()
                     memory_info = current_process.memory_info()
-                    memory_usage = memory_info.rss / (1024 * 1024)  ##
-
+                    memory_usage = memory_info.rss / (1024 * 1024)  # MB
                     
                     if memory_usage > self.performance_metrics["peak_memory"]:
                         self.performance_metrics["peak_memory"] = memory_usage
                         
-                    ##
-
+                    # Save metrics periodically
                     self._save_metrics()
                     
                 except:
                     pass
                     
-                time.sleep(300)  ##
-
+                time.sleep(300)  # Run every 5 minutes
         
-        ##
-
+        # Start thread
         thread = threading.Thread(target=collect_metrics, daemon=True)
         thread.start()
     
     def record(self, event_type, data=None):
-        #--
-        ##
-
+        """Record an event"""
+        # Check privacy level
         if self.privacy_level == "minimal" and event_type != "errors":
-            ##
-
+            # In minimal mode, only track errors
             return True
             
-        ##
-
+        # Update counts
         if event_type in self.metrics:
             self.metrics[event_type] += 1
         else:
             self.metrics[event_type] = 1
             
-        ##
-
+        # Special handling for errors
         if event_type == "errors":
             self.performance_metrics["last_error_time"] = datetime.now().isoformat()
             
-        ##
-
+        # Special handling for function calls with timing data
         if event_type == "function_calls" and data and "execution_time" in data:
-            ##
-
+            # Keep up to 100 latest execution times
             self.performance_metrics["execution_times"].append(data["execution_time"])
             if len(self.performance_metrics["execution_times"]) > 100:
                 self.performance_metrics["execution_times"] = self.performance_metrics["execution_times"][-100:]
                 
-        ##
-
+        # Save if metrics change significantly
         if self.metrics["function_calls"] % 100 == 0 or event_type == "errors":
             self._save_metrics()
             
         return True
     
     def get_metrics(self):
-        #--
-        ##
-
+        """Get current metrics"""
+        # Calculate derived metrics
         avg_execution_time = 0
         if self.performance_metrics["execution_times"]:
             avg_execution_time = sum(self.performance_metrics["execution_times"]) / len(self.performance_metrics["execution_times"])
             
-        ##
-
+        # Add derived metrics to output
         output = self.metrics.copy()
         output.update({
             "avg_execution_time": avg_execution_time,
@@ -221,7 +196,7 @@ class Tracker:
         return output
     
     def reset(self):
-        #--
+        """Reset metrics"""
         self.metrics = {
             "startup_time": datetime.now().isoformat(),
             "function_calls": 0,
@@ -239,11 +214,10 @@ class Tracker:
         self._save_metrics()
         return True
 
-##
-
+# Create singleton instance
 tracker = Tracker()
 
 
 def record(event_type, data=None):
-    #--
+    """Record an event"""
     return tracker.record(event_type, data)

{vnai-2.0.3.dist-info → vnai-2.0.5.dist-info}/METADATA

@@ -1,11 +1,10 @@
 Metadata-Version: 2.4
 Name: vnai
-Version: 2.0.3
+Version: 2.0.5
 Summary: System optimization and resource management toolkit
-Home-page: https://github.com/yourusername/vnai
-Author: Your Name
-Author-email: your.email@example.com
+Author-email: Vnstock HQ <support@vnstocks.com>
 License: MIT
+Project-URL: Homepage, https://vnstocks.com
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 4 - Beta
@@ -17,17 +16,5 @@ Requires-Dist: requests>=2.25.0
 Requires-Dist: psutil>=5.8.0
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0.0; extra == "dev"
-Requires-Dist: black>=21.5b2; extra == "dev"
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
-System resource management and performance optimization toolkit
+# VnAI