fluidattacks_gitlab_sdk 1.0.0__py3-none-any.whl

fluidattacks_gitlab_sdk/milestones/_client.py

@@ -0,0 +1,147 @@
+from __future__ import (
+    annotations,
+)
+
+import inspect
+import logging
+from dataclasses import (
+    dataclass,
+)
+
+from fa_purity import (
+    Cmd,
+    Coproduct,
+    CoproductFactory,
+    FrozenDict,
+    FrozenList,
+    Maybe,
+    NewFrozenList,
+    Result,
+    ResultE,
+    cast_exception,
+)
+from fa_purity.json import JsonObj, Primitive, UnfoldedFactory
+from fluidattacks_etl_utils.bug import Bug
+from fluidattacks_etl_utils.decode import int_to_str
+
+from fluidattacks_gitlab_sdk._decoders import assert_multiple, decode_maybe_single
+from fluidattacks_gitlab_sdk._handlers import NotFound, handle_not_found
+from fluidattacks_gitlab_sdk._http_client import (
+    ClientFactory,
+    Credentials,
+    HttpJsonClient,
+    RelativeEndpoint,
+)
+from fluidattacks_gitlab_sdk.ids import MilestoneFullId, MilestoneInternalId, ProjectId
+
+from ._decode import decode_milestone_and_id
+from .core import Milestone, MilestoneClient
+
+LOG = logging.getLogger(__name__)
+
+
+def handler_empty(
+    item: Maybe[tuple[MilestoneFullId, Milestone]],
+) -> Result[tuple[MilestoneFullId, Milestone], Coproduct[NotFound, Exception]]:
+    return item.to_coproduct().map(
+        Result.success,
+        lambda _: Result.failure(Coproduct.inl(NotFound(ValueError("Milestone Not Found")))),
+    )
+
+
+def handler_empty_two(
+    item: ResultE[Maybe[tuple[MilestoneFullId, Milestone]]],
+) -> Result[tuple[MilestoneFullId, Milestone], Coproduct[NotFound, Exception]]:
+    factory: CoproductFactory[NotFound, Exception] = CoproductFactory()
+    return item.alt(lambda i: factory.inr(i)).bind(handler_empty)
+
+
+def get_milestone(
+    client: HttpJsonClient,
+    project: ProjectId,
+    milestone_id: MilestoneInternalId,
+) -> Cmd[Result[tuple[MilestoneFullId, Milestone], Coproduct[NotFound, Exception]]]:
+    endpoint = RelativeEndpoint.new(
+        "projects",
+        int_to_str(project.project_id.value),
+        f"milestones?iids[]={int_to_str(milestone_id.internal.value)}",  # cspell:ignore iids
+    )
+    msg = Cmd.wrap_impure(lambda: LOG.info("[API] get_milestone(%s, %s)", project, milestone_id))
+    return msg + client.get(
+        endpoint,
+        FrozenDict({}),
+    ).map(
+        lambda r: r.alt(
+            lambda e: e.map(handle_not_found, lambda e: Coproduct.inr(cast_exception(e))),
+        )
+        .bind(lambda v: assert_multiple(v).alt(Coproduct.inr))
+        .bind(lambda v: handler_empty_two(decode_milestone_and_id(v)))
+        .alt(
+            lambda c: c.map(
+                Coproduct.inl,
+                lambda e: Coproduct.inr(
+                    Bug.new(
+                        "_get_milestone",
+                        inspect.currentframe(),
+                        e,
+                        (),
+                    ),
+                ),
+            ),
+        ),
+    )
+
+
+def most_recent_milestone(
+    client: HttpJsonClient,
+    project: ProjectId,
+) -> Cmd[ResultE[Maybe[tuple[MilestoneFullId, Milestone]]]]:
+    endpoint = RelativeEndpoint.new(
+        "projects",
+        int_to_str(project.project_id.value),
+        "milestones",
+    )
+    params: dict[str, Primitive] = {
+        "order_by": "created_at",
+        "sort": "desc",
+        "per_page": 1,
+    }
+    empty: Maybe[tuple[MilestoneFullId, Milestone]] = Maybe.empty()
+    return client.get(
+        endpoint,
+        UnfoldedFactory.from_dict(params),
+    ).map(
+        lambda r: r.alt(
+            lambda e: cast_exception(
+                Bug.new(
+                    "most_recent_milestone",
+                    inspect.currentframe(),
+                    e,
+                    (),
+                ),
+            ),
+        )
+        .bind(assert_multiple)
+        .map(NewFrozenList)
+        .map(decode_maybe_single)
+        .bind(
+            lambda m: m.to_coproduct().map(
+                lambda r: decode_milestone_and_id(FrozenList[JsonObj]((r,))),
+                lambda _: Result.success(empty),
+            ),
+        ),
+    )
+
+
+def _from_client(client: HttpJsonClient) -> MilestoneClient:
+    return MilestoneClient(
+        lambda p, i: get_milestone(client, p, i),
+        lambda p: most_recent_milestone(client, p),
+    )
+
+
+@dataclass(frozen=True)
+class MilestoneFactory:
+    @staticmethod
+    def new(creds: Credentials) -> MilestoneClient:
+        return _from_client(ClientFactory.new(creds))

