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

vnai/scope/promo.py

@@ -5,7 +5,6 @@ import random
 import threading
 import time
 import urllib.parse
-
 _vnii_check_attempted = False
 
 class AdCategory:
@@ -20,37 +19,22 @@ class AdCategory:
     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, không xác định được trạng thái license
-
-# Module-level logger setup
+    lc_init = None
 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)
-    # Set to ERROR level to minimize output
     logger.setLevel(logging.ERROR)
 
 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)
@@ -58,37 +42,30 @@ class ContentManager:
             return cls._instance
 
     def _initialize(self, debug=False):
-        """
-        Internal initializer: sets up display timing, URLs, and starts the periodic display thread.
-        """
-        # Set up content base URL
-        self.content_base_url = "https://hq.vnstocks.com/content-delivery"
-        self.is_paid_user = None  # Mặc định: chưa xác định
+        self.content_base_url ="https://hq.vnstocks.com/content-delivery"
+        self.is_paid_user = None
         self.license_checked = False
         self._debug = debug
         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ì không xác định được trạng thái license
         import sys
         import importlib
         try:
             import importlib.metadata
-            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"
+            VNII_LATEST_VERSION ="0.1.1"
+            VNII_URL =f"https://github.com/vnstock-hq/licensing/releases/download/vnii-{VNII_LATEST_VERSION}/vnii-{VNII_LATEST_VERSION}.tar.gz"
             import subprocess
             try:
                 old_version = importlib.metadata.version("vnii")
