flyteplugins-gitlab 0.0.0a0__py3-none-any.whl

flyteplugins/gitlab/__init__.py

@@ -0,0 +1,71 @@
+"""GitLab webhooks for Flyte.
+
+Hand a `GitLabProvider()` to a `WebhookAppEnvironment` and register handlers with the
+typed constants in `events`:
+
+```python
+import flyte
+from flyte.extras.webhooks import WebhookAppEnvironment, run_once
+from flyteplugins.gitlab import GitLabProvider, events
+
+# GitLabProvider.default_secret_env (GITLAB_WEBHOOK_TOKEN) is mounted for you.
+app_env = WebhookAppEnvironment(name="gitlab-webhooks", providers=[GitLabProvider()])
+
+
+@app_env.on_event(events.MergeRequest.OPEN)
+async def triage(event):
+    import flyte.remote as remote
+
+    task = remote.Task.get(name="gitlab-triage.triage_mr", auto_version="latest")
+    result = await run_once.aio(task, key=event.dedupe_key(), repo=event.scope)
+    if not result.created:
+        return {"skipped": result.run.name, "url": result.run.url}
+    return {"run": result.run.name}
+```
+
+Note GitLab does not sign its webhooks; it authenticates with a shared token
+sent verbatim in `X-Gitlab-Token` (the legacy *Secret token* mode — its newer
+Standard-Webhooks *Signing token* mode, with `webhook-signature` /
+`webhook-id` / `webhook-timestamp` headers, is not covered). See `_provider`
+for what this plugin does with that. Calling the GitLab API (opening MRs, commenting, approving) is not
+this plugin's job — use the `python-gitlab` package from your tasks, installed
+via `flyteplugins-gitlab[gitlab]`. See `examples/external_saas_integrations`.
+"""
+
+from . import events, payloads
+from ._provider import GitLabProvider, parse, verify
+
+__all__ = [
+    "SAMPLE_DELIVERY",
+    "GitLabProvider",
+    "events",
+    "parse",
+    "payloads",
+    "verify",
+]
+
+
+def _sample_headers(body: bytes, secret: str) -> dict[str, str]:
+    # No signature to compute: GitLab sends a static shared token.
+    return {
+        "X-Gitlab-Event": "Merge Request Hook",
+        "X-Gitlab-Event-UUID": "00000000-0000-0000-0000-000000000000",
+        "X-Gitlab-Token": secret,
+    }
+
+
+#: A real `merge_request` "open" delivery, trimmed to the fields the parser reads.
+#: The conformance harness replays it under the shared token, so `verify` and
+#: `parse` are checked against an actual payload rather than against each other.
+SAMPLE_DELIVERY = (
+    _sample_headers,
+    (
+        b'{"object_kind": "merge_request", "event_type": "merge_request",'
+        b' "user": {"name": "Octocat", "username": "octocat"},'
+        b' "project": {"id": 1, "name": "repo", "path_with_namespace": "octo/repo"},'
+        b' "object_attributes": {"id": 99, "iid": 7, "action": "open", "state": "opened",'
+        b' "title": "Add a feature", "url": "https://gitlab.com/octo/repo/-/merge_requests/7",'
+        b' "source_branch": "feature", "target_branch": "main",'
+        b' "updated_at": "2024-01-01T00:00:00Z"}}'
+    ),
+)

flyteplugins/gitlab/_provider.py

