validio-sdk 0.0.1__tar.gz → 0.2.0__tar.gz

validio_sdk-0.2.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.1
+Name: validio-sdk
+Version: 0.2.0
+Summary: SDK to interact with the Validio platform
+Home-page: https://validio.io/
+License: Apache-2.0
+Author: Validio
+Author-email: support@validio.io
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: camel-converter (>=3.0.0,<4.0.0)
+Requires-Dist: httpx (>=0.24.0,<0.25.0)
+Requires-Dist: platformdirs (>=3.5.0,<4.0.0)
+Requires-Dist: pydantic (>=1.10.7,<2.0.0)
+Project-URL: Documentation, https://docs.validio.io/
+Description-Content-Type: text/markdown
+
+# validio-sdk
+
+This SDK is maintained by [Validio] to enable users to integrate with the Validio platform in a programmatic way.
+
+See the [SDK docs] for more information.
+
+## Installation
+
+```sh
+pip install validio-sdk
+```
+
+  [Validio]: https://validio.io
+  [SDK docs]: https://dev.validio.io/sdk-docs
+

validio_sdk-0.2.0/README_PUBLIC.md

@@ -0,0 +1,14 @@
+# validio-sdk
+
+This SDK is maintained by [Validio] to enable users to integrate with the Validio platform in a programmatic way.
+
+See the [SDK docs] for more information.
+
+## Installation
+
+```sh
+pip install validio-sdk
+```
+
+  [Validio]: https://validio.io
+  [SDK docs]: https://dev.validio.io/sdk-docs

validio_sdk-0.2.0/pyproject.toml

