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

vnai/scope/lc_integration.py

@@ -0,0 +1,351 @@
+import json
+import logging
+from pathlib import Path
+from typing import Optional, Dict, Any
+from datetime import datetime
+logger = logging.getLogger(__name__)
+
+def _get_ide_info() -> Dict:
+    try:
+        from vnai.scope.device import get_current_ide_info
+        return get_current_ide_info()
+    except Exception as e:
+        logger.debug(f"Failed to get IDE info: {e}")
+        return {}
+
+def _sync_profile_to_api(
+    device_info: Dict[str, Any],
+    ide_info: Dict[str, Any],
+    license_info: Dict[str, Any],
+    api_key: Optional[str] = None,
+    force: bool = False
+) -> Dict[str, Any]:
+    try:
+        import requests
+    except ImportError:
+        logger.debug("requests library not available, skipping API sync")
+        return {
+'status':'skipped',
+'reason':'requests_not_available',
+        }
+    try:
+        profile = {
+'timestamp': datetime.now().isoformat(),
+'device': {
+'device_id': device_info.get('machine_id'),
+'os': device_info.get('os_name'),
+'os_platform': device_info.get('platform'),
+'python_version': device_info.get('python_version'),
+'arch': device_info.get('platform','').split('-')[-1] if device_info.get('platform') else'unknown',
+'cpu_count': device_info.get('cpu_count'),
+'memory_gb': device_info.get('memory_gb'),
+'environment': device_info.get('environment'),
+'hosting_service': device_info.get('hosting_service'),
+            },
+'ide': {
+'name': ide_info.get('ide_name'),
+'detection_method': ide_info.get('detection_method'),
+'detected_at': ide_info.get('detected_at'),
+'process_chain_depth': ide_info.get('process_chain_depth'),
+'frontend': ide_info.get('frontend'),
+            },
+'license': {
+'is_paid': license_info.get('is_paid'),
+'status': license_info.get('status'),
+'tier': license_info.get('tier'),
+            } if license_info else None,
+        }
+        payload = {
+'profile': profile,
+'sync_timestamp': datetime.now().isoformat(),
+'sync_version':'2.0',
+        }
+        headers = {
+'Content-Type':'application/json',
+'User-Agent':'vnstock-analytics/2.0',
+        }
+        if api_key:
+            headers['Authorization'] =f'Bearer {api_key}'
+        endpoint ="https://api.vnstocks.com/v1/user/profile/sync"
+        response = requests.post(
+            endpoint,
+            json=payload,
+            headers=headers,
+            timeout=10
+        )
+        if response.status_code == 200:
+            logger.info("Profile successfully synced to vnstocks.com API")
+            return {
+'status':'success',
+'synced_at': datetime.now().isoformat(),
+'api_response': response.json(),
+            }
+        else:
+            logger.debug(f"API sync failed: {response.status_code}")
+            return {
+'status':'failed',
+'error': response.text,
+'status_code': response.status_code,
+            }
+    except requests.exceptions.RequestException as e:
+        logger.debug(f"API request failed: {e}")
+        return {
+'status':'failed',
+'error': str(e),
+        }
+    except Exception as e:
+        logger.error(f"Error syncing profile to API: {e}")
+        return {
+'status':'error',
+'error': str(e),
+        }
+
+class APIKeyChecker:
+    _instance = None
+    _lock = None
+
+    def __new__(cls):
+        import threading
+        if cls._lock is None:
+            cls._lock = threading.Lock()
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super(APIKeyChecker, cls).__new__(cls)
+                cls._instance._initialize()
+            return cls._instance
+
+    def _initialize(self) -> None:
+        self.checked = False
+        self.last_check_time = None
+        self.is_paid = None
+        self.license_info = None
+
+    def _get_vnstock_directories(self) -> list[Path]:
+        paths = []
+        local_path = Path.home() /".vnstock"
+        paths.append(local_path)
+        colab_drive_path = Path('/content/drive/MyDrive/.vnstock')
+        if colab_drive_path.parent.exists():
+            paths.append(colab_drive_path)
+        try:
+            from vnstock.core.config.ggcolab import get_vnstock_directory
+            vnstock_dir = get_vnstock_directory()
+            if vnstock_dir not in paths:
+                paths.append(vnstock_dir)
+        except ImportError:
+            pass
+        return paths
+
+    def _find_api_key_file(self) -> Optional[Path]:
+        for vnstock_dir in self._get_vnstock_directories():
+            api_key_path = vnstock_dir /"api_key.json"
+            if api_key_path.exists():
+                logger.debug(f"Found api_key.json at: {api_key_path}")
+                return api_key_path
+        logger.debug("api_key.json not found in any vnstock directory")
+        return None
+
+    def _read_api_key(self, api_key_path: Path) -> Optional[str]:
+        try:
+            with open(api_key_path,'r', encoding='utf-8') as f:
+                data = json.load(f)
+                api_key = data.get('api_key')
+                if api_key and isinstance(api_key, str):
+                    return api_key.strip()
+                else:
+                    logger.warning(
+f"Invalid api_key format in {api_key_path}"
+                    )
+                    return None
+        except json.JSONDecodeError as e:
+            logger.error(f"Invalid JSON in {api_key_path}: {e}")
+            return None
+        except Exception as e:
+            logger.error(f"Error reading {api_key_path}: {e}")
+            return None
+
+    def check_license_with_vnii(
+        self,
+        force: bool = False,
+        include_ide_info: bool = True
+    ) -> Dict[str, Any]:
+        if self.checked and not force:
+            result = {
+'is_paid': self.is_paid,
+'status':'cached',
+'checked_at': self.last_check_time,
+'api_key_found': True,
+'vnii_available': True
+            }
+            if include_ide_info:
+                result['ide_info'] = _get_ide_info()
+            return result
+        result = {
+'is_paid': False,
+'status':'unknown',
+'checked_at': datetime.now().isoformat(),
+'api_key_found': False,
+'vnii_available': False
+        }
+        if include_ide_info:
+            result['ide_info'] = _get_ide_info()
+        try:
+            from vnii import lc_init
+            result['vnii_available'] = True
+        except ImportError:
+            logger.debug("vnii package not available")
+            result['status'] ='vnii_not_installed'
+            return result
+        api_key_path = self._find_api_key_file()
+        if not api_key_path:
+            logger.debug("No api_key.json found")
+            result['status'] ='no_api_key_file'
+            return result
+        api_key = self._read_api_key(api_key_path)
+        if not api_key:
+            logger.warning("Could not read API key from file")
+            result['status'] ='invalid_api_key_file'
+            return result
+        result['api_key_found'] = True
+        try:
+            from vnii import lc_init
+            import os
+            original_env = os.environ.get('VNSTOCK_API_KEY')
+            os.environ['VNSTOCK_API_KEY'] = api_key
+            try:
+                license_info = lc_init(debug=False)
+                status = license_info.get('status','').lower()
+                tier = license_info.get('tier','').lower()
+                is_paid = (
+'recognized and verified' in status or
+                    tier in ['bronze','silver','golden','gold']
+                )
+                result['is_paid'] = is_paid
+                result['status'] ='verified' if is_paid else'free_user'
+                result['license_info'] = license_info
+                self.checked = True
+                self.last_check_time = result['checked_at']
+                self.is_paid = is_paid
+                self.license_info = license_info
+                logger.info(
+f"License verified via vnii: "
+f"is_paid={is_paid}, tier={tier}"
+                )
+            finally:
+                if original_env is None:
+                    os.environ.pop('VNSTOCK_API_KEY', None)
+                else:
+                    os.environ['VNSTOCK_API_KEY'] = original_env
+        except SystemExit as e:
+            error_msg = str(e)
+            if'device limit exceeded' in error_msg.lower():
+                logger.warning(f"Device limit exceeded but user is paid")
+                result['status'] ='device_limit_exceeded'
+                result['is_paid'] = True
+                result['error'] = error_msg
+                self.checked = True
+                self.last_check_time = result['checked_at']
+                self.is_paid = True
+                self.license_info = {'status':'Device limit','tier':'paid'}
+            else:
+                logger.warning(f"vnii license check failed: {e}")
+                result['status'] ='license_check_failed'
+                result['error'] = error_msg
+        except Exception as e:
+            logger.error(f"Error calling vnii lc_init: {e}")
+            result['status'] ='error'
+            result['error'] = str(e)
+        return result
+
+    def sync_profile_to_api(
+        self,
+        device_info: Optional[Dict[str, Any]] = None,
+        api_key: Optional[str] = None,
+        force: bool = False
+    ) -> Dict[str, Any]:
+        try:
+            ide_info = _get_ide_info()
+            license_info = {
+'is_paid': self.is_paid,
+'status':'verified' if self.is_paid else'free_user',
+'tier': self.license_info.get('tier') if self.license_info else None,
+            } if self.checked else None
+            if device_info is None:
+                try:
+                    from vnai.scope.profile import inspector
+                    device_data = inspector.examine()
+                    device_info = {
+'machine_id': device_data.get('machine_id'),
+'os_name': device_data.get('os_name'),
+'platform': device_data.get('platform'),
+'python_version': device_data.get('python_version'),
+'cpu_count': device_data.get('cpu_count'),
+'memory_gb': device_data.get('memory_gb'),
+'environment': device_data.get('environment'),
+'hosting_service': device_data.get('hosting_service'),
+                    }
+                except Exception as e:
+                    logger.debug(f"Failed to get device info: {e}")
+                    device_info = {}
+            return _sync_profile_to_api(
+                device_info=device_info,
+                ide_info=ide_info,
+                license_info=license_info,
+                api_key=api_key,
+                force=force
+            )
+        except Exception as e:
+            logger.error(f"Error in sync_profile_to_api: {e}")
+            return {
+'status':'error',
+'error': str(e),
+            }
+
+    def is_paid_user(self) -> Optional[bool]:
+        if not self.checked:
+            result = self.check_license_with_vnii()
+            return result.get('is_paid')
+        return self.is_paid
+
+    def get_license_info(self) -> Optional[Dict]:
+        return self.license_info
+api_key_checker = APIKeyChecker()
+
+def check_license_via_api_key(force: bool = False) -> Dict[str, Any]:
+    return api_key_checker.check_license_with_vnii(force=force)
+
+def is_paid_user_via_api_key() -> Optional[bool]:
+    return api_key_checker.is_paid_user()
+
+def check_license_status() -> Optional[bool]:
+    try:
+        is_paid = api_key_checker.is_paid_user()
+        return is_paid
+    except ImportError:
+        logger.warning("API key checker not available")
+        return None
+    except Exception as e:
+        logger.error(f"Error checking license status: {e}")
+        return None
+
+def update_license_from_vnii() -> bool:
+    try:
+        result = api_key_checker.check_license_with_vnii(force=True)
+        if result.get('status') in ['verified','cached']:
+            is_paid = result.get('is_paid', False)
+            logger.info(f"License updated via API key: is_paid={is_paid}")
+            return True
+        else:
+            logger.warning(
+f"Failed to update license: {result.get('status')}"
+            )
+            return False
+    except Exception as e:
+        logger.error(f"Error updating license from vnii: {e}")
+        return False
+
+def sync_user_profile_to_api(
+    api_key: Optional[str] = None,
+    force: bool = False
+) -> Dict[str, Any]:
+    return api_key_checker.sync_profile_to_api(api_key=api_key, force=force)

