validio-sdk 5.3.0__tar.gz → 6.0.0__tar.gz

{validio_sdk-5.3.0 → validio_sdk-6.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: validio-sdk
-Version: 5.3.0
+Version: 6.0.0
 Summary: SDK to interact with the Validio platform
 Home-page: https://validio.io/
 License: Apache-2.0

{validio_sdk-5.3.0 → validio_sdk-6.0.0}/pyproject.toml

@@ -3,7 +3,7 @@ name = "validio-sdk"
 # This version does not represent the released version or any tag. For each
 # release we automatically bump this before building and publishing so this
 # should be kept at 0.0.1dev1
-version = "5.3.0"
+version = "6.0.0"
 description = "SDK to interact with the Validio platform"
 authors = ["Validio <support@validio.io>"]
 license = "Apache-2.0"

{validio_sdk-5.3.0 → validio_sdk-6.0.0}/validio_sdk/_api/api.py

@@ -1,10 +1,11 @@
 import os
 from datetime import datetime
 from enum import Enum
-from typing import Any
+from typing import Any, Callable
 
 from aiohttp.client_exceptions import ClientConnectorError
 from gql import gql
+from gql.transport.aiohttp import AIOHTTPTransport
 from gql.transport.exceptions import TransportQueryError, TransportServerError
 from graphql import DocumentNode, FieldNode, utilities
 
@@ -22,6 +23,7 @@ from validio_sdk.exception import (
 )
 
 NUM_CONCURRENT_CONNECTIONS = 5
+DEFAULT_TIMEOUT_SECONDS = 600  # 10 min
 
 
 class APIClient:
@@ -31,9 +33,38 @@ class APIClient:
         # We use a somewhat higher timeout that the default 10 seconds to
         # account for longer running operations.
         self.client.client.execute_timeout = int(
-            os.environ.get("VALIDIO_TIMEOUT_SECONDS", "60")
+            os.environ.get("VALIDIO_TIMEOUT_SECONDS", DEFAULT_TIMEOUT_SECONDS)
         )
 
+    def set_timeout(self, timeout: int | None) -> Callable:
+        original_execute_timeout = self.client.client.execute_timeout
+        original_transport_timeout = None
+
+        if isinstance(self.client.client.transport, AIOHTTPTransport):
+            original_transport_timeout = self.client.client.transport.timeout
+
+        # When creating a session we're connecting to the destination so we have
+        # to do this on the client level and can't defer it to the session.
+        #
+        # This timeout only affects request timeout and not connect timeout when
+        # trying to connect to the destination.
+        self.client.client.execute_timeout = timeout
+
+        # This timeout affects connection timeouts and when we should give up
+        # when trying to connect to the destination.
+        if isinstance(self.client.client.transport, AIOHTTPTransport):
+            self.client.client.transport.timeout = timeout
+
+        # To not have to return and handle multiple values we just return a
+        # function that can be used to restore them.
+        def reset_values() -> None:
+            self.client.client.execute_timeout = original_execute_timeout
+
+            if isinstance(self.client.client.transport, AIOHTTPTransport):
+                self.client.client.transport.timeout = original_transport_timeout
+
+        return reset_values
+
     async def execute(self, query: str, **kwargs: Any) -> Any:
         async with self.client as session:
             return await execute(session, query, **kwargs)
@@ -68,8 +99,12 @@ class APIClient:
             return await infer_schema(session, class_name, variable_values, no_args)
 
     async def test_connection(self) -> None:
+        reset_timeout_values = self.set_timeout(30)
+
         async with self.client as session:
-            return await test_connection(session)
+            await test_connection(session)
+
+            reset_timeout_values()
 
     async def test_credential(self, variable_values: dict[str, Any]) -> None:
         async with self.client as session:
@@ -289,6 +324,13 @@ class APIClient:
         async with self.client as session:
             return await get_users(session, user_id)
 
+    async def users_by_emails(
+        self,
+        emails: list[str],
+    ) -> dict[str, str]:
+        async with self.client as session:
+            return await users_by_emails(session, emails)
+
     async def get_tags(
         self,
     ) -> list[dict[str, Any]] | dict[str, Any]:
@@ -367,6 +409,10 @@ async def get_sources(
         key
         value
       }
+      priority
+      owner {
+        email
+      }
       ... on GcpBigQuerySource {
         config {
           project
@@ -1194,7 +1240,6 @@ async def get_channels(
       }
       ... on SlackChannel {
         config {
-          slackWebhookUrl: webhookUrl
           applicationLinkUrl
           slackChannelId
           interactiveMessageEnabled
@@ -1207,7 +1252,6 @@ async def get_channels(
       }
       ... on MsTeamsChannel {
         config {
-          msTeamsWebhookUrl: webhookUrl
           applicationLinkUrl
           msTeamsChannelId
           msTeamsInteractiveMessageEnabled: interactiveMessageEnabled
@@ -1276,8 +1320,6 @@ async def get_channels(
         _replace_aliases(
             ftr["config"],
             [
-                ("slackWebhookUrl", "webhookUrl"),
-                ("msTeamsWebhookUrl", "webhookUrl"),
                 ("msTeamsInteractiveMessageEnabled", "interactiveMessageEnabled"),
                 ("emailInteractiveMessageEnabled", "interactiveMessageEnabled"),
             ],
@@ -1739,7 +1781,6 @@ async def get_validators(
         sensitivity
         decisionBoundsType
         adaptionRate
-        algorithm
       }}
       ... on DifferenceThreshold {{
         differenceOperator: operator
@@ -1760,6 +1801,9 @@ async def get_validators(
       namespace {{
         id
       }}
+      owner {{
+        email
+      }}
       sourceConfig {{
         filter
         segmentation {{
@@ -1784,6 +1828,7 @@ async def get_validators(
         key
         value
       }}
+      priority
       ... on NumericValidator {{
         config {{
           sourceField
@@ -2422,6 +2467,31 @@ async def get_users(
     return await execute(session, query, variable_values=variable_values)
 
 
+async def users_by_emails(
+    session: Session,
+    emails: list[str],
+) -> dict[str, str]:
+    if not emails:
+        return {}
+
+    query = """
+    query UserByEmails($emails: [String!]!) {
+      usersByEmails(emails: $emails) {
+        id
+        email
+      }
+    }
+    """
+
+    result = await execute(
+        session,
+        query,
+        variable_values={"emails": emails},
+    )
+
+    return {x["email"]: x["id"] for x in result}
+
+
 async def get_tags(
     session: Session,
 ) -> list[dict[str, Any]] | dict[str, Any]:

{validio_sdk-5.3.0 → validio_sdk-6.0.0}/validio_sdk/code/_import.py

@@ -69,6 +69,7 @@ class ImportContext:
         imports = (
             [
                 "from validio_sdk import *",
+                "from validio_sdk.resource.enums import *",
                 "from validio_sdk.resource.thresholds import *",
             ]
             + [
@@ -277,7 +278,7 @@ async def _import(
             ("tags", resource_tags(r), None),
         ]
 
-        if v._filter_resource_mode() and v.filter_name:
+        if v.filter_name:
             filter_ = import_ctx.get_variable(Filter, v.filter_name)
             inits.append(("filter", filter_, None))
 

{validio_sdk-5.3.0 → validio_sdk-6.0.0}/validio_sdk/code/plan.py

@@ -24,7 +24,7 @@ from validio_sdk.resource._resource import (
 )
 from validio_sdk.resource._server_resources import load_resources
 from validio_sdk.resource._util import SourceSchemaReinference
-from validio_sdk.resource.channels import Channel, WebhookChannel
+from validio_sdk.resource.channels import WebhookChannel
 from validio_sdk.resource.tags import Tag
 
 
@@ -286,10 +286,6 @@ def _create_resource_diff_object(
     if not show_secrets and hasattr(r, "_secret_fields"):
         secret_fields = r._secret_fields()
 
-        # Workaround for Channel having a special secret field
-        if isinstance(r, Channel):
-            secret_fields.update(r._deprecated_secret_fields())
-
         if secret_fields:
             for field in secret_fields:
                 # We want to avoid overriding webhook_url if it is None already

{validio_sdk-5.3.0 → validio_sdk-6.0.0}/validio_sdk/resource/_diff.py

@@ -12,7 +12,11 @@ from typing import (
 from camel_converter import to_snake
 from gql.transport.exceptions import TransportQueryError
 
-from validio_sdk._api.api import secrets_changed_by_field, split_to_n_chunks
+from validio_sdk._api.api import (
+    secrets_changed_by_field,
+    split_to_n_chunks,
+    users_by_emails,
+)
 from validio_sdk.client import Session
 from validio_sdk.exception import ValidioBugError, ValidioError
 from validio_sdk.resource._diffable import (
@@ -26,7 +30,6 @@ from validio_sdk.resource._errors import (
 )
 from validio_sdk.resource._resource import CREATE_ONLY_RESOURCES, DiffContext, Resource
 from validio_sdk.resource._util import SourceSchemaReinference, _sanitize_error
-from validio_sdk.resource.channels import Channel
 from validio_sdk.resource.replacement import (
     CascadeReplacementReason,
     ImmutableFieldReplacementReason,
@@ -36,7 +39,7 @@ from validio_sdk.resource.replacement import (
 from validio_sdk.resource.segmentations import Segmentation
 from validio_sdk.resource.sources import Source
 from validio_sdk.resource.tags import Tag
-from validio_sdk.resource.validators import Reference, Validator
+from validio_sdk.resource.validators import Validator
 from validio_sdk.resource.windows import TumblingWindow
 
 if TYPE_CHECKING:
@@ -190,6 +193,8 @@ async def diff_resource_graph(
         show_secrets=show_secrets,
     )
 
+    await create_email_lookup_table(manifest_ctx, session)
+
     _compute_replacements(
         manifest_ctx=manifest_ctx,
         server_ctx=server_ctx,
@@ -254,8 +259,7 @@ def _visit_resource_to_replace(
     to_delete: dict[str, Resource] = getattr(graph_diff.to_delete, resource_type)
 
     # Remove the resource from the update list.
-    if resource_name in to_update:
-        del to_update[resource_name]
+    to_update.pop(resource_name, None)
 
     # Flag the resource to be created.
     manifest_resources: dict[str, Resource] = getattr(manifest_ctx, resource_type)
@@ -566,23 +570,6 @@ def diff(
     if isinstance(manifest_object, Resource) and manifest_object.ignore_changes:
         return None
 
-    # NOTE: Backwards compatibility while we transition to Filter resources.
-    # If we're about to diff a validator where the manifest validator still uses
-    # the JSONFilterExpression mode, then force the server object to work
-    # in the JSONFilterExpression mode so that we can compare the same fields.
-    # Same for validator reference.
-    if (
-        isinstance(manifest_object, (Reference, Validator))
-        and
-        # NOTE: the server resource is always the Validator. Even if
-        # the server object is potentially the nested 'Reference'.
-        # This is mostly for type-checking.
-        isinstance(server_resource, Validator)
-        and isinstance(manifest_resource, Validator)
-    ) and not manifest_object._filter_resource_mode():
-        manifest_resource._force_filter_expression_mode()
-        server_resource._force_filter_expression_mode()
-
     if isinstance(server_resource, Segmentation) and isinstance(
         manifest_resource, Segmentation
     ):
@@ -642,20 +629,6 @@ def diff(
         server = getattr(server_object, field)
 
         if manifest != server:
-            # This is a temporary fix to support marking deprecated secret fields as
-            # changed on a `Channel`. If the field is both in `_mutable_fields`
-            # and also in `_deprecated_secret_fields` we will flag the field in
-            # `secret_fields_changed` if there has been an update. This ensures
-            # that the value is redacted by default when displaying the config.
-            secret_fields_changed = None
-            if (
-                isinstance(manifest_object, Channel)
-                and field in manifest_object._deprecated_secret_fields()
-            ):
-                secret_fields_changed = {
-                    field: True,
-                }
-
             # Whenever we find there's a change to make, grab all fields on both
             # resource versions so that we can present them as a diff.
             # Regardless of at what depth we find a change, the diff we present
@@ -664,7 +637,6 @@ def diff(
             return ResourceUpdate(
                 manifest_resource,
                 server_resource,
-                secret_fields_changed=secret_fields_changed,
             )
 
     # Some fields require the resource to be re-created if the type changes
@@ -773,6 +745,43 @@ async def enrich_resource_graph(
     )
 
 
+async def create_email_lookup_table(
+    manifest_ctx: DiffContext,
+    session: Session,
+) -> None:
+    emails_to_lookup = set()
+
+    # Only sources and validators can have owners.
+    for field in ["sources", "validators"]:
+        manifest_resources = getattr(manifest_ctx, field)
+
+        # Add all owner email addresses from the manifest (create and update) to
+        # the lookup set for lookup.
+        for resource in manifest_resources.values():
+            if not isinstance(resource, (Source, Validator)):
+                continue
+
+            if resource.owner is not None:
+                emails_to_lookup.add(resource.owner)
+
+    if not emails_to_lookup:
+        return
+
+    user_email_ids = await users_by_emails(session, list(emails_to_lookup))
+
+    if len(emails_to_lookup) != len(user_email_ids):
+        missing_emails = [x for x in emails_to_lookup if x not in user_email_ids]
+        owner_or_owners = "owner" if len(missing_emails) == 1 else "owners"
+        address_or_addresses = "address" if len(missing_emails) == 1 else "addresses"
+
+        raise ValidioError(
+            f"Invalid {owner_or_owners}, unknown email {address_or_addresses}: "
+            f"{', '.join(missing_emails)}"
+        )
+
+    manifest_ctx.user_email_ids = user_email_ids
+
+
 async def check_for_source_schema_changes(
     manifest_ctx: DiffContext,
     server_ctx: DiffContext,

{validio_sdk-5.3.0 → validio_sdk-6.0.0}/validio_sdk/resource/_resource.py

@@ -68,13 +68,14 @@ class DiffContext:
     pending_validators_raw: dict[str, tuple[type, dict[str, Any]]] = dataclasses.field(
         default_factory=dict
     )
+    user_email_ids: dict[str, str] = dataclasses.field(default_factory=dict)
 
     @staticmethod
     def fields() -> list[str]:
         return [
             f
             for f in list(inspect.signature(DiffContext).parameters)
-            if f != "pending_validators_raw"
+            if f not in ["pending_validators_raw", "user_email_ids"]
         ]
 
     @staticmethod

{validio_sdk-5.3.0 → validio_sdk-6.0.0}/validio_sdk/resource/_server_resources.py

@@ -498,7 +498,6 @@ async def load_channels(
 
         cfg = ch["config"]
         application_link_url = cfg["applicationLinkUrl"]
-        unset_or_none = None if cfg.get("webhookUrl") else "UNSET"
         interactive_message_enabled = cfg.get("interactiveMessageEnabled", None)
         display_name = ch["name"]
         # The 'secret' parts of a channel are left unset since they are not
@@ -509,10 +508,9 @@ async def load_channels(
                     name=name,
                     application_link_url=application_link_url,
                     ms_teams_channel_id=cfg["msTeamsChannelId"],
-                    client_id=unset_or_none,
-                    client_secret=unset_or_none,
+                    client_id="UNSET",
+                    client_secret="UNSET",
                     interactive_message_enabled=interactive_message_enabled,
-                    webhook_url=cfg["webhookUrl"],
                     display_name=display_name,
                     __internal__=g,
                 )
@@ -521,11 +519,10 @@ async def load_channels(
                     name=name,
                     application_link_url=application_link_url,
                     slack_channel_id=cfg["slackChannelId"],
-                    token=unset_or_none,
-                    signing_secret=unset_or_none,
-                    app_token=unset_or_none,
+                    token="UNSET",
+                    signing_secret="UNSET",
+                    app_token="UNSET",
                     interactive_message_enabled=interactive_message_enabled,
-                    webhook_url=cfg["webhookUrl"],
                     display_name=display_name,
                     __internal__=g,
                 )
@@ -606,6 +603,7 @@ async def load_sources(
     for s in server_sources:
         name = s["resourceName"]
         source_config = s.get("config", {})
+        owner = s.get("owner") or {}
 
         cls = eval(f"validio_sdk.resource.sources.{s['__typename']}")
         source = cls(
@@ -613,11 +611,13 @@ async def load_sources(
                 **{to_snake(k): v for k, v in source_config.items()},
                 "name": name,
                 "display_name": s["name"],
+                "owner": owner.get("email"),
                 "credential": must_find_credential(
                     ctx, s["credential"]["resourceName"]
                 ),
                 "jtd_schema": s["jtdSchema"],
                 "description": s["description"],
+                "priority": s["priority"],
                 "tags": [
                     must_find_tag(ctx, Tag._unique_name(t["key"], t["value"]))
                     for t in s["tags"]
@@ -765,7 +765,9 @@ async def load_validators(
         name = v["resourceName"]
         display_name = v["name"]
         description = v["description"]
+        priority = v["priority"]
         config = v["config"]
+        owner = v.get("owner") or {}
 
         window = must_find_window(ctx, v["sourceConfig"]["window"]["resourceName"])
         segmentation = must_find_segmentation(
@@ -808,7 +810,9 @@ async def load_validators(
                 "window": window,
                 "segmentation": segmentation,
                 "display_name": display_name,
+                "owner": owner.get("email"),
                 "description": description,
+                "priority": priority,
                 "tags": [
                     must_find_tag(ctx, Tag._unique_name(t["key"], t["value"]))
                     for t in v["tags"]