@@ -0,0 +1,169 @@
+[tool.poetry]
+name = "validio-sdk"
+version = "0.2.0"
+description = "SDK to interact with the Validio platform"
+authors = ["Validio <support@validio.io>"]
+license = "Apache-2.0"
+homepage = "https://validio.io/"
+documentation = "https://docs.validio.io/"
+packages = [{ include = "validio_sdk" }]
+exclude = ["./validio_sdk/bin/pull_graphql.py", "./schema/**", "./plugins/**", "./examples/**"]
+readme = "README_PUBLIC.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+camel-converter = "^3.0.0"
+httpx = "^0.24.0"
+platformdirs = "^3.5.0"
+pydantic = "^1.10.7"
+
+[tool.poetry.group.dev.dependencies]
+black = "^23.3.0"
+licensecheck = "^2023.1.1"
+mypy = "^1.2.0"
+pytest = "^7.3.1"
+pytest-asyncio = "^0.21.0"
+ruff = "^0.0.263"
+sphinx = "^6.2.1" # We use <7 because most themes only work with that.
+sphinx-rtd-theme = "^1.2.1"
+ariadne-codegen = "^0.7.1"
+tqdm = "^4.65.0"
+types-tqdm = "^4.65.0.1"
+python-dotenv = "^1.0.0"
+
+[tool.ariadne-codegen]
+queries_path = "./schema/operations/"
+schema_path = "./schema/schema.graphql"
+target_package_path = "./validio_sdk/"
+include_comments = false
+plugins = [
+    "ariadne_codegen.contrib.shorter_results.ShorterResultsPlugin",
+    "plugins.schema_translation.SchemaFieldTranslationPlugin",
+]
+
+[tool.ariadne-codegen.scalars.CredentialId]
+type = "validio_sdk.scalars.CredentialId"
+
+[tool.ariadne-codegen.scalars.DestinationId]
+type = "validio_sdk.scalars.DestinationId"
+
+[tool.ariadne-codegen.scalars.SegmentationId]
+type = "validio_sdk.scalars.SegmentationId"
+
+[tool.ariadne-codegen.scalars.SourceId]
+type = "validio_sdk.scalars.SourceId"
+
+[tool.ariadne-codegen.scalars.ValidatorId]
+type = "validio_sdk.scalars.ValidatorId"
+
+[tool.ariadne-codegen.scalars.WindowId]
+type = "validio_sdk.scalars.WindowId"
+
+[tool.ariadne-codegen.scalars.DateTime]
+type = "datetime.datetime"
+
+[tool.ariadne-codegen.scalars.JsonPointer]
+type = "validio_sdk.scalars.JsonPointer"
+
+# The JsonFilterExpression is a scalar but a union in python representation so
+# we need to add a map between all our union types.
+[tool.ariadne-codegen.scalars.JsonFilterExpression]
+type = "validio_sdk.scalars.JsonFilterExpression"
+
+[tool.ariadne-codegen.scalars.EnumFilter]
+type = "validio_sdk.scalars.EnumFilter"
+serialize = "validio_sdk.scalars.serialize_json_filter_expression"
+
+[tool.ariadne-codegen.scalars.NullFilter]
+type = "validio_sdk.scalars.NullFilter"
+serialize = "validio_sdk.scalars.serialize_json_filter_expression"
+
+[tool.ariadne-codegen.scalars.StringFilter]
+type = "validio_sdk.scalars.StringFilter"
+serialize = "validio_sdk.scalars.serialize_json_filter_expression"
+
+[tool.ariadne-codegen.scalars.ThresholdFilter]
+type = "validio_sdk.scalars.ThresholdFilter"
+serialize = "validio_sdk.scalars.serialize_json_filter_expression"
+
+[tool.ariadne-codegen.scalars.JsonTypeDefinition]
+type = "validio_sdk.scalars.JsonTypeDefinition"
+
+[tool.ariadne-codegen.scalars.CronExpression]
+type = "validio_sdk.scalars.CronExpression"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+example-client = "examples.client:run"
+example-config = "examples.use_config:run"
+pull-graphql = "validio_sdk.bin.pull_graphql:run"
+
+[tool.ruff]
+fix = true
+
+exclude = [
+    # Generated code
+    "validio_sdk/graphql_client/*",
+    # Docs (mostly generated)
+    "docs/*",
+]
+
+select = [
+    "ARG", # flake8-unused-argument
+    "C4", # flake8-comprehension
+    "D", # pydocstyle
+    "E", # pycodestyle error
+    "F", # pyflakes
+    "I", # isort
+    "N", # pep8-naming
+    "PIE", # flake8-pie
+    "PL", # pylint
+    "PT", # flake8-pytest-style
+    "PTH", # flake8-use-pathlib
+    "RET", # flake8-ret
+    "RUF", # ruff specific rules
+    "SIM", # flake8-simplify
+    "UP", # pyupgrade
+    "W", # pycodestyle warning
+]
+
+ignore = [
+    "D203", # `one-blank-line-before-class` Incompatible with D211
+    "D212", # `multi-line-summary-first-line` Incompatible with D213
+    "D205", #  blank line required between summary line and description
+    "PLR0913", # Too many arguments to function call (named arguments take care of this)
+]
+
+[tool.ruff.per-file-ignores]
+"__init__.py" = [
+    # We don't need docstrings in __init__
+    "D104",
+]
+
+# Raw error handling for testing purposes
+# No need for documentation in binaries, examples or generated code
+"*/bin/*.py" = ["D"]
+"examples/*.py" = ["D", "E"]
+"*/graphql_client/*.py" = ["D"]
+"*/tests/*.py" = ["D"]
+
+[tool.ruff.pydocstyle]
+convention = "google"
+
+[tool.black]
+preview = true
+
+# For some reason this is not a list but a regex
+extend-exclude = """
+    (
+        # Generated code
+        validio_sdk/graphql_client/*
+    )
+"""
+
+[tool.mypy]
+ignore_missing_imports = true
+plugins = "pydantic.mypy"

validio_sdk-0.2.0/validio_sdk/__init__.py

@@ -0,0 +1,27 @@
+from validio_sdk.resource.filters import (
+    BooleanFilter,
+    BooleanFilterOperator,
+    EnumFilter,
+    EnumFilterOperator,
+    NullFilter,
+    NullFilterOperator,
+    StringFilter,
+    StringFilterOperator,
+    ThresholdFilter,
+    ThresholdFilterOperator,
+)
+from validio_sdk.util import load_jtd_schema
+
+__all__ = [
+    "BooleanFilter",
+    "BooleanFilterOperator",
+    "EnumFilter",
+    "EnumFilterOperator",
+    "NullFilter",
+    "NullFilterOperator",
+    "StringFilter",
+    "StringFilterOperator",
+    "ThresholdFilter",
+    "ThresholdFilterOperator",
+    "load_jtd_schema",
+]

validio_sdk-0.2.0/validio_sdk/code/apply.py

@@ -0,0 +1,17 @@
+"""Apply command implementation."""
+
+from validio_sdk.resource._diff import GraphDiff
+from validio_sdk.resource._resource import DiffContext
+from validio_sdk.resource._server_resources import apply_updates_on_server
+from validio_sdk.validio_client import ValidioAPIClient
+
+
+async def apply(
+    namespace: str,
+    client: ValidioAPIClient,
+    ctx: DiffContext,
+    diff: GraphDiff,
+    show_secrets: bool,
+):
+    """Applies the provided diff operations on the server."""
+    await apply_updates_on_server(namespace, ctx, diff, client, show_secrets)

