transcodely 0.2.0__py3-none-any.whl

transcodely/resources/api_keys.py

@@ -0,0 +1,48 @@
+"""API key resource."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from .._transport.transport import CallOptions, Transport
+from ..pagination import Page, PageContents
+from ..v1 import api_key_pb2
+from ._helpers import assign_pagination, fill_from_dict
+
+_SERVICE = "transcodely.v1.APIKeyService"
+
+
+class ApiKeys:
+    def __init__(self, transport: Transport) -> None:
+        self._t = transport
+
+    def create(self, **kwargs: Any) -> api_key_pb2.CreateAPIKeyResponse:
+        """Create a new key. The full secret is only present on this response — store it safely."""
+        req = fill_from_dict(api_key_pb2.CreateAPIKeyRequest(), kwargs)
+        return self._t.unary(_SERVICE, "Create", req, api_key_pb2.CreateAPIKeyResponse())
+
+    def get(self, id: str, opts: Optional[CallOptions] = None) -> api_key_pb2.APIKey:
+        req = api_key_pb2.GetAPIKeyRequest(id=id)
+        return self._t.unary(_SERVICE, "Get", req, api_key_pb2.GetAPIKeyResponse(), opts).api_key
+
+    def list(
+        self,
+        *,
+        limit: Optional[int] = None,
+        opts: Optional[CallOptions] = None,
+    ) -> Page[api_key_pb2.APIKey]:
+        def fetch(cursor: Optional[str]) -> PageContents[api_key_pb2.APIKey]:
+            req = api_key_pb2.ListAPIKeysRequest()
+            assign_pagination(req.pagination, limit=limit, cursor=cursor)
+            res = self._t.unary(_SERVICE, "List", req, api_key_pb2.ListAPIKeysResponse(), opts)
+            return PageContents(
+                items=list(res.api_keys), next_cursor=res.pagination.next_cursor or None
+            )
+
+        return Page(fetch)
+
+    def revoke(self, id: str, opts: Optional[CallOptions] = None) -> api_key_pb2.APIKey:
+        req = api_key_pb2.RevokeAPIKeyRequest(id=id)
+        return self._t.unary(
+            _SERVICE, "Revoke", req, api_key_pb2.RevokeAPIKeyResponse(), opts
+        ).api_key

transcodely/resources/apps.py

@@ -0,0 +1,59 @@
+"""App resource."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from .._transport.transport import CallOptions, Transport
+from ..pagination import Page, PageContents
+from ..v1 import app_pb2
+from ._helpers import assign_pagination, fill_from_dict
+
+_SERVICE = "transcodely.v1.AppService"
+
+
+class Apps:
+    def __init__(self, transport: Transport) -> None:
+        self._t = transport
+
+    def create(self, **kwargs: Any) -> app_pb2.App:
+        req = fill_from_dict(app_pb2.CreateAppRequest(), kwargs)
+        return self._t.unary(_SERVICE, "Create", req, app_pb2.CreateAppResponse()).app
+
+    def get(self, id: str, opts: Optional[CallOptions] = None) -> app_pb2.App:
+        req = app_pb2.GetAppRequest(id=id)
+        return self._t.unary(_SERVICE, "Get", req, app_pb2.GetAppResponse(), opts).app
+
+    def update(self, **kwargs: Any) -> app_pb2.App:
+        req = fill_from_dict(app_pb2.UpdateAppRequest(), kwargs)
+        return self._t.unary(_SERVICE, "Update", req, app_pb2.UpdateAppResponse()).app
+
+    def list(
+        self,
+        *,
+        limit: Optional[int] = None,
+        opts: Optional[CallOptions] = None,
+    ) -> Page[app_pb2.App]:
+        def fetch(cursor: Optional[str]) -> PageContents[app_pb2.App]:
+            req = app_pb2.ListAppsRequest()
+            assign_pagination(req.pagination, limit=limit, cursor=cursor)
+            res = self._t.unary(_SERVICE, "List", req, app_pb2.ListAppsResponse(), opts)
+            return PageContents(
+                items=list(res.apps), next_cursor=res.pagination.next_cursor or None
+            )
+
+        return Page(fetch)
+
+    def archive(self, id: str, opts: Optional[CallOptions] = None) -> app_pb2.App:
+        req = app_pb2.ArchiveAppRequest(id=id)
+        return self._t.unary(_SERVICE, "Archive", req, app_pb2.ArchiveAppResponse(), opts).app
+
+    def enable_hosting(self, **kwargs: Any) -> app_pb2.EnableHostingResponse:
+        req = fill_from_dict(app_pb2.EnableHostingRequest(), kwargs)
+        return self._t.unary(_SERVICE, "EnableHosting", req, app_pb2.EnableHostingResponse())
+
+    def update_hosting_config(self, **kwargs: Any) -> app_pb2.UpdateHostingConfigResponse:
+        req = fill_from_dict(app_pb2.UpdateHostingConfigRequest(), kwargs)
+        return self._t.unary(
+            _SERVICE, "UpdateHostingConfig", req, app_pb2.UpdateHostingConfigResponse()
+        )