@@ -0,0 +1,188 @@
+"""GitLab webhook verification and payload normalization.
+
+GitLab does **not** sign its webhooks. There is no HMAC over the body; the
+*Secret token* you set on a webhook is a static shared token that GitLab echoes
+verbatim in the `X-Gitlab-Token` header. This plugin authenticates with that
+token (a constant-time comparison, exactly like `JiraProvider`), and reports
+`signed=False` so the dashboard says so rather than implying a guarantee that
+is absent.
+
+(GitLab's newer *Signing token* mode instead signs the body following the
+Standard Webhooks spec: `webhook-signature` carries an HMAC-SHA256 over
+`webhook-id`.`webhook-timestamp`.body. This plugin does not cover it — the legacy
+shared token is what the webhook *Secret token* field sets, and it is what the
+sample delivery exercises.)
+
+`parse` normalizes the payload into a `WebhookEvent`: the event type comes from
+`object_kind`, the action from `object_attributes.action` (or `status` for
+pipelines and deployments), and the resource id follows GitLab's `!` / `#`
+convention — merge requests use `!`, issues use `#`, on a `path_with_namespace`
+scope. Pipelines, deployments, and releases key on their own id, tag, or
+deployment id instead, so a redelivery dedupes even without a delivery UUID.
+
+Deployment and release hooks are the odd ones out: GitLab sends their fields at
+the top level of the payload, with no `object_attributes` at all.
+"""
+
+from __future__ import annotations
+
+from typing import Any, ClassVar, Mapping
+
+from flyte.extras.webhooks import (
+    Provider,
+    WebhookEvent,
+    constant_time_equals,
+    json_body,
+    lower_headers,
+)
+
+
+def verify(body: bytes, headers: Mapping[str, str], secret: str) -> bool:
+    """Compare the `X-Gitlab-Token` header against the shared secret token."""
+    token = lower_headers(headers).get("x-gitlab-token")
+    if not token:
+        return False
+    return constant_time_equals(token.strip(), secret)
+
+
+# Hooks whose fields GitLab sends flat, at the top level of the payload, rather
+# than nested under `object_attributes`.
+_FLAT_KINDS = frozenset({"deployment", "release"})
+
+# Hooks whose state is a `status` rather than an `action`.
+_STATUS_KINDS = frozenset({"pipeline", "deployment"})
+
+
+def _build_resource(obj_kind: str, payload: dict[str, Any], attrs: dict[str, Any], namespace: str | None) -> str | None:
+    """A stable, human-readable id for the resource an event is about.
+
+    Push and tag-push hooks return None on purpose, matching the GitHub plugin:
+    a push is a delivery, not a resource, so the delivery id is the right key.
+    """
+    if not namespace:
+        return None
+    if obj_kind in ("merge_request", "issue"):
+        iid = attrs.get("iid")
+        if iid is not None:
+            marker = "!" if obj_kind == "merge_request" else "#"
+            return f"{namespace}{marker}{iid}"
+    elif obj_kind == "note":
+        # A comment's parent is beside the note, not inside object_attributes.
+        parent = payload.get("merge_request") or payload.get("issue") or {}
+        parent_iid = parent.get("iid")
+        note_id = attrs.get("id")
+        if parent_iid is not None and note_id is not None:
+            marker = "!" if payload.get("merge_request") else "#"
+            return f"{namespace}{marker}{parent_iid}:{note_id}"
+    elif obj_kind == "pipeline":
+        pipeline_id = attrs.get("id")
+        if pipeline_id is not None:
+            return f"{namespace}/-/pipelines/{pipeline_id}"
+    elif obj_kind == "deployment":
+        deployment_id = attrs.get("deployment_id")
+        if deployment_id is not None:
+            return f"{namespace}/-/deployments/{deployment_id}"
+    elif obj_kind == "release":
+        tag = attrs.get("tag")
+        if tag:
+            return f"{namespace}/-/releases/{tag}"
+    return None
+
+
+def parse(headers: Mapping[str, str], body: bytes) -> WebhookEvent:
+    """Normalize a GitLab delivery into a `WebhookEvent`."""
+    payload = json_body(body)
+    lowered = lower_headers(headers)
+
+    obj_kind = payload.get("object_kind") or payload.get("event_type") or "unknown"
+    project = payload.get("project") or {}
+    namespace = project.get("path_with_namespace") or project.get("name")
+
+    # Most hooks nest the changed object under `object_attributes`. Deployment and
+    # release hooks do not: their `status` / `action`, ids, and timestamps sit at
+    # the top level, so read the payload itself as the attributes for those.
+    if obj_kind in _FLAT_KINDS:
+        attrs: dict[str, Any] = payload
+    else:
+        attrs = payload.get("object_attributes") or {}
+
+    # A note (comment) has no title of its own; the parent MR/issue does, which is
+    # what the dashboard should show for a comment the way it would for the thread.
+    # Releases call theirs `name`; a deployment's most useful label is its environment.
+    title = attrs.get("title")
+    if obj_kind == "note":
+        parent = payload.get("merge_request") or payload.get("issue") or {}
+        title = parent.get("title") or title
+    elif obj_kind == "release":
+        title = attrs.get("name") or title
+    elif obj_kind == "deployment":
+        title = attrs.get("environment") or title
+
+    user = payload.get("user")
+    if isinstance(user, dict):
+        actor = user.get("username") or user.get("name")
+    else:
+        # Push and tag-push hooks send the author as a plain string instead.
+        actor = payload.get("user_username") or payload.get("user_name")
+
+    # Pipelines and deployments report their state in `status`, not `action`.
+    if obj_kind in _STATUS_KINDS:
+        action = attrs.get("status")
+    else:
+        action = attrs.get("action")
+
+    return WebhookEvent(
+        provider="gitlab",
+        event_type=obj_kind,
+        action=action,
+        delivery_id=lowered.get("x-gitlab-event-uuid", ""),
+        resource_id=_build_resource(obj_kind, payload, attrs, namespace),
+        occurred_at=(
+            attrs.get("updated_at")
+            or attrs.get("status_changed_at")  # deployment
+            or attrs.get("released_at")  # release
+            or attrs.get("finished_at")  # pipeline
+            or attrs.get("created_at")
+        ),
+        scope=namespace,
+        title=title,
+        url=attrs.get("url") or attrs.get("deployable_url"),
+        actor=actor,
+        payload=payload,
+    )
+
+
+class GitLabProvider(Provider):
+    """GitLab's webhook provider, with its defaults pre-wired.
+
+    ```python
+    from flyte.extras.webhooks import WebhookAppEnvironment
+    from flyteplugins.gitlab import GitLabProvider
+
+    app_env = WebhookAppEnvironment(name="webhooks", providers=[GitLabProvider()])
+    ```
+
+    GitLab does not sign its webhooks, so this provider authenticates with the
+    shared token in `X-Gitlab-Token` and reports `signed=False` — which is what
+    makes the dashboard say so rather than implying a guarantee that is absent.
+
+    `WebhookAppEnvironment` mounts `default_secret_env` for you, so it does not
+    need naming again in `secrets=`.
+
+    Args:
+        secret_env: Environment variable holding the secret. Pass one only to
+            point this provider at a secret stored under a different name;
+            otherwise `default_secret_env` applies.
+    """
+
+    default_secret_env: ClassVar[str] = "GITLAB_WEBHOOK_TOKEN"
+
+    def __init__(self, *, secret_env: str | None = None) -> None:
+        super().__init__(
+            name="gitlab",
+            secret_env=secret_env or self.default_secret_env,
+            verify=verify,
+            parse=parse,
+            signed=False,
+            setup_hint="Project Settings -> Webhooks (secret token sent verbatim in X-Gitlab-Token)",
+        )

