Tapi 0.1.2__py3-none-any.whl

tapi/__init__.py

@@ -0,0 +1,2 @@
+from .api    import *
+from .client import *

tapi/api/__init__.py

@@ -0,0 +1,46 @@
+from .case       import *
+from .team       import *
+from .note       import *
+from .story      import *
+from .event      import *
+from .admin      import *
+from .folder     import *
+from .action     import *
+from .record     import *
+from .report     import *
+from .resource   import *
+from .audit_log  import *
+from .credential import *
+from .tenant     import TenantAPI
+
+__all__ = [
+    "TenantAPI",
+
+    "CasesAPI", "CaseActionsAPI", "CaseActivitiesAPI", "CaseAssigneesAPI", "CaseInputsAPI", "CaseInputsFieldsAPI",
+    "CaseCommentsAPI", "CaseCommentsReactionsAPI", "CaseFieldsAPI", "CaseFilesAPI", "LinkedCasesAPI", "CaseMetadataAPI",
+    "CaseNotesAPI", "CaseRecordsAPI", "CaseSubscribersAPI", "GroupsAPI", "CaseBlocksAPI", "CaseBlockElementsAPI",
+
+    "ActionsAPI", "ActionLogsAPI", "ActionEventsAPI",
+
+    "NotesAPI",
+
+    "AuditLogsAPI",
+
+    "CredentialsAPI",
+
+    "EventsAPI",
+
+    "FoldersAPI",
+
+    "ResourcesAPI",
+
+    "RecordsAPI", "RecordTypesAPI", "RecordArtifactsAPI",
+
+    "ReportingAPI",
+
+    "AdminAPI", "ActionEgressControlRulesAPI", "IpAccessControlAPI", "JobsAPI", "SCIMUserGroupMappingAPI",
+    "TemplatesAPI", "UsersAPI", "DraftsAPI",
+
+    "StoriesAPI", "ChangeRequestAPI", "RunsAPI", "VersionsAPI",
+    "TeamsAPI", "MembersAPI"
+]

tapi/api/action/__init__.py

@@ -0,0 +1,7 @@
+from .actions import ActionsAPI
+from .logs    import ActionLogsAPI
+from .events  import ActionEventsAPI
+
+__all__ = [
+    "ActionsAPI", "ActionLogsAPI", "ActionEventsAPI"
+]

tapi/api/action/actions.py

@@ -0,0 +1,106 @@
+from tapi.client      import Client
+from .logs            import ActionLogsAPI
+from .events          import ActionEventsAPI
+from tapi.utils.types import AgentType, StoryMode
+from typing           import List, Dict, Any, Optional, Union
+
+
+class ActionsAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "actions"
+        self.logs   = ActionLogsAPI(domain, apiKey)
+        self.events = ActionEventsAPI(domain, apiKey)
+
+    def create(
+            self,
+            type:                      Union[AgentType, str],
+            name:                      str,
+            options:                   Dict[str, Any],
+            position:                  Dict[str, int],
+            story_id:                  Optional[int]                              = None,
+            group_id:                  Optional[int]                              = None,
+            description:               Optional[str]                              = None,
+            disabled:                  bool                                       = False,
+            source_ids:                Optional[List[int]]                        = None,
+            links_to_sources:          Optional[List[Dict[str, Union[str, int]]]] = None,
+            receiver_ids:              Optional[List[int]]                        = None,
+            links_to_receivers:        Optional[List[Dict[str, Union[str, int]]]] = None,
+            schedule:                  Optional[List[Dict[str, str]]]             = None,
+            monitor_failures:          bool                                       = True,
+            monitor_all_events:        bool                                       = False,
+            monitor_no_events_emitted: 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,
+            action_id: int
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{action_id}"
+        )
+
+    def update(
+            self,
+            action_id:                 int,
+            name:                      Optional[str]                              = None,
+            description:               Optional[str]                              = None,
+            options:                   Optional[Dict[str, Any]]                   = None,
+            position:                  Optional[Dict[str, int]]                   = None,
+            source_ids:                Optional[List[int]]                        = None,
+            links_to_sources:          Optional[List[Dict[str, Union[int, str]]]] = None,
+            receiver_ids:              Optional[List[str]]                        = None,
+            links_to_receivers:        Optional[List[Dict[str, Union[int, str]]]] = None,
+            schedule:                  Optional[Dict[str, Any]]                   = None,
+            disabled:                  Optional[bool]                             = None,
+            monitor_failures:          Optional[bool]                             = None,
+            monitor_all_events:        Optional[bool]                             = None,
+            monitor_no_events_emitted: Optional[int]                              = None
+    ):
+        return self._http_request(
+            "PUT",
+            f"{self.base_endpoint}/{action_id}",
+            json = {key: value for key, value in locals().items()
+                    if value is not None and key not in ("self", "action_id")}
+        )
+
+    def list(
+            self,
+            story_id:    Optional[int]                   = None,
+            story_mode:  Optional[Union[StoryMode, str]] = None,
+            team_id:     Optional[int]                   = None,
+            group_id:    Optional[int]                   = None,
+            draft_id:    Optional[str]                   = None,
+            action_type: Optional[str]                   = 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,
+            action_id: int
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/{action_id}"
+        )
+
+    def clear_memory(
+            self,
+            action_id: int
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/{action_id}/clear_memory"
+        )

