bugpipe 3.0.1__py3-none-any.whl

bugpipe/cli/update_checker.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+import json
+import re
+import time
+import typing as t
+from importlib.metadata import version
+from pathlib import Path
+from tempfile import gettempdir
+
+import httpx
+from rich.status import Status
+
+__pkg__ = "bugpipe"
+__version__ = version(__pkg__)
+
+CACHE_FILE = Path(gettempdir()) / "bugpipe_update_check.json"
+CACHE_TTL = 3600
+
+
+def query_pypi(package: str, include_prereleases: bool) -> dict:
+    """
+    Query PyPI for the latest version of a package.
+
+    :param package: The package name to look up on PyPI.
+    :param include_prereleases: Whether to consider pre-release versions.
+    :return: A dict with ``success`` key, and ``data`` containing
+        ``version`` and ``upload_time`` on success.
+    """
+
+    try:
+        response = httpx.get(f"https://pypi.org/pypi/{package}/json", timeout=3)
+    except httpx.HTTPError:
+        return {"success": False}
+    if response.status_code != 200:
+        return {"success": False}
+    data = response.json()
+    versions = list(data["releases"].keys())
+    versions.sort(key=parse_version, reverse=True)
+
+    version = versions[0]
+    for tmp_version in versions:
+        if include_prereleases or standard_release(tmp_version):
+            version = tmp_version
+            break
+
+    upload_time = None
+    for file_info in data["releases"][version]:
+        if file_info["upload_time"]:
+            upload_time = file_info["upload_time"]
+            break
+
+    return {"success": True, "data": {"upload_time": upload_time, "version": version}}
+
+
+def cached_query_pypi(package: str, include_prereleases: bool) -> dict:
+    """
+    Return the PyPI lookup result, reusing a cached one under an hour old.
+
+    :param package: The package name to look up on PyPI.
+    :param include_prereleases: Whether to consider pre-release versions.
+    :return: The same dict as :func:`query_pypi`.
+    """
+
+    key = {"package": package, "include_prereleases": include_prereleases}
+    try:
+        cached = json.loads(CACHE_FILE.read_text())
+        if cached["key"] == key and time.time() - cached["time"] < CACHE_TTL:
+            return cached["data"]
+    except (OSError, ValueError, KeyError, TypeError):
+        pass  # missing or unreadable cache, query PyPI
+
+    data = query_pypi(package=package, include_prereleases=include_prereleases)
+    if data.get("success"):
+        try:
+            CACHE_FILE.write_text(
+                json.dumps({"key": key, "time": time.time(), "data": data})
+            )
+        except OSError:
+            pass  # cache is best effort
+    return data
+
+
+def standard_release(version: str) -> bool:
+    """
+    Check whether a version string represents a standard (non-pre-release) release.
+
+    :param version: The version string to check.
+    :return: ``True`` if the version contains only digits and dots.
+    """
+
+    return version.replace(".", "").isdigit()
+
+
+def check(
+    package_name: str = "buganize",
+    package_version: str = __version__,
+    status: Status | None = None,
+):
+    """Print a notice when PyPI has a newer version.
+
+    :param package_name: Package to check.
+    :param package_version: Running version.
+    """
+
+    if isinstance(status, Status):
+        status.update("[dim]Checking for updates…[/dim]")
+
+    data = cached_query_pypi(
+        package=package_name,
+        include_prereleases=not standard_release(version=package_version),
+    )
+    if not data.get("success") or (
+        parse_version(string=package_version)
+        >= parse_version(string=data["data"]["version"])
+    ):
+        return
+
+    available = data["data"]["version"]
+    message = (
+        f"Version {package_version} of {package_name} is outdated. "
+        f"Version {available} "
+    )
+    release_date = data["data"]["upload_time"]
+    message += (
+        f"was released on {release_date[:10]}." if release_date else "is available."
+    )
+
+    from .term import console
+
+    console.log(f"[bold blue]⬆[/bold blue] {message}")
+
+
+# The following section of code is taken from setuptools pkg_resources.py (PSF
+# license). Unfortunately importing pkg_resources to directly use the
+# parse_version function results in some undesired side effects.
+
+component_re = re.compile(r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE)
+replace = {"pre": "c", "preview": "c", "-": "final-", "rc": "c", "dev": "@"}.get
+
+
+def _parse_version_parts(version_string: str) -> t.Generator[str]:
+    """
+    Yield normalized version parts from a version string.
+
+    :param version_string: A version string to split into comparable parts.
+    """
+
+    for part in component_re.split(version_string):
+        part = replace(part, part)
+        if not part or part == ".":
+            continue
+        if part[:1] in "0123456789":
+            yield part.zfill(8)  # pad for numeric comparison
+        else:
+            yield "*" + part
+
+    yield "*final"  # ensure that alpha/beta/candidate are before final
+
+
+def parse_version(string: str) -> tuple[str, ...]:
+    """
+    Convert a version string to a chronologically-sortable key.
+
+    This is a rough cross between distutils' StrictVersion and LooseVersion;
+    if you give it versions that would work with StrictVersion, then it behaves
+    the same; otherwise it acts like a slightly-smarter LooseVersion. It is
+    *possible* to create pathological version coding schemes that will fool
+    this parser, but they should be very rare in practice.
+
+    The returned value will be a tuple of strings.  Numeric portions of the
+    version are padded to 8 digits so they will compare numerically, but
+    without relying on how numbers compare relative to strings.  Dots are
+    dropped, but dashes are retained.  Trailing zeros between alpha segments
+    or dashes are suppressed, so that e.g. "2.4.0" is considered the same as
+    "2.4". Alphanumeric parts are lower-cased.
+
+    The algorithm assumes that strings like "-" and any alpha string that
+    alphabetically follows "final"  represents a "patch level".  So, "2.4-1"
+    is assumed to be a branch or patch of "2.4", and therefore "2.4.1" is
+    considered newer than "2.4-1", which in turn is newer than "2.4".
+
+    Strings like "a", "b", "c", "alpha", "beta", "candidate" and so on (that
+    come before "final" alphabetically) are assumed to be pre-release versions,
+    so that the version "2.4" is considered newer than "2.4a1".
+
+    Finally, to handle miscellaneous cases, the strings "pre", "preview", and
+    "rc" are treated as if they were "c", i.e. as though they were release
+    candidates, and therefore are not as new as a version string that does not
+    contain them, and "dev" is replaced with an '@' so that it sorts lower than
+    any other pre-release tag.
+
+    :param string: The version string to parse.
+    :return: A tuple of strings suitable for comparison.
+    """
+
+    parts = []
+    for part in _parse_version_parts(string.lower()):
+        if part.startswith("*"):
+            if part < "*final":  # remove '-' before a prerelease tag
+                while parts and parts[-1] == "*final-":
+                    parts.pop()
+            # remove trailing zeros from each series of numeric parts
+            while parts and parts[-1] == "00000000":
+                parts.pop()
+        parts.append(part)
+    return tuple(parts)