flyteplugins/gitlab/events.py

@@ -0,0 +1,112 @@
+"""GitLab webhook events, from the payload's `object_kind` plus `object_attributes.action`.
+
+GitLab names each hook after its object; the header is `X-Gitlab-Event`
+("Merge Request Hook"), and the payload's `object_kind` carries the same idea in
+snake_case (`merge_request`). The action then lives on
+`object_attributes.action` ("open", "close", ...). These constants spell the
+wire values so a handler can match without assembling either part by hand.
+
+Note hooks (comments) have no action of their own, and push / tag-push hooks
+send none either — those classes expose only `ANY`. Pipelines and deployments
+report a `status` instead of an action, and deployment / release hooks put it
+at the top level of the payload rather than under `object_attributes`; the
+parser folds all of that into the same `kind.action` shape used here.
+"""
+
+from __future__ import annotations
+
+from flyte.extras.webhooks import EventType
+
+__all__ = [
+    "Deployment",
+    "Issue",
+    "MergeRequest",
+    "Note",
+    "Pipeline",
+    "Push",
+    "Release",
+    "TagPush",
+]
+
+
+class MergeRequest(EventType):
+    """`merge_request` events. GitLab marks merge requests with `!` (`octo/repo!7`); issues use `#`."""
+
+    ANY = "merge_request"
+    OPEN = "merge_request.open"
+    CLOSE = "merge_request.close"
+    REOPEN = "merge_request.reopen"
+    UPDATE = "merge_request.update"
+    APPROVAL = "merge_request.approval"
+    APPROVED = "merge_request.approved"
+    UNAPPROVAL = "merge_request.unapproval"
+    UNAPPROVED = "merge_request.unapproved"
+    MERGE = "merge_request.merge"
+
+
+class Issue(EventType):
+    """`issue` events."""
+
+    ANY = "issue"
+    OPEN = "issue.open"
+    CLOSE = "issue.close"
+    REOPEN = "issue.reopen"
+    UPDATE = "issue.update"
+
+
+class Note(EventType):
+    """`note` events — comments on issues, merge requests, commits, or snippets.
+
+    GitLab sends no action for notes. `object_attributes.noteable_type` says what
+    the comment is on; the note's own `id` keeps two comments on one thread
+    from collapsing onto a single dedupe key.
+    """
+
+    ANY = "note"
+
+
+class Push(EventType):
+    """`push` events — a branch push to a project. No action."""
+
+    ANY = "push"
+
+
+class TagPush(EventType):
+    """`tag_push` events — a tag created or deleted. No action."""
+
+    ANY = "tag_push"
+
+
+class Pipeline(EventType):
+    """`pipeline` events. The action is the pipeline's `status`."""
+
+    ANY = "pipeline"
+    CREATED = "pipeline.created"
+    WAITING_FOR_RESOURCE = "pipeline.waiting_for_resource"
+    PREPARING = "pipeline.preparing"
+    PENDING = "pipeline.pending"
+    RUNNING = "pipeline.running"
+    SUCCESS = "pipeline.success"
+    FAILED = "pipeline.failed"
+    CANCELED = "pipeline.canceled"
+    SKIPPED = "pipeline.skipped"
+    MANUAL = "pipeline.manual"
+    SCHEDULED = "pipeline.scheduled"
+
+
+class Release(EventType):
+    """`release` events. The action sits at the top level of the payload."""
+
+    ANY = "release"
+    CREATE = "release.create"
+    UPDATE = "release.update"
+
+
+class Deployment(EventType):
+    """`deployment` events. The action is the top-level `status`."""
+
+    ANY = "deployment"
+    RUNNING = "deployment.running"
+    SUCCESS = "deployment.success"
+    FAILED = "deployment.failed"
+    CANCELED = "deployment.canceled"