tapi/api/action/events.py

@@ -0,0 +1,33 @@
+from tapi.client import Client
+from typing      import Optional
+
+
+class ActionEventsAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "actions"
+
+    def list(
+            self,
+            action_id: Optional[int] = None,
+            since_id:  Optional[int] = None,
+            until_id:  Optional[int] = None,
+            per_page:  int           = 10,
+            page:      int           = 1
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{action_id}/events",
+            params = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        )
+
+    def delete(
+            self,
+            action_id:      int,
+            async_deletion: bool = True
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/{action_id}/remove_events",
+            json = {"async_deletion": async_deletion}
+        )

tapi/api/action/logs.py

@@ -0,0 +1,34 @@
+from tapi.client      import Client
+from typing           import Optional, Union
+from tapi.utils.types import LogSeverityLevel
+
+
+class ActionLogsAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "actions"
+
+    def list(
+            self,
+            action_id: int,
+            level:     Optional[Union[LogSeverityLevel, str]] = None,
+            per_page:  int                                    = 10,
+            page:      int                                    = 1
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{action_id}/logs",
+            params = {key: value for key, value in locals().items()
+                      if value is not None and key not in ("self", "action_id")}
+        )
+
+    def delete(
+            self,
+            action_id:      int,
+            async_deletion: bool = True
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/{action_id}/remove_logs",
+            json={"async_deletion": async_deletion}
+        )

tapi/api/admin/__init__.py

@@ -0,0 +1,12 @@
+from .job                         import JobsAPI
+from .user                        import UsersAPI
+from .admin                       import AdminAPI
+from .template                    import TemplatesAPI
+from .ip_access_control           import IpAccessControlAPI
+from .scim                        import SCIMUserGroupMappingAPI
+from .action_egress_control_rules import ActionEgressControlRulesAPI
+
+__all__ = [
+    "AdminAPI", "ActionEgressControlRulesAPI", "IpAccessControlAPI", "JobsAPI", "SCIMUserGroupMappingAPI",
+    "TemplatesAPI", "UsersAPI"
+]

tapi/api/admin/action_egress_control_rules.py

