webscout 8.2.2__py3-none-any.whl → 2026.1.19__py3-none-any.whl

webscout/update_checker.py

@@ -1,136 +1,280 @@
-from pkg_resources import get_distribution, DistributionNotFound as PackageNotFoundError
-def get_package_version(package_name: str) -> str:
-    return get_distribution(package_name).version
-"""
-Webscout Update Checker
->>> from webscout import check_for_updates
->>> result = check_for_updates()
->>> print(result)
-'New Webscout version available: 2.0.0 - Update with: pip install --upgrade webscout'
-"""
-
-from typing import Optional, Dict, Any, Literal
-
-import requests
-from packaging import version
-
-# Constants
-PYPI_URL = "https://pypi.org/pypi/webscout/json"
-
-# Create a session for HTTP requests
-session = requests.Session()
-
-# Version comparison result type
-VersionCompareResult = Literal[-1, 0, 1]
-
-def get_installed_version() -> Optional[str]:
-    """Get the currently installed version of webscout.
-
-    Returns:
-        Optional[str]: The installed version string or None if not found
-
-    Examples:
-        >>> version = get_installed_version()
-        >>> print(version)
-        '1.2.3'
-    """
-    try:
-        return get_package_version('webscout')
-    except PackageNotFoundError:
-        return None
-
-def get_pypi_version() -> Optional[str]:
-    """Get the latest version available on PyPI.
-
-    Returns:
-        Optional[str]: The latest version string or None if retrieval failed
-
-    Examples:
-        >>> latest = get_pypi_version()
-        >>> print(latest)
-        '2.0.0'
-    """
-    try:
-        response = session.get(PYPI_URL, timeout=10)
-        response.raise_for_status()
-        data: Dict[str, Any] = response.json()
-        return data['info']['version']
-    except (requests.RequestException, KeyError, ValueError):
-        return None
-
-def version_compare(v1: str, v2: str) -> VersionCompareResult:
-    """Compare two version strings.
-
-    Args:
-        v1: First version string
-        v2: Second version string to compare with
-
-    Returns:
-        VersionCompareResult: -1 if v1 < v2, 1 if v1 > v2, 0 if equal
-
-    Examples:
-        >>> version_compare('1.0.0', '2.0.0')
-        -1
-    """
-    try:
-        version1 = version.parse(v1)
-        version2 = version.parse(v2)
-        if version1 < version2:
-            return -1
-        if version1 > version2:
-            return 1
-        return 0
-    except version.InvalidVersion:
-        return 0
-
-def get_update_message(installed: str, latest: str) -> Optional[str]:
-    """Generate appropriate update message based on version comparison.
-
-    Args:
-        installed: Currently installed version
-        latest: Latest available version
-
-    Returns:
-        Optional[str]: Update message if needed, None if already on latest version
-
-    Examples:
-        >>> get_update_message('1.0.0', '2.0.0')
-        'New Webscout version available: 2.0.0 - Update with: pip install --upgrade webscout'
-    """
-    comparison_result = version_compare(installed, latest)
-    if comparison_result < 0:
-        return f"New Webscout version available: {latest} - Update with: pip install --upgrade webscout"
-    elif comparison_result > 0:
-        return f"You're running a development version ({installed}) ahead of latest release ({latest})"
-    return None  # Already on the latest version
-
-def check_for_updates() -> Optional[str]:
-    """Check if a newer version of Webscout is available.
-
-    Returns:
-        Optional[str]: Update message if newer version exists, None otherwise
-
-    Examples:
-        >>> result = check_for_updates()
-        >>> print(result)
-        'New Webscout version available: 2.0.0 - Update with: pip install --upgrade webscout'
-    """
-    installed_version = get_installed_version()
-    if not installed_version:
-        return None
-
-    latest_version = get_pypi_version()
-    if not latest_version:
-        return None
-
-    return get_update_message(installed_version, latest_version)
-
-if __name__ == "__main__":
-    try:
-        update_message = check_for_updates()
-        if update_message:
-            print(update_message)
-    except KeyboardInterrupt:
-        print("Update check canceled")
-    except Exception as e:
-        print(f"Update check failed: {str(e)}")
+import importlib.metadata
+import os
+import sys
+import tempfile
+import time
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from curl_cffi.requests import Session
+from packaging import version
+
+try:
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.text import Text
+
+    HAS_RICH = True
+except ImportError:
+
+    class _Dummy:
+        def __init__(self, *_args: Any, **_kwargs: Any) -> None:
+            pass
+
+        def print(self, *_args: Any, **_kwargs: Any) -> None:
+            pass
+
+        @staticmethod
+        def assemble(*_args: Any, **_kwargs: Any) -> str:
+            return ""
+
+    Console = _Dummy  # type: ignore
+    Panel = _Dummy  # type: ignore
+    Text = _Dummy  # type: ignore
+    HAS_RICH = False
+
+PYPI_URL = "https://pypi.org/pypi/webscout/json"
+YOUTUBE_URL = "https://youtube.com/@OEvortex"
+GITHUB_URL = "https://github.com/OEvortex/Webscout"
+CACHE_FILE = Path(tempfile.gettempdir()) / "webscout_update_check.cache"
+
+session = Session()
+
+
+def get_installed_version() -> str:
+    """Get the currently installed version of webscout."""
+    try:
+        from .version import __version__
+
+        return __version__
+    except (ImportError, ValueError):
+        pass
+
+    try:
+        import webscout.version
+
+        return webscout.version.__version__
+    except (ImportError, AttributeError):
+        pass
+
+    try:
+        return importlib.metadata.version("webscout")
+    except importlib.metadata.PackageNotFoundError:
+        return "0.0.0"
+
+
+def get_pypi_versions() -> Dict[str, Optional[str]]:
+    """Get stable and latest versions from PyPI."""
+    try:
+        response = session.get(PYPI_URL, timeout=3)
+        response.raise_for_status()
+        data = response.json()
+
+        stable = data.get("info", {}).get("version")
+
+        releases = data.get("releases", {}).keys()
+        parsed_versions = []
+        for v in releases:
+            try:
+                parsed_versions.append(version.parse(v))
+            except Exception:
+                continue
+
+        all_versions = sorted(parsed_versions)
+        latest = str(all_versions[-1]) if all_versions else stable
+
+        return {"stable": stable, "latest": latest}
+    except Exception:
+        return {"stable": None, "latest": None}
+
+
+def should_check(force: bool = False) -> bool:
+    """Check if we should perform an update check based on cache."""
+    if os.environ.get("WEBSCOUT_NO_UPDATE"):
+        return False
+
+    if force:
+        return True
+
+    try:
+        if not CACHE_FILE.exists():
+            return True
+
+        last_check = float(CACHE_FILE.read_text().strip())
+        if time.time() - last_check > 43200:
+            return True
+    except Exception:
+        return True
+    return False
+
+
+def mark_checked() -> Any:
+    """Mark the current time as the last update check."""
+    try:
+        CACHE_FILE.write_text(str(time.time()))
+    except Exception:
+        pass
+
+
+def is_venv() -> bool:
+    """Check if we are running inside a virtual environment."""
+    return hasattr(sys, "real_prefix") or (
+        hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix
+    )
+
+
+def get_env_name() -> str:
+    """Get the name of the current environment."""
+    if is_venv():
+        return os.path.basename(sys.prefix)
+    return "Global"
+
+
+def format_update_message(current: str, new: str, utype: str) -> str:
+    """Format the update message with colors and style."""
+    cmd = "pip install -U webscout"
+    if utype == "Pre-release" or version.parse(new).is_prerelease:
+        cmd = "pip install -U --pre webscout"
+
+    if HAS_RICH:
+        from io import StringIO
+
+        capture = StringIO()
+        console = Console(file=capture, force_terminal=True, width=80)
+
+        content = Text.assemble(
+            ("A new ", "white"),
+            (f"{utype} ", "bold yellow" if utype == "Pre-release" else "bold green"),
+            ("version of Webscout is available!\n\n", "white"),
+            ("Current:     ", "white"),
+            (f"{current}", "bold red"),
+            ("\n", ""),
+            ("Latest:      ", "white"),
+            (f"{new}", "bold green"),
+            ("\n\n", ""),
+            ("To update, run: ", "white"),
+            (f"{cmd}", "bold cyan"),
+            ("\n\n", ""),
+            ("Subscribe to my YouTube: ", "dim"),
+            (f"{YOUTUBE_URL}", "dim cyan"),
+            ("\n", ""),
+            ("Star on GitHub: ", "dim"),
+            (f"{GITHUB_URL}", "dim cyan"),
+        )
+
+        panel = Panel(
+            content,
+            title="[bold magenta]Update Available[/bold magenta]",
+            border_style="bright_blue",
+            expand=False,
+            padding=(1, 2),
+        )
+        console.print(panel)
+        return capture.getvalue()
+    else:
+        return (
+            f"\n\033[1;36m[ Webscout Update ]\033[0m\n"
+            f"New {utype} version available: \033[1;32m{new}\033[0m (Current: \033[1;31m{current}\033[0m)\n"
+            f"Run: \033[1;33m{cmd}\033[0m to update.\n"
+            f"\033[1;32mYouTube: {YOUTUBE_URL}\033[0m\n"
+        )
+
+
+def format_dev_message(current: str, latest: str) -> str:
+    """Format the message for development versions."""
+    if HAS_RICH:
+        from io import StringIO
+
+        capture = StringIO()
+        console = Console(file=capture, force_terminal=True, width=80)
+
+        content = Text.assemble(
+            ("You are running a ", "white"),
+            ("Development Version", "bold yellow"),
+            ("\n\nLocal Version: ", "white"),
+            (f"{current}", "bold cyan"),
+            ("\n", ""),
+            ("Latest PyPI:   ", "white"),
+            (f"{latest}", "bold green"),
+            ("\n\n", ""),
+            ("YouTube: ", "dim"),
+            (f"{YOUTUBE_URL}", "dim cyan"),
+        )
+
+        panel = Panel(
+            content,
+            title="[bold blue]Webscout Dev Mode[/bold blue]",
+            border_style="yellow",
+            expand=False,
+            padding=(1, 2),
+        )
+        console.print(panel)
+        return capture.getvalue()
+    else:
+        return (
+            f"\n\033[1;33m[ Webscout Info ]\033[0m\n"
+            f"You're running a development version (\033[1;36m{current}\033[0m)\n"
+            f"Latest stable release: \033[1;32m{latest}\033[0m\n"
+            f"\033[1;32mYouTube: {YOUTUBE_URL}\033[0m\n"
+        )
+
+
+def check_for_updates(force: bool = False) -> Optional[str]:
+    """
+    Check if a newer version of Webscout is available.
+
+    Args:
+        force (bool): If True, ignore cache and force check.
+
+    Returns:
+        Optional[str]: Formatted update message or None.
+    """
+    if not sys.stdout.isatty() and not force:
+        return None
+
+    if not should_check(force):
+        return None
+
+    try:
+        installed_str = get_installed_version()
+        installed_v = version.parse(installed_str)
+
+        pypi = get_pypi_versions()
+        mark_checked()
+
+        stable_ver = pypi.get("stable")
+        latest_ver = pypi.get("latest")
+
+        if not stable_ver or not latest_ver:
+            return None
+
+        latest_stable_str = stable_ver
+        latest_stable_v = version.parse(latest_stable_str)
+
+        latest_any_str = latest_ver
+        latest_any_v = version.parse(latest_any_str)
+
+        is_prerelease = installed_v.is_prerelease
+
+        if is_prerelease:
+            if installed_v < latest_any_v:
+                utype = "Pre-release" if latest_any_v.is_prerelease else "Stable"
+                return format_update_message(installed_str, latest_any_str, utype)
+            elif installed_v > latest_any_v:
+                return format_dev_message(installed_str, latest_any_str)
+        else:
+            if installed_v < latest_stable_v:
+                return format_update_message(installed_str, latest_stable_str, "Stable")
+            elif installed_v > latest_stable_v:
+                return format_dev_message(installed_str, latest_stable_str)
+
+    except Exception:
+        pass
+
+    return None
+
+
+if __name__ == "__main__":
+    msg = check_for_updates(force=True)
+    if msg:
+        print(msg)

