validio-sdk 7.0.0__tar.gz → 7.3.1__tar.gz

{validio_sdk-7.0.0 → validio_sdk-7.3.1}/PKG-INFO

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

{validio_sdk-7.0.0 → validio_sdk-7.3.1}/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 = "7.0.0"
+version = "7.3.1"
 description = "SDK to interact with the Validio platform"
 authors = ["Validio <support@validio.io>"]
 license = "Apache-2.0"

{validio_sdk-7.0.0 → validio_sdk-7.3.1}/validio_sdk/_api/api.py

@@ -553,6 +553,13 @@ async def get_sources(
           schedule
         }
       }
+      ... on TeradataSource {
+        config {
+          database
+          table
+          schedule
+        }
+      }
     }
     """
 
@@ -962,6 +969,12 @@ async def get_credentials(
           baseUrl
         }
       }
+      ... on AnthropicCredential {
+        config {
+          model
+          optBaseUrl: baseUrl
+        }
+      }
       ... on AwsCredential {
         config {
           accessKey
@@ -1063,6 +1076,12 @@ async def get_credentials(
         }
         enableCatalog
       }
+      ... on OmniCredential {
+        config {
+          baseUrl
+          optUser: user
+        }
+      }
       ... on OracleCredential {
         config {
           host
@@ -1160,6 +1179,21 @@ async def get_credentials(
         }
         enableCatalog
       }
+      ... on TeradataCredential {
+        config {
+          host
+          sslMode
+          httpsPort
+          tdmstPort
+          auth {
+            __typename
+            ... on TeradataCredentialUserPassword {
+              user
+            }
+          }
+        }
+        enableCatalog
+      }
     }
     """
 
@@ -1207,6 +1241,8 @@ async def get_credentials(
             [
                 ("powerBiAuth", "auth"),
                 ("databaseRequired", "database"),
+                ("optUser", "user"),
+                ("optBaseUrl", "baseUrl"),
             ],
         )
         result[i] = credential
@@ -1246,6 +1282,7 @@ async def get_channels(
         config {
           applicationLinkUrl
           msTeamsChannelId
+          tenantId
           msTeamsInteractiveMessageEnabled: interactiveMessageEnabled
         }
       }

{validio_sdk-7.0.0 → validio_sdk-7.3.1}/validio_sdk/code/plan.py

@@ -72,7 +72,6 @@ async def plan(
     no_capture: bool,
     show_secrets: bool,
     targets: ResourceNames = ResourceNames(),
-    import_mode: bool = False,
     show_progress: bool = True,
 ) -> PlanResult:
     """Computes a diff between the manifest program and the live server resources."""
@@ -101,7 +100,6 @@ async def plan(
                 show_secrets=show_secrets,
                 manifest_ctx=manifest_ctx,
                 server_ctx=server_ctx,
-                import_mode=import_mode,
             )
             diff.retain(targets)
             progress_bar.update(advance=1)

{validio_sdk-7.0.0 → validio_sdk-7.3.1}/validio_sdk/exception.py

@@ -1,11 +1,17 @@
 """Exceptions used throughout the system."""
 
 import os
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from aiohttp.client_exceptions import ClientConnectorError
 from gql.transport.exceptions import TransportQueryError, TransportServerError
 
+if TYPE_CHECKING:
+    from validio_sdk.resource._resource import Resource
+
+
+NUM_FIELDS_IN_GRAPHQL_ERROR = 3
+
 
 class ValidioError(Exception):
     """Base exception used for every exception thrown by Validio."""
@@ -15,6 +21,29 @@ class ValidioError(Exception):
         super().__init__(*args)
 
 
+class ManifestConfigurationError(ValidioError):
+    """Raised when there is an invalid configuration in the manifest."""
+
+
+class ValidioResourceError(ValidioError):
+    """Exception related to a specific resource."""
+
+    def __init__(self, resource: "Resource", message: str):
+        """Construct the exception.
+
+        :param resource: The resource with error.
+        :param message: The exception message.
+        """
+        self.resource = resource
+        self.message = message
+
+    def __str__(self) -> str:
+        """String representation for the exception."""
+        return (
+            f"{self.resource.__class__.__name__} '{self.resource.name}': {self.message}"
+        )
+
+
 class ValidioTimeoutError(ValidioError):
     """Validio specific timeout error."""
 