@@ -0,0 +1,87 @@
+from tapi.client        import Client
+from tapi.utils.helpers import is_ip_valid
+from typing             import List, Optional, Literal, Union
+
+
+class ActionEgressControlRulesAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "admin"
+
+    def create(
+            self,
+            ip:                   Optional[str]                               = None,
+            fqdn:                 Optional[str]                               = None,
+            description:          str                                         = "",
+            allowed_action_types: List[Literal["http-request", "send-email"]] = None
+    ):
+        if ip and fqdn:
+            raise ValueError("Only IP or FQDN is allowed, not both.")
+
+        if not ip and not fqdn:
+            raise ValueError("Either IP or FQDN must be provided.")
+
+        if ip and not is_ip_valid(ip):
+            raise ValueError("Invalid IP address or CIDR range.")
+
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/action_egress_control_rules",
+            json = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        )
+
+    def get(
+            self,
+            id: int
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/action_egress_control_rules/{id}"
+        )
+
+    def update(
+            self,
+            id:                   Union[str, int],
+            ip:                   Optional[str]                               = None,
+            fqdn:                 Optional[str]                               = None,
+            description:          Optional[str]                               = None,
+            allowed_action_types: List[Literal["http-request", "send-email"]] = None
+    ):
+        if ip and fqdn:
+            raise ValueError("Only IP or FQDN is allowed, not both.")
+
+        if not ip and not fqdn:
+            raise ValueError("Either IP or FQDN must be provided.")
+
+        if ip and not is_ip_valid(ip):
+            raise ValueError("Invalid IP address or CIDR range.")
+
+        return self._http_request(
+            "PUT",
+            f"{self.base_endpoint}/ip_access_control_rules/{id}",
+            json = {key: value for key, value in locals().items()
+                    if value is not None and key not in ("self", "id")}
+        )
+
+    def list(
+            self,
+            per_page: int = 10,
+            page:     int = 1,
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/action_egress_control_rules",
+            params = {
+                "per_page": per_page,
+                "page":     page
+            }
+        )
+
+    def delete(
+            self,
+            id: Union[str, int]
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/action_egress_control_rules/{id}"
+        )

tapi/api/admin/admin.py

@@ -0,0 +1,43 @@
+from tapi.client                  import Client
+from .job                         import JobsAPI
+from .user                        import UsersAPI
+from .template                    import TemplatesAPI
+from .ip_access_control           import IpAccessControlAPI
+from .scim                        import SCIMUserGroupMappingAPI
+from .action_egress_control_rules import ActionEgressControlRulesAPI
+
+
+class AdminAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint           = "admin"
+        self.jobs                    = JobsAPI(domain, apiKey)
+        self.users                   = UsersAPI(domain, apiKey)
+        self.templates               = TemplatesAPI(domain, apiKey)
+        self.ip_access_control       = IpAccessControlAPI(domain, apiKey)
+        self.scim_user_group_mapping = SCIMUserGroupMappingAPI(domain, apiKey)
+        self.egress_rules            = ActionEgressControlRulesAPI(domain, apiKey)
+
+    def set_custom_certificate_authority(
+            self,
+            name:        str,
+            certificate: str
+
+    ):
+        return self._http_request(
+            "PUT",
+            f"{self.base_endpoint}/custom_certificate_authority",
+            json = {
+                "name":        name,
+                "certificate": certificate
+            }
+        )
+
+    def tunnel_health(
+            self,
+            tunnel_name: str
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/tunnel/{tunnel_name}/health"
+        )

tapi/api/admin/ip_access_control.py

@@ -0,0 +1,76 @@
+from tapi.client        import Client
+from tapi.utils.helpers import is_ip_valid
+from typing             import Optional, Union
+
+class IpAccessControlAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "admin"
+
+    def create(
+            self,
+            ip:          str,
+            description: str
+    ):
+        if not is_ip_valid(ip):
+            raise ValueError("Invalid IP address or CIDR range.")
+
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/ip_access_control_rules",
+            json = {
+                "ip": ip,
+                "description": description
+            }
+        )
+
+    def get(
+            self,
+            id: Union[str, int]
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/ip_access_control_rules/{id}"
+        )
+
+    def update(
+            self,
+            id:          Union[str, int],
+            ip:          str,
+            description: str
+    ):
+        if not is_ip_valid(ip):
+            raise ValueError("Invalid IP address or CIDR range.")
+
+        return self._http_request(
+            "PUT",
+            f"{self.base_endpoint}/ip_access_control_rules/{id}",
+            json = {
+                "ip": ip,
+                "description": description
+            }
+        )
+
+    def list(
+            self,
+            matching_ip: Optional[str] = None,
+            per_page:    int           = 10,
+            page:        int           = 1
+    ):
+        if matching_ip and not is_ip_valid(matching_ip):
+            raise ValueError("Invalid IP address or CIDR range.")
+
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/ip_access_control_rules",
+            params = {key: value for key, value in locals().items() if value is not None and key != "self"}
+        )
+
+    def delete(
+            self,
+            id: Union[str, int]
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/ip_access_control_rules/{id}"
+        )

