taegis-sdk-python 1.6.5__tar.gz → 1.6.7__tar.gz

{taegis_sdk_python-1.6.5 → taegis_sdk_python-1.6.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taegis-sdk-python
-Version: 1.6.5
+Version: 1.6.7
 Summary: Taegis Python SDK
 Project-URL: Homepage, https://github.com/secureworks/taegis-sdk-python
 Project-URL: Bug Reports, https://github.com/secureworks/taegis-sdk-python/issues

{taegis_sdk_python-1.6.5 → taegis_sdk_python-1.6.7}/taegis_sdk_python/_consts.py

@@ -34,6 +34,8 @@ TAEGIS_TENANTS_URLS = {
 UNIVERSAL_ENVIRONMENT = "universal"
 UNIVERSAL_AUTHENTICATION_URL = "https://api.taegis.secureworks.com"
 
+DEFAULT_GATEWAY = "/graphql"
+
 
 class TaegisEnum(str, Enum):
     """Handler for Unknown Enums."""

{taegis_sdk_python-1.6.5 → taegis_sdk_python-1.6.7}/taegis_sdk_python/_version.py

@@ -1,3 +1,3 @@
 """Version idenitier."""
 
-__version__ = "1.6.5"
+__version__ = "1.6.7"

{taegis_sdk_python-1.6.5 → taegis_sdk_python-1.6.7}/taegis_sdk_python/middlewares/utils.py

@@ -22,7 +22,7 @@ def scrub_dict(d: Mapping):
     """Remove sensitive data from dictionary keys and values."""
     access_tokens = get_access_tokens()
 
-    if "authorization" in d:
+    if "Authorization" in d:
         token = d["Authorization"].replace("Bearer ", "")
         access_tokens.append(token)
 

{taegis_sdk_python-1.6.5 → taegis_sdk_python-1.6.7}/taegis_sdk_python/service_core.py

@@ -16,6 +16,7 @@ from gql.transport.aiohttp import AIOHTTPTransport
 from gql.transport.aiohttp_websockets import AIOHTTPWebsocketsTransport
 from graphql import GraphQLError, GraphQLField, GraphQLSchema
 
+from taegis_sdk_python._consts import DEFAULT_GATEWAY
 from taegis_sdk_python._version import __version__
 from taegis_sdk_python.errors import InvalidGraphQLEndpoint
 from taegis_sdk_python.utils import async_block, prepare_variables, remove_node
@@ -167,7 +168,7 @@ class ServiceCore:
         self.service = service
 
         self._urls = self.service._environments
-        self._gateway = self.service._gateway
+        self._gateway = None
         self._input_value_deprecation = True
 
         self._cache_map = SchemaCacheMap(expires=self.service.schema_expiry)
@@ -189,7 +190,7 @@ class ServiceCore:
     @property
     def gateway(self) -> str:
         """GraphQL Gateway"""
-        return self.service.gateway or self._gateway
+        return self.service.gateway or self._gateway or DEFAULT_GATEWAY
 
     @property
     def query(self):  # pragma: no cover

{taegis_sdk_python-1.6.5 → taegis_sdk_python-1.6.7}/taegis_sdk_python/services/__init__.py

@@ -45,6 +45,7 @@ from taegis_sdk_python.services.endpoint_management_service import (
     EndpointManagementServiceService,
 )
 from taegis_sdk_python.services.entity_context import EntityContextService
+from taegis_sdk_python.services.escalation_policies import EscalationPoliciesService
 from taegis_sdk_python.services.event_search import EventSearchService
 from taegis_sdk_python.services.events import EventsService
 from taegis_sdk_python.services.exports import ExportsService
@@ -60,6 +61,7 @@ from taegis_sdk_python.services.multi_tenant_ioc import MultiTenantIocService
 from taegis_sdk_python.services.nl_search import NlSearchService
 from taegis_sdk_python.services.notebooks import NotebooksService
 from taegis_sdk_python.services.notifications import NotificationsService
+from taegis_sdk_python.services.notifications2 import Notifications2Service
 from taegis_sdk_python.services.preferences import PreferencesService
 from taegis_sdk_python.services.process_trees import ProcessTreesService
 from taegis_sdk_python.services.queries import QueriesService
@@ -157,7 +159,7 @@ class GraphQLService:
             raise ValueError(f"environment must be in {self._environments.keys()}")
 
         self._tenant_id = tenant_id
-        self._gateway = gateway or "/graphql"
+        self._gateway = gateway
         self._thread_id = threading.get_ident()
         self._context_kwargs = {}
         if not extra_headers:
@@ -204,6 +206,7 @@ class GraphQLService:
         self._endpoint_management_service = None
         self._entity_context = None
         self._event_search = None
+        self._escalation_policies = None
         self._events = None
         self._exports = None
         self._fast_ioc = None
@@ -218,6 +221,7 @@ class GraphQLService:
         self._nl_search = None
         self._notebooks = None
         self._notifications = None
+        self._notifications2 = None
         self._preferences = None
         self._process_trees = None
         self._queries = None
@@ -343,7 +347,7 @@ class GraphQLService:
     @property
     def gateway(self):
         """Taegis GraphQL Gateway."""
-        return self._context_manager.get("gateway")
+        return self._context_manager.get("gateway", self._gateway)
 
     @property
     def tenant_id(self):
@@ -613,6 +617,13 @@ class GraphQLService:
             self._entity_context = EntityContextService(self)
         return self._entity_context
 
+    @property
+    def escalation_policies(self):
+        """Escalation Policies Service Endpoint."""
+        if not self._escalation_policies:
+            self._escalation_policies = EscalationPoliciesService(self)
+        return self._escalation_policies
+
     @property
     def event_search(self):
         """Events Search Service Endpoint."""
@@ -718,6 +729,13 @@ class GraphQLService:
             self._notifications = NotificationsService(self)
         return self._notifications
 
+    @property
+    def notifications2(self):
+        """Notifications2 Service Endpoint."""
+        if not self._notifications2:
+            self._notifications2 = Notifications2Service(self)
+        return self._notifications2
+
     @property
     def preferences(self):
         """Preferences Service Endpoint."""

{taegis_sdk_python-1.6.5 → taegis_sdk_python-1.6.7}/taegis_sdk_python/services/authz/queries.py

@@ -222,7 +222,11 @@ class TaegisSDKAuthzQuery:
             "for query authzCanSubjectAssumeTenantDetailed"
         )
 
-    def authz_can_subject_idassume_tenant(self, subject_id: str) -> bool:
+    def authz_can_subject_idassume_tenant(
+        self,
+        subject_id: str,
+        subject_type: Optional[Union[AuthzSubjectIDType, TaegisEnum]] = None,
+    ) -> bool:
         """Indicates if the input subject can assume the target tenant."""
         endpoint = "authzCanSubjectIDAssumeTenant"
 
@@ -230,6 +234,7 @@ class TaegisSDKAuthzQuery:
             endpoint=endpoint,
             variables={
                 "subjectID": prepare_input(subject_id),
+                "subjectType": prepare_input(subject_type),
             },
             output="",
         )