bugpipe-3.0.1.dist-info/METADATA

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: bugpipe
+Version: 3.0.1
+Summary: Unofficial Python client for Buganizer; the Google Issue Tracking system
+Keywords: buganizer,google-issue-tracker,issue-tracker,bug-tracker,bug-bounty,vulnerability,security,chromium,cve,vrp,google
+Author: Ritchie Mwewa
+Author-email: Ritchie Mwewa <rly0nheart@duck.com>
+License-Expression: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Bug Tracking
+Classifier: Framework :: AsyncIO
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: rich>=14.3.3
+Requires-Python: >=3.13
+Project-URL: Changelog, https://github.com/rly0nheart/bugpipe/blob/master/CHANGELOG.md
+Project-URL: Documentation, https://bugpipe.readthedocs.io
+Project-URL: Repository, https://github.com/rly0nheart/bugpipe
+Description-Content-Type: text/markdown
+
+<p align="center">
+<img alt="logo" src="https://www.gstatic.com/buganizer/img/v0/logo.svg" width="150" height="150">
+<br>
+<br>
+<strong><i>Unofficial Python client for Buganizer; the Google Issue Tracking system.</i></strong>
+</p>
+
+## Quick Start
+
+```bash
+bugpipe search "status:open"
+```
+
+```python
+from bugpipe import Bugpipe
+
+
+with Bugpipe() as client:
+    result = client.search(query="status:open priority:p1", page_size=25)
+    for issue in result.issues:
+        print(f"#{issue.id} [{issue.status.name}] {issue.title}")
+```
+
+## Documentation
+
+Refer to [the docs](https://bugpipe.readthedocs.io) for installation, usage and api reference.

bugpipe-3.0.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+bugpipe/__init__.py,sha256=QO0tHq-83svpy4MoCN6nPHNcwt3-jpz2gUDKYaOsbfI,732
+bugpipe/api/AUDIT.md,sha256=9g2HYEOtges3nPY7xQBwTwge129KP6ho46fga58LOhM,10668
+bugpipe/api/README.md,sha256=V41sjZ9upbNxZ8iNw4yFoOsqDr_wiwKBpSzMshN_XNM,26191
+bugpipe/api/__init__.py,sha256=uty5L3YBFqcW79GG97ldKgWtHY5I-TaYh6Wje7VfNzc,79
+bugpipe/api/client.py,sha256=RZ3fmQV9yXuz2lc1cpd-vtHJTM7kUHJ-dUCBTo03ryQ,10539
+bugpipe/api/models.py,sha256=cPx30gx1yZmchb6XkN0wv2n8VdtC23raaE5sfqCLokU,23157
+bugpipe/api/parser.py,sha256=xShNVE_ok7rWKzGRsA7Omct2AEOZLWe0zi6IllKDST0,24239
+bugpipe/cli/__init__.py,sha256=-vcD4_pFoFmFfx-Z7Bz-W4RLn5c-XHVDiN-PEnCmBQ4,2167
+bugpipe/cli/cmd.py,sha256=0BSoXTiF6N5vw9g-9NKDRtPvgJ054uxsOJwkzkeWs18,9533
+bugpipe/cli/term.py,sha256=SqjUkuVQCngPE8sxhPZOsqCXhw2VojxCMjOEbH1UXdA,7095
+bugpipe/cli/update_checker.py,sha256=HxOvPo-EgaLlseY-X1DfAP18hSmMBp8QxSsvRn8SAfE,7266
+bugpipe-3.0.1.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+bugpipe-3.0.1.dist-info/entry_points.txt,sha256=wND_xpvRjJOmnH18Cp1s68Bb0CGmLgYVioPtnEnblGU,47
+bugpipe-3.0.1.dist-info/METADATA,sha256=rHQdo9G5FI9x2_EbL-F8YktM23g-KK-E8FOHaNyvuV4,1846
+bugpipe-3.0.1.dist-info/RECORD,,

bugpipe-3.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.24
+Root-Is-Purelib: true
+Tag: py3-none-any

bugpipe-3.0.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+bugpipe = bugpipe.cli:start
+