Tapi 0.1.2__py3-none-any.whl

tapi/api/resource/resources.py

@@ -0,0 +1,152 @@
+from tapi.client import Client
+from typing      import Optional, Dict, List, Union, Any, Literal
+
+
+class ResourcesAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "global_resources"
+
+    def create(
+            self,
+            name:              str,
+            value:             Union[str, Dict[str, Any], List[Union[int, str, Dict[str, Any]]]],
+            team_id:           int                                         = None,
+            folder_id:         Optional[int]                               = None,
+            read_access:       Literal["TEAM", "GLOBAL", "SPECIFIC_TEAMS"] = "TEAM",
+            shared_team_slugs: Optional[List[str]]                         = None,
+            description:       Optional[str]                               = None,
+            live_resource_id:  Optional[int]                               = None,
+
+    ):
+        return self._http_request(
+            "POST",
+            self.base_endpoint,
+            json = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        )
+
+    def get(
+            self,
+            resource_id: int
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{resource_id}"
+        )
+
+    def update(
+            self,
+            resource_id:           int,
+            value:                 Union[str, Dict[str, Any], List[Dict[str, Any]]],
+            name:                  Optional[str]                                         = None,
+            folder_id:             Optional[int]                                         = None,
+            read_access:           Optional[Literal["TEAM", "GLOBAL", "SPECIFIC_TEAMS"]] = None,
+            shared_team_slugs:     Optional[List[str]]                                   = None,
+            description:           Optional[str]                                         = None,
+            test_resource_enabled: Optional[bool]                                        = None,
+            is_test:               Optional[bool]                                        = None
+    ):
+        return self._http_request(
+            "PUT",
+            f"{self.base_endpoint}/{resource_id}",
+            json = {key: value for key, value in locals().items()
+                    if value is not None and key not in ("self", "resource_id")}
+        )
+
+    def list(
+            self,
+            team_id:   Optional[int] = None,
+            folder_id: Optional[int] = None,
+            per_page:  int           = 10,
+            page:      int           = 1,
+    ):
+        return self._http_request(
+            "GET",
+            self.base_endpoint,
+            params = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        )
+
+    def remove_element(
+            self,
+            resource_id: int,
+            key:         Optional[str]  = None,
+            index:       Optional[int]  = None,
+            is_test:     Optional[bool] = None
+    ):
+        if not key and not index:
+            raise ValueError("Please specify either 'key' or 'index'.")
+        elif key and index:
+            raise ValueError("Please specify only one of 'key' or 'index', not both.")
+
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/{resource_id}/remove",
+            json = {key: value for key, value in locals().items()
+                    if value is not None and key not in ("self", "resource_id")}
+        )
+
+    def delete(
+            self,
+            resource_id: int
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/{resource_id}"
+        )
+
+    def append_element(
+            self,
+            resource_id: int,
+            value:       Union[str, List],
+            is_test:     Optional[bool] = None
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/{resource_id}/append",
+            json = {key: value for key, value in locals().items()
+                  if value is not None and key not in ("self", "resource_id")}
+        )
+
+    def replace_element(
+            self,
+            resource_id: int,
+            value:       str,
+            key:         Optional[str]  = None,
+            index:       Optional[str]  = None,
+            is_test:     Optional[bool] = None
+    ):
+        if not key and not index:
+            raise ValueError("Please specify either 'key' or 'index'.")
+        elif key and index:
+            raise ValueError("Please specify only one of 'key' or 'index', not both.")
+
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/{resource_id}/append",
+            json = {key: value for key, value in locals().items()
+                  if value is not None and key not in ("self", "resource_id")}
+        )
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

tapi/api/story/__init__.py

@@ -0,0 +1,10 @@
+from .runs            import RunsAPI
+from .groups          import GroupsAPI
+from .drafts          import DraftsAPI
+from .stories         import StoriesAPI
+from .versions        import VersionsAPI
+from .change_requests import ChangeRequestAPI
+
+__all__ = [
+    "RunsAPI", "StoriesAPI", "VersionsAPI", "ChangeRequestAPI", "GroupsAPI", "DraftsAPI"
+]

tapi/api/story/change_requests.py

@@ -0,0 +1,64 @@
+from tapi.client import Client
+from typing      import Optional
+
+
+class ChangeRequestAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "stories"
+
+    def create(
+            self,
+            story_id:    int,
+            title:       Optional[str] = None,
+            description: Optional[str] = None
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/{story_id}/change_request",
+            json={key: value for key, value in locals().items() if
+                  value is not None and key not in ("self", "story_id")}
+        )
+
+    def approve(
+            self,
+            story_id:          int,
+            change_request_id: int
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/{story_id}/change_request/approve",
+            json={"change_request_id": change_request_id}
+        )
+
+    def cancel(
+            self,
+            story_id:          int,
+            change_request_id: int
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/{story_id}/change_request/cancel",
+            json={"change_request_id": change_request_id}
+        )
+
+    def promote(
+            self,
+            story_id:          int,
+            change_request_id: int
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/{story_id}/change_request/promote",
+            json={"change_request_id": change_request_id}
+        )
+
+    def view(
+            self,
+            story_id: int
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{story_id}/change_request/view"
+        )
+