-                # Chỉ cài nếu version chưa đúng
                 if old_version != VNII_LATEST_VERSION:
                     try:
                         subprocess.check_call([
-                            sys.executable, "-m", "pip", "install", f"vnii@{VNII_URL}", "--quiet"
+                            sys.executable,"-m","pip","install",f"vnii@{VNII_URL}","--quiet"
                         ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                         importlib.invalidate_caches()
-                        if "vnii" in sys.modules:
+                        if"vnii" in sys.modules:
                             importlib.reload(sys.modules["vnii"])
                         else:
                             import vnii
@@ -96,17 +73,15 @@ class ContentManager:
                     except Exception as e:
                         logger.error(f"Lỗi khi cài đặt vnii: {e}")
                         pass
-                # Nếu đã đúng version thì không log gì cả
             except importlib.metadata.PackageNotFoundError:
-                # Nếu chưa từng cài, không cài, luôn coi là free user
                 self.is_paid_user = False
                 return
         except Exception as e:
             logger.error(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}"
+"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:
@@ -115,15 +90,13 @@ class ContentManager:
                 pass
             self.is_paid_user = False
             return
-
-        # Kiểm tra trạng thái paid user (sponsor) và cache lại
         if lc_init is not None:
             try:
                 license_info = lc_init(repo_name='vnstock', debug=self._debug)
-                status = license_info.get('status', '').lower()
+                status = license_info.get('status','').lower()
                 if self._debug:
                     logger.info(f"License check result: {status}")
-                if 'recognized and verified' in status:
+                if'recognized and verified' in status:
                     self.is_paid_user = True
                     if self._debug:
                         logger.info("Detected paid user (license recognized and verified).")
@@ -140,110 +113,72 @@ class ContentManager:
             if self._debug:
                 logger.warning("Không tìm thấy package vnii. Không xác định được trạng thái paid user.")
             self.is_paid_user = None
-
-        # Timestamp of last content display (epoch seconds)
         self.last_display = 0
-        # Minimum interval between displays (24 hours)
         self.display_interval = 24 * 3600
-
-        # Base endpoints for fetching remote content and linking
-        self.content_base_url = "https://hq.vnstocks.com/content-delivery"
-        self.target_url = "https://vnstocks.com/lp-khoa-hoc-python-chung-khoan"
+        self.content_base_url ="https://hq.vnstocks.com/content-delivery"
+        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"
+"https://vnstocks.com/img/trang-chu-vnstock-python-api-phan-tich-giao-dich-chung-khoan.jpg"
         )
-
-        # Launch the background thread to periodically present content
         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.
-        """
         def periodic_display():
             while True:
-                # Nếu là paid user thì không bao giờ hiện ads
                 if self.is_paid_user:
                     break
-                # Randomize sleep to avoid synchronized requests across instances
                 sleep_time = random.randint(2 * 3600, 6 * 3600)
                 time.sleep(sleep_time)
-
-                # Present content if enough time has passed since last_display
                 current_time = time.time()
                 if current_time - self.last_display >= self.display_interval:
                     self.present_content(context="periodic")
                 else:
                     pass
-
         thread = threading.Thread(target=periodic_display, daemon=True)
         thread.start()
 
-    def fetch_remote_content(self, context: str = "init", html: bool = True) -> str:
+    def fetch_remote_content(self, context: str ="init", html: bool = True) -> str:
         if self.is_paid_user:
-            return ""
-
+            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)}"
-
+            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.error(f"Non-200 response fetching content: {response.status_code}")
             return None
         except Exception as e:
-            # Log exceptions without interrupting user code
             logger.error(f"Failed to fetch remote content: {e}")
             return None
 
-    def present_content(self, context: str = "init", ad_category: int = AdCategory.FREE) -> None:
+    def present_content(self, context: str ="init", ad_category: int = AdCategory.FREE) -> None:
         environment = 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:
+        if getattr(self,'is_paid_user', False) and ad_category == AdCategory.FREE:
             return
-
-        # 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")
+                environment = inspector.examine().get("environment","unknown")
             except Exception as e:
                 logger.error(f"Không detect được environment: {e}")
-                environment = "unknown"
-
-        # Retrieve remote or HTML/text content based on environment
+                environment ="unknown"
         remote_content = self.fetch_remote_content(
-            context=context, html=(environment == "jupyter")
+            context=context, html=(environment =="jupyter")
         )
-
-        # Generate fallback messages if remote fetch fails
         fallback = self._generate_fallback_content(context)
-
-        if environment == "jupyter":
+        if environment =="jupyter":
             try:
                 from IPython.display import display, HTML, Markdown
-
                 if remote_content:
                     display(HTML(remote_content))
                 else:
@@ -253,23 +188,19 @@ class ContentManager:
                         display(HTML(fallback["html"]))
             except Exception as e:
                 pass
-
-        elif environment == "terminal":
-            # Hiển thị quảng cáo dạng text ra terminal
+        elif environment =="terminal":
             if remote_content:
                 print(remote_content)
             else:
                 print(fallback["terminal"])
-
         else:
             print(fallback["simple"])
 
     def _generate_fallback_content(self, context):
-        fallback = {"html": "", "markdown": "", "terminal": "", "simple": ""}
-
-        if context == "loop":
+        fallback = {"html":"","markdown":"","terminal":"","simple":""}
+        if context =="loop":
             fallback["html"] = (
-                f"""
+f"""
             <div style="border: 1px solid #e74c3c; padding: 15px; border-radius: 5px; margin: 10px 0;">
                 <h3 style="color: #e74c3c;">⚠️ Bạn đang sử dụng vòng lặp với quá nhiều requests</h3>
                 <p>Để tránh bị giới hạn tốc độ và tối ưu hiệu suất:</p>
@@ -282,9 +213,8 @@ class ContentManager:
             """
             )
             fallback["markdown"] = (
-                """
+"""
 ## ⚠️ Bạn đang sử dụng vòng lặp với quá nhiều requests
-
 Để tránh bị giới hạn tốc độ và tối ưu hiệu suất:
 * Thêm thời gian chờ giữa các lần gọi API
 * Sử dụng xử lý theo batch thay vì lặp liên tục
@@ -292,7 +222,7 @@ class ContentManager:
             """
             )
             fallback["terminal"] = (
-                """
+"""
 ╔═════════════════════════════════════════════════════════════════╗
 ║                                                                 ║
 ║   🚫 ĐANG BỊ CHẶN BỞI GIỚI HẠN API? GIẢI PHÁP Ở ĐÂY!            ║
@@ -307,12 +237,12 @@ class ContentManager:
                 """
             )
             fallback["simple"] = (
-                "🚫 Đang bị giới hạn API? Tăng tốc độ gọi API lên 500% với gói "
-                "Vnstock Insider: https://vnstocks.com/insiders-program"
+"🚫 Đang bị giới hạn API? Tăng tốc độ gọi API lên 500% với gói "
+"Vnstock Insider: https://vnstocks.com/insiders-program"
             )
         else:
             fallback["html"] = (
-                f"""
+f"""
             <div style="border: 1px solid #3498db; padding: 15px; border-radius: 5px; margin: 10px 0;">
                 <h3 style="color: #3498db;">👋 Chào mừng bạn đến với Vnstock!</h3>
                 <p>Cảm ơn bạn đã sử dụng thư viện phân tích chứng khoán #1 tại Việt Nam cho Python</p>
@@ -325,19 +255,16 @@ class ContentManager:
             """
             )
             fallback["markdown"] = (
-                """
+"""
 ## 👋 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: [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!                         ║
@@ -355,21 +282,12 @@ Khám phá các tính năng mới nhất và tham gia cộng đồng để nhậ
                 """
             )
             fallback["simple"] = (
-                "👋 Chào mừng bạn đến với Vnstock! "
-                "Tài liệu: https://vnstocks.com/onboard | "
-                "Cộng đồng: https://facebook.com/groups/vnstock.official"
+"👋 Chào mừng bạn đến với Vnstock! "
+"Tài liệu: https://vnstocks.com/onboard | "
+"Cộng đồng: https://facebook.com/groups/vnstock.official"
             )
         return fallback
