skyflow-flowvault-python 1.0.0__py3-none-any.whl

common/utils/validations/_validations.py

@@ -0,0 +1,267 @@
+from common.errors import SkyflowError
+from common.service_account import is_expired
+from common.service_account._utils import _validate_and_resolve_ctx
+from common.utils import SkyflowMessages
+from common.utils.constants import ApiKey, ConfigField, CredentialField, OptionField
+from common.utils.enums import Env, LogLevel
+from common.utils.logger import log_error_log, log_info
+from common.utils._helpers import is_valid_url
+
+invalid_input_error_code = SkyflowMessages.ErrorCodes.INVALID_INPUT.value
+
+VALID_VAULT_CONFIG_KEYS = [
+    ConfigField.VAULT_ID,
+    ConfigField.CLUSTER_ID,
+    ConfigField.CREDENTIALS,
+    ConfigField.ENV,
+]
+
+
+def validate_required_field(logger, config, field_name, expected_type, empty_error, invalid_error, messages=None):
+    messages = messages or SkyflowMessages
+    field_value = config.get(field_name)
+
+    if field_name not in config or not isinstance(field_value, expected_type):
+        if field_name == ConfigField.VAULT_ID:
+            log_error_log(messages.ErrorLogs.VAULTID_IS_REQUIRED.value, logger)
+        if field_name == ConfigField.CLUSTER_ID:
+            log_error_log(messages.ErrorLogs.CLUSTER_ID_IS_REQUIRED.value, logger)
+        if field_name == OptionField.CONNECTION_ID:
+            log_error_log(messages.ErrorLogs.CONNECTION_ID_IS_REQUIRED.value, logger)
+        if field_name == OptionField.CONNECTION_URL:
+            log_error_log(messages.ErrorLogs.INVALID_CONNECTION_URL.value, logger)
+        raise SkyflowError(invalid_error, invalid_input_error_code)
+
+    if isinstance(field_value, str) and not field_value.strip():
+        if field_name == ConfigField.VAULT_ID:
+            log_error_log(messages.ErrorLogs.EMPTY_VAULTID.value, logger)
+        if field_name == ConfigField.CLUSTER_ID:
+            log_error_log(messages.ErrorLogs.EMPTY_CLUSTER_ID.value, logger)
+        if field_name == OptionField.CONNECTION_ID:
+            log_error_log(messages.ErrorLogs.EMPTY_CONNECTION_ID.value, logger)
+        if field_name == OptionField.CONNECTION_URL:
+            log_error_log(messages.ErrorLogs.EMPTY_CONNECTION_URL.value, logger)
+        if field_name == CredentialField.PATH:
+            log_error_log(messages.ErrorLogs.EMPTY_CREDENTIALS_PATH.value, logger)
+        if field_name == CredentialField.CREDENTIALS_STRING:
+            log_error_log(messages.ErrorLogs.EMPTY_CREDENTIALS_STRING.value, logger)
+        if field_name == CredentialField.TOKEN:
+            log_error_log(messages.ErrorLogs.EMPTY_TOKEN_VALUE.value, logger)
+        if field_name == CredentialField.API_KEY:
+            log_error_log(messages.ErrorLogs.EMPTY_API_KEY_VALUE.value, logger)
+        raise SkyflowError(empty_error, invalid_input_error_code)
+
+
+def validate_api_key(api_key: str, logger=None, messages=None) -> bool:
+    messages = messages or SkyflowMessages
+    if not api_key.startswith(ApiKey.SKY_PREFIX):
+        log_error_log(messages.ErrorLogs.INVALID_API_KEY.value, logger=logger)
+        return False
+
+    if len(api_key) != ApiKey.LENGTH:
+        log_error_log(messages.ErrorLogs.INVALID_API_KEY.value, logger=logger)
+        return False
+
+    return True
+
+
+def validate_token_options(logger, credentials, config_id_type=None, config_id=None, messages=None):
+    messages = messages or SkyflowMessages
+
+    if CredentialField.ROLES in credentials:
+        empty_roles_error = (
+            messages.Error.EMPTY_ROLES_IN_CONFIG.value.format(config_id_type, config_id)
+            if config_id_type and config_id else messages.Error.EMPTY_ROLES.value
+        )
+        validate_required_field(
+            logger, credentials, CredentialField.ROLES, list,
+            empty_roles_error,
+            messages.Error.INVALID_ROLES_KEY_TYPE_IN_CONFIG.value.format(config_id_type, config_id)
+            if config_id_type and config_id else messages.Error.INVALID_ROLES_KEY_TYPE.value,
+            messages=messages)
+        if not credentials.get(CredentialField.ROLES):
+            raise SkyflowError(empty_roles_error, invalid_input_error_code)
+
+        invalid_role_element_error = (
+            messages.Error.INVALID_ROLE_ELEMENT_TYPE_IN_CONFIG.value.format(config_id_type, config_id)
+            if config_id_type and config_id else messages.Error.INVALID_ROLE_ELEMENT_TYPE.value
+        )
+        for role in credentials.get(CredentialField.ROLES):
+            if not isinstance(role, str) or not role.strip():
+                raise SkyflowError(invalid_role_element_error, invalid_input_error_code)
+
+    if CredentialField.CONTEXT in credentials:
+        empty_context_error = (
+            messages.Error.EMPTY_CONTEXT_IN_CONFIG.value.format(config_id_type, config_id)
+            if config_id_type and config_id else messages.Error.EMPTY_CONTEXT.value
+        )
+        validate_required_field(
+            logger, credentials, CredentialField.CONTEXT, (str, dict, bool, int, float),
+            empty_context_error,
+            messages.Error.INVALID_CONTEXT_IN_CONFIG.value.format(config_id_type, config_id)
+            if config_id_type and config_id else messages.Error.INVALID_CONTEXT.value,
+            messages=messages)
+        context = credentials.get(CredentialField.CONTEXT)
+        if isinstance(context, dict):
+            if not context:
+                raise SkyflowError(empty_context_error, invalid_input_error_code)
+            _validate_and_resolve_ctx(context, messages=messages)
+
+def validate_credentials(logger, credentials, config_id_type=None, config_id=None, messages=None):
+    messages = messages or SkyflowMessages
+    key_present = [k for k in [CredentialField.PATH, CredentialField.TOKEN, CredentialField.CREDENTIALS_STRING, CredentialField.API_KEY] if credentials.get(k)]
+
+    if len(key_present) == 0:
+        error_message = (
+            messages.Error.INVALID_CREDENTIALS_IN_CONFIG.value.format(config_id_type, config_id)
+            if config_id_type and config_id else
+            messages.Error.INVALID_CREDENTIALS.value
+        )
+        log_error_log(error_message, logger)
+        raise SkyflowError(error_message, invalid_input_error_code)
+    elif len(key_present) > 1:
+        error_message = (
+            messages.Error.MULTIPLE_CREDENTIALS_PASSED_IN_CONFIG.value.format(config_id_type, config_id)
+            if config_id_type and config_id else
+            messages.Error.MULTIPLE_CREDENTIALS_PASSED.value
+        )
+        log_error_log(error_message, logger)
+        raise SkyflowError(error_message, invalid_input_error_code)
+
+    validate_token_options(logger, credentials, config_id_type, config_id, messages=messages)
+
+    if CredentialField.CREDENTIALS_STRING in credentials:
+        validate_required_field(
+            logger, credentials, CredentialField.CREDENTIALS_STRING, str,
+            messages.Error.EMPTY_CREDENTIALS_STRING_IN_CONFIG.value.format(config_id_type, config_id)
+            if config_id_type and config_id else messages.Error.EMPTY_CREDENTIALS_STRING.value,
+            messages.Error.INVALID_CREDENTIALS_STRING_IN_CONFIG.value.format(config_id_type, config_id)
+            if config_id_type and config_id else messages.Error.INVALID_CREDENTIALS_STRING.value,
+        messages=messages)
+    elif CredentialField.PATH in credentials:
+        validate_required_field(
+            logger, credentials, CredentialField.PATH, str,
+            messages.Error.EMPTY_CREDENTIAL_FILE_PATH_IN_CONFIG.value.format(config_id_type, config_id)
+            if config_id_type and config_id else messages.Error.EMPTY_CREDENTIAL_FILE_PATH.value,
+            messages.Error.INVALID_CREDENTIAL_FILE_PATH_IN_CONFIG.value.format(config_id_type, config_id)
+            if config_id_type and config_id else messages.Error.INVALID_CREDENTIAL_FILE_PATH.value,
+        messages=messages)
+    elif CredentialField.TOKEN in credentials:
+        validate_required_field(
+            logger, credentials, CredentialField.TOKEN, str,
+            messages.Error.EMPTY_CREDENTIALS_TOKEN.value.format(config_id_type, config_id)
+            if config_id_type and config_id else messages.Error.EMPTY_CREDENTIALS_TOKEN.value,
+            messages.Error.INVALID_CREDENTIALS_TOKEN.value.format(config_id_type, config_id)
+            if config_id_type and config_id else messages.Error.INVALID_CREDENTIALS_TOKEN.value,
+        messages=messages)
+        if is_expired(credentials.get(CredentialField.TOKEN), logger):
+            log_error_log(messages.ErrorLogs.INVALID_BEARER_TOKEN.value, logger)
+            raise SkyflowError(
+                messages.Error.EXPIRED_BEARER_TOKEN.value
+                if config_id_type and config_id else messages.Error.EXPIRED_BEARER_TOKEN.value,
+                invalid_input_error_code
+            )
+    elif CredentialField.API_KEY in credentials:
+        validate_required_field(
+            logger, credentials, CredentialField.API_KEY, str,
+            messages.Error.EMPTY_API_KEY.value.format(config_id_type, config_id)
+            if config_id_type and config_id else messages.Error.EMPTY_API_KEY.value,
+            messages.Error.INVALID_API_KEY.value.format(config_id_type, config_id)
+            if config_id_type and config_id else messages.Error.INVALID_API_KEY.value,
+        messages=messages)
+        if not validate_api_key(credentials.get(CredentialField.API_KEY), logger, messages=messages):
+            raise SkyflowError(messages.Error.INVALID_API_KEY.value.format(config_id_type, config_id)
+                               if config_id_type and config_id else messages.Error.INVALID_API_KEY.value,
+                               invalid_input_error_code)
+
+    if CredentialField.TOKEN_URI_OPTION in credentials:
+        token_uri = credentials.get(CredentialField.TOKEN_URI_OPTION)
+        if (
+            token_uri is None
+            or not isinstance(token_uri, str)
+            or not is_valid_url(token_uri)
+        ):
+            log_error_log(messages.ErrorLogs.INVALID_TOKEN_URI.value, logger)
+            raise SkyflowError(messages.Error.INVALID_TOKEN_URI.value, invalid_input_error_code)
+
+
+def validate_log_level(logger, log_level, messages=None):
+    messages = messages or SkyflowMessages
+    if not isinstance(log_level, LogLevel):
+        log_error_log(messages.ErrorLogs.INVALID_LOG_LEVEL.value, logger)
+        raise SkyflowError(messages.Error.INVALID_LOG_LEVEL.value, invalid_input_error_code)
+
+
+def validate_keys(logger, config, config_keys, messages=None):
+    messages = messages or SkyflowMessages
+    for key in config.keys():
+        if key not in config_keys:
+            log_error_log(messages.ErrorLogs.INVALID_KEY.value.format(key), logger)
+            raise SkyflowError(messages.Error.INVALID_KEY.value.format(key), invalid_input_error_code)
+
+
+def validate_non_empty_string_list(logger, value, error):
+    if not isinstance(value, list) or not value or not all(isinstance(item, str) and item.strip() for item in value):
+        raise SkyflowError(error, invalid_input_error_code)
+
+
+def validate_vault_config(logger, config, messages=None, allowed_keys=None):
+    messages = messages or SkyflowMessages
+    allowed_keys = allowed_keys or VALID_VAULT_CONFIG_KEYS
+    log_info(messages.Info.VALIDATING_VAULT_CONFIG.value, logger)
+    validate_keys(logger, config, allowed_keys, messages=messages)
+
+    validate_required_field(
+        logger, config, ConfigField.VAULT_ID, str,
+        messages.Error.EMPTY_VAULT_ID.value,
+        messages.Error.INVALID_VAULT_ID.value,
+        messages=messages
+    )
+    vault_id = config.get(ConfigField.VAULT_ID)
+
+    validate_required_field(
+        logger, config, ConfigField.CLUSTER_ID, str,
+        messages.Error.EMPTY_CLUSTER_ID.value.format(vault_id),
+        messages.Error.INVALID_CLUSTER_ID.value.format(vault_id),
+        messages=messages
+    )
+
+    if ConfigField.CREDENTIALS in config and not config.get(ConfigField.CREDENTIALS):
+        raise SkyflowError(messages.Error.EMPTY_CREDENTIALS.value.format("vault", vault_id), invalid_input_error_code)
+
+    if ConfigField.CREDENTIALS in config and config.get(ConfigField.CREDENTIALS):
+        validate_credentials(logger, config.get(ConfigField.CREDENTIALS), "vault", vault_id, messages=messages)
+
+    if ConfigField.ENV in config and config.get(ConfigField.ENV) not in Env:
+        log_error_log(messages.ErrorLogs.ENV_IS_REQUIRED.value, logger)
+        raise SkyflowError(messages.Error.INVALID_ENV.value.format(vault_id), invalid_input_error_code)
+
+    return True
+
+
+def validate_update_vault_config(logger, config, messages=None, allowed_keys=None):
+    """Credentials are required on update (unlike on initial add, where they're optional)."""
+    messages = messages or SkyflowMessages
+    allowed_keys = allowed_keys or VALID_VAULT_CONFIG_KEYS
+    validate_keys(logger, config, allowed_keys, messages=messages)
+
+    validate_required_field(
+        logger, config, ConfigField.VAULT_ID, str,
+        messages.Error.EMPTY_VAULT_ID.value,
+        messages.Error.INVALID_VAULT_ID.value,
+        messages=messages
+    )
+    vault_id = config.get(ConfigField.VAULT_ID)
+
+    if ConfigField.CLUSTER_ID in config and not config.get(ConfigField.CLUSTER_ID):
+        raise SkyflowError(messages.Error.INVALID_CLUSTER_ID.value.format(vault_id), invalid_input_error_code)
+
+    if ConfigField.ENV in config and config.get(ConfigField.ENV) not in Env:
+        raise SkyflowError(messages.Error.INVALID_ENV.value.format(vault_id), invalid_input_error_code)
+
+    if ConfigField.CREDENTIALS not in config:
+        raise SkyflowError(messages.Error.EMPTY_CREDENTIALS.value.format("vault", vault_id), invalid_input_error_code)
+
+    validate_credentials(logger, config.get(ConfigField.CREDENTIALS), "vault", vault_id, messages=messages)
+
+    return True