tapi/api/story/drafts.py

@@ -0,0 +1,45 @@
+from tapi.client import Client
+
+
+class DraftsAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "stories"
+
+    def create(
+            self,
+            story_id: int,
+            name:     str
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/{story_id}/drafts",
+            json = {
+                "name": name
+            }
+        )
+
+    def list(
+            self,
+            story_id: int,
+            per_page: int = 10,
+            page:     int = 1
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{story_id}/drafts",
+            params = {
+                "per_page": per_page,
+                "page": page
+            }
+        )
+
+    def delete(
+            self,
+            story_id: int,
+            draft_id: int
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/{story_id}/drafts/{draft_id}"
+        )

tapi/api/story/groups.py

@@ -0,0 +1,38 @@
+from tapi.client import Client
+
+
+class GroupsAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "groups"
+
+    def list_run_events(
+            self,
+            group_id:       int,
+            group_run_guid: str,
+            per_page:       int = 10,
+            page:           int = 1
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{group_id}/runs/{group_run_guid}",
+            params = {
+                "page": page,
+                "per_page": per_page
+            }
+        )
+
+    def list_runs(
+            self,
+            group_id: int,
+            per_page: int = 10,
+            page:     int = 1
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{group_id}/runs",
+            params={
+                "page": page,
+                "per_page": per_page
+            }
+        )

tapi/api/story/runs.py

@@ -0,0 +1,43 @@
+from tapi.client      import Client
+from datetime         import datetime
+from tapi.utils.types import StoryMode
+from typing           import Optional, Union
+
+
+class RunsAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "stories"
+
+    def events(
+            self,
+            story_id:       int,
+            story_run_guid: str,
+            story_mode:     Optional[Union[StoryMode, str]] = None,
+            draft_id:       Optional[int]                   = None,
+            per_page:       int                             = 10,
+            page:           int                             = 1,
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{story_id}/runs/{story_run_guid}",
+            json={key: value for key, value in locals().items() if
+                  value is not None and key not in ("self", "story_id", "story_run_guid")}
+        )
+
+    def list(
+            self,
+            story_id:   int,
+            story_mode: Optional[Union[StoryMode, str]] = None,
+            draft_id:   Optional[int]                   = None,
+            since:      Optional[Union[datetime, str]]  = None,
+            until:      Optional[Union[datetime, str]]  = None,
+            per_page:   int                             = 10,
+            page:       int                             = 1,
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{story_id}/runs",
+            json={key: value for key, value in locals().items() if
+                  value is not None and key not in ("self", "story_id")}
+        )

tapi/api/story/stories.py

@@ -0,0 +1,162 @@
+from tapi.utils.types import *
+from tapi.client      import Client
+from .runs            import RunsAPI
+from ..note           import NotesAPI
+from .groups          import GroupsAPI
+from .drafts          import DraftsAPI
+from ..action.actions import ActionsAPI
+from .versions        import VersionsAPI
+from .change_requests import ChangeRequestAPI
+from typing           import List, Optional, Dict, Any
+
+
+class StoriesAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint  = "stories"
+        self.runs           = RunsAPI(domain, apiKey)
+        self.notes          = NotesAPI(domain, apiKey)
+        self.groups         = GroupsAPI(domain, apiKey)
+        self.drafts         = DraftsAPI(domain, apiKey)
+        self.actions        = ActionsAPI(domain, apiKey)
+        self.versions       = VersionsAPI(domain, apiKey)
+        self.change_request = ChangeRequestAPI(domain, apiKey)
+
+    def create(
+            self,
+            team_id:         int,
+            name:            Optional[str]             = None,
+            description:     Optional[str]             = None,
+            keep_events_for: Union[KeepEventsFor, int] = KeepEventsFor.ONE_DAY,
+            folder_id:       Optional[int]             = None,
+            tags:            Optional[List[str]]       = None,
+            disabled:        bool                      = False,
+            priority:        bool                      = False
+        ):
+        return self._http_request(
+            "POST",
+            self.base_endpoint,
+            json = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        )
+
+    def get(
+            self,
+            story_id:   int,
+            story_mode: Union[StoryMode, str] = StoryMode.ALL,
+            draft_id:   Optional[int]         = None
+        ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{story_id}",
+            json = {
+                "story_mode": story_mode,
+                "draft_id": draft_id
+            }
+        )
+
+    def update(
+            self,
+            story_id:                                      int,
+            name:                                          Optional[str]                                 = None,
+            description:                                   Optional[str]                                 = None,
+            add_tag_names:                                 Optional[List[str]]                           = None,
+            remove_tag_names:                              Optional[List[str]]                           = None,
+            keep_events_for:                               Optional[Union[KeepEventsFor, str]]           = None,
+            disabled:                                      Optional[bool]                                = None,
+            locked:                                        Optional[bool]                                = None,
+            priority:                                      Optional[bool]                                = None,
+            webhook_api_enabled:                           Optional[bool]                                = None,
+            send_to_story_access_source:                   Optional[Union[SendToStoryAccessSource, str]] = None,
+            send_to_story_access:                          Optional[Union[SendToStoryAccess, str]]       = None,
+            shared_team_slugs:                             Optional[List[str]]                           = None,
+            send_to_story_skill_use_requires_confirmation: Optional[bool]                                = None,
+            api_entry_action_id:                           Optional[int]                                 = None,
+            api_exit_action_ids:                           Optional[int]                                 = None,
+            team_id:                                       Optional[int]                                 = None,
+            folder_id:                                     Optional[int]                                 = None,
+            change_control_enabled:                        Optional[bool]                                = None,
+            draft_id:                                      Optional[int]                                 = None,
+            monitor_failures:                              Optional[bool]                                = None
+
+        ):
+        return self._http_request(
+            "PUT",
+            f"{self.base_endpoint}/{story_id}",
+            json = {key: value for key, value in locals().items() if value is not None and key not in ("self", "story_id")}
+        )
+
+    def list(
+            self,
+            team_id:   Optional[int]                            = None,
+            folder_id: Optional[int]                            = None,
+            tags:      Optional[List[str]]                      = None,
+            search:    Optional[str]                            = None,
+            filter:    Optional[Union[Filter, str]]             = None,
+            order:     Optional[Union[StoriesReturnOrder, str]] = None,
+            per_page:  int                                      = 10,
+            page:      int                                      = 1
+        ):
+        return self._http_request(
+            "GET",
+            self.base_endpoint,
+            json = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        )
+
+    def delete(
+            self,
+            story_id: int
+        ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/{story_id}"
+        )
+
+    def batch_delete(
+            self,
+            story_ids: List[int]
+        ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/batch",
+            json = {"ids": story_ids}
+        )
+
+    def export(
+            self,
+            story_id:       int,
+            randomize_urls: Optional[bool] = True,
+            draft_id:       Optional[int]  = None,
+        ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{story_id}/export",
+            json = {
+                "randomize_urls": randomize_urls,
+                "draft_id": draft_id
+            }
+        )
+
+    def import_(
+            self,
+            new_name:  str,
+            data:      Dict[str, Any],
+            team_id:   int,
+            folder_id: Optional[int]    = None,
+            mode:      Union[Mode, str] = Mode.NEW
+        ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/import",
+            json = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        )
+
+    def disable(
+            self,
+            id:       int,
+            disabled: bool
+        ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/{id}/disable",
+            json = {"disabled": disabled}
+        )