transcodely/resources/events.py

@@ -0,0 +1,118 @@
+"""Event resource — query and replay events.
+
+Every event handed back is the same unified :class:`~transcodely.webhooks.types.Event`
+that :func:`transcodely.construct_event` produces, so a ``job.succeeded`` handler
+can be exercised against an event pulled from :meth:`Events.retrieve` and behave
+identically. The bridge from the proto-shape ``Event`` (which carries the inner
+resource as a JSON string) to the SDK-shape :class:`Event` is
+:func:`proto_event_to_sdk`.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from typing import Any, Optional
+
+from .._transport.transport import CallOptions, Transport
+from ..pagination import Page, PageContents
+from ..v1 import common_pb2, webhook_pb2
+from ..webhooks.types import Event, EventRequest, decoder_for_type
+
+_SERVICE = "transcodely.v1.WebhookService"
+
+
+class Events:
+    def __init__(self, transport: Transport) -> None:
+        self._t = transport
+
+    def retrieve(self, id: str, opts: Optional[CallOptions] = None) -> Event:
+        req = webhook_pb2.RetrieveEventRequest(id=id)
+        res = self._t.unary(
+            _SERVICE, "RetrieveEvent", req, webhook_pb2.RetrieveEventResponse(), opts
+        )
+        return proto_event_to_sdk(res.event)
+
+    def resend(
+        self,
+        id: str,
+        *,
+        endpoint_ids: Optional[list[str]] = None,
+        opts: Optional[CallOptions] = None,
+    ) -> list[webhook_pb2.WebhookDelivery]:
+        """Resend an existing event, creating new pending delivery records — one
+        per target endpoint. When ``endpoint_ids`` is omitted, resends to every
+        currently-subscribed enabled endpoint."""
+        req = webhook_pb2.ResendEventRequest(id=id)
+        if endpoint_ids:
+            req.endpoint_ids.extend(endpoint_ids)
+        res = self._t.unary(_SERVICE, "ResendEvent", req, webhook_pb2.ResendEventResponse(), opts)
+        return list(res.deliveries)
+
+    def list(
+        self,
+        *,
+        app_id: str,
+        type: Optional[str] = None,
+        created_after: Optional[datetime] = None,
+        created_before: Optional[datetime] = None,
+        limit: Optional[int] = None,
+        opts: Optional[CallOptions] = None,
+    ) -> Page[Event]:
+        def fetch(cursor: Optional[str]) -> PageContents[Event]:
+            req = webhook_pb2.ListEventsRequest(app_id=app_id)
+            if type is not None:
+                req.type = type
+            if created_after is not None:
+                req.created_after.FromDatetime(created_after)
+            if created_before is not None:
+                req.created_before.FromDatetime(created_before)
+            pagination = common_pb2.PaginationRequest()
+            if limit is not None:
+                pagination.limit = limit
+            if cursor is not None:
+                pagination.cursor = cursor
+            req.pagination.CopyFrom(pagination)
+            res = self._t.unary(_SERVICE, "ListEvents", req, webhook_pb2.ListEventsResponse(), opts)
+            return PageContents(
+                items=[proto_event_to_sdk(e) for e in res.events],
+                next_cursor=res.pagination.next_cursor or None,
+            )
+
+        return Page(fetch)
+
+
+def proto_event_to_sdk(proto: webhook_pb2.Event) -> Event:
+    """Bridge a proto ``Event`` (``data`` as a JSON string, ``created_at`` as a
+    ``Timestamp``) to the SDK :class:`Event` (decoded resource, RFC 3339 string).
+
+    Used by :meth:`Events.retrieve` and :meth:`Events.list`.
+    """
+    parsed_data: Any = {}
+    if proto.data:
+        try:
+            parsed_data = json.loads(proto.data)
+        except ValueError:
+            # Server-controlled; if it ever fails, leave the placeholder so the
+            # event still surfaces.
+            pass
+
+    decode = decoder_for_type(proto.type)
+    data: Any = decode(parsed_data) if decode and isinstance(parsed_data, dict) else parsed_data
+
+    created = proto.created_at.ToJsonString() if proto.HasField("created_at") else ""
+
+    return Event(
+        id=proto.id,
+        object="event",
+        api_version=proto.api_version,
+        created=created,
+        type=proto.type,
+        data=data,
+        pending_webhooks=proto.pending_webhooks,
+        # proto Event carries only request_id; idempotency_key is always None
+        # until JobService.Create propagates it. An unset request_id maps to
+        # None so this path matches the webhook envelope path (both use None for
+        # events emitted outside a request scope).
+        request=EventRequest(id=proto.request_id or None, idempotency_key=None),
+    )

transcodely/resources/health.py

@@ -0,0 +1,19 @@
+"""Health resource — liveness check for the API."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .._transport.transport import CallOptions, Transport
+from ..v1 import health_pb2
+
+_SERVICE = "transcodely.v1.HealthService"
+
+
+class Health:
+    def __init__(self, transport: Transport) -> None:
+        self._t = transport
+
+    def check(self, opts: Optional[CallOptions] = None) -> health_pb2.HealthCheckResponse:
+        req = health_pb2.HealthCheckRequest()
+        return self._t.unary(_SERVICE, "Check", req, health_pb2.HealthCheckResponse(), opts)

