devrev-Python-SDK 1.0.0__py3-none-any.whl

devrev/services/rev_users.py

@@ -0,0 +1,235 @@
+"""Rev Users service for DevRev SDK.
+
+This module provides the RevUsersService for managing DevRev customer users.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any
+
+from devrev.models.rev_users import (
+    RevUser,
+    RevUsersCreateRequest,
+    RevUsersCreateResponse,
+    RevUsersDeleteRequest,
+    RevUsersDeleteResponse,
+    RevUsersGetRequest,
+    RevUsersGetResponse,
+    RevUsersListRequest,
+    RevUsersListResponse,
+    RevUsersMergeRequest,
+    RevUsersMergeResponse,
+    RevUsersUpdateRequest,
+    RevUsersUpdateResponse,
+)
+from devrev.services.base import AsyncBaseService, BaseService
+
+if TYPE_CHECKING:
+    from devrev.utils.http import AsyncHTTPClient, HTTPClient
+
+
+class RevUsersService(BaseService):
+    """Synchronous service for managing DevRev customer users."""
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        """Initialize the RevUsersService."""
+        super().__init__(http_client)
+
+    def create(
+        self,
+        rev_org: str,
+        *,
+        display_name: str | None = None,
+        email: str | None = None,
+        phone_numbers: list[str] | None = None,
+        external_ref: str | None = None,
+    ) -> RevUser:
+        """Create a new Rev user.
+
+        Args:
+            rev_org: Rev organization ID
+            display_name: Display name
+            email: Email address
+            phone_numbers: Phone numbers
+            external_ref: External reference identifier
+
+        Returns:
+            The created RevUser
+        """
+        request = RevUsersCreateRequest(
+            rev_org=rev_org,
+            display_name=display_name,
+            email=email,
+            phone_numbers=phone_numbers,
+            external_ref=external_ref,
+        )
+        response = self._post("/rev-users.create", request, RevUsersCreateResponse)
+        return response.rev_user
+
+    def get(self, id: str) -> RevUser:
+        """Get a Rev user by ID.
+
+        Args:
+            id: Rev user ID
+
+        Returns:
+            The RevUser
+        """
+        request = RevUsersGetRequest(id=id)
+        response = self._post("/rev-users.get", request, RevUsersGetResponse)
+        return response.rev_user
+
+    def list(
+        self,
+        *,
+        cursor: str | None = None,
+        email: list[str] | None = None,
+        limit: int | None = None,
+        rev_org: list[str] | None = None,
+        external_ref: list[str] | None = None,
+    ) -> RevUsersListResponse:
+        """List Rev users.
+
+        Args:
+            cursor: Pagination cursor
+            email: Filter by emails
+            limit: Maximum number of results
+            rev_org: Filter by Rev org IDs
+            external_ref: Filter by external refs
+
+        Returns:
+            Paginated list of Rev users
+        """
+        request = RevUsersListRequest(
+            cursor=cursor,
+            email=email,
+            limit=limit,
+            rev_org=rev_org,
+            external_ref=external_ref,
+        )
+        return self._post("/rev-users.list", request, RevUsersListResponse)
+
+    def update(
+        self,
+        id: str,
+        *,
+        display_name: str | None = None,
+        email: str | None = None,
+        phone_numbers: Sequence[str] | None = None,
+        custom_fields: dict[str, Any] | None = None,
+    ) -> RevUser:
+        """Update a Rev user.
+
+        Args:
+            id: Rev user ID
+            display_name: New display name
+            email: New email address
+            phone_numbers: New phone numbers
+            custom_fields: Custom fields to update
+
+        Returns:
+            The updated RevUser
+        """
+        request = RevUsersUpdateRequest(
+            id=id,
+            display_name=display_name,
+            email=email,
+            phone_numbers=phone_numbers,
+            custom_fields=custom_fields,
+        )
+        response = self._post("/rev-users.update", request, RevUsersUpdateResponse)
+        return response.rev_user
+
+    def delete(self, id: str) -> None:
+        """Delete a Rev user.
+
+        Args:
+            id: Rev user ID
+        """
+        request = RevUsersDeleteRequest(id=id)
+        self._post("/rev-users.delete", request, RevUsersDeleteResponse)
+
+    def merge(self, primary_user: str, secondary_user: str) -> None:
+        """Merge two Rev users.
+
+        Args:
+            primary_user: Primary user ID (will be retained)
+            secondary_user: Secondary user ID (will be merged)
+        """
+        request = RevUsersMergeRequest(
+            primary_user=primary_user,
+            secondary_user=secondary_user,
+        )
+        self._post("/rev-users.merge", request, RevUsersMergeResponse)
+
+
+class AsyncRevUsersService(AsyncBaseService):
+    """Asynchronous service for managing DevRev customer users."""
+
+    def __init__(self, http_client: AsyncHTTPClient) -> None:
+        """Initialize the AsyncRevUsersService."""
+        super().__init__(http_client)
+
+    async def create(
+        self,
+        rev_org: str,
+        *,
+        display_name: str | None = None,
+        email: str | None = None,
+        phone_numbers: list[str] | None = None,
+        external_ref: str | None = None,
+    ) -> RevUser:
+        """Create a new Rev user."""
+        request = RevUsersCreateRequest(
+            rev_org=rev_org,
+            display_name=display_name,
+            email=email,
+            phone_numbers=phone_numbers,
+            external_ref=external_ref,
+        )
+        response = await self._post("/rev-users.create", request, RevUsersCreateResponse)
+        return response.rev_user
+
+    async def get(self, id: str) -> RevUser:
+        """Get a Rev user by ID."""
+        request = RevUsersGetRequest(id=id)
+        response = await self._post("/rev-users.get", request, RevUsersGetResponse)
+        return response.rev_user
+
+    async def list(
+        self,
+        *,
+        cursor: str | None = None,
+        email: list[str] | None = None,
+        limit: int | None = None,
+        rev_org: list[str] | None = None,
+    ) -> RevUsersListResponse:
+        """List Rev users."""
+        request = RevUsersListRequest(cursor=cursor, email=email, limit=limit, rev_org=rev_org)
+        return await self._post("/rev-users.list", request, RevUsersListResponse)
+
+    async def update(
+        self,
+        id: str,
+        *,
+        display_name: str | None = None,
+        email: str | None = None,
+        phone_numbers: Sequence[str] | None = None,
+    ) -> RevUser:
+        """Update a Rev user."""
+        request = RevUsersUpdateRequest(
+            id=id, display_name=display_name, email=email, phone_numbers=phone_numbers
+        )
+        response = await self._post("/rev-users.update", request, RevUsersUpdateResponse)
+        return response.rev_user
+
+    async def delete(self, id: str) -> None:
+        """Delete a Rev user."""
+        request = RevUsersDeleteRequest(id=id)
+        await self._post("/rev-users.delete", request, RevUsersDeleteResponse)
+
+    async def merge(self, primary_user: str, secondary_user: str) -> None:
+        """Merge two Rev users."""
+        request = RevUsersMergeRequest(primary_user=primary_user, secondary_user=secondary_user)
+        await self._post("/rev-users.merge", request, RevUsersMergeResponse)

devrev/services/slas.py

@@ -0,0 +1,82 @@
+"""SLAs service for DevRev SDK."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from devrev.models.slas import (
+    Sla,
+    SlasCreateRequest,
+    SlasCreateResponse,
+    SlasGetRequest,
+    SlasGetResponse,
+    SlasListRequest,
+    SlasListResponse,
+    SlasTransitionRequest,
+    SlasTransitionResponse,
+    SlasUpdateRequest,
+    SlasUpdateResponse,
+)
+from devrev.services.base import AsyncBaseService, BaseService
+
+
+class SlasService(BaseService):
+    """Service for managing DevRev SLAs."""
+
+    def create(self, request: SlasCreateRequest) -> Sla:
+        """Create a new SLA."""
+        response = self._post("/slas.create", request, SlasCreateResponse)
+        return response.sla
+
+    def get(self, request: SlasGetRequest) -> Sla:
+        """Get an SLA by ID."""
+        response = self._post("/slas.get", request, SlasGetResponse)
+        return response.sla
+
+    def list(self, request: SlasListRequest | None = None) -> Sequence[Sla]:
+        """List SLAs."""
+        if request is None:
+            request = SlasListRequest()
+        response = self._post("/slas.list", request, SlasListResponse)
+        return response.slas
+
+    def update(self, request: SlasUpdateRequest) -> Sla:
+        """Update an SLA."""
+        response = self._post("/slas.update", request, SlasUpdateResponse)
+        return response.sla
+
+    def transition(self, request: SlasTransitionRequest) -> Sla:
+        """Transition an SLA status."""
+        response = self._post("/slas.transition", request, SlasTransitionResponse)
+        return response.sla
+
+
+class AsyncSlasService(AsyncBaseService):
+    """Async service for managing DevRev SLAs."""
+
+    async def create(self, request: SlasCreateRequest) -> Sla:
+        """Create a new SLA."""
+        response = await self._post("/slas.create", request, SlasCreateResponse)
+        return response.sla
+
+    async def get(self, request: SlasGetRequest) -> Sla:
+        """Get an SLA by ID."""
+        response = await self._post("/slas.get", request, SlasGetResponse)
+        return response.sla
+
+    async def list(self, request: SlasListRequest | None = None) -> Sequence[Sla]:
+        """List SLAs."""
+        if request is None:
+            request = SlasListRequest()
+        response = await self._post("/slas.list", request, SlasListResponse)
+        return response.slas
+
+    async def update(self, request: SlasUpdateRequest) -> Sla:
+        """Update an SLA."""
+        response = await self._post("/slas.update", request, SlasUpdateResponse)
+        return response.sla
+
+    async def transition(self, request: SlasTransitionRequest) -> Sla:
+        """Transition an SLA status."""
+        response = await self._post("/slas.transition", request, SlasTransitionResponse)
+        return response.sla