{taegis_sdk_python-1.6.5 → taegis_sdk_python-1.6.7}/taegis_sdk_python/services/authz/types.py

@@ -45,6 +45,13 @@ class AuthzSupportedFeatureTarget(str, Enum):
     PARTNER_TENANTS = "PARTNER_TENANTS"
 
 
+class AuthzSubjectIDType(str, Enum):
+    """AuthzSubjectIDType."""
+
+    TAEGIS = "TAEGIS"
+    CENTRAL = "CENTRAL"
+
+
 @dataclass_json
 @dataclass(order=True, eq=True, frozen=True)
 class Subject:

taegis_sdk_python-1.6.7/taegis_sdk_python/services/escalation_policies/__init__.py

@@ -0,0 +1,34 @@
+"""EscalationPolicies Service."""
+
+from taegis_sdk_python.service_core import ServiceCore
+from taegis_sdk_python.services.escalation_policies.mutations import (
+    TaegisSDKEscalationPoliciesMutation,
+)
+from taegis_sdk_python.services.escalation_policies.queries import (
+    TaegisSDKEscalationPoliciesQuery,
+)
+from taegis_sdk_python.services.escalation_policies.subscriptions import (
+    TaegisSDKEscalationPoliciesSubscription,
+)
+
+
+class EscalationPoliciesService(ServiceCore):
+    """Taegis EscalationPolicies Service."""
+
+    @property
+    def query(self):
+        if not self._queries:
+            self._queries = TaegisSDKEscalationPoliciesQuery(self)
+        return self._queries
+
+    @property
+    def mutation(self):
+        if not self._mutations:
+            self._mutations = TaegisSDKEscalationPoliciesMutation(self)
+        return self._mutations
+
+    @property
+    def subscription(self):
+        if not self._subscriptions:
+            self._subscriptions = TaegisSDKEscalationPoliciesSubscription(self)
+        return self._subscriptions