transcodely/resources/jobs.py

@@ -0,0 +1,120 @@
+"""Job resource — create / get / list / cancel / confirm / watch."""
+
+from __future__ import annotations
+
+from typing import Any, Generator, Mapping, Optional
+
+from .._transport.transport import CallOptions, Transport
+from ..pagination import Page, PageContents
+from ..streaming import watch
+from ..v1 import job_pb2
+
+_SERVICE = "transcodely.v1.JobService"
+
+
+class Jobs:
+    def __init__(self, transport: Transport) -> None:
+        self._t = transport
+
+    def create(
+        self,
+        input_url: Optional[str] = None,
+        outputs: Optional[list[Mapping[str, Any]]] = None,
+        *,
+        idempotency_key: Optional[str] = None,
+        webhook_url: Optional[str] = None,
+        priority: Optional[int] = None,
+        metadata: Optional[Mapping[str, str]] = None,
+        request: Optional[job_pb2.CreateJobRequest] = None,
+        opts: Optional[CallOptions] = None,
+    ) -> job_pb2.Job:
+        """Create a new transcoding job. Auto-fills ``idempotency_key`` if omitted."""
+        if request is None:
+            req = job_pb2.CreateJobRequest()
+            if input_url is not None:
+                req.input_url = input_url
+            if outputs:
+                from google.protobuf import json_format
+
+                from .._codec.json_codec import transform_enums_in_dict
+
+                # Outputs are nested messages — round-trip through JSON so callers can
+                # pass plain dicts with simplified-enum strings.
+                payload = {"outputs": list(outputs)}
+                transform_enums_in_dict(payload, req.DESCRIPTOR, mode="expand")
+                json_format.ParseDict(payload, req, ignore_unknown_fields=True)
+            if webhook_url is not None:
+                req.webhook_url = webhook_url
+            if priority is not None:
+                req.priority = priority
+            if metadata:
+                for k, v in metadata.items():
+                    req.metadata[k] = v
+        else:
+            req = request
+        if not req.idempotency_key:
+            from .._transport.headers import new_idempotency_key
+
+            req.idempotency_key = idempotency_key or new_idempotency_key()
+        res = self._t.unary(_SERVICE, "Create", req, job_pb2.CreateJobResponse(), opts)
+        return res.job
+
+    def get(self, id: str, opts: Optional[CallOptions] = None) -> job_pb2.Job:
+        req = job_pb2.GetJobRequest(id=id)
+        return self._t.unary(_SERVICE, "Get", req, job_pb2.GetJobResponse(), opts).job
+
+    def list(
+        self,
+        *,
+        status: Optional[int] = None,
+        limit: Optional[int] = None,
+        opts: Optional[CallOptions] = None,
+    ) -> Page[job_pb2.Job]:
+        from ..v1 import common_pb2
+
+        def fetch(cursor: Optional[str]) -> PageContents[job_pb2.Job]:
+            req = job_pb2.ListJobsRequest()
+            if status is not None:
+                req.status = status
+            pagination = common_pb2.PaginationRequest()
+            if limit is not None:
+                pagination.limit = limit
+            if cursor is not None:
+                pagination.cursor = cursor
+            req.pagination.CopyFrom(pagination)
+            res = self._t.unary(_SERVICE, "List", req, job_pb2.ListJobsResponse(), opts)
+            return PageContents(
+                items=list(res.jobs),
+                next_cursor=res.pagination.next_cursor or None,
+            )
+
+        return Page(fetch)
+
+    def cancel(self, id: str, opts: Optional[CallOptions] = None) -> job_pb2.Job:
+        req = job_pb2.CancelJobRequest(id=id)
+        return self._t.unary(_SERVICE, "Cancel", req, job_pb2.CancelJobResponse(), opts).job
+
+    def confirm(self, id: str, opts: Optional[CallOptions] = None) -> job_pb2.Job:
+        req = job_pb2.ConfirmJobRequest(id=id)
+        return self._t.unary(_SERVICE, "Confirm", req, job_pb2.ConfirmJobResponse(), opts).job
+
+    def watch(
+        self,
+        id: str,
+        *,
+        include_heartbeats: bool = False,
+        max_reconnects: int = 5,
+        opts: Optional[CallOptions] = None,
+    ) -> Generator[job_pb2.WatchJobResponse, None, None]:
+        """Stream live job state. Auto-reconnects + filters HEARTBEAT events by default."""
+
+        def factory() -> Generator[job_pb2.WatchJobResponse, None, None]:
+            req = job_pb2.WatchJobRequest(id=id)
+            yield from self._t.stream(_SERVICE, "Watch", req, job_pb2.WatchJobResponse, opts)
+
+        yield from watch(
+            factory,
+            is_heartbeat=lambda e: e.event == job_pb2.WATCH_EVENT_TYPE_HEARTBEAT,
+            include_heartbeats=include_heartbeats,
+            max_reconnects=max_reconnects,
+        )