validio_sdk-0.2.0/validio_sdk/code/plan.py

@@ -0,0 +1,145 @@
+"""Plan command implementation."""
+
+import json
+import os
+import pathlib
+import subprocess
+import sys
+from enum import Enum
+from typing import Any
+
+from validio_sdk.code import scaffold
+from validio_sdk.code.settings import dump_graph_var, graph_preamble_var
+from validio_sdk.graphql_client import GraphQLClientHttpError
+from validio_sdk.resource._diff import (
+    GraphDiff,
+    diff_resource_graph,
+)
+from validio_sdk.resource._resource import DiffContext, Resource, ResourceGraph
+from validio_sdk.resource._server_resources import load_resources
+from validio_sdk.resource._util import SourceSchemaReinference
+from validio_sdk.resource.credentials import Credential
+from validio_sdk.validio_client import ValidioAPIClient
+
+
+async def plan(
+    namespace: str,
+    client: ValidioAPIClient,
+    directory: pathlib.Path,
+    schema_reinference: SourceSchemaReinference,
+    destroy: bool,
+    no_capture: bool,
+    show_secrets: bool,
+) -> tuple[GraphDiff, DiffContext]:
+    """Computes a diff between the manifest program and the live server resources."""
+    try:
+        manifest_ctx = (
+            _get_manifest_graph(directory, no_capture) if not destroy else DiffContext()
+        )
+        server_ctx = await load_resources(namespace, client)
+
+        diff = await diff_resource_graph(
+            namespace=namespace,
+            client=client,
+            schema_reinference=schema_reinference,
+            show_secrets=show_secrets,
+            manifest_ctx=manifest_ctx,
+            server_ctx=server_ctx,
+        )
+
+        return diff, manifest_ctx
+    except GraphQLClientHttpError as e:
+        raise RuntimeError(f"API error: ({e.status_code}: {e.response.json()})")
+
+
+def _get_manifest_graph(directory: pathlib.Path, no_capture: bool) -> DiffContext:
+    """Runs the manifest program and captures its output into a ResourceGraph."""
+    process_env = os.environ.copy()
+    process_env[dump_graph_var] = "1"
+    child = subprocess.run(
+        ["python", directory / scaffold.main_file_name],
+        cwd=directory,
+        env=process_env,
+        capture_output=True,
+    )
+
+    if child.returncode != 0:
+        _dump_child_stderr(child)
+        sys.exit(child.returncode)
+
+    raw_output: str = child.stdout.decode("utf-8")
+    (_graph, ctx, captured_output) = _extract_resource_graph(raw_output, child)
+    if no_capture and captured_output:
+        print(captured_output)
+
+    return ctx
+
+
+def _dump_child_stderr(child: subprocess.CompletedProcess):
+    print(child.stderr.decode("unicode_escape"), file=sys.stderr)
+    print(
+        f"{scaffold.main_file_name} terminated with a non-zero exit code",
+        file=sys.stderr,
+    )
+
+
+# Parse the graph from the child program's output. Returns also any captured stdout
+# of the child program.
+def _extract_resource_graph(
+    raw_output: str,
+    child: subprocess.CompletedProcess,
+) -> tuple[ResourceGraph, DiffContext, str]:
+    preamble_start_idx: int = raw_output.find(graph_preamble_var)
+    if preamble_start_idx < 0:
+        return ResourceGraph(), DiffContext(), ""
+
+    std_output = raw_output[:preamble_start_idx]
+
+    graph_str = raw_output[preamble_start_idx + len(graph_preamble_var) :].strip()
+    if len(graph_str) == 0:
+        _dump_child_stderr(child)
+        raise RuntimeError(
+            "BUG(internal): missing resource graph from manifest program"
+        )
+
+    try:
+        graph_json = json.loads(graph_str)
+    except Exception as e:
+        # We wrap the error here, because otherwise the exception thrown by
+        # JSON parser can be cryptic if it lands in the terminal on its own.
+        raise RuntimeError(f"failed to load resource graph output JSON: {e}")
+
+    graph, ctx = ResourceGraph._decode(graph_json)
+    return graph, ctx, std_output
+
+
+def _create_resource_diff_object(
+    r: Resource | dict, show_secrets: bool, rewrites: dict[str, Any] | None = None
+) -> dict[str, object]:
+    if rewrites is None:
+        rewrites = {}
+
+    data = r.__dict__ if isinstance(r, Resource) else r
+
+    diff_object = {}
+    for k, v in data.items():
+        if k.startswith("_"):
+            continue
+
+        if k in rewrites:
+            diff_object[k] = rewrites[k]
+        elif isinstance(v, Resource | dict):
+            diff_object[k] = _create_resource_diff_object(v, show_secrets)
+        elif hasattr(v, "__dict__") and not isinstance(v, Enum):
+            diff_object[k] = _create_resource_diff_object(v.__dict__, show_secrets)
+        else:
+            diff_object[k] = v
+
+    # Mask any sensitive info if requested.
+    if not show_secrets and isinstance(r, Credential):
+        secret_fields = r._secret_fields()
+        if secret_fields:
+            for field in secret_fields:
+                diff_object[field] = "REDACTED"
+
+    return diff_object