fluidattacks_gitlab_sdk/milestones/_decode.py

@@ -0,0 +1,78 @@
+import inspect
+import logging
+
+from fa_purity import FrozenList, Maybe, Result, ResultE
+from fa_purity.json import JsonObj, JsonUnfolder
+from fluidattacks_etl_utils import smash
+from fluidattacks_etl_utils.bug import Bug
+from fluidattacks_etl_utils.decode import DecodeUtils
+
+from fluidattacks_gitlab_sdk._decoders import (
+    decode_date,
+    decode_milestone_full_id,
+)
+from fluidattacks_gitlab_sdk.ids import MilestoneFullId
+from fluidattacks_gitlab_sdk.milestones.core import Milestone, MilestoneDates
+
+LOG = logging.getLogger(__name__)
+
+
+def decode_milestone_dates(raw: JsonObj) -> ResultE[MilestoneDates]:
+    return smash.smash_result_4(
+        JsonUnfolder.require(raw, "created_at", DecodeUtils.to_date_time),
+        JsonUnfolder.optional(raw, "updated_at", DecodeUtils.to_opt_date_time).map(
+            lambda v: v.bind(lambda j: j),
+        ),
+        JsonUnfolder.optional(
+            raw,
+            "due_date",
+            lambda v: DecodeUtils.to_maybe(v, lambda i: DecodeUtils.to_str(i).bind(decode_date)),
+        ).map(lambda m: m.bind(lambda x: x)),
+        JsonUnfolder.optional(
+            raw,
+            "start_date",
+            lambda v: DecodeUtils.to_maybe(v, lambda i: DecodeUtils.to_str(i).bind(decode_date)),
+        ).map(lambda m: m.bind(lambda x: x)),
+    ).map(lambda v: MilestoneDates(*v))
+
+
+def decode_milestone(raw: JsonObj) -> ResultE[Milestone]:
+    dates = decode_milestone_dates(raw)
+    group = smash.smash_result_4(
+        JsonUnfolder.require(raw, "title", DecodeUtils.to_str),
+        JsonUnfolder.require(raw, "description", DecodeUtils.to_str),
+        JsonUnfolder.require(raw, "state", DecodeUtils.to_str),
+        JsonUnfolder.require(raw, "expired", DecodeUtils.to_bool),
+    )
+    return (
+        smash.smash_result_2(
+            group,
+            dates,
+        )
+        .map(
+            lambda v: Milestone(
+                *v[0],
+                v[1],
+            ),
+        )
+        .alt(
+            lambda e: Bug.new(
+                "decode_mr",
+                inspect.currentframe(),
+                e,
+                (JsonUnfolder.dumps(raw),),
+            ),
+        )
+    )
+
+
+def decode_milestone_and_id(
+    raw: FrozenList[JsonObj],
+) -> ResultE[Maybe[tuple[MilestoneFullId, Milestone]]]:
+    if not raw:
+        return Result.success(Maybe.empty())
+
+    return smash.smash_result_2(
+        decode_milestone_full_id(raw[0]),
+        decode_milestone(raw[0]),
+    ).map(Maybe.some)

