datahub-client 0.1.0__py3-none-any.whl

Http/authentication.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+from fable_library.reflection import (TypeInfo, class_type)
+from fable_library.util import (UNIT, Unit)
+
+def _expr53() -> TypeInfo:
+    return class_type("DataHubClient.Authentication", None, Authentication)
+
+
+class Authentication:
+    def __init__(self, header: str, value: str) -> None:
+        self.header: str = header
+        self.value: str = value
+
+    @property
+    def Header(self, __unit: Unit=UNIT) -> str:
+        _: Authentication = self
+        return _.header
+
+    @property
+    def Value(self, __unit: Unit=UNIT) -> str:
+        _: Authentication = self
+        return _.value
+
+    @staticmethod
+    def PersonalAccessToken(token: str) -> Authentication:
+        return Authentication(header = "PRIVATE-TOKEN", value = token)
+
+    @staticmethod
+    def OAuthToken(token: str) -> Authentication:
+        return Authentication(header = "Authorization", value = "Bearer " + token)
+
+    @staticmethod
+    def JobToken(token: str) -> Authentication:
+        return Authentication(header = "JOB-TOKEN", value = token)
+
+
+Authentication_reflection = _expr53
+
+def Authentication__ctor_Z384F8060(header: str, value: str) -> Authentication:
+    return Authentication(header, value)
+
+
+__all__ = ["Authentication_reflection"]
+

Http/http_request.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+from typing import cast
+from fable_library.list import (FSharpList, empty)
+from fable_library.reflection import (TypeInfo, class_type)
+from fable_library.util import (UNIT, Unit)
+
+def _expr54() -> TypeInfo:
+    return class_type("DataHubClient.HttpRequest", None, HttpRequest)
+
+
+class HttpRequest:
+    def __init__(self, url: str, method: str) -> None:
+        self._url: str = url
+        self._method: str = method
+        self._headers: FSharpList[tuple[str, str]] = empty()
+        self._body: str | None = cast(str | None, None)
+
+    @property
+    def Url(self, __unit: Unit=UNIT) -> str:
+        _: HttpRequest = self
+        return _._url
+
+    @Url.setter
+    def Url(self, value: str) -> None:
+        _: HttpRequest = self
+        _._url = value
+
+    @property
+    def Method(self, __unit: Unit=UNIT) -> str:
+        _: HttpRequest = self
+        return _._method
+
+    @Method.setter
+    def Method(self, value: str) -> None:
+        _: HttpRequest = self
+        _._method = value
+
+    @property
+    def Headers(self, __unit: Unit=UNIT) -> FSharpList[tuple[str, str]]:
+        _: HttpRequest = self
+        return _._headers
+
+    @Headers.setter
+    def Headers(self, value: FSharpList[tuple[str, str]]) -> None:
+        _: HttpRequest = self
+        _._headers = value
+
+    @property
+    def Body(self, __unit: Unit=UNIT) -> str | None:
+        _: HttpRequest = self
+        return _._body
+
+    @Body.setter
+    def Body(self, value: str | None=None) -> None:
+        _: HttpRequest = self
+        _._body = value
+
+
+HttpRequest_reflection = _expr54
+
+def HttpRequest__ctor_Z384F8060(url: str, method: str) -> HttpRequest:
+    return HttpRequest(url, method)
+
+
+__all__ = ["HttpRequest_reflection"]
+

Http/http_response.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+from fable_library.core import int32
+from fable_library.list import FSharpList
+from fable_library.reflection import (TypeInfo, class_type)
+from fable_library.util import (UNIT, Unit)
+
+def _expr51() -> TypeInfo:
+    return class_type("DataHubClient.HttpResponse", None, HttpResponse)
+
+
+class HttpResponse:
+    def __init__(self, status_code: int32, body: str, headers: FSharpList[tuple[str, str]]) -> None:
+        self.status_code: int32 = status_code
+        self.body: str = body
+        self.headers: FSharpList[tuple[str, str]] = headers
+
+    @property
+    def StatusCode(self, __unit: Unit=UNIT) -> int32:
+        _: HttpResponse = self
+        return _.status_code
+
+    @property
+    def Body(self, __unit: Unit=UNIT) -> str:
+        _: HttpResponse = self
+        return _.body
+
+    @property
+    def Headers(self, __unit: Unit=UNIT) -> FSharpList[tuple[str, str]]:
+        _: HttpResponse = self
+        return _.headers
+
+
+HttpResponse_reflection = _expr51
+
+def HttpResponse__ctor_54FCE56A(status_code: int32, body: str, headers: FSharpList[tuple[str, str]]) -> HttpResponse:
+    return HttpResponse(status_code, body, headers)
+
+
+__all__ = ["HttpResponse_reflection"]
+