common/vault/base_vault_client.py

@@ -0,0 +1,122 @@
+from abc import ABC, abstractmethod
+
+from common.service_account import generate_bearer_token, generate_bearer_token_from_creds, is_expired
+from common.utils import get_credentials, SkyflowMessages
+from common.utils.logger import log_info
+from common.utils.constants import OptionField, CredentialField, ConfigField
+from common.utils.validations import validate_token_options
+
+
+class IVaultClient(ABC):
+    @abstractmethod
+    def resolve_vault_url(self, cluster_id, env, vault_id, logger=None):
+        raise NotImplementedError
+
+    @abstractmethod
+    def initialize_api_client(self, vault_url, bearer_token):
+        raise NotImplementedError
+
+
+class BaseVaultClient(IVaultClient):
+    def __init__(self, config):
+        self._config = config
+        self._common_skyflow_credentials = None
+        self._log_level = None
+        self._api_client = None
+        self._logger = None
+        self._is_config_updated = False
+        self._bearer_token = None
+        self._credentials = None
+        self._vault_url = None
+        self._is_static_token = None
+
+    def set_common_skyflow_credentials(self, credentials):
+        self._common_skyflow_credentials = credentials
+
+    def set_logger(self, log_level, logger):
+        self._log_level = log_level
+        self._logger = logger
+
+    def initialize_client_configuration(self):
+        if self._api_client is not None and not self._is_config_updated:
+            if self._is_static_token:
+                return
+            if self._bearer_token is not None and not is_expired(self._bearer_token):
+                return
+
+        needs_reinit = self._api_client is None or self._is_config_updated
+        if needs_reinit:
+            self._credentials = get_credentials(self._config.get(ConfigField.CREDENTIALS), self._common_skyflow_credentials, logger=self._logger)
+            self._vault_url = self.resolve_vault_url(self._config.get(ConfigField.CLUSTER_ID),
+                                                       self._config.get(ConfigField.ENV),
+                                                       self._config.get(ConfigField.VAULT_ID),
+                                                       logger=self._logger)
+            self._is_static_token = CredentialField.TOKEN in self._credentials or CredentialField.API_KEY in self._credentials
+        bearer_token = self.get_bearer_token(self._credentials)
+        self._bearer_token = bearer_token
+        if needs_reinit:
+            self.initialize_api_client(self._vault_url, bearer_token)
+
+    def get_current_bearer_token(self):
+        return self._bearer_token
+
+    def get_current_vault_url(self):
+        return self._vault_url
+
+    def get_vault_id(self):
+        return self._config.get(ConfigField.VAULT_ID)
+
+    def get_bearer_token(self, credentials):
+        if CredentialField.API_KEY in credentials:
+            return credentials.get(CredentialField.API_KEY)
+        elif CredentialField.TOKEN in credentials:
+            return credentials.get(CredentialField.TOKEN)
+
+        validate_token_options(self._logger, credentials)
+
+        options = {}
+        if CredentialField.ROLES in credentials:
+            options[OptionField.ROLE_IDS] = credentials.get(CredentialField.ROLES)
+
+        if CredentialField.CONTEXT in credentials:
+            options[OptionField.CTX] = credentials.get(CredentialField.CONTEXT)
+
+        if CredentialField.TOKEN_URI_OPTION in credentials and credentials.get(CredentialField.TOKEN_URI_OPTION):
+            options[CredentialField.TOKEN_URI_OPTION] = credentials.get(CredentialField.TOKEN_URI_OPTION)
+
+        if self._bearer_token is None or self._is_config_updated or is_expired(self._bearer_token):
+            if CredentialField.PATH in credentials:
+                self._bearer_token, _ = generate_bearer_token(
+                    credentials.get(CredentialField.PATH),
+                    options,
+                    self._logger
+                )
+            else:
+                credentials_string = credentials.get(CredentialField.CREDENTIALS_STRING)
+                log_info(SkyflowMessages.Info.GENERATE_BEARER_TOKEN_FROM_CREDENTIALS_STRING_TRIGGERED.value, self._logger)
+                self._bearer_token, _ = generate_bearer_token_from_creds(
+                    credentials_string,
+                    options,
+                    self._logger
+                )
+            self._is_config_updated = False
+        else:
+            log_info(SkyflowMessages.Info.REUSE_BEARER_TOKEN.value, self._logger)
+
+        return self._bearer_token
+
+    def update_config(self, config):
+        self._config.update(config)
+        self._is_config_updated = True
+
+    def get_config(self):
+        return self._config
+
+    def get_common_skyflow_credentials(self):
+        return self._common_skyflow_credentials
+
+    def get_log_level(self):
+        return self._log_level
+
+    def get_logger(self):
+        return self._logger