devrev/services/tags.py

@@ -0,0 +1,80 @@
+"""Tags service for DevRev SDK."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from devrev.models.tags import (
+    Tag,
+    TagsCreateRequest,
+    TagsCreateResponse,
+    TagsDeleteRequest,
+    TagsDeleteResponse,
+    TagsGetRequest,
+    TagsGetResponse,
+    TagsListRequest,
+    TagsListResponse,
+    TagsUpdateRequest,
+    TagsUpdateResponse,
+)
+from devrev.services.base import AsyncBaseService, BaseService
+
+
+class TagsService(BaseService):
+    """Service for managing DevRev Tags."""
+
+    def create(self, request: TagsCreateRequest) -> Tag:
+        """Create a new tag."""
+        response = self._post("/tags.create", request, TagsCreateResponse)
+        return response.tag
+
+    def get(self, request: TagsGetRequest) -> Tag:
+        """Get a tag by ID."""
+        response = self._post("/tags.get", request, TagsGetResponse)
+        return response.tag
+
+    def list(self, request: TagsListRequest | None = None) -> Sequence[Tag]:
+        """List tags."""
+        if request is None:
+            request = TagsListRequest()
+        response = self._post("/tags.list", request, TagsListResponse)
+        return response.tags
+
+    def update(self, request: TagsUpdateRequest) -> Tag:
+        """Update a tag."""
+        response = self._post("/tags.update", request, TagsUpdateResponse)
+        return response.tag
+
+    def delete(self, request: TagsDeleteRequest) -> None:
+        """Delete a tag."""
+        self._post("/tags.delete", request, TagsDeleteResponse)
+
+
+class AsyncTagsService(AsyncBaseService):
+    """Async service for managing DevRev Tags."""
+
+    async def create(self, request: TagsCreateRequest) -> Tag:
+        """Create a new tag."""
+        response = await self._post("/tags.create", request, TagsCreateResponse)
+        return response.tag
+
+    async def get(self, request: TagsGetRequest) -> Tag:
+        """Get a tag by ID."""
+        response = await self._post("/tags.get", request, TagsGetResponse)
+        return response.tag
+
+    async def list(self, request: TagsListRequest | None = None) -> Sequence[Tag]:
+        """List tags."""
+        if request is None:
+            request = TagsListRequest()
+        response = await self._post("/tags.list", request, TagsListResponse)
+        return response.tags
+
+    async def update(self, request: TagsUpdateRequest) -> Tag:
+        """Update a tag."""
+        response = await self._post("/tags.update", request, TagsUpdateResponse)
+        return response.tag
+
+    async def delete(self, request: TagsDeleteRequest) -> None:
+        """Delete a tag."""
+        await self._post("/tags.delete", request, TagsDeleteResponse)

devrev/services/timeline_entries.py

@@ -0,0 +1,80 @@
+"""Timeline Entries service for DevRev SDK."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from devrev.models.timeline_entries import (
+    TimelineEntriesCreateRequest,
+    TimelineEntriesCreateResponse,
+    TimelineEntriesDeleteRequest,
+    TimelineEntriesDeleteResponse,
+    TimelineEntriesGetRequest,
+    TimelineEntriesGetResponse,
+    TimelineEntriesListRequest,
+    TimelineEntriesListResponse,
+    TimelineEntriesUpdateRequest,
+    TimelineEntriesUpdateResponse,
+    TimelineEntry,
+)
+from devrev.services.base import AsyncBaseService, BaseService
+
+
+class TimelineEntriesService(BaseService):
+    """Service for managing DevRev Timeline Entries."""
+
+    def create(self, request: TimelineEntriesCreateRequest) -> TimelineEntry:
+        """Create a new timeline entry."""
+        response = self._post("/timeline-entries.create", request, TimelineEntriesCreateResponse)
+        return response.timeline_entry
+
+    def get(self, request: TimelineEntriesGetRequest) -> TimelineEntry:
+        """Get a timeline entry by ID."""
+        response = self._post("/timeline-entries.get", request, TimelineEntriesGetResponse)
+        return response.timeline_entry
+
+    def list(self, request: TimelineEntriesListRequest) -> Sequence[TimelineEntry]:
+        """List timeline entries for an object."""
+        response = self._post("/timeline-entries.list", request, TimelineEntriesListResponse)
+        return response.timeline_entries
+
+    def update(self, request: TimelineEntriesUpdateRequest) -> TimelineEntry:
+        """Update a timeline entry."""
+        response = self._post("/timeline-entries.update", request, TimelineEntriesUpdateResponse)
+        return response.timeline_entry
+
+    def delete(self, request: TimelineEntriesDeleteRequest) -> None:
+        """Delete a timeline entry."""
+        self._post("/timeline-entries.delete", request, TimelineEntriesDeleteResponse)
+
+
+class AsyncTimelineEntriesService(AsyncBaseService):
+    """Async service for managing DevRev Timeline Entries."""
+
+    async def create(self, request: TimelineEntriesCreateRequest) -> TimelineEntry:
+        """Create a new timeline entry."""
+        response = await self._post(
+            "/timeline-entries.create", request, TimelineEntriesCreateResponse
+        )
+        return response.timeline_entry
+
+    async def get(self, request: TimelineEntriesGetRequest) -> TimelineEntry:
+        """Get a timeline entry by ID."""
+        response = await self._post("/timeline-entries.get", request, TimelineEntriesGetResponse)
+        return response.timeline_entry
+
+    async def list(self, request: TimelineEntriesListRequest) -> Sequence[TimelineEntry]:
+        """List timeline entries for an object."""
+        response = await self._post("/timeline-entries.list", request, TimelineEntriesListResponse)
+        return response.timeline_entries
+
+    async def update(self, request: TimelineEntriesUpdateRequest) -> TimelineEntry:
+        """Update a timeline entry."""
+        response = await self._post(
+            "/timeline-entries.update", request, TimelineEntriesUpdateResponse
+        )
+        return response.timeline_entry
+
+    async def delete(self, request: TimelineEntriesDeleteRequest) -> None:
+        """Delete a timeline entry."""
+        await self._post("/timeline-entries.delete", request, TimelineEntriesDeleteResponse)