webscout/utils.py

@@ -1,3 +1,4 @@
+import json
 import re
 from decimal import Decimal
 from html import unescape
@@ -7,33 +8,46 @@ from urllib.parse import unquote
 
 from .exceptions import WebscoutE
 
-try:
-    HAS_ORJSON = True
-    import orjson
-except ImportError:
-    HAS_ORJSON = False
-    import json
-
 REGEX_STRIP_TAGS = re.compile("<.*?>")
 
+
 def _expand_proxy_tb_alias(proxy: Optional[str]) -> Optional[str]:
     """Expand "tb" to a full proxy URL if applicable."""
     return "socks5://127.0.0.1:9150" if proxy == "tb" else proxy
 
+
 def json_dumps(obj: Any) -> str:
+    """Serialize object to JSON string.
+
+    Args:
+        obj: Object to serialize
+
+    Returns:
+        JSON string representation
+
+    Raises:
+        WebscoutE: If serialization fails
+    """
     try:
-        return (
-            orjson.dumps(obj, option=orjson.OPT_INDENT_2).decode()
-            if HAS_ORJSON
-            else json.dumps(obj, ensure_ascii=False, indent=2)
-        )
+        return json.dumps(obj, ensure_ascii=False, indent=2)
     except Exception as ex:
         raise WebscoutE(f"{type(ex).__name__}: {ex}") from ex
 
 
 def json_loads(obj: Union[str, bytes]) -> Any:
+    """Deserialize JSON string to Python object.
+
+    Args:
+        obj: JSON string or bytes to deserialize
+
+    Returns:
+        Deserialized Python object
+
+    Raises:
+        WebscoutE: If deserialization fails
+    """
     try:
-        return orjson.loads(obj) if HAS_ORJSON else json.loads(obj)
+        return json.loads(obj)
     except Exception as ex:
         raise WebscoutE(f"{type(ex).__name__}: {ex}") from ex
 
@@ -84,4 +98,4 @@ def _calculate_distance(lat1: Decimal, lon1: Decimal, lat2: Decimal, lon2: Decim
     dlon, dlat = rlon2 - rlon1, rlat2 - rlat1
     a = sin(dlat / 2) ** 2 + cos(rlat1) * cos(rlat2) * sin(dlon / 2) ** 2
     c = 2 * atan2(sqrt(a), sqrt(1 - a))
-    return R * c
+    return R * c

webscout/version.py

@@ -1,2 +1,3 @@
-__version__ = "8.2.2"
+
+__version__ = "2026.1.19"
 __prog__ = "webscout"

webscout/version.py.bak

@@ -0,0 +1,3 @@
+
+__version__ = "2026.1.18"
+__prog__ = "webscout"