common/vault/base_vault_controller.py

@@ -0,0 +1,58 @@
+from abc import ABC, abstractmethod
+
+from common.errors import SkyflowError
+from common.utils import SkyflowMessages as _CommonSkyflowMessages
+from common.vault.data import BaseInsertRequest, BaseInsertResponse
+
+_INVALID_INPUT_ERROR_CODE = _CommonSkyflowMessages.ErrorCodes.INVALID_INPUT.value
+
+
+class IVaultController(ABC):
+
+    @abstractmethod
+    def insert(self, request: BaseInsertRequest) -> BaseInsertResponse:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get(self, request):
+        raise NotImplementedError
+
+    @abstractmethod
+    def update(self, request):
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete(self, request):
+        raise NotImplementedError
+
+    @abstractmethod
+    def detokenize(self, request):
+        raise NotImplementedError
+
+
+class BaseVaultController(IVaultController):
+
+    _skyflow_messages = None
+
+    def __init__(self, vault_client):
+        self._vault_client = vault_client
+
+    def _validate_table_name_if_present(self, table):
+        if table is not None and (not isinstance(table, str) or not table.strip()):
+            raise SkyflowError(
+                self._skyflow_messages.Error.INVALID_TABLE_NAME_IN_INSERT.value,
+                _INVALID_INPUT_ERROR_CODE,
+            )
+
+    def _validate_field_values(self, values):
+        if not isinstance(values, dict) or not values:
+            raise SkyflowError(
+                self._skyflow_messages.Error.INVALID_RECORD_DATA_IN_INSERT.value,
+                _INVALID_INPUT_ERROR_CODE,
+            )
+        for key, value in values.items():
+            if not isinstance(key, str) or not key.strip():
+                raise SkyflowError(
+                    self._skyflow_messages.Error.EMPTY_KEY_IN_INSERT_DATA.value,
+                    _INVALID_INPUT_ERROR_CODE,
+                )