fluidattacks_gitlab_sdk/milestones/core.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import date
+
+from fa_purity import Cmd, Coproduct, Maybe, Result, ResultE
+from fa_purity.date_time import DatetimeUTC
+
+from fluidattacks_gitlab_sdk._handlers import NotFound
+from fluidattacks_gitlab_sdk.ids import MilestoneFullId, MilestoneInternalId, ProjectId
+
+
+@dataclass(frozen=True)
+class Milestone:
+    title: str
+    description: str
+    state: str
+    expired: bool
+    dates: MilestoneDates
+
+
+@dataclass(frozen=True)
+class MilestoneDates:
+    create_at: DatetimeUTC
+    update_at: Maybe[DatetimeUTC]
+    due_date: Maybe[date]
+    start_date: Maybe[date]
+
+
+@dataclass(frozen=True)
+class MilestoneClient:
+    get_milestone: Callable[
+        [ProjectId, MilestoneInternalId],
+        Cmd[Result[tuple[MilestoneFullId, Milestone], Coproduct[NotFound, Exception]]],
+    ]
+    most_recent_milestone: Callable[
+        [ProjectId],
+        Cmd[ResultE[Maybe[tuple[MilestoneFullId, Milestone]]]],
+    ]

fluidattacks_gitlab_sdk/mr_approvals/__init__.py

@@ -0,0 +1,4 @@
+from ._client import MrApprovalsFactory
+from .core import ApprovalsClient, Approver
+
+__all__ = ["ApprovalsClient", "Approver", "MrApprovalsFactory"]

fluidattacks_gitlab_sdk/mr_approvals/_client.py

@@ -0,0 +1,69 @@
+from __future__ import (
+    annotations,
+)
+
+import inspect
+from dataclasses import dataclass
+
+from fa_purity import (
+    Cmd,
+    FrozenDict,
+    ResultE,
+    cast_exception,
+)
+from fluidattacks_etl_utils.bug import Bug
+from fluidattacks_etl_utils.decode import int_to_str
+
+from fluidattacks_gitlab_sdk._decoders import assert_single
+from fluidattacks_gitlab_sdk._http_client import (
+    ClientFactory,
+    Credentials,
+    HttpJsonClient,
+    RelativeEndpoint,
+)
+from fluidattacks_gitlab_sdk.ids import MrFullId, MrInternalId, ProjectId
+from fluidattacks_gitlab_sdk.mr_approvals.core import ApprovalsClient, MrApprovals
+
+from ._decode import decode_id_and_mr_approvals
+
+
+def _get_mr_approvals(
+    client: HttpJsonClient,
+    project: ProjectId,
+    mr_internal: MrInternalId,
+) -> Cmd[ResultE[tuple[MrFullId, MrApprovals]]]:
+    endpoint = RelativeEndpoint.new(
+        "projects",
+        int_to_str(project.project_id.value),
+        "merge_requests",
+        int_to_str(mr_internal.internal.value),
+        "approvals",
+    )
+    return client.get(
+        endpoint,
+        FrozenDict({}),
+    ).map(
+        lambda r: r.alt(
+            lambda e: cast_exception(
+                Bug.new(
+                    "get_mr_approvals",
+                    inspect.currentframe(),
+                    e,
+                    (),
+                ),
+            ),
+        )
+        .bind(assert_single)
+        .bind(decode_id_and_mr_approvals),
+    )
+
+
+def _from_client(client: HttpJsonClient) -> ApprovalsClient:
+    return ApprovalsClient(lambda p, i: _get_mr_approvals(client, p, i))
+
+
+@dataclass(frozen=True)
+class MrApprovalsFactory:
+    @staticmethod
+    def new(creds: Credentials) -> ApprovalsClient:
+        return _from_client(ClientFactory.new(creds))

fluidattacks_gitlab_sdk/mr_approvals/_decode.py

