imbi-plugin-github 2.10.0__py3-none-any.whl → 2.11.2__py3-none-any.whl

imbi_plugin_github/commits.py

@@ -50,12 +50,14 @@ from imbi_common.json_pointer import JsonPointer
 from imbi_common.models import CommitRecord, TagRecord
 from imbi_common.plugins.base import (
     ActionDescriptor,
+    CheckStatus,
     CredentialField,
     PluginContext,
     PluginManifest,
     ServicePlugin,
     WebhookActionPlugin,
 )
+from imbi_common.plugins.errors import PluginRateLimited
 
 from imbi_plugin_github import _app_auth
 from imbi_plugin_github._hosts import (
@@ -66,10 +68,13 @@ from imbi_plugin_github._hosts import (
 from imbi_plugin_github._repos import resolve_owner_repo
 from imbi_plugin_github.deployment import (
     _auth_headers,  # pyright: ignore[reportPrivateUsage]
+    _check_runs_to_status,  # pyright: ignore[reportPrivateUsage]
+    _checks_disabled,  # pyright: ignore[reportPrivateUsage]
     _next_page_url,  # pyright: ignore[reportPrivateUsage]
     _parse_iso,  # pyright: ignore[reportPrivateUsage]
     _query_param,  # pyright: ignore[reportPrivateUsage]
     _raise_on_401,  # pyright: ignore[reportPrivateUsage]
+    _record_checks_disabled,  # pyright: ignore[reportPrivateUsage]
     _short_sha,  # pyright: ignore[reportPrivateUsage]
 )
 
@@ -91,6 +96,11 @@ _MAX_COMPARE_PAGES = 20
 # backfill so a very deep repo can't pin the worker indefinitely; the
 # walk logs a truncation warning when it hits the cap.
 _MAX_HISTORY_PAGES = 100
+# CI status is hydrated with one ``/check-runs`` call per commit, which is
+# prohibitively expensive across a full-history backfill.  Bound it to the
+# most-recent commits (the only ones whose CI is still meaningful and
+# unexpired); older commits keep the ``'unknown'`` default.
+_BACKFILL_CI_LIMIT = 25
 
 # Per-context ceilings on how long a *single* rate-limit pause may block
 # before the sync gives up best-effort (logged).  The webhook actions
@@ -140,6 +150,12 @@ def _throttle_wait(response: httpx.Response) -> float | None:
     * a 403/429 that exhausted the quota but gives no reset -> the
       conservative ``_SECONDARY_LIMIT_WAIT_SECONDS`` floor.
 
+    GHES/GHEC sometimes return a secondary (abuse) limit as a 403/429 with
+    *none* of the standard headers -- only the documented body message
+    ("You have exceeded a secondary rate limit ..."); that phrase is
+    matched as a last resort so such a response pauses on the floor rather
+    than being mistaken for a hard failure.
+
     Returns ``None`` for anything that is *not* a throttle signal --
     including a non-rate-limit 403 (e.g. insufficient scope), which must
     fall through to the caller's normal error handling rather than be
@@ -159,9 +175,27 @@ def _throttle_wait(response: httpx.Response) -> float | None:
             return max(0.0, reset - time.time()) + _RESET_BUFFER_SECONDS
         if response.status_code in (403, 429):
             return _SECONDARY_LIMIT_WAIT_SECONDS
+    if response.status_code in (403, 429) and _is_secondary_limit_body(
+        response
+    ):
+        return _SECONDARY_LIMIT_WAIT_SECONDS
     return None
 
 
+def _is_secondary_limit_body(response: httpx.Response) -> bool:
+    """True if a 403/429 body carries GitHub's secondary-limit message.
+
+    Matched conservatively on the documented phrase so a genuine
+    permission 403 (which the caller must surface) is never mistaken for
+    a throttle.
+    """
+    try:
+        body = response.text
+    except (UnicodeDecodeError, httpx.ResponseNotRead):
+        return False
+    return 'secondary rate limit' in body.lower()
+
+
 async def _request(
     client: httpx.AsyncClient,
     method: str,
@@ -176,11 +210,13 @@ async def _request(
     for the interval GitHub states in its headers, then retries -- up to
     ``_MAX_THROTTLE_RETRIES`` times and never longer than *max_wait* on a
     single pause.  When the stated wait exceeds *max_wait* (or the retries
-    are exhausted) the throttled response is handed back unchanged so the
-    caller's ``raise_for_status`` surfaces it and the sync bails
-    best-effort.  After a *successful* response that exhausted the
-    remaining quota, pauses pre-emptively (subject to the same cap) so the
-    next call doesn't spend a round-trip on a guaranteed rejection.
+    are exhausted) :class:`PluginRateLimited` is raised carrying the epoch
+    at which GitHub will resume, so the host can pause the work and keep it
+    queued rather than fail it; on the webhook path the caller swallows it
+    (a later push re-syncs the gap).  After a *successful* response that
+    exhausted the remaining quota, pauses pre-emptively (subject to the
+    same cap) so the next call doesn't spend a round-trip on a guaranteed
+    rejection.
     """
     attempts = 0
     while True:
@@ -204,13 +240,19 @@ async def _request(
         if wait > max_wait or attempts >= _MAX_THROTTLE_RETRIES:
             LOGGER.warning(
                 'github-commit-sync rate-limited on %s (wait %.0fs, cap '
-                '%.0fs, attempt %d); bailing best-effort',
+                '%.0fs, attempt %d); pausing job until GitHub resumes',
                 url,
                 wait,
                 max_wait,
                 attempts + 1,
             )
-            return response
+            raise PluginRateLimited(
+                retry_at=time.time() + wait,
+                message=(
+                    f'github-commit-sync rate-limited on {url}; '
+                    f'resume in {wait:.0f}s'
+                ),
+            )
         attempts += 1
         LOGGER.warning(
             'github-commit-sync rate-limited on %s; pausing %.0fs then '
@@ -493,6 +535,7 @@ def _commit_record(
     ref: str,
     pushed_at: datetime.datetime,
     author_user: str = '',
+    ci_status: CheckStatus = 'unknown',
 ) -> CommitRecord:
     """Map a GitHub commit object onto a :class:`CommitRecord`.
 
@@ -500,7 +543,8 @@ def _commit_record(
     email + linked login + committer), which the UI-facing
     ``Commit``/``_commit_from_payload`` mapping drops, so it maps the raw
     item directly while reusing the low-level ``_short_sha`` / ``_parse_iso``
-    helpers.
+    helpers.  ``ci_status`` is supplied by the caller (hydrated from
+    ``/check-runs``); it defaults to ``'unknown'`` when not resolved.
     """
     sha = str(item.get('sha') or '')
     commit_meta: dict[str, typing.Any] = item.get('commit') or {}
@@ -519,6 +563,7 @@ def _commit_record(
         author_login=str(gh_author.get('login') or ''),
         author_user=author_user,
         committer_name=str(committer_meta.get('name') or ''),
+        ci_status=ci_status,
         authored_at=authored_at or pushed_at,
         committed_at=_parse_iso(committer_meta.get('date')),
         url=str(item.get('html_url') or ''),
@@ -598,6 +643,92 @@ async def _fetch_recent_commits(
     return typing.cast('list[dict[str, typing.Any]]', resp.json())
 
 
+async def _ci_status(
+    client: httpx.AsyncClient,
+    sha: str,
+    *,
+    credentials: dict[str, str],
+    base: str,
+    owner: str,
+    repo: str,
+    max_wait: float,
+) -> CheckStatus:
+    """Roll up ``/commits/{sha}/check-runs`` into a ci_status string.
+
+    Reuses the deployment plugin's ``/check-runs`` mapping and its 403
+    "checks disabled" cache so a token without the scope spends one 403
+    rather than one per commit.  Degrades to ``'unknown'`` on a 403, any
+    non-200, a parse error, a network error, or a rate-limit pause -- CI
+    status is best-effort metadata and must never fail the sync, mirroring
+    the swallow-and-continue contract the rest of this module follows.
+    """
+    if _checks_disabled(credentials, base, owner, repo):
+        return 'unknown'
+    try:
+        resp = await _request(
+            client, 'GET', f'/commits/{sha}/check-runs', max_wait=max_wait
+        )
+        if resp.status_code == 403:
+            _record_checks_disabled(credentials, base, owner, repo)
+            return 'unknown'
+        if resp.status_code != 200:
+            return 'unknown'
+        payload = typing.cast('dict[str, typing.Any]', resp.json())
+    except Exception:  # noqa: BLE001 - CI status is best-effort metadata
+        return 'unknown'
+    return _check_runs_to_status(payload)
+
+
+async def _hydrate_ci(
+    client: httpx.AsyncClient,
+    shas: list[str],
+    *,
+    credentials: dict[str, str],
+    base: str,
+    owner: str,
+    repo: str,
+    max_wait: float,
+) -> dict[str, CheckStatus]:
+    """Resolve ``ci_status`` for ``shas`` -> ``{sha: status}``.
+
+    Probes the head commit first so a 403 (missing scope / Actions
+    disabled) populates the cache and short-circuits the rest, mirroring
+    the deployment plugin's commit picker.  Shas absent from the returned
+    map fall back to ``'unknown'`` at the call site.
+    """
+    out: dict[str, CheckStatus] = {}
+    if not shas or _checks_disabled(credentials, base, owner, repo):
+        return out
+    head, *tail = shas
+    out[head] = await _ci_status(
+        client,
+        head,
+        credentials=credentials,
+        base=base,
+        owner=owner,
+        repo=repo,
+        max_wait=max_wait,
+    )
+    if not tail or _checks_disabled(credentials, base, owner, repo):
+        return out
+    results = await asyncio.gather(
+        *(
+            _ci_status(
+                client,
+                sha,
+                credentials=credentials,
+                base=base,
+                owner=owner,
+                repo=repo,
+                max_wait=max_wait,
+            )
+            for sha in tail
+        )
+    )
+    out.update(dict(zip(tail, results, strict=True)))
+    return out
+
+
 def _resolve_host_for_context(ctx: PluginContext) -> str | None:
     """Resolve the GitHub web host for an on-demand sync (no payload).
 
@@ -772,24 +903,43 @@ async def sync_commits(
     before = _resolve(action_config.before_selector, event)
     pushed_at = datetime.datetime.now(datetime.UTC)
     token = await _resolve_bearer(credentials, base, owner, repo)
-    async with _client(base, owner, repo, token) as client:
-        if isinstance(before, str) and before and before != _ZERO_SHA:
-            raw = await _fetch_compare_commits(
-                client, before, after, max_wait=_WEBHOOK_MAX_WAIT_SECONDS
-            )
-        else:
-            last = await _last_known_sha(ctx.project_id)
-            if last:
+    ci_by_sha: dict[str, CheckStatus] = {}
+    try:
+        async with _client(base, owner, repo, token) as client:
+            if isinstance(before, str) and before and before != _ZERO_SHA:
                 raw = await _fetch_compare_commits(
-                    client, last, after, max_wait=_WEBHOOK_MAX_WAIT_SECONDS
+                    client, before, after, max_wait=_WEBHOOK_MAX_WAIT_SECONDS
                 )
             else:
-                raw = await _fetch_recent_commits(
-                    client,
-                    after,
-                    action_config.initial_limit,
-                    max_wait=_WEBHOOK_MAX_WAIT_SECONDS,
-                )
+                last = await _last_known_sha(ctx.project_id)
+                if last:
+                    raw = await _fetch_compare_commits(
+                        client, last, after, max_wait=_WEBHOOK_MAX_WAIT_SECONDS
+                    )
+                else:
+                    raw = await _fetch_recent_commits(
+                        client,
+                        after,
+                        action_config.initial_limit,
+                        max_wait=_WEBHOOK_MAX_WAIT_SECONDS,
+                    )
+            ci_by_sha = await _hydrate_ci(
+                client,
+                [str(i['sha']) for i in raw if i.get('sha')],
+                credentials=credentials,
+                base=base,
+                owner=owner,
+                repo=repo,
+                max_wait=_WEBHOOK_MAX_WAIT_SECONDS,
+            )
+    except PluginRateLimited as exc:
+        LOGGER.warning(
+            'github-commit-sync: rate-limited syncing commits for project '
+            '%s; skipping this push (a later push re-syncs the gap): %s',
+            ctx.project_id,
+            exc,
+        )
+        return
     user_map = await _resolve_author_users(
         raw, ctx.resolve_user_by_identity, base
     )
@@ -800,6 +950,7 @@ async def sync_commits(
             ref=ref,
             pushed_at=pushed_at,
             author_user=_author_user(item, user_map),
+            ci_status=ci_by_sha.get(str(item['sha']), 'unknown'),
         )
         for item in raw
         if item.get('sha')
@@ -826,6 +977,73 @@ async def _annotated_tag(
     return typing.cast('dict[str, typing.Any]', resp.json())
 
 
+async def _commit_date(
+    client: httpx.AsyncClient, sha: str, *, max_wait: float
+) -> datetime.datetime | None:
+    """Committer date of commit *sha*, ``None`` when unavailable.
+
+    Lightweight tags carry no tagger date, so their target commit's
+    date stands in for ``tagged_at`` — otherwise the ClickHouse row
+    falls back to ``recorded_at`` (sync time) and every release in the
+    UI reads "just now" after a full reconcile.
+    """
+    resp = await _request(
+        client, 'GET', f'/git/commits/{sha}', max_wait=max_wait
+    )
+    if resp.status_code != 200:
+        return None
+    data = typing.cast('dict[str, typing.Any]', resp.json())
+    committer: dict[str, typing.Any] = data.get('committer') or {}
+    return _parse_iso(committer.get('date'))
+
+
+async def _release_published_for_tag(
+    client: httpx.AsyncClient, name: str, *, max_wait: float
+) -> datetime.datetime | None:
+    """Published date of the GitHub release for tag *name*, if any."""
+    resp = await _request(
+        client,
+        'GET',
+        f'/releases/tags/{urllib.parse.quote(name, safe="")}',
+        max_wait=max_wait,
+    )
+    if resp.status_code != 200:
+        return None
+    data = typing.cast('dict[str, typing.Any]', resp.json())
+    return _parse_iso(data.get('published_at'))
+
+
+async def _release_published_map(
+    client: httpx.AsyncClient, *, max_wait: float
+) -> dict[str, datetime.datetime]:
+    """Map tag name -> GitHub release published date for the repo.
+
+    One paginated ``/releases`` sweep instead of a per-tag lookup;
+    drafts (``published_at`` null) are skipped.
+    """
+    out: dict[str, datetime.datetime] = {}
+    params: dict[str, str] = {'per_page': '100'}
+    while True:
+        resp = await _request(
+            client, 'GET', '/releases', params=params, max_wait=max_wait
+        )
+        if resp.status_code != 200:
+            return out
+        rows = typing.cast('list[dict[str, typing.Any]]', resp.json())
+        for row in rows:
+            tag = row.get('tag_name')
+            published = _parse_iso(row.get('published_at'))
+            if tag and published:
+                out[str(tag)] = published
+        next_url = _next_page_url(resp.headers.get('link'))
+        if next_url is None:
+            return out
+        next_page = _query_param(next_url, 'page')
+        if next_page is None:
+            return out
+        params['page'] = next_page
+
+
 def _web_base(api_base: str) -> str:
     """Map a REST API base to the web host (inverse of the routing table).
 
@@ -857,9 +1075,24 @@ def _tag_record(
     sha: str,
     annotated: dict[str, typing.Any] | None = None,
     url: str = '',
+    published_at: datetime.datetime | None = None,
+    fallback_tagged_at: datetime.datetime | None = None,
 ) -> TagRecord:
+    """Build the ClickHouse row for one tag.
+
+    ``tagged_at`` preference: the GitHub release's published date
+    (*published_at*), then the annotated tag's tagger date, then the
+    target commit's committer date (*fallback_tagged_at*, lightweight
+    tags only).
+    """
     if annotated is None:
-        return TagRecord(project_id=project_id, name=name, sha=sha, url=url)
+        return TagRecord(
+            project_id=project_id,
+            name=name,
+            sha=sha,
+            url=url,
+            tagged_at=published_at or fallback_tagged_at,
+        )
     tagger: dict[str, typing.Any] = annotated.get('tagger') or {}
     return TagRecord(
         project_id=project_id,
@@ -869,7 +1102,7 @@ def _tag_record(
         message=str(annotated.get('message') or ''),
         tagger_name=str(tagger.get('name') or ''),
         tagger_email=str(tagger.get('email') or ''),
-        tagged_at=_parse_iso(tagger.get('date')),
+        tagged_at=published_at or _parse_iso(tagger.get('date')),
     )
 
 
@@ -886,6 +1119,8 @@ async def _reconcile_tags(
     out: list[TagRecord] = []
     prefix = 'refs/tags/'
     params: dict[str, str] = {'per_page': '100'}
+    # Lazily fetched on the first tag so tag-less repos cost nothing.
+    released: dict[str, datetime.datetime] | None = None
     while True:
         resp = await _request(
             client,
@@ -903,6 +1138,11 @@ async def _reconcile_tags(
             if not ref.startswith(prefix) or not sha:
                 continue
             name = ref[len(prefix) :]
+            if released is None:
+                released = await _release_published_map(
+                    client, max_wait=max_wait
+                )
+            published = released.get(name)
             annotated = (
                 await _annotated_tag(client, sha, max_wait=max_wait)
                 if obj.get('type') == 'tag'
@@ -915,6 +1155,12 @@ async def _reconcile_tags(
                     sha=sha,
                     annotated=annotated,
                     url=_tag_web_url(client, name),
+                    published_at=published,
+                    fallback_tagged_at=(
+                        await _commit_date(client, sha, max_wait=max_wait)
+                        if annotated is None and published is None
+                        else None
+                    ),
                 )
             )
         next_url = _next_page_url(resp.headers.get('link'))
@@ -954,25 +1200,45 @@ async def sync_tags(
         return
     owner, repo, base = resolved
     token = await _resolve_bearer(credentials, base, owner, repo)
-    async with _client(base, owner, repo, token) as client:
-        annotated = await _annotated_tag(
-            client, after, max_wait=_WEBHOOK_MAX_WAIT_SECONDS
-        )
-        records: list[pydantic.BaseModel] = [
-            _tag_record(
-                project_id=ctx.project_id,
-                name=name,
-                sha=after,
-                annotated=annotated,
-                url=_tag_web_url(client, name),
+    try:
+        async with _client(base, owner, repo, token) as client:
+            annotated = await _annotated_tag(
+                client, after, max_wait=_WEBHOOK_MAX_WAIT_SECONDS
             )
-        ]
-        if action_config.reconcile_all:
-            extra = await _reconcile_tags(
-                client, ctx.project_id, max_wait=_WEBHOOK_MAX_WAIT_SECONDS
+            published = await _release_published_for_tag(
+                client, name, max_wait=_WEBHOOK_MAX_WAIT_SECONDS
             )
-            seen = {name}
-            records.extend(r for r in extra if r.name not in seen)
+            records: list[pydantic.BaseModel] = [
+                _tag_record(
+                    project_id=ctx.project_id,
+                    name=name,
+                    sha=after,
+                    annotated=annotated,
+                    url=_tag_web_url(client, name),
+                    published_at=published,
+                    fallback_tagged_at=(
+                        await _commit_date(
+                            client, after, max_wait=_WEBHOOK_MAX_WAIT_SECONDS
+                        )
+                        if annotated is None and published is None
+                        else None
+                    ),
+                )
+            ]
+            if action_config.reconcile_all:
+                extra = await _reconcile_tags(
+                    client, ctx.project_id, max_wait=_WEBHOOK_MAX_WAIT_SECONDS
+                )
+                seen = {name}
+                records.extend(r for r in extra if r.name not in seen)
+    except PluginRateLimited as exc:
+        LOGGER.warning(
+            'github-commit-sync: rate-limited syncing tags for project '
+            '%s; skipping this push (a later push re-syncs the gap): %s',
+            ctx.project_id,
+            exc,
+        )
+        return
     try:
         await clickhouse.insert('tags', records)
     except Exception:
@@ -1102,7 +1368,10 @@ class GitHubCommitSyncPlugin(WebhookActionPlugin):
         Returns ``(commits_recorded, tags_recorded)``.  Raises
         :class:`ValueError` only when the host or repository can't be
         resolved; ClickHouse failures are swallowed (the count reflects
-        what was written).
+        what was written).  Propagates :class:`PluginRateLimited` when a
+        GitHub rate-limit reset is further out than
+        ``_BACKFILL_MAX_WAIT_SECONDS`` so the host can pause the worker and
+        keep the job queued until GitHub resumes rather than fail it.
         """
         host = _resolve_host_for_context(ctx)
         if host is None:
@@ -1124,6 +1393,22 @@ class GitHubCommitSyncPlugin(WebhookActionPlugin):
             tags = await _reconcile_tags(
                 client, ctx.project_id, max_wait=_BACKFILL_MAX_WAIT_SECONDS
             )
+            # CI status only for the most-recent commits: one /check-runs
+            # call per commit is too costly across full history, and old
+            # commits' CI is no longer meaningful.
+            ci_by_sha = await _hydrate_ci(
+                client,
+                [
+                    str(i['sha'])
+                    for i in raw_commits[:_BACKFILL_CI_LIMIT]
+                    if i.get('sha')
+                ],
+                credentials=credentials,
+                base=base,
+                owner=owner,
+                repo=repo,
+                max_wait=_BACKFILL_MAX_WAIT_SECONDS,
+            )
         user_map = await _resolve_author_users(
             raw_commits, ctx.resolve_user_by_identity, base
         )
@@ -1134,6 +1419,7 @@ class GitHubCommitSyncPlugin(WebhookActionPlugin):
                 ref=branch,
                 pushed_at=pushed_at,
                 author_user=_author_user(item, user_map),
+                ci_status=ci_by_sha.get(str(item['sha']), 'unknown'),
             )
             for item in raw_commits
             if item.get('sha')

imbi_plugin_github/deployment.py

@@ -1035,12 +1035,18 @@ class _DeploymentBase(DeploymentPlugin):
         description = deployment.get('description')
         deployment_url = deployment.get('url') or deployment.get('html_url')
         creator_login: str | None = None
+        creator_subject: str | None = None
         creator_raw = deployment.get('creator')
         if isinstance(creator_raw, dict):
             creator_dict = typing.cast(dict[str, typing.Any], creator_raw)
             login = creator_dict.get('login')
             if isinstance(login, str) and login:
                 creator_login = login
+            # GitHub's numeric user id is the stable identity subject the
+            # host resolves to an Imbi user (logins can be renamed).
+            creator_id = creator_dict.get('id')
+            if isinstance(creator_id, int):
+                creator_subject = str(creator_id)
         return RemoteDeployment(
             environment=environment,
             sha=str(sha),
@@ -1052,6 +1058,7 @@ class _DeploymentBase(DeploymentPlugin):
             deployment_url=str(deployment_url) if deployment_url else None,
             description=str(description) if description else None,
             creator=creator_login,
+            creator_subject=creator_subject,
         )
 
     async def _latest_status(

{imbi_plugin_github-2.10.0.dist-info → imbi_plugin_github-2.11.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: imbi-plugin-github
-Version: 2.10.0
+Version: 2.11.2
 Summary: GitHub identity plugin for Imbi (github.com / GHEC / GHES)
 Author-email: "Gavin M. Roy" <gavinr@aweber.com>
 License: BSD-3-Clause
@@ -13,7 +13,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.14
 Requires-Dist: httpx>=0.27
-Requires-Dist: imbi-common[databases]==2.10.0
+Requires-Dist: imbi-common[databases]==2.11.2
 Requires-Dist: pydantic>=2
 Requires-Dist: pyjwt[crypto]>=2.8
 Description-Content-Type: text/markdown

{imbi_plugin_github-2.10.0.dist-info → imbi_plugin_github-2.11.2.dist-info}/RECORD

@@ -2,12 +2,12 @@ imbi_plugin_github/__init__.py,sha256=8ZVhm8XpGqgYRUtpHl0uuZTT3gmMyHNhKd9k6qoatB
 imbi_plugin_github/_app_auth.py,sha256=LnLrvqmu2UC27uHHJfIzFPNDh33RtgeOX1RXceX9Pj0,7000
 imbi_plugin_github/_hosts.py,sha256=jQ1Z6yEpjAa4b7LocLfEelnBcRYYQLNLBNCdWZtAXUc,2258
 imbi_plugin_github/_repos.py,sha256=agp4ZgRuqbrGBRMFeHomnUf1HvvaNvapBCWHQebdviQ,4559
-imbi_plugin_github/commits.py,sha256=hZiTCboherDMY4noKF2T6BKKWMm0uYK4dPAV5c1Giv0,42141
-imbi_plugin_github/deployment.py,sha256=V6YlZX24m33BPJWkC-vCZZLSsH71etkl0xkhkDsKASg,47914
+imbi_plugin_github/commits.py,sha256=Pp4-LHnNpDrhsDbJSmQQO7qLgWiaBpOBPQJKTkTcn5w,53014
+imbi_plugin_github/deployment.py,sha256=d82G7zGcN-A_1J19tUZuzVzK3AOfvIbowtGJ6zLEeck,48287
 imbi_plugin_github/identity.py,sha256=RSs1cLQpZmfyQ_0KQkohDIZEBYVBnre6RJIt166EtdQ,15525
 imbi_plugin_github/lifecycle.py,sha256=48mLKjFPG7BOanpA7jWnmbWOdsDLh1F39g2AoxDLL7M,33211
-imbi_plugin_github-2.10.0.dist-info/METADATA,sha256=iLcyJ1p6YvChsBou6DyMlf-HHq3jDKZ1c-Rn5jPUYc8,5811
-imbi_plugin_github-2.10.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-imbi_plugin_github-2.10.0.dist-info/entry_points.txt,sha256=RavN_FYCeS97iauHgCG3tHFdVULbEMXmQfvgCgLeGkI,805
-imbi_plugin_github-2.10.0.dist-info/licenses/LICENSE,sha256=el9B20zOqEcv_mRrHgbdkVyxSC6I8np7am0D6mO2A9Y,1491
-imbi_plugin_github-2.10.0.dist-info/RECORD,,
+imbi_plugin_github-2.11.2.dist-info/METADATA,sha256=Z15EFgty_LerbZ2KfYsmAMXJKyWcM64pKMkO9igS71c,5811
+imbi_plugin_github-2.11.2.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+imbi_plugin_github-2.11.2.dist-info/entry_points.txt,sha256=RavN_FYCeS97iauHgCG3tHFdVULbEMXmQfvgCgLeGkI,805
+imbi_plugin_github-2.11.2.dist-info/licenses/LICENSE,sha256=el9B20zOqEcv_mRrHgbdkVyxSC6I8np7am0D6mO2A9Y,1491
+imbi_plugin_github-2.11.2.dist-info/RECORD,,

{imbi_plugin_github-2.10.0.dist-info → imbi_plugin_github-2.11.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.29.0
+Generator: hatchling 1.30.1
 Root-Is-Purelib: true
 Tag: py3-none-any