transcodely/resources/memberships.py

@@ -0,0 +1,54 @@
+"""Membership resource."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from .._transport.transport import CallOptions, Transport
+from ..pagination import Page, PageContents
+from ..v1 import membership_pb2
+from ._helpers import assign_pagination, fill_from_dict
+
+_SERVICE = "transcodely.v1.MembershipService"
+
+
+class Memberships:
+    def __init__(self, transport: Transport) -> None:
+        self._t = transport
+
+    def list(
+        self,
+        *,
+        limit: Optional[int] = None,
+        opts: Optional[CallOptions] = None,
+    ) -> Page[membership_pb2.MembershipWithUser]:
+        def fetch(cursor: Optional[str]) -> PageContents[membership_pb2.MembershipWithUser]:
+            req = membership_pb2.ListMembershipsRequest()
+            assign_pagination(req.pagination, limit=limit, cursor=cursor)
+            res = self._t.unary(
+                _SERVICE, "List", req, membership_pb2.ListMembershipsResponse(), opts
+            )
+            return PageContents(
+                items=list(res.memberships), next_cursor=res.pagination.next_cursor or None
+            )
+
+        return Page(fetch)
+
+    def get(self, id: str, opts: Optional[CallOptions] = None) -> membership_pb2.MembershipWithUser:
+        req = membership_pb2.GetMembershipRequest(id=id)
+        return self._t.unary(
+            _SERVICE, "Get", req, membership_pb2.GetMembershipResponse(), opts
+        ).membership
+
+    def update_role(self, **kwargs: Any) -> membership_pb2.Membership:
+        req = fill_from_dict(membership_pb2.UpdateMembershipRoleRequest(), kwargs)
+        return self._t.unary(
+            _SERVICE,
+            "UpdateRole",
+            req,
+            membership_pb2.UpdateMembershipRoleResponse(),
+        ).membership
+
+    def remove(self, id: str, opts: Optional[CallOptions] = None) -> None:
+        req = membership_pb2.RemoveMembershipRequest(id=id)
+        self._t.unary(_SERVICE, "Remove", req, membership_pb2.RemoveMembershipResponse(), opts)

transcodely/resources/organizations.py

@@ -0,0 +1,73 @@
+"""Organization resource."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from .._transport.transport import CallOptions, Transport
+from ..pagination import Page, PageContents
+from ..v1 import organization_pb2
+from ._helpers import assign_pagination, fill_from_dict
+
+_SERVICE = "transcodely.v1.OrganizationService"
+
+
+class Organizations:
+    def __init__(self, transport: Transport) -> None:
+        self._t = transport
+
+    def check_slug(
+        self, slug: str, opts: Optional[CallOptions] = None
+    ) -> organization_pb2.CheckSlugResponse:
+        req = organization_pb2.CheckSlugRequest(slug=slug)
+        return self._t.unary(_SERVICE, "CheckSlug", req, organization_pb2.CheckSlugResponse(), opts)
+
+    def create(self, **kwargs: Any) -> organization_pb2.Organization:
+        req = fill_from_dict(organization_pb2.CreateOrganizationRequest(), kwargs)
+        return self._t.unary(
+            _SERVICE,
+            "Create",
+            req,
+            organization_pb2.CreateOrganizationResponse(),
+        ).organization
+
+    def get(
+        self, id_or_slug: str, opts: Optional[CallOptions] = None
+    ) -> organization_pb2.Organization:
+        """Look up by ID (``org_*``) or slug."""
+        req = organization_pb2.GetOrganizationRequest(id_or_slug=id_or_slug)
+        return self._t.unary(
+            _SERVICE,
+            "Get",
+            req,
+            organization_pb2.GetOrganizationResponse(),
+            opts,
+        ).organization
+
+    def update(self, **kwargs: Any) -> organization_pb2.Organization:
+        req = fill_from_dict(organization_pb2.UpdateOrganizationRequest(), kwargs)
+        return self._t.unary(
+            _SERVICE,
+            "Update",
+            req,
+            organization_pb2.UpdateOrganizationResponse(),
+        ).organization
+
+    def list(
+        self,
+        *,
+        limit: Optional[int] = None,
+        opts: Optional[CallOptions] = None,
+    ) -> Page[organization_pb2.Organization]:
+        def fetch(cursor: Optional[str]) -> PageContents[organization_pb2.Organization]:
+            req = organization_pb2.ListOrganizationsRequest()
+            assign_pagination(req.pagination, limit=limit, cursor=cursor)
+            res = self._t.unary(
+                _SERVICE, "List", req, organization_pb2.ListOrganizationsResponse(), opts
+            )
+            return PageContents(
+                items=list(res.organizations),
+                next_cursor=res.pagination.next_cursor or None,
+            )
+
+        return Page(fetch)