taegis_sdk_python-1.6.7/taegis_sdk_python/services/escalation_policies/mutations.py

@@ -0,0 +1,87 @@
+"""EscalationPolicies Mutation."""
+
+# pylint: disable=no-member, unused-argument, too-many-locals, duplicate-code, wildcard-import, unused-wildcard-import, cyclic-import
+
+
+# Autogenerated
+# DO NOT MODIFY
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
+
+from taegis_sdk_python import GraphQLNoRowsInResultSetError
+from taegis_sdk_python._consts import TaegisEnum
+from taegis_sdk_python.services.escalation_policies.types import *
+from taegis_sdk_python.utils import (
+    build_output_string,
+    parse_union_result,
+    prepare_input,
+)
+
+if TYPE_CHECKING:  # pragma: no cover
+    from taegis_sdk_python.services.escalation_policies import EscalationPoliciesService
+
+log = logging.getLogger(__name__)
+
+
+class TaegisSDKEscalationPoliciesMutation:
+    """Taegis Escalation_policies Mutation operations."""
+
+    def __init__(self, service: EscalationPoliciesService):
+        self.service = service
+
+    def create_escalation_policy(
+        self, input_: CreateEscalationPolicyInput
+    ) -> EscalationPolicy:
+        """Create a new escalation policy."""
+        endpoint = "createEscalationPolicy"
+
+        result = self.service.execute_mutation(
+            endpoint=endpoint,
+            variables={
+                "input": prepare_input(input_),
+            },
+            output=build_output_string(EscalationPolicy),
+        )
+        if result.get(endpoint) is not None:
+            return EscalationPolicy.from_dict(result.get(endpoint))
+        raise GraphQLNoRowsInResultSetError("for mutation createEscalationPolicy")
+
+    def update_escalation_policy(
+        self, input_: UpdateEscalationPolicyInput
+    ) -> EscalationPolicy:
+        """Update an existing escalation policy."""
+        endpoint = "updateEscalationPolicy"
+
+        result = self.service.execute_mutation(
+            endpoint=endpoint,
+            variables={
+                "input": prepare_input(input_),
+            },
+            output=build_output_string(EscalationPolicy),
+        )
+        if result.get(endpoint) is not None:
+            return EscalationPolicy.from_dict(result.get(endpoint))
+        raise GraphQLNoRowsInResultSetError("for mutation updateEscalationPolicy")
+
+    def delete_escalation_policy(
+        self, input_: DeleteEscalationPolicyInput
+    ) -> EscalationPolicy:
+        """Delete an existing escalation policy.
+        This is a hard delete and will remove the escalation policy from the system entirely.
+        Policies that are in use by notification rules will need to be unlinked before they can be deleted..
+        """
+        endpoint = "deleteEscalationPolicy"
+
+        result = self.service.execute_mutation(
+            endpoint=endpoint,
+            variables={
+                "input": prepare_input(input_),
+            },
+            output=build_output_string(EscalationPolicy),
+        )
+        if result.get(endpoint) is not None:
+            return EscalationPolicy.from_dict(result.get(endpoint))
+        raise GraphQLNoRowsInResultSetError("for mutation deleteEscalationPolicy")

taegis_sdk_python-1.6.7/taegis_sdk_python/services/escalation_policies/queries.py