vnai/scope/license.py

@@ -0,0 +1,197 @@
+import json
+import time
+import threading
+import logging
+from pathlib import Path
+from datetime import datetime
+from typing import Optional, Dict, Union, Any
+logger = logging.getLogger(__name__)
+
+class LicenseCache:
+    _instance = None
+    _lock = threading.Lock()
+    CACHE_TTL = 24 * 3600
+    GRACE_PERIOD = 48 * 3600
+
+    def __new__(cls):
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super(LicenseCache, cls).__new__(cls)
+                cls._instance._initialize()
+            return cls._instance
+
+    def _initialize(self) -> None:
+        try:
+            from vnstock.core.config.ggcolab import get_vnstock_directory
+            cache_dir = get_vnstock_directory() /"id"
+        except ImportError:
+            cache_dir = Path.home() /".vnstock" /"id"
+        self.cache_dir = cache_dir
+        self.cache_file = self.cache_dir /"license_cache.json"
+        self.cache = None
+        self.lock = threading.Lock()
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self._load_cache()
+
+    def _load_cache(self) -> None:
+        try:
+            if self.cache_file.exists():
+                with open(self.cache_file,'r') as f:
+                    self.cache = json.load(f)
+                    msg =f"Loaded license cache from {self.cache_file}"
+                    logger.debug(msg)
+        except Exception as e:
+            logger.warning(f"Failed to load license cache: {e}")
+            self.cache = None
+
+    def _save_cache(self) -> None:
+        try:
+            with open(self.cache_file,'w') as f:
+                json.dump(self.cache, f, indent=2)
+                logger.debug(f"Saved license cache to {self.cache_file}")
+        except Exception as e:
+            logger.error(f"Failed to save license cache: {e}")
+
+    def get(self, user_id: str | None = None) -> dict | None:
+        with self.lock:
+            if not self.cache:
+                return None
+            current_time = time.time()
+            cache_time = self.cache.get("checked_at")
+            if not cache_time:
+                return None
+            try:
+                cache_time_ts = datetime.fromisoformat(
+                    cache_time
+                ).timestamp()
+            except (ValueError, TypeError):
+                cache_time_ts = 0
+            age = current_time - cache_time_ts
+            if age > self.CACHE_TTL:
+                logger.info(
+f"License cache expired (age: {age:.0f}s, TTL: "
+f"{self.CACHE_TTL}s)"
+                )
+                return None
+            return self.cache
+
+    def set(self, is_paid: bool, checked_at: str | None = None) -> bool:
+        with self.lock:
+            try:
+                if checked_at is None:
+                    checked_at = datetime.now().isoformat()
+                cache_time = datetime.fromisoformat(
+                    checked_at
+                ).timestamp()
+                cache_ttl_until = cache_time + self.CACHE_TTL
+                grace_until = cache_time + self.GRACE_PERIOD
+                self.cache = {
+"is_paid": is_paid,
+"checked_at": checked_at,
+"cache_ttl_until": cache_ttl_until,
+"grace_period_until": grace_until,
+"cache_age_seconds": 0
+                }
+                self._save_cache()
+                logger.info(
+f"License cache updated: is_paid={is_paid}, "
+f"TTL_expires={datetime.fromtimestamp(cache_ttl_until)}"
+                )
+                return True
+            except Exception as e:
+                logger.error(f"Failed to set license cache: {e}")
+                return False
+
+    def is_valid(self) -> bool:
+        with self.lock:
+            if not self.cache:
+                return False
+            current_time = time.time()
+            cache_time = self.cache.get("checked_at")
+            if not cache_time:
+                return False
+            try:
+                cache_time_ts = datetime.fromisoformat(
+                    cache_time
+                ).timestamp()
+            except (ValueError, TypeError):
+                return False
+            age = current_time - cache_time_ts
+            return age <= self.CACHE_TTL
+
+    def is_in_grace_period(self) -> bool:
+        with self.lock:
+            if not self.cache:
+                return False
+            current_time = time.time()
+            cache_time = self.cache.get("checked_at")
+            if not cache_time:
+                return False
+            try:
+                cache_time_ts = datetime.fromisoformat(
+                    cache_time
+                ).timestamp()
+            except (ValueError, TypeError):
+                return False
+            age = current_time - cache_time_ts
+            return (age > self.CACHE_TTL and
+                    age <= self.CACHE_TTL + self.GRACE_PERIOD)
+
+    def get_is_paid(self) -> bool | None:
+        cache = self.get()
+        if cache:
+            return cache.get("is_paid", False)
+        if self.is_in_grace_period():
+            if self.cache:
+                logger.info(
+"Using cached license status (grace period active)"
+                )
+                return self.cache.get("is_paid", False)
+        return None
+
+    def clear(self) -> bool:
+        with self.lock:
+            try:
+                self.cache = None
+                if self.cache_file.exists():
+                    self.cache_file.unlink()
+                logger.info("License cache cleared")
+                return True
+            except Exception as e:
+                logger.error(f"Failed to clear license cache: {e}")
+                return False
+
+    def get_cache_info(self) -> dict:
+        with self.lock:
+            if not self.cache:
+                return {"status":"empty"}
+            current_time = time.time()
+            cache_time_str = self.cache.get("checked_at")
+            if not isinstance(cache_time_str, str):
+                return {"status":"invalid"}
+            try:
+                cache_time = datetime.fromisoformat(cache_time_str)
+                cache_time_ts = cache_time.timestamp()
+            except (ValueError, TypeError):
+                return {"status":"invalid"}
+            age = current_time - cache_time_ts
+            is_valid = age <= self.CACHE_TTL
+            in_grace = (age > self.CACHE_TTL and
+                        age <= self.CACHE_TTL + self.GRACE_PERIOD)
+            return {
+"status":"valid" if is_valid else (
+"grace_period" if in_grace else"expired"
+                ),
+"is_paid": self.cache.get("is_paid"),
+"checked_at": cache_time_str,
+"age_seconds": int(age),
+"ttl_seconds": self.CACHE_TTL,
+"ttl_remaining_seconds": max(
+                    0, self.CACHE_TTL - int(age)
+                ),
+"grace_period_seconds": self.GRACE_PERIOD,
+"grace_remaining_seconds": max(
+                    0, self.CACHE_TTL + self.GRACE_PERIOD - int(age)
+                )
+            }
+license_cache = LicenseCache()