flyteplugins/gitlab/payloads.py

@@ -0,0 +1,184 @@
+"""Typed views of GitLab payloads, for autocomplete inside handlers.
+
+`event.payload` is `dict[str, Any]` — correct, since it carries GitLab's JSON
+verbatim, but blind to write against. These TypedDicts spell the fields GitLab
+actually sends, so `payloads.merge_request(event)` gives editors and agents
+something to complete against:
+
+```python
+from flyteplugins.gitlab import payloads
+
+@app_env.on_event(events.MergeRequest.OPEN)
+async def on_mr(event):
+    payload = payloads.merge_request(event)
+    author = payload["user"]["username"]
+    branch = payload["object_attributes"]["source_branch"]
+```
+
+The helpers are casts, not validators: the dict is returned untouched, and a
+field GitLab did not send is still a `KeyError` at runtime. Every class is
+`total=False` because GitLab's payloads vary by hook and trigger — treat
+presence the way you already would with a raw dict. Fields beyond these still
+exist in the dict; the types name the commonly-read ones, not the whole wire
+format.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, TypedDict, cast
+
+if TYPE_CHECKING:
+    from flyte.extras.webhooks import WebhookEvent
+
+__all__ = [
+    "Author",
+    "Commit",
+    "MergeRequestEvent",
+    "NoteEvent",
+    "NoteThread",
+    "ObjectAttributes",
+    "Project",
+    "PushEvent",
+    "Repository",
+    "User",
+    "merge_request",
+    "note",
+    "push",
+]
+
+
+class User(TypedDict, total=False):
+    """The actor on issue / merge request / note hooks."""
+
+    name: str
+    username: str
+    id: int
+    avatar_url: str
+
+
+class Author(TypedDict, total=False):
+    """`commit["author"]` on push hooks."""
+
+    name: str
+    email: str
+
+
+class Commit(TypedDict, total=False):
+    """One entry of `payload["commits"]` on push hooks."""
+
+    id: str
+    message: str
+    title: str
+    timestamp: str
+    url: str
+    author: Author
+    added: list[str]
+    modified: list[str]
+    removed: list[str]
+
+
+class Project(TypedDict, total=False):
+    """`payload["project"]` — the repo the event is about."""
+
+    id: int
+    name: str
+    path_with_namespace: str
+    default_branch: str
+    web_url: str
+    visibility: str
+
+
+class Repository(TypedDict, total=False):
+    """`payload["repository"]` — the repo as push hooks call it."""
+
+    name: str
+    url: str
+    path: str
+    homepage: str
+
+
+class ObjectAttributes(TypedDict, total=False):
+    """`payload["object_attributes"]` — the object that changed."""
+
+    id: int
+    iid: int
+    action: str
+    state: str
+    title: str
+    description: str
+    url: str
+    source_branch: str
+    target_branch: str
+    merge_status: str
+    updated_at: str
+    created_at: str
+
+
+class MergeRequestEvent(TypedDict, total=False):
+    """A `merge_request` delivery."""
+
+    object_kind: str
+    event_type: str
+    user: User
+    project: Project
+    object_attributes: ObjectAttributes
+
+
+class NoteThread(TypedDict, total=False):
+    """`payload["merge_request"]` or `payload["issue"]` — the thread a note is on."""
+
+    id: int
+    iid: int
+    title: str
+    url: str
+    state: str
+
+
+class NoteEvent(TypedDict, total=False):
+    """A `note` delivery — a comment on an issue or merge request.
+
+    Exactly one of `merge_request` / `issue` is present, matching
+    `object_attributes["noteable_type"]`.
+    """
+
+    object_kind: str
+    event_type: str
+    user: User
+    project: Project
+    object_attributes: ObjectAttributes
+    merge_request: NoteThread
+    issue: NoteThread
+
+
+class PushEvent(TypedDict, total=False):
+    """A `push` or `tag_push` delivery. The actor arrives as plain strings, not a `User`."""
+
+    object_kind: str
+    event_name: str
+    ref: str
+    before: str
+    after: str
+    checkout_sha: str
+    user_id: int
+    user_name: str
+    user_username: str
+    user_email: str
+    project: Project
+    repository: Repository
+    commits: list[Commit]
+    total_commits_count: int
+
+
+def merge_request(event: WebhookEvent) -> MergeRequestEvent:
+    """Typed view of a `merge_request` delivery's payload. A cast, not validation."""
+    return cast("MergeRequestEvent", event.payload)
+
+
+def note(event: WebhookEvent) -> NoteEvent:
+    """Typed view of a `note` delivery's payload. A cast, not validation."""
+    return cast("NoteEvent", event.payload)
+
+
+def push(event: WebhookEvent) -> PushEvent:
+    """Typed view of a `push` or `tag_push` delivery's payload. A cast, not validation."""
+    return cast("PushEvent", event.payload)