Http/httpx_http_client.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+from abc import abstractmethod
+from typing import (Protocol, Any, cast)
+from fable_library.async_ import await_task
+from fable_library.async_builder import (singleton, Async)
+from fable_library.core import int32
+from fable_library.list import FSharpList
+from fable_library.protocols import IEnumerable_1
+from fable_library.reflection import (TypeInfo, class_type)
+from fable_library.resize_array import of_seq
+from fable_library.seq import (to_list, delay, collect, singleton as singleton_1)
+from fable_library.util import (UNIT, Unit)
+from .http_request import HttpRequest
+from .http_response import HttpResponse
+
+class HttpxResponse(Protocol):
+    @property
+    @abstractmethod
+    def status_code(self, /) -> int32:
+        ...
+
+    @property
+    @abstractmethod
+    def text(self, /) -> str:
+        ...
+
+
+class HttpxAsyncClient(Protocol):
+    pass
+
+def _expr510() -> TypeInfo:
+    return class_type("DataHubClient.HttpxHttpClient", None, HttpxHttpClient)
+
+
+class HttpxHttpClient:
+    def __init__(self, __unit: Unit=UNIT) -> None:
+        pass
+
+    def SendAsync(self, request: HttpRequest) -> Async[HttpResponse]:
+        def _arrow509(__unit: Unit=UNIT) -> Async[HttpResponse]:
+            client: HttpxAsyncClient = __import__('httpx').AsyncClient()
+            def _arrow504(__unit: Unit=UNIT) -> IEnumerable_1[tuple[str, str]]:
+                def _arrow503(match_value: tuple[str, str]) -> IEnumerable_1[tuple[str, str]]:
+                    return singleton_1((match_value[0], match_value[1]))
+
+                return collect(_arrow503, request.Headers)
+
+            headers: Any = of_seq(to_list(delay(_arrow504)))
+            content: Any
+            match_value_1: str | None = request.Body
+            content = cast(Any, None) if (match_value_1 is None) else match_value_1
+            def _arrow508(_arg: HttpxResponse) -> Async[HttpResponse]:
+                response: HttpxResponse = _arg
+                def _arrow507(__unit: Unit=UNIT) -> Async[HttpResponse]:
+                    def _arrow506(__unit: Unit=UNIT) -> IEnumerable_1[tuple[str, str]]:
+                        def _arrow505(match_value_2: tuple[str, str]) -> IEnumerable_1[tuple[str, str]]:
+                            return singleton_1((match_value_2[0], match_value_2[1]))
+
+                        return collect(_arrow505, list(response.headers.items()))
+
+                    collected: FSharpList[tuple[str, str]] = to_list(delay(_arrow506))
+                    return singleton.Return(HttpResponse(status_code = response.status_code, body = response.text, headers = collected))
+
+                return singleton.Bind(await_task(client.aclose()), _arrow507)
+
+            return singleton.Bind(await_task(client.request(request.Method, request.Url, headers=headers, content=content)), _arrow508)
+
+        return singleton.Delay(_arrow509)
+
+
+HttpxHttpClient_reflection = _expr510
+
+def HttpxHttpClient__ctor(__unit: Unit=UNIT) -> HttpxHttpClient:
+    return HttpxHttpClient(__unit)
+
+
+__all__ = ["HttpxHttpClient_reflection"]
+