tapi/api/admin/job.py

@@ -0,0 +1,42 @@
+from tapi.client import Client
+from typing      import Literal
+
+
+class JobsAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint      = "admin"
+
+    def list(
+            self,
+            job_type: Literal["dead", "in_progress", "queued", "retry"],
+            per_page: int = 10,
+            page:     int = 1
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/{job_type}_jobs",
+            params = {
+                "per_page": per_page,
+                "page": page
+            }
+        )
+
+    def delete(
+            self,
+            job_type: Literal["dead", "queued", "retry"]
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/delete_all_{job_type}_jobs"
+        )
+
+    def delete_by_action(
+            self,
+            action_id: int,
+            job_type: Literal["dead", "queued", "retry"]
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/actions/{action_id}/delete_all_{job_type}_jobs"
+        )

tapi/api/admin/scim.py

@@ -0,0 +1,27 @@
+from tapi.client      import Client
+from typing           import Union, Dict
+from tapi.utils.types import SCIMUserGroupMapping
+
+
+class SCIMUserGroupMappingAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint      = "admin"
+
+    def list(self):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/scim_user_group_mapping"
+        )
+
+    def update(
+            self,
+            mappings: Union[SCIMUserGroupMapping, Dict[str, str]]
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/scim_user_group_mapping",
+            json = {
+                "mappings": mappings
+            }
+        )

tapi/api/admin/template.py

@@ -0,0 +1,86 @@
+from tapi.client      import Client
+from tapi.utils.types import AgentType
+from typing           import Union, Dict, Any
+
+
+class TemplatesAPI(Client):
+    def __init__(self, domain: str, apiKey: str):
+        super().__init__(domain, apiKey)
+        self.base_endpoint = "admin"
+
+    def create(
+            self,
+            name:          str,
+            description:   str,
+            vendor:        str,
+            product:       str,
+            agent_type:    Union[AgentType, str],
+            agent_options: Dict[str, Any]
+    ):
+        return self._http_request(
+            "POST",
+            f"{self.base_endpoint}/templates",
+            json = {
+                "name": name,
+                "description": description,
+                "vendor": vendor,
+                "product": product,
+                "agent_type": agent_type,
+                "agent_options": agent_options
+            }
+        )
+
+    def get(
+            self,
+            template_id: int
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/templates/{template_id}"
+        )
+
+    def update(
+            self,
+            template_id:   int,
+            name:          str,
+            description:   str,
+            vendor:        str,
+            product:       str,
+            agent_type:    Union[AgentType, str],
+            agent_options: Dict[str, Any]
+    ):
+        return self._http_request(
+            "PUT",
+            f"{self.base_endpoint}/templates/{template_id}",
+            json = {
+                "name": name,
+                "description": description,
+                "vendor": vendor,
+                "product": product,
+                "agent_type": agent_type,
+                "agent_options": agent_options
+            }
+        )
+
+    def list(
+            self,
+            per_page: int = 10,
+            page:     int = 1
+    ):
+        return self._http_request(
+            "GET",
+            f"{self.base_endpoint}/templates",
+            params = {
+                "per_page": per_page,
+                "page": page
+            }
+        )
+
+    def delete(
+            self,
+            template_id: int
+    ):
+        return self._http_request(
+            "DELETE",
+            f"{self.base_endpoint}/templates/{template_id}"
+        )