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

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

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

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

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

@@ -453,6 +453,22 @@ async def get_sources(
           schedule
         }
       }
+      ... on MsSqlServerSource {
+        config {
+          database
+          schema
+          table
+          schedule
+        }
+      }
+      ... on OracleSource {
+        config {
+          database
+          schema
+          table
+          schedule
+        }
+      }
       ... on PostgreSqlSource {
         config {
           database
@@ -992,6 +1008,37 @@ async def get_credentials(
         }
         enableCatalog
       }
+      ... on MsSqlServerCredential {
+        config {
+          host
+          port
+          database
+          auth {
+            __typename
+            ... on MsSqlServerCredentialEntraId {
+              clientId
+            }
+            ... on MsSqlServerCredentialUserPassword {
+              user
+            }
+          }
+        }
+        enableCatalog
+      }
+      ... on OracleCredential {
+        config {
+          host
+          port
+          databaseRequired: database
+          auth {
+            __typename
+            ... on OracleCredentialUserPassword {
+              user
+            }
+          }
+        }
+        enableCatalog
+      }
       ... on PostgreSqlCredential {
         config {
           host
@@ -1117,7 +1164,13 @@ async def get_credentials(
         result = [result]
 
     for i, credential in enumerate(result):
-        _replace_aliases(credential.get("config", {}), [("powerBiAuth", "auth")])
+        _replace_aliases(
+            credential.get("config", {}),
+            [
+                ("powerBiAuth", "auth"),
+                ("databaseRequired", "database"),
+            ],
+        )
         result[i] = credential
 
     return result[0] if return_first else result
@@ -2523,6 +2576,7 @@ async def apply_source_action(
             result = {f"source{action.value}": {"errors": e.errors}}
         else:
             result = {f"source{action.value}": {"errors": [{"message": str(e)}]}}
+
     return result[f"source{action.value}"]
 
 

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

@@ -1,7 +1,5 @@
 import asyncio
-import copy
 import dataclasses
-import re
 import typing
 from dataclasses import dataclass
 from typing import (
@@ -9,7 +7,6 @@ from typing import (
     Any,
     Optional,
     TypeVar,
-    cast,
 )
 
 from camel_converter import to_snake
@@ -18,7 +15,6 @@ from gql.transport.exceptions import TransportQueryError
 from validio_sdk._api.api import secrets_changed_by_field, split_to_n_chunks
 from validio_sdk.client import Session
 from validio_sdk.exception import ValidioBugError, ValidioError
-from validio_sdk.resource._diff_util import must_find_source
 from validio_sdk.resource._diffable import (
     ApiSecretChangeNestedResource,
     Diffable,
@@ -28,7 +24,6 @@ from validio_sdk.resource._errors import (
     max_resource_depth_exceeded,
     updated_resource_type_mismatch_exception,
 )
-from validio_sdk.resource._field_selector import SelectorWithFieldName
 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
@@ -179,51 +174,29 @@ async def diff_resource_graph(
     server_ctx: DiffContext,
     import_mode: bool = False,
 ) -> GraphDiff:
-    partial_diff = _diff_resource_graph(
+    graph_diff = _diff_resource_graph(
         namespace=namespace,
         manifest_ctx=manifest_ctx,
         server_ctx=server_ctx,
-        for_validators=False,
         import_mode=import_mode,
     )
 
-    # Enrich resource_graph. We do this before expanding field selectors
-    # because the latter depends on the schema for all sources being present.
     await enrich_resource_graph(
         manifest_ctx=manifest_ctx,
         server_ctx=server_ctx,
-        graph=partial_diff,
+        graph=graph_diff,
         session=session,
         schema_reinference=schema_reinference,
         show_secrets=show_secrets,
     )
 
-    # Expand field selector for validators.
-    expand_validator_field_selectors(manifest_ctx)
-
-    # Now after expanding field selectors, we can diff validators.
-    validators_diff = _diff_resource_graph(
-        namespace=namespace,
-        manifest_ctx=manifest_ctx,
-        server_ctx=server_ctx,
-        for_validators=True,
-        import_mode=import_mode,
-    )
-
-    final_diff = partial_diff
-    final_diff.to_create.validators = validators_diff.to_create.validators
-    final_diff.to_update.validators = validators_diff.to_update.validators
-    final_diff.to_delete.validators = validators_diff.to_delete.validators
-    for k, v in validators_diff.replacement_ctx.validators.items():
-        final_diff.replacement_ctx.validators[k] = v
-
     _compute_replacements(
         manifest_ctx=manifest_ctx,
         server_ctx=server_ctx,
-        graph_diff=final_diff,
+        graph_diff=graph_diff,
     )
 
-    return final_diff
+    return graph_diff
 
 
 def _compute_replacements(
@@ -406,85 +379,10 @@ def _visit_resource_to_cascade_update(
     )
 
 
-def expand_validator_field_selectors(manifest_ctx: DiffContext) -> None:
-    for name in list(manifest_ctx.validators.keys()):
-        template = manifest_ctx.validators[name]
-
-        source_field_selector: SelectorWithFieldName | None = getattr(
-            template, "_field_selector", None
-        )
-        reference_field_selector: dict[str, str] | None = getattr(
-            template, "_reference_field_selector", None
-        )
-        filter_field_selector: SelectorWithFieldName | None = (
-            getattr(template.filter, "_field_selector", None)
-            if template.filter
-            else None
-        )
-
-        if source_field_selector:
-            field_selector = source_field_selector
-        elif filter_field_selector:
-            field_selector = filter_field_selector
-        else:
-            continue
-
-        source = must_find_source(manifest_ctx, template.source_name)
-        if source.jtd_schema is None:
-            # If we have no schema then it means we're doing a diff where the
-            # source's credential has not yet been created - which means we can't
-            # do schema inference. As a result, we can't yet expand the selector.
-            continue
-
-        if source_field_selector:
-            delattr(template, "_field_selector")
-        if reference_field_selector:
-            delattr(template, "_reference_field_selector")
-        if filter_field_selector:
-            delattr(template.filter, "_field_selector")
-
-        # Remove the placeholder validator.
-        del manifest_ctx.validators[name]
-
-        fields = field_selector.field_selector._get_matching_fields(
-            cast(Any, source.jtd_schema)
-        )
-
-        # We don't want to deep copy the entire resource graph
-        resource_graph = template._resource_graph
-        template._resource_graph = None  # type: ignore
-        for field in fields:
-            validator = copy.deepcopy(template)
-            validator._resource_graph = resource_graph
-
-            # We must obey to our own naming convention so we drop everything
-            # that's not valid.
-            resource_name = validator.name % {"field": field}
-            resource_name = resource_name.replace(" ", "_").lower()
-            resource_name = re.sub(r"[^a-z0-9_.-]", "_", resource_name)
-            validator.name = resource_name
-
-            if source_field_selector:
-                setattr(validator, field_selector.field_name, field)
-
-            if reference_field_selector:
-                setattr(validator, reference_field_selector["field_name"], field)
-
-            if filter_field_selector:
-                setattr(
-                    validator.filter,
-                    field_selector.field_name,
-                    field,
-                )
-
-            manifest_ctx.validators[resource_name] = validator
-
-
 def _diff_resource_graph(
     namespace: str,
     manifest_ctx: DiffContext,
     server_ctx: DiffContext,
-    for_validators: bool | None = None,
     import_mode: bool = False,
 ) -> GraphDiff:
     # Backwards compatibility: Here we note the filters that
@@ -506,14 +404,6 @@ def _diff_resource_graph(
         for field in fields:
             if field in CREATE_ONLY_RESOURCES:
                 continue
-
-            include_diff = (
-                True
-                if for_validators is None
-                else (field == "validators") == for_validators
-            )
-            if not include_diff:
-                continue
             diff_by_resource[field] = diff_fn(
                 namespace, getattr(manifest_ctx, field), getattr(server_ctx, field)
             )
@@ -974,7 +864,7 @@ async def check_for_source_schema_changes(
                 manifest_source, server_source
             )
 
-        # Ensure the source has a schema in case we need it in a field selector.
+        # Ensure the source has a schema in case we need it later on.
         if manifest_source.jtd_schema is None:
             manifest_source.jtd_schema = server_source.jtd_schema
 

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

@@ -10,16 +10,13 @@ from gql.transport.exceptions import TransportQueryError
 import validio_sdk
 from validio_sdk._api import api
 from validio_sdk.client import Session
-from validio_sdk.client.client import Client
 from validio_sdk.code._progress import ProgressBar
-from validio_sdk.config import Config, ValidioConfig
 from validio_sdk.exception import ValidioBugError, ValidioError
 from validio_sdk.resource._diff import (
     DiffContext,
     GraphDiff,
     ResourceUpdate,
     ResourceUpdates,
-    expand_validator_field_selectors,
     infer_schemas,
 )
 from validio_sdk.resource._diff_util import (
@@ -59,6 +56,13 @@ from validio_sdk.resource.credentials import (
     LookerCredential,
     MsPowerBiCredential,
     MsPowerBiCredentialAuthEntraId,
+    MsSqlServerCredential,
+    MsSqlServerCredentialAuth,
+    MsSqlServerCredentialEntraId,
+    MsSqlServerCredentialUserPassword,
+    OracleCredential,
+    OracleCredentialAuth,
+    OracleCredentialUserPassword,
     PostgreSqlCredential,
     SigmaCredential,
     SnowflakeCredential,
@@ -314,12 +318,12 @@ async def load_credentials(
                 auth_type = c["config"]["auth"]["__typename"]
 
                 if auth_type == "SnowflakeCredentialUserPassword":
-                    auth: SnowflakeCredentialAuth = SnowflakeCredentialUserPassword(
+                    sf_auth: SnowflakeCredentialAuth = SnowflakeCredentialUserPassword(
                         user=c["config"]["auth"]["user"],
                         password="UNSET",
                     )
                 elif auth_type == "SnowflakeCredentialKeyPair":
-                    auth = SnowflakeCredentialKeyPair(
+                    sf_auth = SnowflakeCredentialKeyPair(
                         user=c["config"]["auth"]["user"],
                         private_key="UNSET",
                         private_key_passphrase="UNSET",
@@ -330,13 +334,64 @@ async def load_credentials(
                 credential = SnowflakeCredential(
                     name=name,
                     account=c["config"]["account"],
-                    auth=auth,
+                    auth=sf_auth,
                     warehouse=c["config"]["warehouse"],
                     role=c["config"]["role"],
                     display_name=display_name,
                     enable_catalog=c["enableCatalog"],
                     __internal__=g,
                 )
+            case "MsSqlServerCredential":
+                auth_type = c["config"]["auth"]["__typename"]
+
+                if auth_type == "MsSqlServerCredentialUserPassword":
+                    ms_auth: MsSqlServerCredentialAuth = (
+                        MsSqlServerCredentialUserPassword(
+                            user=c["config"]["auth"]["user"],
+                            password="UNSET",
+                        )
+                    )
+                elif auth_type == "MsSqlServerCredentialEntraId":
+                    ms_auth = MsSqlServerCredentialEntraId(
+                        client_id=c["config"]["auth"]["clientId"],
+                        client_secret="UNSET",
+                    )
+                else:
+                    raise ValidioBugError(
+                        f"Unknown MsSqlServer auth type: '{auth_type}'"
+                    )
+
+                credential = MsSqlServerCredential(
+                    name=name,
+                    host=c["config"]["host"],
+                    port=c["config"]["port"],
+                    database=c["config"]["database"],
+                    auth=ms_auth,
+                    display_name=display_name,
+                    enable_catalog=c["enableCatalog"],
+                    __internal__=g,
+                )
+            case "OracleCredential":
+                auth_type = c["config"]["auth"]["__typename"]
+
+                if auth_type == "OracleCredentialUserPassword":
+                    oracle_auth: OracleCredentialAuth = OracleCredentialUserPassword(
+                        user=c["config"]["auth"]["user"],
+                        password="UNSET",
+                    )
+                else:
+                    raise ValidioBugError(f"Unknown Oracle auth type: '{auth_type}'")
+
+                credential = OracleCredential(
+                    name=name,
+                    host=c["config"]["host"],
+                    port=c["config"]["port"],
+                    database=c["config"]["database"],
+                    auth=oracle_auth,
+                    display_name=display_name,
+                    enable_catalog=c["enableCatalog"],
+                    __internal__=g,
+                )
             case "KafkaSslCredential":
                 credential = KafkaSslCredential(
                     name=name,
@@ -839,10 +894,6 @@ async def apply_updates_on_server(
         dry_run_sql=dry_run_sql,
     )
 
-    # Now we should have all source schemas available. We can expand
-    # field selectors.
-    expand_validator_field_selectors(ctx)
-
     # Then apply updates.
     await apply_updates(
         namespace=namespace,

{validio_sdk-5.2.0 → validio_sdk-5.3.0}/validio_sdk/resource/credentials.py

@@ -713,8 +713,6 @@ class SnowflakeCredential(Credential):
 
         :param name: Unique resource name assigned to the credential
         :param account: Snowflake account identifier.
-        :param user: Deprecated, use auth instead.
-        :param password: Deprecated, use auth instead.
         :param auth: Credentials to use for authentication.
         :param warehouse: Snowflake virtual warehouse to use to run queries.
         :param role: Snowflake role to assume when running queries.
@@ -1308,6 +1306,249 @@ class AzureSynapseSqlCredential(AzureSynapseCredential):
         return {"password"}
 
 
+class MsSqlServerCredentialUserPassword(ApiSecretChangeNestedResource):
+    """MsSql-compatible credential via user-password auth."""
+
+    def __init__(
+        self,
+        user: str,
+        password: str,
+    ):
+        """
+        Constructor.
+
+        :param user: User name.
+        :param password: Password.
+        """
+        self.user = user
+        self.password = password
+
+    def _api_variant_name(self) -> str:
+        return "userPassword"
+
+    def _immutable_fields(self) -> set[str]:
+        return set({})
+
+    def _mutable_fields(self) -> set[str]:
+        return {"user"}
+
+    def _secret_fields(self) -> set[str]:
+        return {"password"}
+
+    def _nested_objects(
+        self,
+    ) -> dict[str, Optional["Diffable | list[Diffable]"] | None]:
+        return {}
+
+
+class MsSqlServerCredentialEntraId(ApiSecretChangeNestedResource):
+    """MsSql-compatible credential via entra-id auth."""
+
+    def __init__(
+        self,
+        client_id: str,
+        client_secret: str,
+    ):
+        """
+        Constructor.
+
+        :param client_id: The client ID of your Azure registered application.
+        :param client_secret: The client secret of your Azure registered application.
+        """
+        self.client_id = client_id
+        self.client_secret = client_secret
+
+    def _api_variant_name(self) -> str:
+        return "entraId"
+
+    def _immutable_fields(self) -> set[str]:
+        return set({})
+
+    def _mutable_fields(self) -> set[str]:
+        return {"client_id"}
+
+    def _secret_fields(self) -> set[str]:
+        return {"client_secret"}
+
+    def _nested_objects(
+        self,
+    ) -> dict[str, Optional["Diffable | list[Diffable]"] | None]:
+        return {}
+
+
+MsSqlServerCredentialAuth = Union[
+    MsSqlServerCredentialUserPassword, MsSqlServerCredentialEntraId
+]
+
+
+class MsSqlServerCredential(Credential):
+    """Credential to connect to a Microsoft Sql Server warehouse."""
+
+    def __init__(
+        self,
+        name: str,
+        host: str,
+        port: int,
+        auth: MsSqlServerCredentialAuth,
+        database: str | None = None,
+        enable_catalog: bool = False,
+        display_name: str | None = None,
+        ignore_changes: bool = False,
+        __internal__: ResourceGraph | None = None,
+    ):
+        """
+        Constructor.
+
+        :param name: Unique resource name assigned to the credential
+        :param host: Host address of the server.
+        :param port: Port number of the server.
+        :param auth: Credentials to use for authentication.
+        :param database: Name of the database to connect to
+        :param enable_catalog: If set to true, this credential will
+            be used to fetch catalog information.
+        :param display_name: Human-readable name for the credential. This name is
+          visible in the UI and does not need to be unique.
+        :param ignore_changes: If set to true, changes to the resource will be ignored.
+        """
+        super().__init__(
+            name=name,
+            display_name=display_name,
+            ignore_changes=ignore_changes,
+            __internal__=__internal__,
+        )
+
+        self.host = host
+        self.port = port
+        self.auth = auth
+        self.database = database
+        self.enable_catalog = enable_catalog
+
+    def _immutable_fields(self) -> set[str]:
+        return set({})
+
+    def _mutable_fields(self) -> set[str]:
+        return {
+            *super()._mutable_fields(),
+            *{
+                "host",
+                "port",
+                "database",
+                "enable_catalog",
+            },
+        }
+
+    def _secret_fields(self) -> set[str]:
+        return set()
+
+    def _nested_objects(
+        self,
+    ) -> dict[str, Optional["Diffable | list[Diffable]"] | None]:
+        return {"auth": self.auth}
+
+
+class OracleCredentialUserPassword(ApiSecretChangeNestedResource):
+    """Oracle credential via user-password auth."""
+
+    def __init__(
+        self,
+        user: str,
+        password: str,
+    ):
+        """
+        Constructor.
+
+        :param user: User name.
+        :param password: Password.
+        """
+        self.user = user
+        self.password = password
+
+    def _api_variant_name(self) -> str:
+        return "userPassword"
+
+    def _immutable_fields(self) -> set[str]:
+        return set({})
+
+    def _mutable_fields(self) -> set[str]:
+        return {"user"}
+
+    def _secret_fields(self) -> set[str]:
+        return {"password"}
+
+    def _nested_objects(
+        self,
+    ) -> dict[str, Optional["Diffable | list[Diffable]"] | None]:
+        return {}
+
+
+OracleCredentialAuth = Union[OracleCredentialUserPassword]
+
+
+class OracleCredential(Credential):
+    """Credential to connect to an Oracle database."""
+
+    def __init__(
+        self,
+        name: str,
+        host: str,
+        port: int,
+        database: str,
+        auth: OracleCredentialAuth,
+        enable_catalog: bool = False,
+        display_name: str | None = None,
+        ignore_changes: bool = False,
+        __internal__: ResourceGraph | None = None,
+    ):
+        """
+        Constructor.
+
+        :param name: Unique resource name assigned to the credential
+        :param host: Host address of the server.
+        :param port: Port number of the server.
+        :param auth: Credentials to use for authentication.
+        :param database: Name of the database to connect to
+        :param enable_catalog: If set to true, this credential will
+            be used to fetch catalog information.
+        :param display_name: Human-readable name for the credential. This name is
+          visible in the UI and does not need to be unique.
+        :param ignore_changes: If set to true, changes to the resource will be ignored.
+        """
+        super().__init__(
+            name=name,
+            display_name=display_name,
+            ignore_changes=ignore_changes,
+            __internal__=__internal__,
+        )
+
+        self.host = host
+        self.port = port
+        self.database = database
+        self.auth = auth
+        self.enable_catalog = enable_catalog
+
+    def _immutable_fields(self) -> set[str]:
+        return set({})
+
+    def _mutable_fields(self) -> set[str]:
+        return {
+            *super()._mutable_fields(),
+            *{
+                "host",
+                "port",
+                "database",
+                "enable_catalog",
+            },
+        }
+
+    def _secret_fields(self) -> set[str]:
+        return set()
+
+    def _nested_objects(
+        self,
+    ) -> dict[str, Optional["Diffable | list[Diffable]"] | None]:
+        return {"auth": self.auth}
+
+
 class TableauConnectedAppCredential(Credential):
     """
     A credential resource that can be used to connect