@@ -0,0 +1,103 @@
+"""EscalationPolicies Query."""
+
+# pylint: disable=no-member, unused-argument, too-many-locals, duplicate-code, wildcard-import, unused-wildcard-import, cyclic-import
+
+
+# Autogenerated
+# DO NOT MODIFY
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
+
+from taegis_sdk_python import GraphQLNoRowsInResultSetError
+from taegis_sdk_python._consts import TaegisEnum
+from taegis_sdk_python.services.escalation_policies.types import *
+from taegis_sdk_python.utils import (
+    build_output_string,
+    parse_union_result,
+    prepare_input,
+)
+
+if TYPE_CHECKING:  # pragma: no cover
+    from taegis_sdk_python.services.escalation_policies import EscalationPoliciesService
+
+log = logging.getLogger(__name__)
+
+
+class TaegisSDKEscalationPoliciesQuery:
+    """Taegis Escalation_policies Query operations."""
+
+    def __init__(self, service: EscalationPoliciesService):
+        self.service = service
+
+    def escalation_policy(
+        self, arguments: EscalationPolicyArguments
+    ) -> EscalationPolicy:
+        """Get a single escalation policy by id."""
+        endpoint = "escalationPolicy"
+
+        result = self.service.execute_query(
+            endpoint=endpoint,
+            variables={
+                "arguments": prepare_input(arguments),
+            },
+            output=build_output_string(EscalationPolicy),
+        )
+        if result.get(endpoint) is not None:
+            return EscalationPolicy.from_dict(result.get(endpoint))
+        raise GraphQLNoRowsInResultSetError("for query escalationPolicy")
+
+    def escalation_policies(
+        self, arguments: EscalationPoliciesArguments
+    ) -> EscalationPolicies:
+        """Get a list of escalation policies."""
+        endpoint = "escalationPolicies"
+
+        result = self.service.execute_query(
+            endpoint=endpoint,
+            variables={
+                "arguments": prepare_input(arguments),
+            },
+            output=build_output_string(EscalationPolicies),
+        )
+        if result.get(endpoint) is not None:
+            return EscalationPolicies.from_dict(result.get(endpoint))
+        raise GraphQLNoRowsInResultSetError("for query escalationPolicies")
+
+    def walk_escalation_policy(
+        self, arguments: WalkEscalationPolicyArguments
+    ) -> EscalationPolicyStep:
+        """Walk Escalation Policy gets the next valid contact to try in an escalation policy.
+        If there are no more contacts to try, the escalationStep field will be null and no error will be returned..
+        """
+        endpoint = "walkEscalationPolicy"
+
+        result = self.service.execute_query(
+            endpoint=endpoint,
+            variables={
+                "arguments": prepare_input(arguments),
+            },
+            output=build_output_string(EscalationPolicyStep),
+        )
+        if result.get(endpoint) is not None:
+            return EscalationPolicyStep.from_dict(result.get(endpoint))
+        raise GraphQLNoRowsInResultSetError("for query walkEscalationPolicy")
+
+    def contact_method_options(
+        self, arguments: Optional[ContactMethodOptionsArguments] = None
+    ) -> ContactMethods:
+        """Contact Method Options returns a list of currently supported contact methods for the tenant.."""
+        endpoint = "contactMethodOptions"
+
+        result = self.service.execute_query(
+            endpoint=endpoint,
+            variables={
+                "arguments": prepare_input(arguments),
+            },
+            output=build_output_string(ContactMethods),
+        )
+        if result.get(endpoint) is not None:
+            return ContactMethods.from_dict(result.get(endpoint))
+        raise GraphQLNoRowsInResultSetError("for query contactMethodOptions")

taegis_sdk_python-1.6.7/taegis_sdk_python/services/escalation_policies/subscriptions.py

@@ -0,0 +1,33 @@
+"""EscalationPolicies Subscription."""
+
+# pylint: disable=no-member, unused-argument, too-many-locals, duplicate-code, wildcard-import, unused-wildcard-import, cyclic-import
+
+
+# Autogenerated
+# DO NOT MODIFY
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
+
+from taegis_sdk_python import GraphQLNoRowsInResultSetError
+from taegis_sdk_python._consts import TaegisEnum
+from taegis_sdk_python.services.escalation_policies.types import *
+from taegis_sdk_python.utils import (
+    build_output_string,
+    parse_union_result,
+    prepare_input,
+)
+
+if TYPE_CHECKING:  # pragma: no cover
+    from taegis_sdk_python.services.escalation_policies import EscalationPoliciesService
+
+log = logging.getLogger(__name__)
+
+
+class TaegisSDKEscalationPoliciesSubscription:
+    """Taegis Escalation_policies Subscription operations."""
+
+    def __init__(self, service: EscalationPoliciesService):
+        self.service = service