validio_sdk-0.2.0/validio_sdk/code/scaffold.py

@@ -0,0 +1,56 @@
+"""Init command implementation."""
+
+import json
+import os
+import pathlib
+from dataclasses import dataclass
+
+settings_file_name: str = "validio.json"
+main_file_name: str = "main.py"
+
+
+@dataclass
+class ProjectSettings:
+    """Represents the settings for a project."""
+
+    namespace: str
+
+
+def _new_project(namespace: str, directory: pathlib.Path, force: bool):
+    _ensure_directory(directory, force)
+    _ensure_project_settings_file(directory, namespace)
+    _gen_main_py_file(directory)
+
+
+def _ensure_directory(p: pathlib.Path, force: bool):
+    if not p.exists():
+        pathlib.Path.mkdir(p)
+
+    if not p.is_dir():
+        raise RuntimeError(f"{p} is not a directory; rerun specifying a directory")
+
+    if not force and len(os.listdir(p)):
+        raise RuntimeError(
+            f"{p} is not empty; rerun in an empty directory, or use --force"
+        )
+
+
+def _ensure_project_settings_file(p: pathlib.Path, namespace: str):
+    with pathlib.Path.open(_project_settings_file_path(p), "w") as f:
+        print(
+            json.dumps(ProjectSettings(namespace=namespace).__dict__, indent=2), file=f
+        )
+
+
+def _read_project_settings(p: pathlib.Path) -> ProjectSettings:
+    with pathlib.Path.open(_project_settings_file_path(p)) as f:
+        return ProjectSettings(**json.load(f))
+
+
+def _project_settings_file_path(p: pathlib.Path) -> pathlib.Path:
+    return p / settings_file_name
+
+
+def _gen_main_py_file(p: pathlib.Path):
+    with pathlib.Path.open(p / main_file_name, "w") as f:
+        print("from validio_sdk.resource import credentials", file=f)

validio_sdk-0.2.0/validio_sdk/code/settings.py

@@ -0,0 +1,8 @@
+"""Contains shared constants."""
+
+# Flag to write out the resource graph on exit.
+dump_graph_var = "VALIDIO_DUMP_GRAPH"
+
+# Preamble says where the graph output starts from. Anything before that is
+# output belong to the program which will be captured.
+graph_preamble_var = "VALIDIO_CONFIG_GRAPH_PREAMBLE"

validio_sdk-0.2.0/validio_sdk/config.py