Http/ihttp_client.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+from abc import abstractmethod
+from typing import Protocol
+from fable_library.async_builder import Async
+from .http_request import HttpRequest
+from .http_response import HttpResponse
+
+class IHttpClient(Protocol):
+    @abstractmethod
+    def SendAsync(self, request: HttpRequest, /) -> Async[HttpResponse]:
+        ...
+
+

Json/branch.py

@@ -0,0 +1,88 @@
+"""JSON encoder and decoder for <see cref="T:DataHubClient.Branch"/>.
+"""
+from __future__ import annotations
+from typing import Any
+from fable_library.protocols import IEnumerable_1
+from fable_library.seq import map
+from fable_library.util import (UNIT, Unit, to_enumerable)
+from ..fable_modules.thoth_json_core.decode import (object, IRequiredGetter, string, bool_1, IGetters)
+from ..fable_modules.thoth_json_core.types import (Decoder_1, IEncodable, IEncoderHelpers_1)
+from ..Models.branch import Branch
+from ..Models.commit import Commit
+from .commit import (decoder as decoder_1, encoder as encoder_1)
+
+def _arrow131(get: IGetters) -> Branch:
+    def _arrow124(__unit: Unit=UNIT) -> str:
+        object_arg: IRequiredGetter = get.Required
+        return object_arg.Field("name", string)
+
+    def _arrow126(__unit: Unit=UNIT) -> bool:
+        object_arg_1: IRequiredGetter = get.Required
+        return object_arg_1.Field("default", bool_1)
+
+    def _arrow128(__unit: Unit=UNIT) -> bool:
+        object_arg_2: IRequiredGetter = get.Required
+        return object_arg_2.Field("protected", bool_1)
+
+    def _arrow129(__unit: Unit=UNIT) -> bool:
+        object_arg_3: IRequiredGetter = get.Required
+        return object_arg_3.Field("merged", bool_1)
+
+    def _arrow130(__unit: Unit=UNIT) -> Commit:
+        object_arg_4: IRequiredGetter = get.Required
+        return object_arg_4.Field("commit", decoder_1)
+
+    return Branch(name = _arrow124(), is_default = _arrow126(), is_protected = _arrow128(), merged = _arrow129(), commit = _arrow130())
+
+
+decoder: Decoder_1[Branch] = object(_arrow131)
+
+def encoder(branch: Branch) -> IEncodable:
+    """Encodes a <see cref="T:DataHubClient.Branch"/> to its GitLab JSON representation.
+    """
+    def _arrow137(branch: Any=branch) -> IEncodable:
+        value: str = branch.Name
+        class ObjectExpr136(IEncodable):
+            def Encode[_A](self, helpers: IEncoderHelpers_1[_A]) -> _A:
+                return helpers.encode_string(value)
+
+        return ObjectExpr136()
+
+    def _arrow141(branch: Any=branch) -> IEncodable:
+        value_1: bool = branch.Default
+        class ObjectExpr140(IEncodable):
+            def Encode[_A](self, helpers_1: IEncoderHelpers_1[_A]) -> _A:
+                return helpers_1.encode_bool(value_1)
+
+        return ObjectExpr140()
+
+    def _arrow143(branch: Any=branch) -> IEncodable:
+        value_2: bool = branch.Protected
+        class ObjectExpr142(IEncodable):
+            def Encode[_A](self, helpers_2: IEncoderHelpers_1[_A]) -> _A:
+                return helpers_2.encode_bool(value_2)
+
+        return ObjectExpr142()
+
+    def _arrow147(branch: Any=branch) -> IEncodable:
+        value_3: bool = branch.Merged
+        class ObjectExpr146(IEncodable):
+            def Encode[_A](self, helpers_3: IEncoderHelpers_1[_A]) -> _A:
+                return helpers_3.encode_bool(value_3)
+
+        return ObjectExpr146()
+
+    values: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("name", _arrow137()), ("default", _arrow141()), ("protected", _arrow143()), ("merged", _arrow147()), ("commit", encoder_1(branch.Commit))])
+    class ObjectExpr154(IEncodable):
+        def Encode[_A](self, helpers_4: IEncoderHelpers_1[_A]) -> _A:
+            def mapping(tupled_arg: tuple[str, IEncodable]) -> tuple[str, _A]:
+                return (tupled_arg[0], tupled_arg[1].Encode(helpers_4))
+
+            arg: IEnumerable_1[tuple[str, Any]] = map(mapping, values)
+            return helpers_4.encode_object(arg)
+
+    return ObjectExpr154()
+
+
+__all__ = ["decoder", "encoder"]
+