-
-# Singleton instance for module-level use
 manager = ContentManager()
 
-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)
+def present(context: str ="init", ad_category: int = AdCategory.FREE) -> None:
+    manager.present_content(context=context, ad_category=ad_category)

vnai/scope/state.py

@@ -1,5 +1,3 @@
-# vnai/scope/state.py
-
 import time
 import threading
 import json
@@ -8,215 +6,150 @@ from datetime import datetime
 from pathlib import Path
 
 class Tracker:
-    """Tracks system state and performance metrics"""
-    
     _instance = None
     _lock = threading.Lock()
-    
+
     def __new__(cls):
         with cls._lock:
             if cls._instance is None:
                 cls._instance = super(Tracker, cls).__new__(cls)
                 cls._instance._initialize()
             return cls._instance
-    
+
     def _initialize(self):
-        """Initialize tracker"""
         self.metrics = {
-            "startup_time": datetime.now().isoformat(),
-            "function_calls": 0,
-            "api_requests": 0,
-            "errors": 0,
-            "warnings": 0
+"startup_time": datetime.now().isoformat(),
+"function_calls": 0,
+"api_requests": 0,
+"errors": 0,
+"warnings": 0
         }
-        
         self.performance_metrics = {
-            "execution_times": [],
-            "last_error_time": None,
-            "peak_memory": 0
+"execution_times": [],
+"last_error_time": None,
+"peak_memory": 0
         }
-        
-        self.privacy_level = "standard"
-        
-        # Setup data directory
+        self.privacy_level ="standard"
         self.home_dir = Path.home()
-        self.project_dir = self.home_dir / ".vnstock"
+        self.project_dir = self.home_dir /".vnstock"
         self.project_dir.mkdir(exist_ok=True)
-        self.data_dir = self.project_dir / 'data'
+        self.data_dir = self.project_dir /'data'
         self.data_dir.mkdir(exist_ok=True)
-        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
+        self.metrics_path = self.data_dir /"usage_metrics.json"
+        self.privacy_config_path = self.project_dir /'config' /"privacy.json"
         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:
+                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
             except:
                 pass
-    
+
     def _save_metrics(self):
-        """Save metrics to file"""
         try:
-            with open(self.metrics_path, 'w') as f:
+            with open(self.metrics_path,'w') as f:
                 json.dump(self.metrics, f)
         except:
             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:
+                with open(self.privacy_config_path,'r') as f:
                     settings = json.load(f)
-                    self.privacy_level = settings.get("level", "standard")
+                    self.privacy_level = settings.get("level","standard")
             except:
                 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",
-            "enhanced": "Detailed operation analytics" 
+"minimal":"Essential system data only",
+"standard":"Performance metrics and errors",
+"enhanced":"Detailed operation analytics"
         }
-        
         if level is None:
-            # Default level
-            level = "standard"
-        
+            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:
+        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)  # MB
-                    
+                    memory_usage = memory_info.rss / (1024 * 1024)
                     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)  # Run every 5 minutes
-        
-        # Start thread
+                time.sleep(300)
         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
+        if self.privacy_level =="minimal" and event_type !="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":
+        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
+        if event_type =="function_calls" and data and"execution_time" in data:
             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":
+        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,
-            "peak_memory_mb": self.performance_metrics["peak_memory"],
-            "uptime": (datetime.now() - datetime.fromisoformat(self.metrics["startup_time"])).total_seconds(),
-            "privacy_level": self.privacy_level
+"avg_execution_time": avg_execution_time,
+"peak_memory_mb": self.performance_metrics["peak_memory"],
+"uptime": (datetime.now() - datetime.fromisoformat(self.metrics["startup_time"])).total_seconds(),
+"privacy_level": self.privacy_level
         })
-        
         return output
-    
+
     def reset(self):
-        """Reset metrics"""
         self.metrics = {
-            "startup_time": datetime.now().isoformat(),
-            "function_calls": 0,
-            "api_requests": 0,
-            "errors": 0,
-            "warnings": 0
+"startup_time": datetime.now().isoformat(),
+"function_calls": 0,
+"api_requests": 0,
+"errors": 0,
+"warnings": 0
         }
-        
         self.performance_metrics = {
-            "execution_times": [],
-            "last_error_time": None,
-            "peak_memory": 0
+"execution_times": [],
+"last_error_time": None,
+"peak_memory": 0
         }
-        
         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)
+    return tracker.record(event_type, data)

{vnai-2.1.8.dist-info → vnai-2.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vnai
-Version: 2.1.8
+Version: 2.1.9
 Summary: Vnstock Analytics Interface
 Author-email: Vnstock Analytics Team <support@vnstocks.com>
 License: proprietary

vnai-2.1.9.dist-info/RECORD

@@ -0,0 +1,16 @@
+vnai/__init__.py,sha256=oTfe5Hu8UUDUW3Gq84fqX4InkIfqIZTUqTv2Q28RB3c,5733
+vnai/beam/__init__.py,sha256=h19ZEQFnWTvqed0mpTcuQf-sT9XifWhfVbaobTEs91Q,131
+vnai/beam/metrics.py,sha256=2BmdJl7gB4rHwCN7G7WUMg_6rnlY3xfulBzU7usqNfE,6275
+vnai/beam/pulse.py,sha256=xu7cStqdkCw8be_yVwfjGtqdy-stYC511oZOkT9j6hs,2485
+vnai/beam/quota.py,sha256=0pgkCdARtojF-xNC0Y_VYYo4GO717F0MOexwNH2NdzY,14416
+vnai/flow/__init__.py,sha256=9JepoOHS1xn0_ZrDyfft42g2cjhaka7xdG0velqmk-I,70
+vnai/flow/queue.py,sha256=9dyMwxen1vCiFJ7wNZn-kzMY8DnB4xD575J1pPSWZLw,3223
+vnai/flow/relay.py,sha256=7VUsiU1T272chBRCRR90Aodfh_PcUUAUlX3SPUtltFQ,12624
+vnai/scope/__init__.py,sha256=gVvOMQ34V3Tm8_XmX4cRCrgKVfZ4XYQup79MWx6CWuM,197
+vnai/scope/profile.py,sha256=RSk8w5h9rvamFozQOUrYcDSXssTF0ro70Qq-VfExQF0,21567
+vnai/scope/promo.py,sha256=AcQDdzcIYCrTQ0Hqr0KVBCOJsBYQevp0T6emQlGlQ-E,13597
+vnai/scope/state.py,sha256=ApzP6U0Hzp047-k3czL933soUXiZjpZSxXk7DKwf7yM,5389
+vnai-2.1.9.dist-info/METADATA,sha256=RiB-4I-sviuL_7kRXBtEPsQyfLs15bJ_nEPHVC6qEbY,662
+vnai-2.1.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+vnai-2.1.9.dist-info/top_level.txt,sha256=4zI0qZHePCwvgSqXl4420sBcd0VzZn4MEcRsAIFae3k,5
+vnai-2.1.9.dist-info/RECORD,,