@@ -0,0 +1,30 @@
+from fa_purity import ResultE
+from fa_purity.json import JsonObj, JsonUnfolder, Unfolder
+from fluidattacks_etl_utils import smash
+from fluidattacks_etl_utils.decode import DecodeUtils
+
+from fluidattacks_gitlab_sdk._decoders import decode_mr_full_id
+from fluidattacks_gitlab_sdk.ids import MrFullId
+from fluidattacks_gitlab_sdk.mr_approvals.core import Approver, MrApprovals
+from fluidattacks_gitlab_sdk.users.decode import decode_user_obj
+
+
+def decode_mr_approvals(raw: JsonObj) -> ResultE[MrApprovals]:
+    return smash.smash_result_2(
+        JsonUnfolder.require(raw, "approved", DecodeUtils.to_bool),
+        JsonUnfolder.require(
+            raw,
+            "approved_by",
+            lambda v: Unfolder.to_list_of(
+                v,
+                lambda x: Unfolder.to_json(x)
+                .bind(lambda user_obj: JsonUnfolder.require(user_obj, "user", Unfolder.to_json))
+                .bind(decode_user_obj)
+                .map(lambda u: Approver(u)),
+            ).map(lambda approvers: tuple(approvers)),
+        ),
+    ).map(lambda v: MrApprovals(v[0], v[1]))
+
+
+def decode_id_and_mr_approvals(raw: JsonObj) -> ResultE[tuple[MrFullId, MrApprovals]]:
+    return smash.smash_result_2(decode_mr_full_id(raw), decode_mr_approvals(raw))

fluidattacks_gitlab_sdk/mr_approvals/core.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from fa_purity import Cmd, FrozenList, ResultE
+
+from fluidattacks_gitlab_sdk.ids import MrFullId, MrInternalId, ProjectId
+from fluidattacks_gitlab_sdk.users import UserObj
+
+
+@dataclass(frozen=True)
+class Approver:
+    user: UserObj
+
+
+@dataclass(frozen=True)
+class MrApprovals:
+    approved: bool
+    approved_by: FrozenList[Approver]
+
+
+@dataclass
+class ApprovalsClient:
+    get_approvals: Callable[[ProjectId, MrInternalId], Cmd[ResultE[tuple[MrFullId, MrApprovals]]]]

fluidattacks_gitlab_sdk/users/__init__.py

@@ -0,0 +1,5 @@
+from fluidattacks_gitlab_sdk.users.core import UserObj
+
+__all__ = [
+    "UserObj",
+]

fluidattacks_gitlab_sdk/users/core.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from fluidattacks_gitlab_sdk.ids import UserId
+
+
+@dataclass(frozen=True)
+class User:
+    """The name of the user in the system."""
+
+    value: str
+
+
+@dataclass(frozen=True)
+class UserName:
+    """The real name of the user."""
+
+    value: str
+
+
+@dataclass(frozen=True)
+class UserObj:
+    user_id: UserId
+    user: User
+    name: UserName

fluidattacks_gitlab_sdk/users/decode.py

@@ -0,0 +1,25 @@
+from fa_purity import ResultE
+from fa_purity.json import JsonObj, JsonUnfolder
+from fluidattacks_etl_utils.decode import DecodeUtils
+from fluidattacks_etl_utils.natural import Natural
+
+from fluidattacks_gitlab_sdk.ids import UserId
+from fluidattacks_gitlab_sdk.users.core import User, UserName, UserObj
+
+
+def decode_user_obj(raw: JsonObj) -> ResultE[UserObj]:
+    return JsonUnfolder.require(raw, "id", DecodeUtils.to_int).bind(
+        lambda uid: Natural.from_int(uid)
+        .map(UserId)
+        .bind(
+            lambda user_id: JsonUnfolder.require(raw, "username", DecodeUtils.to_str)
+            .map(User)
+            .bind(
+                lambda user: JsonUnfolder.require(raw, "name", DecodeUtils.to_str)
+                .map(UserName)
+                .map(
+                    lambda name: UserObj(user_id, user, name),
+                ),
+            ),
+        ),
+    )