transcodely/resources/origins.py

@@ -0,0 +1,55 @@
+"""Origin resource — input/output storage destinations."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from .._transport.transport import CallOptions, Transport
+from ..pagination import Page, PageContents
+from ..v1 import origin_pb2
+from ._helpers import assign_pagination, fill_from_dict
+
+_SERVICE = "transcodely.v1.OriginService"
+
+
+class Origins:
+    def __init__(self, transport: Transport) -> None:
+        self._t = transport
+
+    def create(self, **kwargs: Any) -> origin_pb2.Origin:
+        req = fill_from_dict(origin_pb2.CreateOriginRequest(), kwargs)
+        return self._t.unary(_SERVICE, "Create", req, origin_pb2.CreateOriginResponse()).origin
+
+    def get(self, id: str, opts: Optional[CallOptions] = None) -> origin_pb2.Origin:
+        req = origin_pb2.GetOriginRequest(id=id)
+        return self._t.unary(_SERVICE, "Get", req, origin_pb2.GetOriginResponse(), opts).origin
+
+    def list(
+        self,
+        *,
+        limit: Optional[int] = None,
+        opts: Optional[CallOptions] = None,
+    ) -> Page[origin_pb2.Origin]:
+        def fetch(cursor: Optional[str]) -> PageContents[origin_pb2.Origin]:
+            req = origin_pb2.ListOriginsRequest()
+            assign_pagination(req.pagination, limit=limit, cursor=cursor)
+            res = self._t.unary(_SERVICE, "List", req, origin_pb2.ListOriginsResponse(), opts)
+            return PageContents(
+                items=list(res.origins), next_cursor=res.pagination.next_cursor or None
+            )
+
+        return Page(fetch)
+
+    def update(self, **kwargs: Any) -> origin_pb2.Origin:
+        req = fill_from_dict(origin_pb2.UpdateOriginRequest(), kwargs)
+        return self._t.unary(_SERVICE, "Update", req, origin_pb2.UpdateOriginResponse()).origin
+
+    def validate(self, **kwargs: Any) -> origin_pb2.ValidateOriginResponse:
+        req = fill_from_dict(origin_pb2.ValidateOriginRequest(), kwargs)
+        return self._t.unary(_SERVICE, "Validate", req, origin_pb2.ValidateOriginResponse())
+
+    def archive(self, id: str, opts: Optional[CallOptions] = None) -> origin_pb2.Origin:
+        req = origin_pb2.ArchiveOriginRequest(id=id)
+        return self._t.unary(
+            _SERVICE, "Archive", req, origin_pb2.ArchiveOriginResponse(), opts
+        ).origin

transcodely/resources/presets.py

@@ -0,0 +1,63 @@
+"""Preset resource."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from .._transport.transport import CallOptions, Transport
+from ..pagination import Page, PageContents
+from ..v1 import preset_pb2
+from ._helpers import assign_pagination, fill_from_dict
+
+_SERVICE = "transcodely.v1.PresetService"
+
+
+class Presets:
+    def __init__(self, transport: Transport) -> None:
+        self._t = transport
+
+    def create(self, **kwargs: Any) -> preset_pb2.Preset:
+        req = fill_from_dict(preset_pb2.CreatePresetRequest(), kwargs)
+        return self._t.unary(_SERVICE, "Create", req, preset_pb2.CreatePresetResponse()).preset
+
+    def get(self, id: str, opts: Optional[CallOptions] = None) -> preset_pb2.Preset:
+        req = preset_pb2.GetPresetRequest(id=id)
+        return self._t.unary(_SERVICE, "Get", req, preset_pb2.GetPresetResponse(), opts).preset
+
+    def get_by_slug(self, slug: str, opts: Optional[CallOptions] = None) -> preset_pb2.Preset:
+        req = preset_pb2.GetPresetBySlugRequest(slug=slug)
+        return self._t.unary(
+            _SERVICE, "GetBySlug", req, preset_pb2.GetPresetBySlugResponse(), opts
+        ).preset
+
+    def list(
+        self,
+        *,
+        limit: Optional[int] = None,
+        opts: Optional[CallOptions] = None,
+    ) -> Page[preset_pb2.Preset]:
+        def fetch(cursor: Optional[str]) -> PageContents[preset_pb2.Preset]:
+            req = preset_pb2.ListPresetsRequest()
+            assign_pagination(req.pagination, limit=limit, cursor=cursor)
+            res = self._t.unary(_SERVICE, "List", req, preset_pb2.ListPresetsResponse(), opts)
+            return PageContents(
+                items=list(res.presets), next_cursor=res.pagination.next_cursor or None
+            )
+
+        return Page(fetch)
+
+    def update(self, **kwargs: Any) -> preset_pb2.Preset:
+        req = fill_from_dict(preset_pb2.UpdatePresetRequest(), kwargs)
+        return self._t.unary(_SERVICE, "Update", req, preset_pb2.UpdatePresetResponse()).preset
+
+    def duplicate(self, **kwargs: Any) -> preset_pb2.Preset:
+        req = fill_from_dict(preset_pb2.DuplicatePresetRequest(), kwargs)
+        return self._t.unary(
+            _SERVICE, "Duplicate", req, preset_pb2.DuplicatePresetResponse()
+        ).preset
+
+    def archive(self, id: str, opts: Optional[CallOptions] = None) -> preset_pb2.Preset:
+        req = preset_pb2.ArchivePresetRequest(id=id)
+        return self._t.unary(
+            _SERVICE, "Archive", req, preset_pb2.ArchivePresetResponse(), opts
+        ).preset