@@ -142,14 +171,20 @@ def _parse_error(
                 raise UnauthorizedError(access_key_env, secret_access_key_env)
             case "FORBIDDEN":
                 raise ForbiddenError
-            case _:
-                raise e
 
-    elif isinstance(e, TransportServerError):
+        # If we only have the regular fields from a GraphQL error, only raise
+        # the message part.
+        if len(error_details) == NUM_FIELDS_IN_GRAPHQL_ERROR and all(
+            x in error_details for x in ["message", "locations", "path"]
+        ):
+            raise ValidioError(error_details["message"])
+
+        raise e
+
+    if isinstance(e, TransportServerError):
         raise ValidioError(f"🛑 Server error: {e}")
 
-    elif isinstance(e, TimeoutError):
+    if isinstance(e, TimeoutError):
         raise ValidioTimeoutError(timeout=timeout)
 
-    else:
-        raise e
+    raise e

{validio_sdk-7.0.0 → validio_sdk-7.3.1}/validio_sdk/resource/_diff.py

@@ -18,8 +18,9 @@ from validio_sdk._api.api import (
     users_by_emails,
 )
 from validio_sdk.client import Session
-from validio_sdk.exception import ValidioBugError, ValidioError
+from validio_sdk.exception import ValidioError, ValidioResourceError
 from validio_sdk.resource._diffable import (
+    MAX_RESOURCE_DEPTH,
     ApiSecretChangeNestedResource,
     Diffable,
 )
@@ -28,8 +29,12 @@ from validio_sdk.resource._errors import (
     max_resource_depth_exceeded,
     updated_resource_type_mismatch_exception,
 )
-from validio_sdk.resource._resource import CREATE_ONLY_RESOURCES, DiffContext, Resource
-from validio_sdk.resource._util import SourceSchemaReinference, _sanitize_error
+from validio_sdk.resource._resource import (
+    CREATE_ONLY_RESOURCES,
+    DiffContext,
+    Resource,
+)
+from validio_sdk.resource._util import SourceSchemaReinference, _sanitized_error_str
 from validio_sdk.resource.replacement import (
     CascadeReplacementReason,
     ImmutableFieldReplacementReason,
@@ -52,13 +57,6 @@ NUM_CONCURRENT_INFERENCE_TASKS = 1
 
 R = TypeVar("R", bound=Resource)
 
-"""
-When we descend into nested objects, we set a limit on how deep we go.
-Otherwise, in a bad manifest configuration or due to a bug in our code, we
-could enter a cycle.
-"""
-MAX_RESOURCE_DEPTH = 15
-
 
 @dataclass
 class ResourceUpdate:
@@ -175,13 +173,11 @@ async def diff_resource_graph(
     show_secrets: bool,
     manifest_ctx: DiffContext,
     server_ctx: DiffContext,
-    import_mode: bool = False,
 ) -> GraphDiff:
     graph_diff = _diff_resource_graph(
         namespace=namespace,
         manifest_ctx=manifest_ctx,
         server_ctx=server_ctx,
-        import_mode=import_mode,
     )
 
     await enrich_resource_graph(
@@ -368,9 +364,9 @@ def _visit_resource_to_cascade_update(
     if resource_name not in manifest_resources or resource_name not in server_resources:
         # We expect both manifest and server object, since we've
         # checked for create/delete operation on this resource.
-        raise ValidioBugError(
-            f"unable to cascade update {resource_type} '{resource_name}': "
-            f"missing manifest or server object"
+        raise ValidioResourceError(
+            manifest_resources[resource_name],
+            "unable to cascade update: missing manifest or server object",
         )
 
     to_update[resource_name] = ResourceUpdate(
@@ -387,15 +383,7 @@ def _diff_resource_graph(
     namespace: str,
     manifest_ctx: DiffContext,
     server_ctx: DiffContext,
-    import_mode: bool = False,
 ) -> GraphDiff:
-    # Backwards compatibility: Here we note the filters that
-    # are in-use by validators.
-    # See usage site for more info.
-    # Note: we do this before diff, since we lose some info (when we
-    # force a validator into filter-expression mode) during diff.
-    server_filter_references = _collect_filter_references(server_ctx)
-
     fns = [
         (compute_creates, DiffContext),
         (compute_deletes, DiffContext),
@@ -424,18 +412,13 @@ def _diff_resource_graph(
             ),
         )
 
-    g = GraphDiff(
+    return GraphDiff(
         to_create=diffs[0],
         to_delete=diffs[1],
         to_update=diffs[2],
         replacement_ctx=ReplacementContext(),
     )
 
-    if not import_mode:
-        _retain_auto_generated_filter_resources(g, server_filter_references)
-
-    return g
-
 
 def _collect_filter_references(
     server_ctx: DiffContext,
@@ -450,47 +433,6 @@ def _collect_filter_references(
     return live_filters
 
 
-def _retain_auto_generated_filter_resources(
-    g: GraphDiff,
-    server_filter_references: set[tuple[str, str]],
-) -> None:
-    """
-    Backwards compatibility while we transition to Filter resources.
-
-    On the API side we only deal with Filter resources. While iac
-    side, we support JSONFilterExpression during the transition - on the
-    backend, the filter expression is represented by an actual Filter
-    resource that we auto generate.
-    But this behavior can is inconsistent from a diff pov since there's
-    no representation of the auto-generated filter resource in the iac
-    manifest. So that diff will flag the auto-generated resource to be
-    deleted, which is undesirable.
-
-    To avoid this behavior, we just check for this condition. If we flagged
-    to delete a Filter that is still in use by some validator, then basically
-    un-flag that filter for delete.
-    """
-    if len(g.to_delete.filters) == 0:
-        return
-
-    for validator_name, filter_name in list(server_filter_references):
-        # If a validator is being deleted, then we don't count references
-        # towards its filters.
-        if (
-            validator_name in g.to_delete.validators
-            and validator_name not in g.to_create.validators
-        ):
-            server_filter_references.remove((validator_name, filter_name))
-
-    live_filters = {filter_name for _, filter_name in server_filter_references}
-
-    for filter_name in set(g.to_delete.filters.keys()):
-        # If we were already going to re-create the filter
-        # after deleting, then nothing to do.
-        if filter_name not in g.to_create.filters and filter_name in live_filters:
-            del g.to_delete.filters[filter_name]
-
-
 def compute_creates(
     namespace: str, manifest_resources: dict[str, R], server_resources: dict[str, R]
 ) -> dict[str, R]:
@@ -940,7 +882,7 @@ async def check_for_secret_changes(
             if not server_object:
                 continue
 
-            if not _has_secret_fields(manifest_object, curr_depth=1):
+            if not manifest_object._has_secret_fields(curr_depth=1):
                 continue
 
             secret_fields_changed = await _check_secret_change(
@@ -964,28 +906,6 @@ async def check_for_secret_changes(
             )
 
 
-# Checks if the Diffable object or any of its sub objects
-# defines any secret fields.
-def _has_secret_fields(obj: Diffable, curr_depth: int) -> bool:
-    if curr_depth > MAX_RESOURCE_DEPTH:
-        raise ValidioError(
-            "BUG: max recursion depth exceeded while looking for secrets"
-        )
-
-    if hasattr(obj, "_secret_fields") and obj._secret_fields():
-        return True
-
-    for nested in obj._nested_objects().values():
-        if isinstance(nested, list):
-            for n in nested:
-                if _has_secret_fields(n, curr_depth=curr_depth + 1):
-                    return True
-        elif nested and _has_secret_fields(nested, curr_depth + 1):
-            return True
-
-    return False
-
-
 async def _check_secret_change(
     session: Session,
     show_secrets: bool,
@@ -1024,13 +944,15 @@ async def _check_secret_change(
             query_response_fields=query_response_fields,
             variable_values=resource._api_secret_change_input(),
         )
-    except TransportQueryError as e:
-        raise _sanitize_error(e, show_secrets)
+    except TransportQueryError as sanitized:
+        raise ValidioResourceError(
+            resource, _sanitized_error_str(sanitized, show_secrets)
+        )
 
     if response["errors"]:
-        raise ValidioError(
-            f"failed to check for changed secrets for resource {resource.name}: "
-            f"{response['errors']}"
+        raise ValidioResourceError(
+            resource,
+            f"failed to check for changed secrets: {response['errors']}",
         )
 
     # map response values to secret fields changed
@@ -1058,8 +980,8 @@ def _check_namespace(namespace: str, server_resource: Resource) -> None:
 
     server_namespace = server_resource._must_namespace()
     if namespace != server_namespace:
-        raise ManifestConfigurationError(
-            f"resource {server_resource.__class__.__name__} '{server_resource.name}' "
-            "does not belong to the current namespace; "
-            f"resource namespace = {server_namespace}; current namespace = {namespace}"
+        raise ValidioResourceError(
+            server_resource,
+            "resource does not belong to the current namespace; "
+            f"resource namespace = {server_namespace}; current namespace = {namespace}",
         )

{validio_sdk-7.0.0 → validio_sdk-7.3.1}/validio_sdk/resource/_diffable.py

@@ -1,19 +1,28 @@
 import inspect
 from abc import ABC, abstractmethod
 from collections.abc import Iterator
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from camel_converter import to_camel
 
+from validio_sdk.exception import ValidioError
 from validio_sdk.resource._serde import (
     IGNORE_CHANGES_FIELD_NAME,
     NODE_TYPE_FIELD_NAME,
+    SECRET_VALUE_FIXME_COMMENT,
     _import_value_repr,
 )
 
 if TYPE_CHECKING:
     from validio_sdk.code._import import ImportContext
 
+"""
+When we descend into nested objects, we set a limit on how deep we go.
+Otherwise, in a bad manifest configuration or due to a bug in our code, we
+could enter a cycle.
+"""
+MAX_RESOURCE_DEPTH = 15
+
 
 class Diffable(ABC):
     """
@@ -44,7 +53,7 @@ class Diffable(ABC):
     @abstractmethod
     def _nested_objects(
         self,
-    ) -> dict[str, Optional["Diffable | list[Diffable]"] | None]:
+    ) -> dict[str, "Diffable | list[Diffable] | None"]:
         """Returns any nested objects contained within this object.
 
         Nested objects will be diff-ed recursively.
@@ -59,6 +68,25 @@ class Diffable(ABC):
         """Returns any fields on the object that can should not be diffed."""
         return set({})
 
+    def _has_secret_fields(self, curr_depth: int) -> bool:
+        if curr_depth > MAX_RESOURCE_DEPTH:
+            raise ValidioError(
+                "BUG: max recursion depth exceeded while looking for secrets"
+            )
+
+        if self._secret_fields():
+            return True
+
+        for nested in self._nested_objects().values():
+            if isinstance(nested, list):
+                for n in nested:
+                    if n._has_secret_fields(curr_depth=curr_depth + 1):
+                        return True
+            elif nested and nested._has_secret_fields(curr_depth + 1):
+                return True
+
+        return False
+
     def _all_fields(self) -> set[str]:
         """Return all fields of the resource."""
         return {
@@ -83,6 +111,7 @@ class Diffable(ABC):
         skip_fields: set[str] | None = None,
     ) -> str:
         params = list(inits or [])
+        secret_fields = self._secret_fields()
 
         for f in list(inspect.signature(self.__class__).parameters):
             # If the field is already provided as an init arg then skip,
@@ -100,7 +129,7 @@ class Diffable(ABC):
                         indent_level=indent_level + 1,
                         import_ctx=import_ctx,
                     ),
-                    None,
+                    SECRET_VALUE_FIXME_COMMENT if f in secret_fields else None,
                 )
             )
 
@@ -131,6 +160,7 @@ class Diffable(ABC):
 
         line_indent = "\n" + (" " * self._num_ident_spaces(indent_level + 1))
         import_args = []
+
         for field, arg, comment in sorted_params:
             comment_str = "" if not comment else f" # {comment}"
             import_args.append(f"{field}={arg},{comment_str}")

{validio_sdk-7.0.0 → validio_sdk-7.3.1}/validio_sdk/resource/_errors.py

@@ -1,8 +1,4 @@
-from validio_sdk.exception import ValidioError
-
-
-class ManifestConfigurationError(ValidioError):
-    """Raised when there is an invalid configuration in the manifest."""
+from validio_sdk.exception import ManifestConfigurationError
 
 
 def updated_resource_type_mismatch_exception(

{validio_sdk-7.0.0 → validio_sdk-7.3.1}/validio_sdk/resource/_resource.py

@@ -13,7 +13,7 @@ from camel_converter import to_camel, to_snake
 import validio_sdk
 from validio_sdk._api.api import APIClient, execute_mutation
 from validio_sdk.client import Session
-from validio_sdk.exception import ValidioError
+from validio_sdk.exception import ValidioError, ValidioResourceError
 from validio_sdk.resource._diffable import (
     ApiSecretChangeNestedResource,
     Diffable,
@@ -27,6 +27,7 @@ from validio_sdk.resource._serde import (
     _import_value_repr,
     without_skipped_internal_fields,
 )
+from validio_sdk.resource._util import _sanitized_error_str
 
 if TYPE_CHECKING:
     from validio_sdk.code._import import ImportContext
@@ -281,19 +282,13 @@ class Resource(Diffable):
 
     def _must_id(self) -> str:
         if self._id.value is None:
-            raise ValidioError(
-                f"resource {self.__class__.__name__}(name={self.name}) "
-                "has unresolved ID"
-            )
+            raise ValidioResourceError(self, "has unresolved ID")
 
         return self._id.value
 
     def _must_namespace(self) -> str:
         if self._namespace is None:
-            raise ValidioError(
-                f"resource {self.__class__.__name__}(name={self.name}) "
-                "has unresolved namespace"
-            )
+            raise ValidioResourceError(self, "has unresolved namespace")
 
         return self._namespace
 
@@ -365,14 +360,12 @@ class Resource(Diffable):
     def _api_update_arguments(self) -> dict[str, str]:
         return {"input": f"{self.__class__.__name__}UpdateInput!"}
 
-    def _api_delete_arguments(self) -> dict[str, str]:
-        return {"ids": f"[{self.resource_class_name()}Id!]!"}
-
     async def _api_create(
         self,
         namespace: str,
         ctx: "DiffContext",
         session: Session,
+        show_secrets: bool,
     ) -> str:
         """
         Create the resource, and resolve's the current instance with
@@ -381,14 +374,18 @@ class Resource(Diffable):
         if self.has_user_defined_name() and not re.match(
             r"^[a-z0-9_.-]{2,251}$", self.name, re.IGNORECASE
         ):
-            raise ValidioError(
-                f"invalid resource name '{self.name}': must be 2-253 "
-                "characters containing only a-z, A-Z, 0-9, _, - or ."
+            raise ValidioResourceError(
+                self,
+                "invalid resource name, must be 2-253 "
+                "characters containing only a-z, A-Z, 0-9, _, - or .",
             )
 
         create_input = self._api_create_input(namespace, ctx)
         payload = await self._api_create_or_update(
-            "create", create_input, session=session
+            "create",
+            create_input,
+            session=session,
+            show_secrets=show_secrets,
         )
 
         id_ = payload["id"]
@@ -401,16 +398,23 @@ class Resource(Diffable):
         namespace: str,
         ctx: "DiffContext",
         session: Session,
+        show_secrets: bool,
     ) -> None:
         """Perform api call to update the resource."""
         update_input = self._api_update_input(namespace, ctx)
-        await self._api_create_or_update("update", update_input, session=session)
+        await self._api_create_or_update(
+            "update",
+            update_input,
+            session=session,
+            show_secrets=show_secrets,
+        )
 
     async def _api_create_or_update(
         self,
         verb: str,
         api_input: Any | None,
         session: Session,
+        show_secrets: bool,
     ) -> Any:
         if verb == "create":
             method_name = self._api_create_method_name()
@@ -421,14 +425,23 @@ class Resource(Diffable):
 
         response_field = self._api_create_response_field_name()
 
-        response = await execute_mutation(
-            session,
-            method_name,
-            arguments,
-            api_input,
-            response_field,
-            returns="id",
-        )
+        # We catch and re-throw any error with the resource context.
+        try:
+            response = await execute_mutation(
+                session,
+                method_name,
+                arguments,
+                api_input,
+                response_field,
+                returns="id",
+            )
+        except Exception as e:
+            if self._has_secret_fields(curr_depth=1):
+                error = _sanitized_error_str(e, show_secrets)
+            else:
+                error = str(e)
+
+            raise ValidioResourceError(self, error)
 
         return self._check_graphql_response(
             response=response,
@@ -444,23 +457,19 @@ class Resource(Diffable):
     ) -> Any:
         errors = response.get("errors")
         if errors:
-            raise ValidioError(
-                f"operation '{method_name}' failed for "
-                f"resource {self.__class__.__name__}(name={self.name}): "
-                f"{errors}"
+            raise ValidioResourceError(
+                self, f"operation '{method_name}' failed: {errors}"
             )
 
         if response_field is None:
             return None
 
         if response_field not in response:
-            raise Exception(f"Unexpected response: {response}")
+            raise ValidioResourceError(self, f"Unexpected response: {response}")
 
         if not response.get(response_field):
-            raise ValidioError(
-                f"operation '{method_name}' failed for '"
-                f"resource {self.__class__.__name__}(name={self.name}): '"
-                "missing response body"
+            raise ValidioResourceError(
+                self, f"operation '{method_name}' failed: missing response body"
             )
 
         return response[response_field]
@@ -489,14 +498,6 @@ class Resource(Diffable):
         """
         return _api_update_input_params(self)
 
-    def _api_delete_input(self) -> Any:
-        """
-        Returns the graphql input(s) to delete this resource. Most APIs do bulk
-        deletes so we pass our own ID as a list but not all resources work this
-        way.
-        """
-        return {"ids": [self._must_id()]}
-
     def _import_str(
         self,
         indent_level: int,