flyteplugins_gitlab-0.0.0a0.dist-info/METADATA

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: flyteplugins-gitlab
+Version: 0.0.0a0
+Summary: Receive GitLab webhooks in Flyte.
+Author: Flyte Contributors
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: flyte
+Provides-Extra: app
+Requires-Dist: fastapi>=0.115; extra == "app"
+Requires-Dist: uvicorn>=0.30; extra == "app"
+Provides-Extra: gitlab
+Requires-Dist: python-gitlab>=4; extra == "gitlab"
+
+# flyteplugins-gitlab
+
+Receive GitLab webhooks in Flyte.
+
+```bash
+pip install "flyteplugins-gitlab[app]"
+```
+
+## Using it
+
+Hand a `GitLabProvider()` to a `WebhookAppEnvironment` and register handlers with the
+typed constants in `events`:
+
+```python
+import flyte
+from flyte.extras.webhooks import WebhookAppEnvironment, run_once
+from flyteplugins.gitlab import GitLabProvider, events
+
+# GitLabProvider.default_secret_env is mounted for you.
+app_env = WebhookAppEnvironment(name="gitlab-webhooks", providers=[GitLabProvider()])
+
+
+@app_env.on_event(events.MergeRequest.OPEN)
+async def handle(event):
+    import flyte.remote as remote
+
+    task = remote.Task.get(name="my-env.my_task", auto_version="latest")
+    result = await run_once.aio(task, key=event.dedupe_key(), project=event.scope)
+    if not result.created:
+        return {"skipped": result.run.name, "url": result.run.url}
+    return {"run": result.run.name}
+
+
+flyte.serve(app_env)
+```
+
+Handlers must `await run_once.aio(...)`. The blocking form stalls the
+app's event loop, and GitLab times deliveries out in seconds.
+
+One app can serve several products at once — hand it one provider per product.
+
+## Try it
+
+`examples/gitlab_webhooks.py` runs two ways. The first needs no GitLab account:
+
+```bash
+python examples/gitlab_webhooks.py --local   # replay a real sample delivery in-process
+python examples/gitlab_webhooks.py           # deploy the receiver to Flyte
+```
+
+`--local` posts this plugin's `SAMPLE_DELIVERY` through the app with FastAPI's
+test client, so you see a delivery verified, normalized, and dispatched — plus
+one with the wrong token refused, and the same delivery replayed to show the
+dedupe key is stable.
+
+## Setup
+
+1. Store the secret and mount it on the app:
+   ```bash
+   flyte create secret GITLAB_WEBHOOK_TOKEN --value <token>
+   ```
+2. Point GitLab at `<app-url>/webhook/gitlab`, from
+   Project Settings → Webhooks → Add webhook.
+
+**Verification:** none, in the sense of a signature. GitLab's webhook *Secret
+token* is a static shared token, not an HMAC; GitLab sends it verbatim in
+`X-Gitlab-Token`, which this plugin compares in constant time. The dashboard
+reports `signed=False` so you can tell this apart from a product that actually
+signs the body.
+
+(GitLab's newer *Signing token* mode does sign the body, following the Standard
+Webhooks spec: `webhook-signature` carries an HMAC-SHA256 over
+`webhook-id`.`webhook-timestamp`.body. This plugin authenticates the classic
+secret-token mode and does not cover that one.)
+
+## Event constants
+
+`events` spells every event this plugin can dispatch, as `str` enums grouped by
+event type, so a typo fails at import rather than by silently never matching.
+`MergeRequest`, `Issue`, and `Release` split the action (`merge_request.open`);
+`Pipeline` and `Deployment` split on GitLab's `status` instead
+(`pipeline.success`, `deployment.failed`); `Push`, `TagPush`, and `Note` carry
+only `ANY` because GitLab sends them no action. Raw strings still work, for
+events the constants do not cover yet.
+
+`payloads` adds typed views (`payloads.merge_request(event)`, `payloads.note(event)`,
+`payloads.push(event)`) of the common payload fields for autocomplete inside
+handlers.
+
+## What this plugin does not do
+
+Call the GitLab API. Use `python-gitlab` from your tasks — install
+`flyteplugins-gitlab[gitlab]` for it (the plugin does not import it) — to open,
+comment on, approve, or merge MRs once a webhook has launched a run. This plugin
+owns only the part that is Flyte's: authenticating an inbound delivery and
+turning it into a run.