Json/commit.py

@@ -0,0 +1,131 @@
+"""JSON encoder and decoder for <see cref="T:DataHubClient.Commit"/>.
+"""
+from __future__ import annotations
+from typing import Any
+from fable_library.option import erase
+from fable_library.protocols import IEnumerable_1
+from fable_library.seq import map
+from fable_library.util import (UNIT, Unit, to_enumerable)
+from ..fable_modules.thoth_json_core.decode import (object, IRequiredGetter, string, IOptionalGetter, IGetters)
+from ..fable_modules.thoth_json_core.types import (Decoder_1, IEncodable, IEncoderHelpers_1)
+from ..Models.commit import Commit
+from .thoth_extensions import encode_option
+
+def _arrow127(get: IGetters) -> Commit:
+    def _arrow117(__unit: Unit=UNIT) -> str:
+        object_arg: IRequiredGetter = get.Required
+        return object_arg.Field("id", string)
+
+    def _arrow118(__unit: Unit=UNIT) -> str:
+        object_arg_1: IRequiredGetter = get.Required
+        return object_arg_1.Field("short_id", string)
+
+    def _arrow119(__unit: Unit=UNIT) -> str:
+        object_arg_2: IRequiredGetter = get.Required
+        return object_arg_2.Field("title", string)
+
+    def _arrow120(__unit: Unit=UNIT) -> str:
+        object_arg_3: IRequiredGetter = get.Required
+        return object_arg_3.Field("message", string)
+
+    def _arrow121(__unit: Unit=UNIT) -> str:
+        object_arg_4: IRequiredGetter = get.Required
+        return object_arg_4.Field("author_name", string)
+
+    def _arrow122(__unit: Unit=UNIT) -> str:
+        object_arg_5: IRequiredGetter = get.Required
+        return object_arg_5.Field("author_email", string)
+
+    def _arrow123(__unit: Unit=UNIT) -> str:
+        object_arg_6: IRequiredGetter = get.Required
+        return object_arg_6.Field("created_at", string)
+
+    def _arrow125(__unit: Unit=UNIT) -> str | None:
+        object_arg_7: IOptionalGetter = get.Optional
+        return erase(object_arg_7.Field("web_url", string))
+
+    return Commit(id = _arrow117(), short_id = _arrow118(), title = _arrow119(), message = _arrow120(), author_name = _arrow121(), author_email = _arrow122(), created_at = _arrow123(), web_url = _arrow125())
+
+
+decoder: Decoder_1[Commit] = object(_arrow127)
+
+def encoder(commit: Commit) -> IEncodable:
+    """Encodes a <see cref="T:DataHubClient.Commit"/> to its GitLab JSON representation.
+    """
+    def _arrow133(commit: Any=commit) -> IEncodable:
+        value: str = commit.Id
+        class ObjectExpr132(IEncodable):
+            def Encode[_A](self, helpers: IEncoderHelpers_1[_A]) -> _A:
+                return helpers.encode_string(value)
+
+        return ObjectExpr132()
+
+    def _arrow135(commit: Any=commit) -> IEncodable:
+        value_1: str = commit.ShortId
+        class ObjectExpr134(IEncodable):
+            def Encode[_A](self, helpers_1: IEncoderHelpers_1[_A]) -> _A:
+                return helpers_1.encode_string(value_1)
+
+        return ObjectExpr134()
+
+    def _arrow139(commit: Any=commit) -> IEncodable:
+        value_2: str = commit.Title
+        class ObjectExpr138(IEncodable):
+            def Encode[_A](self, helpers_2: IEncoderHelpers_1[_A]) -> _A:
+                return helpers_2.encode_string(value_2)
+
+        return ObjectExpr138()
+
+    def _arrow145(commit: Any=commit) -> IEncodable:
+        value_3: str = commit.Message
+        class ObjectExpr144(IEncodable):
+            def Encode[_A](self, helpers_3: IEncoderHelpers_1[_A]) -> _A:
+                return helpers_3.encode_string(value_3)
+
+        return ObjectExpr144()
+
+    def _arrow149(commit: Any=commit) -> IEncodable:
+        value_4: str = commit.AuthorName
+        class ObjectExpr148(IEncodable):
+            def Encode[_A](self, helpers_4: IEncoderHelpers_1[_A]) -> _A:
+                return helpers_4.encode_string(value_4)
+
+        return ObjectExpr148()
+
+    def _arrow151(commit: Any=commit) -> IEncodable:
+        value_5: str = commit.AuthorEmail
+        class ObjectExpr150(IEncodable):
+            def Encode[_A](self, helpers_5: IEncoderHelpers_1[_A]) -> _A:
+                return helpers_5.encode_string(value_5)
+
+        return ObjectExpr150()
+
+    def _arrow153(commit: Any=commit) -> IEncodable:
+        value_6: str = commit.CreatedAt
+        class ObjectExpr152(IEncodable):
+            def Encode[_A](self, helpers_6: IEncoderHelpers_1[_A]) -> _A:
+                return helpers_6.encode_string(value_6)
+
+        return ObjectExpr152()
+
+    def _arrow156(value_7: str) -> IEncodable:
+        class ObjectExpr155(IEncodable):
+            def Encode[_A](self, helpers_7: IEncoderHelpers_1[_A]) -> _A:
+                return helpers_7.encode_string(value_7)
+
+        return ObjectExpr155()
+
+    values: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("id", _arrow133()), ("short_id", _arrow135()), ("title", _arrow139()), ("message", _arrow145()), ("author_name", _arrow149()), ("author_email", _arrow151()), ("created_at", _arrow153()), ("web_url", encode_option(_arrow156, commit.WebUrl))])
+    class ObjectExpr157(IEncodable):
+        def Encode[_A](self, helpers_8: IEncoderHelpers_1[_A]) -> _A:
+            def mapping(tupled_arg: tuple[str, IEncodable]) -> tuple[str, _A]:
+                return (tupled_arg[0], tupled_arg[1].Encode(helpers_8))
+
+            arg: IEnumerable_1[tuple[str, Any]] = map(mapping, values)
+            return helpers_8.encode_object(arg)
+
+    return ObjectExpr157()
+
+
+__all__ = ["decoder", "encoder"]
+