transcodely/resources/users.py

@@ -0,0 +1,46 @@
+"""User resource."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from .._transport.transport import CallOptions, Transport
+from ..pagination import Page, PageContents
+from ..v1 import user_pb2
+from ._helpers import assign_pagination, fill_from_dict
+
+_SERVICE = "transcodely.v1.UserService"
+
+
+class Users:
+    def __init__(self, transport: Transport) -> None:
+        self._t = transport
+
+    def get_me(self, opts: Optional[CallOptions] = None) -> user_pb2.UserWithOrganizations:
+        """Returns the authenticated user enriched with org memberships."""
+        req = user_pb2.GetMeRequest()
+        return self._t.unary(_SERVICE, "GetMe", req, user_pb2.GetMeResponse(), opts).user
+
+    def update_me(self, **kwargs: Any) -> user_pb2.User:
+        req = fill_from_dict(user_pb2.UpdateMeRequest(), kwargs)
+        return self._t.unary(_SERVICE, "UpdateMe", req, user_pb2.UpdateMeResponse()).user
+
+    def get(self, id: str, opts: Optional[CallOptions] = None) -> user_pb2.User:
+        req = user_pb2.GetUserRequest(id=id)
+        return self._t.unary(_SERVICE, "Get", req, user_pb2.GetUserResponse(), opts).user
+
+    def list(
+        self,
+        *,
+        limit: Optional[int] = None,
+        opts: Optional[CallOptions] = None,
+    ) -> Page[user_pb2.User]:
+        def fetch(cursor: Optional[str]) -> PageContents[user_pb2.User]:
+            req = user_pb2.ListUsersRequest()
+            assign_pagination(req.pagination, limit=limit, cursor=cursor)
+            res = self._t.unary(_SERVICE, "List", req, user_pb2.ListUsersResponse(), opts)
+            return PageContents(
+                items=list(res.users), next_cursor=res.pagination.next_cursor or None
+            )
+
+        return Page(fetch)