vnai/scope/profile.py

@@ -3,7 +3,6 @@ import sys
 import platform
 import uuid
 import hashlib
-import psutil
 import threading
 import time
 import importlib.metadata
@@ -32,13 +31,25 @@ class Inspector:
         self.machine_id = None
         self._colab_auth_triggered = False
         self.home_dir = Path.home()
-        self.project_dir = self.home_dir /".vnstock"
-        self.project_dir.mkdir(exist_ok=True)
+        self.project_dir = self._get_project_dir()
+        self.project_dir.mkdir(parents=True, exist_ok=True)
         self.id_dir = self.project_dir /'id'
-        self.id_dir.mkdir(exist_ok=True)
+        self.id_dir.mkdir(parents=True, exist_ok=True)
         self.machine_id_path = self.id_dir /"machine_id.txt"
         self.examine()
 
+    def _get_home_dir(self) -> Path:
+        return Path.home()
+
+    def _get_project_dir(self) -> Path:
+        try:
+            from vnstock.core.config.ggcolab import get_vnstock_directory
+            return get_vnstock_directory()
+        except ImportError:
+            if not hasattr(self,'home_dir'):
+                self.home_dir = Path.home()
+            return self.home_dir /".vnstock"
+
     def examine(self, force_refresh=False):
         current_time = time.time()
         if not force_refresh and (current_time - self.last_examination) < self.cache_ttl:
@@ -75,9 +86,11 @@ class Inspector:
         except:
             info["environment"] ="unknown"
         try:
+            import psutil
             info["cpu_count"] = os.cpu_count()
-            info["memory_gb"] = round(psutil.virtual_memory().total / (1024**3), 1)
-        except:
+            memory_total = psutil.virtual_memory().total
+            info["memory_gb"] = round(memory_total / (1024**3), 1)
+        except Exception:
             pass
         is_colab ='google.colab' in sys.modules
         if is_colab:
@@ -98,24 +111,27 @@ class Inspector:
     def fingerprint(self):
         if self.machine_id:
             return self.machine_id
+        try:
+            from vnai.scope.device import device_registry
+            registry = device_registry.get_registry()
+            if registry and registry.get('device_id'):
+                self.machine_id = registry['device_id']
+                return self.machine_id
+        except Exception:
+            pass
         if self.machine_id_path.exists():
             try:
                 with open(self.machine_id_path,"r") as f:
                     self.machine_id = f.read().strip()
                     return self.machine_id
-            except:
+            except Exception:
                 pass
         is_colab = self.detect_colab_with_delayed_auth()
         try:
             system_info = platform.node() + platform.platform() + platform.machine()
             self.machine_id = hashlib.md5(system_info.encode()).hexdigest()
-        except:
+        except Exception:
             self.machine_id = str(uuid.uuid4())
-        try:
-            with open(self.machine_id_path,"w") as f:
-                f.write(self.machine_id)
-        except:
-            pass
         return self.machine_id
 
     def detect_hosting(self):
@@ -559,16 +575,20 @@ class Inspector:
 
     def analyze_dependencies(self):
         try:
-            import pkg_resources
+            try:
+                from importlib.metadata import distributions
+            except ImportError:
+                from importlib_metadata import distributions
             enterprise_packages = [
 "snowflake-connector-python","databricks","azure",
 "aws","google-cloud","stripe","atlassian",
 "salesforce","bigquery","tableau","sap"
             ]
             commercial_deps = []
-            for pkg in pkg_resources.working_set:
-                if any(ent in pkg.key for ent in enterprise_packages):
-                    commercial_deps.append({"name": pkg.key,"version": pkg.version})
+            for dist in distributions():
+                pkg_name = dist.metadata['Name'].lower()
+                if any(ent in pkg_name for ent in enterprise_packages):
+                    commercial_deps.append({"name": pkg_name,"version": dist.version})
             return {
 "has_commercial_deps": len(commercial_deps) > 0,
 "commercial_deps_count": len(commercial_deps),