fluidattacks_gitlab_sdk-1.0.0.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: fluidattacks_gitlab_sdk
+Version: 1.0.0
+Summary: gitlab SDK
+Author-email: Product Team <development@fluidattacks.com>
+Requires-Python: >=3.11
+Requires-Dist: gql >=3.5.0, <4.0.0
+Requires-Dist: requests-toolbelt >=1.0.0, <2.0.0
+Requires-Dist: fa-purity >=2.5.2, <3.0.0
+Requires-Dist: pure-requests >=3.0.0, <4.0.0
+Requires-Dist: python-dateutil >=2.8.0, <3.0.0
+Requires-Dist: fluidattacks-etl-utils >=1.0.0, <2.0.0
+Requires-Dist: fluidattacks-utils-logger >=1.0.0, <2.0.0

fluidattacks_gitlab_sdk-1.0.0.dist-info/RECORD

@@ -0,0 +1,42 @@
+fluidattacks_gitlab_sdk/__init__.py,sha256=AmTm9uvbmWfcQcTQFrXTaMRXErqCp2-mzZYRUfLIolw,348
+fluidattacks_gitlab_sdk/_decoders.py,sha256=FWkAm3KgARFGL06GIF5UiPgvVpXVrHor3ysngHLVWng,4933
+fluidattacks_gitlab_sdk/_handlers.py,sha256=OZD6ke6UYHmZuJb0KrU400eabOcZ7DbDf3sBt0WOkSs,1109
+fluidattacks_gitlab_sdk/_logger.py,sha256=8pUsO-S3wlWfrGhAeZgsd9CqNQOaEFWkcoTtbR0vSZw,847
+fluidattacks_gitlab_sdk/ids.py,sha256=U26vgVHOKlVv5ZSIF30MVqPiDv4_0lA2XoPPEEhJxz4,2258
+fluidattacks_gitlab_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fluidattacks_gitlab_sdk/_gql_client/__init__.py,sha256=J5w-T87PPUhVKl08-IEXbWZZXxVgah_fUrOhvtZ0oMw,156
+fluidattacks_gitlab_sdk/_gql_client/_client.py,sha256=X9so6QnOHjSOxfKufP_pLm6aI6n85Eq9iwl4cBAOju8,2580
+fluidattacks_gitlab_sdk/_gql_client/_error.py,sha256=2c6YyUzx6gMQVqhRMqDuzVM1tH2Uxpf5-g33bSSIwok,354
+fluidattacks_gitlab_sdk/_gql_client/_handlers.py,sha256=KOueIk1B9e3MoJ4wslOuW5LOr8gUgDrzLvJMYaEN4yY,2394
+fluidattacks_gitlab_sdk/_http_client/__init__.py,sha256=sV8TJlA8nkL10JzKPwlSbKdeARviKJCXkHZ5vljdvcY,556
+fluidattacks_gitlab_sdk/_http_client/_client_1.py,sha256=XZ4Vibs-HgDXlCinNMUCEqwhwT4_Uifvs6_eh4ijpe0,5597
+fluidattacks_gitlab_sdk/_http_client/_core.py,sha256=DyvtPFzjJkN0p5LSSclsA6_oDcx7WDjH1pdYpv936YQ,3529
+fluidattacks_gitlab_sdk/issues/__init__.py,sha256=pgJHw1IRhp0EgLXydXGDPAIgcVDtCaMt5F-vOtr0PMc,130
+fluidattacks_gitlab_sdk/issues/core.py,sha256=9PkRct6UJ3Pal7QPd376HO3ecwFa97Ge0hFZx939oF0,2119
+fluidattacks_gitlab_sdk/issues/_client/__init__.py,sha256=A9n17RsnsuiYUMPh-DaG5QHRIUmKyk5EP2BAZEMFXAY,911
+fluidattacks_gitlab_sdk/issues/_client/_decode.py,sha256=zy_Ulga-EeIkSNuO16LgVnGO2xlmu3hrydaMuy9h4ls,5411
+fluidattacks_gitlab_sdk/issues/_client/_get_issue.py,sha256=AuKoV0KKT4m9Xhx9yWNuDUkykpcRoUdQ5ww6yRxIsmA,2609
+fluidattacks_gitlab_sdk/issues/_client/_most_recent.py,sha256=zJd9-2A47Gi66QxNeRcsJtQuyH7TAfqYT-0H6m9nz_A,3807
+fluidattacks_gitlab_sdk/issues/_client/_updated_by.py,sha256=D9-LMpadc-bgm2_pmo6w9hhS2xMelDBn_JXDTdhjp5o,4657
+fluidattacks_gitlab_sdk/members/__init__.py,sha256=YiAfp-an9gfNZ5DLmyb6NWjueV8xGazJ6YQFhhBtoNE,586
+fluidattacks_gitlab_sdk/members/_client.py,sha256=GusGlJb7bCxFLfPjuVcEX2WgAwNqgpViWbrZfvWnJKI,1276
+fluidattacks_gitlab_sdk/members/_decode.py,sha256=26cDfzrB9Xpv5qBRyn8IKmhaffANcoEwR7R2hypsABQ,1408
+fluidattacks_gitlab_sdk/members/core.py,sha256=x0PIggJfuJsaiNPDm7X1fx7QZpb6OLLOzJ9UTThHBLI,488
+fluidattacks_gitlab_sdk/merge_requests/__init__.py,sha256=_0Fm7BvA0_rKh3ior9v1_1LwCRzpGQECSMJ4FcsAmfw,202
+fluidattacks_gitlab_sdk/merge_requests/_client.py,sha256=Xr4ANyLeANBjuCGQcchGKNW9w5EaHTZKMhg0hi7pk_g,7099
+fluidattacks_gitlab_sdk/merge_requests/_decode.py,sha256=yuK7igap9HGNW1Jh1QJi_y73OSY_W16lz8eQT_DT1AM,7980
+fluidattacks_gitlab_sdk/merge_requests/core.py,sha256=-gSNX-6DH_EHVXXDHSn-cU5W0-QcFafu7Bx1ErNuG6c,3136
+fluidattacks_gitlab_sdk/milestones/__init__.py,sha256=HimZnvYbXT6D731ijJ9q7Ak7iFWGRI3jv_YnfRcNenY,123
+fluidattacks_gitlab_sdk/milestones/_client.py,sha256=0bcRxYsaLl8g84E-9M6L1T7AJej7iFzSpGS2q6XZxek,4291
+fluidattacks_gitlab_sdk/milestones/_decode.py,sha256=2gpI2BMfFhnD7WCT4aE7DT4BB5yRP65bnS2Jc5f_D6A,2464
+fluidattacks_gitlab_sdk/milestones/core.py,sha256=55xS5yzzjCQB9qQPMa7xng3AvEeFTBhVBgAMJGQffSU,1026
+fluidattacks_gitlab_sdk/mr_approvals/__init__.py,sha256=EUEXhC5FPOACU0ZGo8TOfB91n3SwzakAk-dJMCuK-VA,149
+fluidattacks_gitlab_sdk/mr_approvals/_client.py,sha256=PMbeyAulvW_HSfU2C6seuvljDavKUL546aOGnOdWjkc,1763
+fluidattacks_gitlab_sdk/mr_approvals/_decode.py,sha256=oqGZgQGh90JtBUCt49JiojeMNUdCBCaTs8-vIbbPVno,1250
+fluidattacks_gitlab_sdk/mr_approvals/core.py,sha256=lHUanNXpI6rj-w15zBBbTzM3pyxF-Nfg-RtutVUzaZs,577
+fluidattacks_gitlab_sdk/users/__init__.py,sha256=gfG-LZrj-ZMZjhqA7_aamyrNGgBx1ZVa2bskbJ6F-eA,85
+fluidattacks_gitlab_sdk/users/core.py,sha256=xzXBt3mxBMFatNP8bc6VeIBzUA3P8ffLUF-S6TUWOZs,408
+fluidattacks_gitlab_sdk/users/decode.py,sha256=cDrGglJM32HPtPks-Hd-Yy-bqYLrIvpPVsS0R0kxLnU,885
+fluidattacks_gitlab_sdk-1.0.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+fluidattacks_gitlab_sdk-1.0.0.dist-info/METADATA,sha256=iZe7qNWtgKyNh-tIJktBt-jXDTzS4jhX6pRlpxWQo1I,497
+fluidattacks_gitlab_sdk-1.0.0.dist-info/RECORD,,

fluidattacks_gitlab_sdk-1.0.0.dist-info/WHEEL

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