flyteplugins_gitlab-0.0.0a0.dist-info/RECORD

@@ -0,0 +1,8 @@
+flyteplugins/gitlab/__init__.py,sha256=_8hqVyHE9bgHydzfBMX9UXDfSJTPJWiYm8Zz9YJC4jU,2764
+flyteplugins/gitlab/_provider.py,sha256=BrcpNm4DXk9yx1hecRmaH5ek_psF4JVWQG8WhJL_srI,7638
+flyteplugins/gitlab/events.py,sha256=T9QDpRIdNgOpyUMJwAsJi1kA9v0_sdC0T1N392rxfFU,3268
+flyteplugins/gitlab/payloads.py,sha256=vd646iAg251USzFLSzg00DYwW2fuuHasC-Nay5vB6KE,4442
+flyteplugins_gitlab-0.0.0a0.dist-info/METADATA,sha256=BVCeZQadrrAeJvHNdoAP9NSwLXHXLyjjSaqRrSiTZS8,3979
+flyteplugins_gitlab-0.0.0a0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+flyteplugins_gitlab-0.0.0a0.dist-info/top_level.txt,sha256=cgd779rPu9EsvdtuYgUxNHHgElaQvPn74KhB5XSeMBE,13
+flyteplugins_gitlab-0.0.0a0.dist-info/RECORD,,

flyteplugins_gitlab-0.0.0a0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

flyteplugins_gitlab-0.0.0a0.dist-info/top_level.txt

@@ -0,0 +1 @@
+flyteplugins