Json/issue.py

@@ -0,0 +1,193 @@
+"""JSON encoder and decoder for <see cref="T:DataHubClient.Issue"/>.
+"""
+from __future__ import annotations
+from typing import Any
+from fable_library.array_ import map
+from fable_library.array_ import Array
+from fable_library.core import int32
+from fable_library.option import erase
+from fable_library.protocols import IEnumerable_1
+from fable_library.seq import map as map_1
+from fable_library.util import (UNIT, Unit, to_enumerable)
+from ..fable_modules.thoth_json_core.decode import (object, IRequiredGetter, int_1, string, array as array_2, IOptionalGetter, IGetters)
+from ..fable_modules.thoth_json_core.types import (Decoder_1, IEncodable, IEncoderHelpers_1)
+from ..Models.issue import Issue
+from ..Models.user import User
+from .thoth_extensions import encode_option
+from .user import (decoder as decoder_1, encoder as encoder_1)
+
+def _arrow271(get: IGetters) -> Issue:
+    def _arrow257(__unit: Unit=UNIT) -> int32:
+        object_arg: IRequiredGetter = get.Required
+        return object_arg.Field("id", int_1)
+
+    def _arrow258(__unit: Unit=UNIT) -> int32:
+        object_arg_1: IRequiredGetter = get.Required
+        return object_arg_1.Field("iid", int_1)
+
+    def _arrow260(__unit: Unit=UNIT) -> int32:
+        object_arg_2: IRequiredGetter = get.Required
+        return object_arg_2.Field("project_id", int_1)
+
+    def _arrow261(__unit: Unit=UNIT) -> str:
+        object_arg_3: IRequiredGetter = get.Required
+        return object_arg_3.Field("title", string)
+
+    def _arrow262(__unit: Unit=UNIT) -> str:
+        object_arg_4: IRequiredGetter = get.Required
+        return object_arg_4.Field("state", string)
+
+    def _arrow263(__unit: Unit=UNIT) -> User:
+        object_arg_5: IRequiredGetter = get.Required
+        return object_arg_5.Field("author", decoder_1)
+
+    def _arrow264(__unit: Unit=UNIT) -> Array[User]:
+        arg_13: Decoder_1[Array[User]] = array_2(decoder_1)
+        object_arg_6: IRequiredGetter = get.Required
+        return object_arg_6.Field("assignees", arg_13)
+
+    def _arrow266(__unit: Unit=UNIT) -> Array[str]:
+        arg_15: Decoder_1[Array[str]] = array_2(string)
+        object_arg_7: IRequiredGetter = get.Required
+        return object_arg_7.Field("labels", arg_15)
+
+    def _arrow267(__unit: Unit=UNIT) -> str:
+        object_arg_8: IRequiredGetter = get.Required
+        return object_arg_8.Field("web_url", string)
+
+    def _arrow268(__unit: Unit=UNIT) -> str:
+        object_arg_9: IRequiredGetter = get.Required
+        return object_arg_9.Field("created_at", string)
+
+    def _arrow269(__unit: Unit=UNIT) -> str:
+        object_arg_10: IRequiredGetter = get.Required
+        return object_arg_10.Field("updated_at", string)
+
+    def _arrow270(__unit: Unit=UNIT) -> str | None:
+        object_arg_11: IOptionalGetter = get.Optional
+        return erase(object_arg_11.Field("description", string))
+
+    return Issue(id = _arrow257(), iid = _arrow258(), project_id = _arrow260(), title = _arrow261(), state = _arrow262(), author = _arrow263(), assignees = _arrow264(), labels = _arrow266(), web_url = _arrow267(), created_at = _arrow268(), updated_at = _arrow269(), description = _arrow270())
+
+
+decoder: Decoder_1[Issue] = object(_arrow271)
+
+def encoder(issue: Issue) -> IEncodable:
+    """Encodes an <see cref="T:DataHubClient.Issue"/> to its GitLab JSON representation.
+    """
+    def _arrow274(issue: Any=issue) -> IEncodable:
+        value: int32 = issue.Id
+        class ObjectExpr273(IEncodable):
+            def Encode[_A](self, helpers: IEncoderHelpers_1[_A]) -> _A:
+                return helpers.encode_signed_integral_number(value)
+
+        return ObjectExpr273()
+
+    def _arrow276(issue: Any=issue) -> IEncodable:
+        value_1: int32 = issue.Iid
+        class ObjectExpr275(IEncodable):
+            def Encode[_A](self, helpers_1: IEncoderHelpers_1[_A]) -> _A:
+                return helpers_1.encode_signed_integral_number(value_1)
+
+        return ObjectExpr275()
+
+    def _arrow278(issue: Any=issue) -> IEncodable:
+        value_2: int32 = issue.ProjectId
+        class ObjectExpr277(IEncodable):
+            def Encode[_A](self, helpers_2: IEncoderHelpers_1[_A]) -> _A:
+                return helpers_2.encode_signed_integral_number(value_2)
+
+        return ObjectExpr277()
+
+    def _arrow281(issue: Any=issue) -> IEncodable:
+        value_3: str = issue.Title
+        class ObjectExpr280(IEncodable):
+            def Encode[_A](self, helpers_3: IEncoderHelpers_1[_A]) -> _A:
+                return helpers_3.encode_string(value_3)
+
+        return ObjectExpr280()
+
+    def _arrow283(issue: Any=issue) -> IEncodable:
+        value_4: str = issue.State
+        class ObjectExpr282(IEncodable):
+            def Encode[_A](self, helpers_4: IEncoderHelpers_1[_A]) -> _A:
+                return helpers_4.encode_string(value_4)
+
+        return ObjectExpr282()
+
+    def _arrow286(issue: Any=issue) -> IEncodable:
+        values: Array[IEncodable] = map(encoder_1, issue.Assignees, None)
+        class ObjectExpr285(IEncodable):
+            def Encode[_A](self, helpers_5: IEncoderHelpers_1[_A]) -> _A:
+                def mapping(v: IEncodable) -> _A:
+                    return v.Encode(helpers_5)
+
+                arg: Array[Any] = map(mapping, values, None)
+                return helpers_5.encode_array(arg)
+
+        return ObjectExpr285()
+
+    def _arrow290(issue: Any=issue) -> IEncodable:
+        def _arrow288(value_5: str) -> IEncodable:
+            class ObjectExpr287(IEncodable):
+                def Encode[_A](self, helpers_6: IEncoderHelpers_1[_A]) -> _A:
+                    return helpers_6.encode_string(value_5)
+
+            return ObjectExpr287()
+
+        values_1: Array[IEncodable] = map(_arrow288, issue.Labels, None)
+        class ObjectExpr289(IEncodable):
+            def Encode[_A](self, helpers_7: IEncoderHelpers_1[_A]) -> _A:
+                def mapping_1(v_1: IEncodable) -> _A:
+                    return v_1.Encode(helpers_7)
+
+                arg_1: Array[Any] = map(mapping_1, values_1, None)
+                return helpers_7.encode_array(arg_1)
+
+        return ObjectExpr289()
+
+    def _arrow294(issue: Any=issue) -> IEncodable:
+        value_7: str = issue.WebUrl
+        class ObjectExpr293(IEncodable):
+            def Encode[_A](self, helpers_8: IEncoderHelpers_1[_A]) -> _A:
+                return helpers_8.encode_string(value_7)
+
+        return ObjectExpr293()
+
+    def _arrow296(issue: Any=issue) -> IEncodable:
+        value_8: str = issue.CreatedAt
+        class ObjectExpr295(IEncodable):
+            def Encode[_A](self, helpers_9: IEncoderHelpers_1[_A]) -> _A:
+                return helpers_9.encode_string(value_8)
+
+        return ObjectExpr295()
+
+    def _arrow298(issue: Any=issue) -> IEncodable:
+        value_9: str = issue.UpdatedAt
+        class ObjectExpr297(IEncodable):
+            def Encode[_A](self, helpers_10: IEncoderHelpers_1[_A]) -> _A:
+                return helpers_10.encode_string(value_9)
+
+        return ObjectExpr297()
+
+    def _arrow302(value_10: str) -> IEncodable:
+        class ObjectExpr301(IEncodable):
+            def Encode[_A](self, helpers_11: IEncoderHelpers_1[_A]) -> _A:
+                return helpers_11.encode_string(value_10)
+
+        return ObjectExpr301()
+
+    values_2: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("id", _arrow274()), ("iid", _arrow276()), ("project_id", _arrow278()), ("title", _arrow281()), ("state", _arrow283()), ("author", encoder_1(issue.Author)), ("assignees", _arrow286()), ("labels", _arrow290()), ("web_url", _arrow294()), ("created_at", _arrow296()), ("updated_at", _arrow298()), ("description", encode_option(_arrow302, issue.Description))])
+    class ObjectExpr303(IEncodable):
+        def Encode[_A](self, helpers_12: IEncoderHelpers_1[_A]) -> _A:
+            def mapping_2(tupled_arg: tuple[str, IEncodable]) -> tuple[str, _A]:
+                return (tupled_arg[0], tupled_arg[1].Encode(helpers_12))
+
+            arg_2: IEnumerable_1[tuple[str, Any]] = map_1(mapping_2, values_2)
+            return helpers_12.encode_object(arg_2)
+
+    return ObjectExpr303()
+
+
+__all__ = ["decoder", "encoder"]
+