@@ -0,0 +1,198 @@
+"""Persistent configuration."""
+import json
+import os
+from pathlib import Path
+
+import platformdirs
+
+from validio_sdk.util import ClassJSONEncoder
+
+CONFIG_PATH_ENV = "VALIDIO_CONFIG_PATH"
+
+
+class ConfigNotFoundError(Exception):
+    """Exception when no configuration is found."""
+
+    def __init__(self):
+        """Construct the exception."""
+        super().__init__(
+            "No configuration file found. Run 'validio config' to create one"
+        )
+
+
+class ConfigInvalidError(Exception):
+    """Exception when the configuration file is invalid."""
+
+    def __init__(self):
+        """Construct the exception."""
+        super().__init__("Configuration file is invalid.")
+
+
+class ValidioConfig:
+    """Representation of configuration to use in the Validio system and SDK."""
+
+    def __init__(
+        self,
+        endpoint: str = "",
+        access_key: str = "",
+        access_secret: str = "",
+        default_namespace: str = "default",
+    ):
+        """
+        Constructor for `ValidioConfig`.
+
+        Will ensure we can construct an object with the exposed property
+        `access_secret`.
+        """
+        self.default_namespace = default_namespace
+        self.endpoint = endpoint
+        self.access_key = access_key
+        self._access_secret = access_secret
+
+    def asdict(self):
+        """
+        Return a dictionary representation of the class.
+
+        This is used from our `ClassJSONEncoder` to ensure we save JSON
+        representing the class with the external property names. By doing this
+        we can also ensure that we can serialize the config by passing the JSON
+        to the constructor.
+        """
+        return {
+            "default_namespace": self.default_namespace,
+            "endpoint": self.endpoint,
+            "access_key": self.access_key,
+            "access_secret": self._access_secret,
+        }
+
+    @staticmethod
+    def _none_or_hidden(maybe_value):
+        """
+        Represent a hidden value but be explicit if unset.
+
+        Will return fix length of asterisks for existing values but if no value
+        exist a single dash is returned.
+        """
+        return "-" if maybe_value is None else "*****"
+
+    @property
+    def access_secret(self):  # noqa: D102 No reason to document property.
+        return self._none_or_hidden(self._access_secret)
+
+    @access_secret.setter
+    def access_secret(self, value):
+        self._access_secret = value
+
+    def __repr__(self):
+        """
+        Representation of a `ValidioConfig`.
+
+        Will ensure we don't print sensitive information.
+        """
+        return (
+            f'{"Default namespace":<20} | {self.default_namespace}\n'
+            f'{"Endpoint":<20} | {self.endpoint}\n'
+            f'{"Access key":<20} | {self.access_key}\n'
+            f'{"Access secret":<20} | {self._none_or_hidden(self.access_secret)}\n'
+        )
+
+
+class Config:
+    """
+    Config management.
+
+    A class to work with configuration such as reading, writing and deleting.
+    """
+
+    def __init__(self, config_dir: Path | None = None):
+        """
+        Creates a new instance of `Config`.
+
+        :param config_dir: Optional directory where to put the config file. Will
+            default to system default set by `platformdirs`.
+
+
+        :returns: A `Config` instance.
+        """
+        if config_dir is None:
+            config_dir = default_config_dir()
+
+        self.config_path: Path = Path(config_dir, "config.json")
+        self.validio_config: ValidioConfig | None = None
+
+    def write(self, config: ValidioConfig):
+        """
+        Write the passed configuration to disk.
+
+        This will fully overwrite the existing configuration, including any
+        fields that's not a part of the `ValidioConfig`.
+
+        :param config: A `ValidioConfig` object.
+        """
+        self.validio_config = config
+
+        file_content = json.dumps(
+            config, indent=2, sort_keys=True, cls=ClassJSONEncoder
+        )
+
+        self.config_path.write_text(file_content)
+
+    def read(self) -> ValidioConfig:
+        """
+        Read persistent configuration.
+
+        Will return `None` if no configuration is created yet.
+
+        :returns: The configuration, or None
+        :rtype: ValidioConfig | None
+        :raises: ConfigNotFoundError if no configuration exists
+        :raises: ConfigNotFoundError if the configuration is invalid
+        """
+        if self.validio_config is not None:
+            return self.validio_config
+
+        if not self.config_path.is_file():
+            raise ConfigNotFoundError
+
+        file_content = self.config_path.read_text()
+
+        try:
+            file_content_json = json.loads(file_content)
+        except json.decoder.JSONDecodeError:
+            raise ConfigInvalidError
+
+        # Ensure we filter out the fields from the configuration that is
+        # supported by ValidioConfig. We silently drop everything else.
+        validio_config_fields = [x.lstrip("_") for x in list(vars(ValidioConfig()))]
+        init_args = {
+            k: v for k, v in file_content_json.items() if k in validio_config_fields
+        }
+
+        try:
+            return ValidioConfig(**init_args)
+        except TypeError:
+            raise ConfigInvalidError
+
+    def remove(self):
+        """Remove the configuration at the instance's `config_path`."""
+        if self.config_path.is_file():
+            self.config_path.unlink()
+
+    def exists(self):
+        """Check if any configuration exist."""
+        return self.validio_config is not None
+
+
+def default_config_dir() -> Path:
+    """Get the default config dir based on the OS."""
+    env_path = os.getenv(CONFIG_PATH_ENV)
+    if env_path is not None:
+        return Path(env_path)
+
+    config_dir = platformdirs.user_config_dir(
+        appname="validio",
+        appauthor="Validio AB",
+        ensure_exists=True,
+    )
+
+    return Path(config_dir)