Tapi 0.1.2__py3-none-any.whl

tapi/api/credential/credentials.py

@@ -0,0 +1,240 @@
+from tapi.client import Client
+from typing      import Literal, Optional, List, Dict, Any
+
+
+class CredentialsAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "user_credentials"
+
+    def create_aws(
+            self,
+            name:                    str,
+            team_id:                 int,
+            aws_authentication_type: Literal["KEY", "ROLE", "INSTANCE_PROFILE"],
+            aws_access_key:          str,
+            aws_secret_key:          str,
+            aws_assumed_role_arn:    Optional[str]                               = 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,
+            metadata:                Optional[Dict[str, Any]]                    = None,
+            allowed_hosts:           Optional[List[str]]                         = None,
+            live_credential_id:      Optional[int]                               = None
+    ):
+        data = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        data.update({"mode": "AWS"})
+
+        return self._http_request(
+            "POST",
+            self.base_endpoint,
+            json = data
+        )
+
+    def create_http_request(
+            self,
+            name:                           str,
+            team_id:                        int,
+            http_request_options:           Dict[str, Any],
+            http_request_location_of_token: str,
+            http_request_secret:            Optional[str]                               = None,
+            http_request_ttl:               Optional[int]                               = None,
+            content_type:                   Optional[str]                               = 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,
+            metadata:                       Optional[Dict[str, Any]]                    = None,
+            allowed_hosts:                  Optional[List[str]]                         = None,
+            live_credential_id:             Optional[int]                               = None
+    ):
+        data = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        data.update({"mode": "HTTP_REQUEST_AGENT"})
+
+        return self._http_request(
+            "POST",
+            self.base_endpoint,
+            json = data
+        )
+
+    def create_jwt(
+            self,
+            name:                          str,
+            team_id:                       int,
+            jwt_algorithm:                 str,
+            jwt_payload:                   Dict[str, str],
+            jwt_auto_generate_time_claims: bool,
+            jwt_private_key:               str,
+            folder_id:                     Optional[int]                               = None,
+            read_access:                   Literal["TEAM", "GLOBAL", "SPECIFIC_TEAMS"] = "TEAM",
+            shared_team_slugs:             Optional[List[str]]                         = None,
+            description:                   Optional[str]                               = None,
+            metadata:                      Optional[Dict[str, Any]]                    = None,
+            allowed_hosts:                 Optional[List[str]]                         = None,
+            live_credential_id:            Optional[int]                               = None
+    ):
+        data = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        data.update({"mode": "JWT"})
+
+        return self._http_request(
+            "POST",
+            self.base_endpoint,
+            json = data
+        )
+
+
+    def create_mtls(
+            self,
+            name:                    str,
+            team_id:                 int,
+            mtls_client_certificate: str,
+            mtls_client_private_key: str,
+            mtls_root_certificate:   str,
+            folder_id:               Optional[int]                               = None,
+            read_access:             Literal["TEAM", "GLOBAL", "SPECIFIC_TEAMS"] = "TEAM",
+            shared_team_slugs:       Optional[List[str]]                         = None,
+            description:             Optional[str]                               = None,
+            metadata:                Optional[Dict[str, Any]]                    = None,
+            allowed_hosts:           Optional[List[str]]                         = None,
+            live_credential_id:      Optional[int]                               = None
+    ):
+        data = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        data.update({"mode": "MTLS"})
+
+        return self._http_request(
+            "POST",
+            self.base_endpoint,
+            json = data
+        )
+
+    def create_multi_request(
+            self,
+            name:                           str,
+            team_id:                        int,
+            http_request_location_of_token: str,
+            credential_requests:            List[Dict[str, Any]],
+            http_request_ttl:               Optional[int]                               = None,
+            content_type:                   Optional[str]                               = 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,
+            metadata:                       Optional[Dict[str, Any]]                    = None,
+            allowed_hosts:                  Optional[List[str]]                         = None,
+            live_credential_id:             Optional[int]                               = None
+    ):
+        data = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        data.update({"mode": "MULTI_REQUEST"})
+
+        return self._http_request(
+            "POST",
+            self.base_endpoint,
+            json = data
+        )
+
+    def create_oauth(
+            self,
+            name:                         str,
+            team_id:                      int,
+            oauth_url:                    str,
+            oauth_token_url:              str,
+            oauth_client_id:              str,
+            oauth_client_secret:          str,
+            oauth_scope:                  str,
+            oauth_grant_type:             Literal["client_credentials", "authorization_code"],
+            oauthPkceCodeChallengeMethod: Optional[Literal["S256", "plain"]]          = 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,
+            metadata:                     Optional[Dict[str, Any]]                    = None,
+            allowed_hosts:                Optional[List[str]]                         = None,
+            live_credential_id:           Optional[int]                               = None
+    ):
+        data = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        data.update({"mode": "OAUTH"})
+
+        return self._http_request(
+            "POST",
+            self.base_endpoint,
+            json = data
+        )
+
+    def create_text(
+            self,
+            name:               str,
+            team_id:            int,
+            value:              str,
+            folder_id:          Optional[int]                               = None,
+            read_access:        Literal["TEAM", "GLOBAL", "SPECIFIC_TEAMS"] = "TEAM",
+            shared_team_slugs:  Optional[List[str]]                         = None,
+            description:        Optional[str]                               = None,
+            metadata:           Optional[Dict[str, Any]]                    = None,
+            allowed_hosts:      Optional[List[str]]                         = None,
+            live_credential_id: Optional[int]                               = None
+    ):
+        data = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        data.update({"mode": "TEXT"})
+
+        return self._http_request(
+            "POST",
+            self.base_endpoint,
+            json = data
+        )
+
+    def update(
+            self,
+            mode:                    Literal["TEXT", "JWT", "OAUTH", "AWS", "MTLS", "HTTP_REQUEST_AGENT", "MULTI_REQUEST"],
+            credential_id:           int,
+            name:                    Optional[str]                               = None,
+            folder_id:               Optional[int]                               = None,
+            read_access:             Literal["TEAM", "GLOBAL", "SPECIFIC_TEAMS"] = None,
+            shared_team_slugs:       Optional[List[str]]                         = None,
+            description:             Optional[str]                               = None,
+            metadata:                Optional[Dict[str, str]]                    = None,
+            allowed_hosts:           Optional[List[str]]                         = None,
+            test_credential_enabled: Optional[bool]                              = None,
+            is_test:                 Optional[bool]                              = None,
+            **options
+    ):
+        data = {key: value for key, value in locals().items() if value is not None and key not in ("self", "credential_id", "options")}
+        data = {**data, **locals()["options"]}
+
+        return self._http_request(
+            "PUT",
+            f"{self.base_endpoint}/{credential_id}",
+            json = data
+        )
+
+    def get(
+            self,
+            credential_id: int
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{credential_id}"
+        )
+
+    def list(
+            self,
+            folder_id: Optional[int] = None,
+            team_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 delete(
+            self,
+            credential_id: int
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/{credential_id}"
+        )
+

tapi/api/event/__init__.py

@@ -0,0 +1 @@
+from .events import EventsAPI

tapi/api/event/events.py

@@ -0,0 +1,44 @@
+from tapi.client import Client
+from typing      import Optional
+
+
+class EventsAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "events"
+
+    def get(
+            self,
+            event_id: int
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{event_id}"
+        )
+
+    def list(
+            self,
+            since_id:       Optional[int]  = None,
+            until_id:       Optional[int]  = None,
+            since:          Optional[str]  = None,
+            until:          Optional[str]  = None,
+            team_id:        Optional[int]  = None,
+            story_id:       Optional[int]  = None,
+            include_groups: Optional[bool] = 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 re_emit(
+            self,
+            event_id: int
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/{event_id}/reemit"
+        )

tapi/api/folder/__init__.py

@@ -0,0 +1 @@
+from .folders import FoldersAPI

tapi/api/folder/folders.py

@@ -0,0 +1,71 @@
+from tapi.client import Client
+from typing      import Optional, Literal
+
+
+class FoldersAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "folders"
+
+    def create(
+            self,
+            name:         str,
+            content_type: Literal["CREDENTIAL", "RESOURCE", "STORY"],
+            team_id:      int
+    ):
+        return self._http_request(
+            "POST",
+            self.base_endpoint,
+            json = {
+                "name": name,
+                "content_type": content_type,
+                "team_id": team_id
+            }
+        )
+
+    def get(
+            self,
+            folder_id: int
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{folder_id}"
+        )
+
+    def update(
+            self,
+            folder_id: int,
+            name:      str
+    ):
+        return self._http_request(
+            "PUT",
+            f"{self.base_endpoint}/{folder_id}",
+            json = {"name": name}
+        )
+
+    def list(
+            self,
+            team_id:      Optional[int]                              = None,
+            content_type: Literal["CREDENTIAL", "RESOURCE", "STORY"] = "STORY",
+            per_page:     int                                        = 10,
+            page:         int                                        = 1
+    ):
+        return self._http_request(
+            "GET",
+            self.base_endpoint,
+            params = {
+                "team_id": team_id,
+                "content_type": content_type,
+                "per_page": per_page,
+                "page": page
+            }
+        )
+
+    def delete(
+            self,
+            folder_id: int
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/{folder_id}"
+        )

tapi/api/note/__init__.py

@@ -0,0 +1,5 @@
+from .notes import NotesAPI
+
+__all__ = [
+    "NotesAPI"
+]

tapi/api/note/notes.py

@@ -0,0 +1,76 @@
+from tapi.client      import Client
+from tapi.utils.types import StoryMode
+from typing           import Optional, Dict, Union
+
+
+class NotesAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "notes"
+
+    def create(
+            self,
+            content:  str,
+            story_id: Optional[int]            = None,
+            group_id: Optional[int]            = None,
+            position: Optional[Dict[str, int]] = None,
+            draft_id: Optional[int]            = None
+    ):
+        if not (story_id or group_id):
+            raise ValueError("Story ID or Group ID must be specified.")
+
+        if story_id and group_id:
+            raise ValueError("Story ID or Group ID must be specified but not both.")
+
+        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,
+            note_id: int
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{note_id}"
+        )
+
+    def update(
+            self,
+            note_id:  int,
+            content:  Optional[str]            = None,
+            position: Optional[Dict[str, int]] = None
+    ):
+        return self._http_request(
+            "PUT",
+            f"{self.base_endpoint}/{note_id}",
+            json = {key: value for key, value in locals().items()
+                    if value is not None and key not in ("self", "note_id")}
+        )
+
+    def list(
+            self,
+            story_id: Optional[int]                   = None,
+            mode:     Optional[Union[StoryMode, str]] = None,
+            team_id:  Optional[int]                   = None,
+            group_id: Optional[int]                   = None,
+            draft_id: Optional[int]                   = 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,
+            note_id: int
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/{note_id}"
+        )

tapi/api/record/__init__.py

@@ -0,0 +1,7 @@
+from .records   import RecordsAPI
+from .types     import RecordTypesAPI
+from .artifacts import RecordArtifactsAPI
+
+__all__ = [
+    "RecordsAPI", "RecordTypesAPI", "RecordArtifactsAPI"
+]

tapi/api/record/artifacts.py

@@ -0,0 +1,17 @@
+from tapi.client import Client
+
+
+class RecordArtifactsAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "records"
+
+    def get(
+            self,
+            record_id:   int,
+            artifact_id: int
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{record_id}/artifacts/{artifact_id}"
+        )

tapi/api/record/records.py

@@ -0,0 +1,85 @@
+from tapi.client      import Client
+from .types           import RecordTypesAPI
+from .artifacts       import RecordArtifactsAPI
+from tapi.utils.types import RecordFieldValue, RecordFilter
+from typing           import Optional, Dict, List, Union, Any, Literal
+
+
+class RecordsAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "records"
+        self.types         = RecordTypesAPI(domain, apiKey)
+        self.artifacts     = RecordArtifactsAPI(domain, apiKey)
+
+    def create(
+            self,
+            record_type_id: int,
+            field_values:   List[Union[RecordFieldValue, Dict[str, Any]]],
+            case_ids:       Optional[List[Union[str, int]]]        = None,
+            test_mode:      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,
+            record_id: int
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{record_id}"
+        )
+
+    def list(
+            self,
+            record_type_id:   Optional[int]                                              = None,
+            record_field_ids: Optional[int]                                              = None,
+            range_start:      Optional[Union[str, int]]                                  = None,
+            range_end:        Optional[Union[str, int]]                                  = None,
+            story_ids:        Optional[List[Union[str, int]]]                            = None,
+            order_direction:  Literal["ASC", "DESC"]                                     = "DESC",
+            order_field_id:   Optional[int]                                              = None,
+            filters:          Optional[List[Union[RecordFilter, Union[Dict[str, str]]]]] = None,
+            test_mode:        Optional[bool]                                             = None,
+            per_page:         int                                                        = 10,
+            page:             int                                                        = 1
+    ):
+        if not record_type_id and not record_field_ids:
+            raise ValueError("Please specify either 'record_type_id' or 'record_field_ids'.")
+        elif record_type_id and record_field_ids:
+            raise ValueError("Please specify only one of 'record_type_id' or 'record_field_ids', not both.")
+
+        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 update(
+            self,
+            record_id: int,
+            add_child_records:    Optional[List[Union[str, int]]]               = None,
+            remove_child_records: Optional[List[Union[str, int]]]               = None,
+            add_team_case_ids:    Optional[List[Union[str, int]]]               = None,
+            remove_team_case_ids: Optional[List[Union[str, int]]]               = None,
+            field_values:         List[Union[RecordFieldValue, Dict[str, Any]]] = None
+    ):
+        return self._http_request(
+            "PUT",
+            f"{self.base_endpoint}/{record_id}",
+            json = {key: value for key, value in locals().items()
+                    if value is not None and key not in ("self", "record_id")}
+        )
+
+    def delete(
+            self,
+            record_id: int
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/{record_id}"
+        )

tapi/api/record/types.py

@@ -0,0 +1,52 @@
+from tapi.client import Client
+from typing      import Dict, Optional, List, Union
+
+
+class RecordTypesAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "record_types"
+
+    def create(
+            self,
+            name:     str,
+            team_id:  int,
+            fields:   List[Dict[str, Union[str, int, bool]]],
+            editable: Optional[bool]                  = None,
+            ttl_days: 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,
+            record_type_id: int
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{record_type_id}"
+        )
+
+    def list(
+            self,
+            team_id:  int,
+            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 delete(
+            self,
+            record_type_id: int
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/{record_type_id}"
+        )

tapi/api/report/__init__.py

@@ -0,0 +1,5 @@
+from .reporting import ReportingAPI
+
+__all__ = [
+    "ReportingAPI"
+]

tapi/api/report/reporting.py

@@ -0,0 +1,41 @@
+from tapi.client import Client
+from datetime    import datetime
+from typing      import Optional, Union, Literal
+
+
+class ReportingAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "reporting"
+
+    def action_performance(
+            self,
+            team_id:       Optional[int] = None,
+            story_id:      Optional[int] = None,
+            action_id:     Optional[int] = None,
+            filter_option: Optional[Literal["most_active_actions", "action_with_least_activity", "slowest_actions", "fastest_actions"]] = None,
+            per_page:      int           = 10,
+            page:          int           = 1,
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/action_performance",
+            params = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        )
+
+    def time_saved(
+            self,
+            start_date: Optional[Union[datetime, str]]          = None,
+            end_date:   Optional[Union[datetime, str]]          = None,
+            date_unit:  Literal["hour", "day", "week", "month"] = "day",
+            fill_gaps:  bool                                    = True,
+            team_id:    Optional[int]                           = None,
+            story_id:   Optional[int]                           = None,
+            per_page:   int                                     = 10,
+            page:       int                                     = 1,
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/time_saved",
+            params = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        )

tapi/api/resource/__init__.py

@@ -0,0 +1 @@
+from .resources import ResourcesAPI