tapi/api/story/versions.py

@@ -0,0 +1,65 @@
+from tapi.client import Client
+from typing      import Optional
+
+
+class VersionsAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "stories"
+
+    def create(
+            self,
+            story_id: int,
+            name:     Optional[str] = None
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/{story_id}/versions",
+            json={key: value for key, value in locals().items() if
+                  value is not None and key not in ("self", "story_id")}
+        )
+
+    def get(
+            self,
+            story_id:   int,
+            version_id: int
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{story_id}/versions/{version_id}"
+        )
+
+    def update(
+            self,
+            name:       str,
+            story_id:   int,
+            version_id: int
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/{story_id}/versions/{version_id}",
+            json={"name": name}
+        )
+
+    def list(
+            self,
+            story_id: int,
+            per_page: int = 10,
+            page:     int = 1,
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{story_id}/versions",
+            json={key: value for key, value in locals().items() if
+                  value is not None and key not in ("self", "story_id")}
+        )
+
+    def delete(
+            self,
+            story_id:   int,
+            version_id: int
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/{story_id}/versions/{version_id}"
+        )

tapi/api/team/__init__.py

@@ -0,0 +1,4 @@
+from .members import MembersAPI
+from .teams import TeamsAPI
+
+__all__ = ["TeamsAPI", "MembersAPI"]

tapi/api/team/members.py

@@ -0,0 +1,62 @@
+from tapi.utils.types import Role
+from tapi.client      import Client
+from typing           import Optional, Union
+
+
+class MembersAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "teams"
+
+    def list(
+            self,
+            team_id:  int,
+            per_page: int = 10,
+            page:     int = 1,
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{team_id}/members",
+            json = {key: value for key, value in locals().items() if value is not None and key not in ("self", "team_id")}
+        )
+
+    def remove(
+            self,
+            team_id: int,
+            user_id: int
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/{team_id}/remove_member",
+            json = {"user_id": user_id}
+        )
+
+    def invite(
+            self,
+            team_id: int,
+            email:   Optional[str]    = None,
+            user_id: Optional[int]    = None,
+            role:    Union[Role, str] = Role.VIEWER
+    ):
+        if email and user_id:
+            raise ValueError("Invalid input: Provide either 'email' or 'user_id', not both.")
+
+        if not email and not user_id:
+            raise ValueError("Invalid input: You must provide at least one of 'email' or 'user_id'.")
+
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/{team_id}/invite_member",
+            json={key: value for key, value in locals().items() if value is not None and key not in ("self", "team_id")}
+        )
+
+    def resend_invite(
+            self,
+            team_id: int,
+            user_id: Optional[int] = None,
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/{team_id}/resend_invitation",
+            json = {"user_id": user_id}
+        )