devrev/services/webhooks.py

@@ -0,0 +1,80 @@
+"""Webhooks service for DevRev SDK."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from devrev.models.webhooks import (
+    Webhook,
+    WebhooksCreateRequest,
+    WebhooksCreateResponse,
+    WebhooksDeleteRequest,
+    WebhooksDeleteResponse,
+    WebhooksGetRequest,
+    WebhooksGetResponse,
+    WebhooksListRequest,
+    WebhooksListResponse,
+    WebhooksUpdateRequest,
+    WebhooksUpdateResponse,
+)
+from devrev.services.base import AsyncBaseService, BaseService
+
+
+class WebhooksService(BaseService):
+    """Service for managing DevRev Webhooks."""
+
+    def create(self, request: WebhooksCreateRequest) -> Webhook:
+        """Create a new webhook."""
+        response = self._post("/webhooks.create", request, WebhooksCreateResponse)
+        return response.webhook
+
+    def get(self, request: WebhooksGetRequest) -> Webhook:
+        """Get a webhook by ID."""
+        response = self._post("/webhooks.get", request, WebhooksGetResponse)
+        return response.webhook
+
+    def list(self, request: WebhooksListRequest | None = None) -> Sequence[Webhook]:
+        """List webhooks."""
+        if request is None:
+            request = WebhooksListRequest()
+        response = self._post("/webhooks.list", request, WebhooksListResponse)
+        return response.webhooks
+
+    def update(self, request: WebhooksUpdateRequest) -> Webhook:
+        """Update a webhook."""
+        response = self._post("/webhooks.update", request, WebhooksUpdateResponse)
+        return response.webhook
+
+    def delete(self, request: WebhooksDeleteRequest) -> None:
+        """Delete a webhook."""
+        self._post("/webhooks.delete", request, WebhooksDeleteResponse)
+
+
+class AsyncWebhooksService(AsyncBaseService):
+    """Async service for managing DevRev Webhooks."""
+
+    async def create(self, request: WebhooksCreateRequest) -> Webhook:
+        """Create a new webhook."""
+        response = await self._post("/webhooks.create", request, WebhooksCreateResponse)
+        return response.webhook
+
+    async def get(self, request: WebhooksGetRequest) -> Webhook:
+        """Get a webhook by ID."""
+        response = await self._post("/webhooks.get", request, WebhooksGetResponse)
+        return response.webhook
+
+    async def list(self, request: WebhooksListRequest | None = None) -> Sequence[Webhook]:
+        """List webhooks."""
+        if request is None:
+            request = WebhooksListRequest()
+        response = await self._post("/webhooks.list", request, WebhooksListResponse)
+        return response.webhooks
+
+    async def update(self, request: WebhooksUpdateRequest) -> Webhook:
+        """Update a webhook."""
+        response = await self._post("/webhooks.update", request, WebhooksUpdateResponse)
+        return response.webhook
+
+    async def delete(self, request: WebhooksDeleteRequest) -> None:
+        """Delete a webhook."""
+        await self._post("/webhooks.delete", request, WebhooksDeleteResponse)