common/vault/data/__init__.py

@@ -0,0 +1,2 @@
+from ._base_insert_request import BaseInsertRequest
+from ._base_insert_response import BaseInsertResponse

common/vault/data/_base_insert_request.py

@@ -0,0 +1,7 @@
+from typing import Union
+
+class BaseInsertRequest:
+    def __init__(self, table: str, values: list, upsert: Union[str, dict] = None):
+        self.table = table
+        self.values = values
+        self.upsert = upsert

common/vault/data/_base_insert_response.py

@@ -0,0 +1,11 @@
+class BaseInsertResponse:
+
+    def __init__(self, inserted_fields=None, errors=None):
+        self.inserted_fields = inserted_fields
+        self.errors = errors
+
+    def __repr__(self):
+        return f"{type(self).__name__}(inserted_fields={self.inserted_fields}, errors={self.errors})"
+
+    def __str__(self):
+        return self.__repr__()

skyflow/__init__.py

@@ -0,0 +1,2 @@
+from .utils import LogLevel, Env
+from .client import Skyflow

skyflow/client/__init__.py

@@ -0,0 +1 @@
+from .skyflow import Skyflow

skyflow/client/_http_config_builder.py

@@ -0,0 +1,45 @@
+from skyflow.utils._http_config import (
+    TIMEOUT_KEY,
+    CONNECT_TIMEOUT_KEY,
+    READ_TIMEOUT_KEY,
+    WRITE_TIMEOUT_KEY,
+    MAX_RETRIES_KEY,
+    INITIAL_RETRY_DELAY_MILLIS_KEY,
+    MAX_RETRY_DELAY_MILLIS_KEY,
+)
+from skyflow.utils.validations._validations import validate_http_config_value
+
+
+class HttpConfigBuilderMixin:
+    def __init__(self):
+        super().__init__()
+        self._client_http_config = {}
+
+    def _set_http_config(self, key, value):
+        validate_http_config_value(key, value)
+        self._client_http_config[key] = value
+        return self
+
+    def timeout(self, seconds):
+        return self._set_http_config(TIMEOUT_KEY, seconds)
+
+    def connect_timeout(self, seconds):
+        return self._set_http_config(CONNECT_TIMEOUT_KEY, seconds)
+
+    def read_timeout(self, seconds):
+        return self._set_http_config(READ_TIMEOUT_KEY, seconds)
+
+    def write_timeout(self, seconds):
+        return self._set_http_config(WRITE_TIMEOUT_KEY, seconds)
+
+    def max_retries(self, retries):
+        return self._set_http_config(MAX_RETRIES_KEY, retries)
+
+    def initial_retry_delay_millis(self, millis):
+        return self._set_http_config(INITIAL_RETRY_DELAY_MILLIS_KEY, millis)
+
+    def max_retry_delay_millis(self, millis):
+        return self._set_http_config(MAX_RETRY_DELAY_MILLIS_KEY, millis)
+
+    def _on_vault_client_created(self, vault_client):
+        vault_client.set_common_http_config(self._client_http_config)

skyflow/client/skyflow.py

@@ -0,0 +1,15 @@
+from common.client.utils import make_skyflow_class
+from common.utils import SkyflowMessages
+from skyflow.client._http_config_builder import HttpConfigBuilderMixin
+from skyflow.utils.validations import validate_vault_config, validate_update_vault_config
+from skyflow.vault.client.client import VaultClient
+from skyflow.vault.controller import VaultController
+
+Skyflow = make_skyflow_class(
+    vault_client_cls=VaultClient,
+    vault_controller_cls=VaultController,
+    skyflow_messages=SkyflowMessages,
+    validate_vault_config=validate_vault_config,
+    validate_update_vault_config=validate_update_vault_config,
+    builder_mixins=(HttpConfigBuilderMixin,),
+)

skyflow/error/__init__.py

@@ -0,0 +1,3 @@
+from common.errors import SkyflowError
+
+__all__ = ["SkyflowError"]