another-ayx-python-sdk 2.4.22__py3-none-any.whl → 2.4.23__py3-none-any.whl

build/lib/another_ayx_python_sdk/providers/e1_provider/e1_plugin_proxy.py

@@ -1,363 +0,0 @@
-# Copyright (C) 2022 Alteryx, Inc. All rights reserved.
-#
-# Licensed under the ALTERYX SDK AND API LICENSE AGREEMENT;
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    https://www.alteryx.com/alteryx-sdk-and-api-license-agreement
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Base plugin definition."""
-import logging
-import os
-import sys
-from pathlib import Path
-from typing import List, NoReturn, Optional, TYPE_CHECKING, Type
-
-import another_ayx_python_sdk.providers.e1_provider.mock_e1_sdk.AlteryxPythonSDK as Sdk
-
-from another_ayx_python_sdk.core.exceptions import (
-    AnchorNotFoundException,
-    WorkflowRuntimeError,
-)
-from another_ayx_python_sdk.core.observable_mixin import ObservableMixin
-from another_ayx_python_sdk.providers.e1_provider.anchor_builder import AnchorBuilder
-from another_ayx_python_sdk.providers.e1_provider.connection_callback_strategy import (
-    UpdateOnlyConnectionCallbackStrategy,
-    WorkflowRunConnectionCallbackStrategy,
-)
-from another_ayx_python_sdk.providers.e1_provider.connection_interface import (
-    ConnectionInterface,
-    ConnectionStatus,
-)
-from another_ayx_python_sdk.providers.e1_provider.e1_environment import E1Environment
-from another_ayx_python_sdk.providers.e1_provider.e1_input_anchor_proxy import (
-    E1InputAnchorProxy,
-)
-from another_ayx_python_sdk.providers.e1_provider.e1_io import E1IO
-from another_ayx_python_sdk.providers.e1_provider.e1_output_anchor_proxy import (
-    E1OutputAnchorProxy,
-)
-from another_ayx_python_sdk.providers.e1_provider.e1_plugin_driver import E1PluginDriver
-from another_ayx_python_sdk.providers.e1_provider.e1_provider import E1Provider
-from another_ayx_python_sdk.providers.e1_provider.events import (
-    ConnectionEvents,
-    PluginEvents,
-)
-from another_ayx_python_sdk.providers.e1_provider.tool_config_loader import ToolConfigLoader
-from another_ayx_python_sdk.providers.e1_provider.workflow_config import WorkflowConfiguration
-
-if TYPE_CHECKING:
-    from another_ayx_python_sdk.core.plugin import Plugin  # noqa: F401
-    from another_ayx_python_sdk.providers.e1_provider.connection_callback_strategy import (
-        ConnectionCallbackStrategy,
-    )
-
-
-class E1PluginProxy(ObservableMixin):
-    """Base plugin to inherit from."""
-
-    __slots__ = [
-        "tool_id",
-        "anchor_builder",
-        "input_anchors",
-        "output_anchors",
-        "workflow_config",
-        "failure_occurred",
-        "initialized",
-        "record_batch_size",
-        "plugin_driver",
-        "engine",
-        "user_plugin",
-        "tool_config_loader",
-        "_output_anchor_mgr",
-        "__environment",
-        "__io",
-        "__input_connections",
-    ]
-
-    user_plugin_class: Type["Plugin"]
-    user_plugin_directory_name: str
-
-    def __init__(
-        self,
-        tool_id: int,
-        alteryx_engine: Sdk.AlteryxEngine,
-        output_anchor_mgr: Sdk.OutputAnchorManager,
-    ):
-        """Construct a plugin."""
-        ObservableMixin.__init__(self)
-        self.tool_id = tool_id
-        self.engine = alteryx_engine
-        self._output_anchor_mgr = output_anchor_mgr
-        self.initialized = False
-        self.failure_occurred = False
-        self.__environment = E1Environment(alteryx_engine, tool_id, self)
-        self.__io = E1IO(alteryx_engine, tool_id)
-        self.__input_connections: List = []
-
-        self.configure_logger()
-
-        # These properties should be assigned before pi_init gets called
-        self.record_batch_size: Optional[int] = None
-
-        # These properties get assigned in pi_init
-        self.anchor_builder: Optional[AnchorBuilder] = None
-        self.workflow_config = WorkflowConfiguration("<Configuration/>")
-        self.input_anchors: List[E1InputAnchorProxy] = []
-        self.output_anchors: List[E1OutputAnchorProxy] = []
-        self.plugin_driver: Optional[E1PluginDriver] = None
-        self.tool_config_loader = ToolConfigLoader(self.user_plugin_directory_name)
-
-    def pi_init(self, workflow_config_xml_string: str) -> None:
-        """Plugin initialization from the engine."""
-        if self.tool_name is None:
-            raise ValueError("Name must be set before plugin can be used.")
-
-        # DO NOT REMOVE NEXT LINE: The base SDK has issues with sys.path updates,
-        # and in order to fix some dependency resolution issues we have to update it again here
-        self.update_sys_path()
-
-        self.anchor_builder = AnchorBuilder(
-            self.tool_config_loader.get_tool_config(), self._output_anchor_mgr
-        )
-        self.workflow_config = WorkflowConfiguration(workflow_config_xml_string)
-        self.input_anchors = self.anchor_builder.build_input_anchors()
-        self.output_anchors = self.anchor_builder.build_output_anchors()
-        self.notify_topic(PluginEvents.PLUGIN_INITIALIZED)
-        self.plugin_driver = E1PluginDriver(
-            self.user_plugin_class, E1Provider(self, self.workflow_config)
-        )
-
-    def pi_add_incoming_connection(
-        self, anchor_name: str, connection_name: str
-    ) -> ConnectionInterface:
-        """Add incoming connection to the tool from the engine."""
-        anchor = [a for a in self.input_anchors if a.name == anchor_name][0]
-
-        connection = ConnectionInterface(self, connection_name, anchor)
-        anchor.connections.append(connection)
-        self._subscribe_to_connection(connection)
-        return connection
-
-    def _subscribe_to_connection(self, connection: ConnectionInterface) -> None:
-        """Subscribe to events of interest generated by a connection."""
-        connection.subscribe(
-            ConnectionEvents.CONNECTION_INITIALIZED,
-            self.callback_strategy.connection_initialized_callback,
-        )
-        connection.subscribe(
-            ConnectionEvents.RECORD_RECEIVED,
-            self.callback_strategy.record_received_callback,
-        )
-        connection.subscribe(
-            ConnectionEvents.CONNECTION_CLOSED,
-            self.callback_strategy.connection_closed_callback,
-        )
-        connection.subscribe(
-            ConnectionEvents.PROGRESS_UPDATE,
-            self.callback_strategy.update_progress_callback,
-        )
-
-    def pi_add_outgoing_connection(self, anchor_name: str) -> bool:
-        """Register an outgoing connection from this tool."""
-        anchor = [a for a in self.output_anchors if a.name == anchor_name][0]
-        anchor.num_connections += 1
-        return True
-
-    def pi_push_all_records(self, n_record_limit: int) -> bool:
-        """Push all records when no inputs are connected."""
-        try:
-            if len(self.required_input_anchors) == 0:
-                if self.plugin_driver is None:
-                    raise ValueError("Record provider must be initialized.")
-                self.plugin_driver.initialize_plugin()
-                self.initialized = True
-
-                if not self.environment.update_only:
-                    self.plugin_driver.on_complete()
-
-                self.close_output_anchors()
-                return True
-
-            self.raise_missing_inputs()
-        except Exception as e:
-            self.handle_plugin_error(e)
-
-        return False
-
-    def raise_missing_inputs(self) -> NoReturn:
-        """Send a missing incoming inputs error to Designer."""
-        raise WorkflowRuntimeError(self.engine.xmsg("Missing Incoming Connection(s)."))
-
-    def pi_close(self, b_has_errors: bool) -> None:
-        """Cleans-up resources, flushes and closes logger's handlers."""
-        logger = self.logger
-        for handler in logger.handlers:
-            logger.removeHandler(handler)
-            handler.flush()
-            handler.close()
-
-    def configure_logger(self) -> None:
-        """Configure the logger."""
-        formatter = logging.Formatter("%(asctime)s %(levelname)s %(message)s")
-
-        file_handler = logging.FileHandler(self.log_filepath)
-        file_handler.setFormatter(formatter)
-        self.logger.addHandler(file_handler)
-
-        stream_handler = logging.StreamHandler()
-        stream_handler.setFormatter(formatter)
-        self.logger.addHandler(stream_handler)
-
-        self.logger.setLevel(logging.INFO)
-
-    def handle_plugin_error(self, e: Exception) -> None:
-        """Log a plugin error to the log and a generic error to Designer."""
-        logger = self.logger
-
-        if isinstance(e, WorkflowRuntimeError):
-            logger.error(str(e))
-            self.io.error(str(e))
-        else:
-            logger.exception(e)
-            self.io.error(
-                f"Unexpected error occurred in plugin please see log file: {str(self.log_filepath)}"
-            )
-        self.failure_occurred = True
-        self.notify_topic(PluginEvents.PLUGIN_FAILURE, exception=e)
-
-    def push_all_metadata(self) -> None:
-        """Push all metadata for anchors."""
-        for anchor in self.output_anchors:
-            anchor.push_metadata()
-
-    def close_output_anchors(self) -> None:
-        """Close connection for all output anchors."""
-        for anchor in self.output_anchors:
-            anchor.close()
-
-    def get_input_anchor(self, input_anchor_name: str) -> E1InputAnchorProxy:
-        """Get an input anchor by name."""
-        try:
-            return [
-                anchor
-                for anchor in self.input_anchors
-                if anchor.name == input_anchor_name
-            ][0]
-        except IndexError:
-            raise AnchorNotFoundException(f"{input_anchor_name} not found.")
-
-    def get_output_anchor(self, output_anchor_name: str) -> E1OutputAnchorProxy:
-        """Get an output anchor by name."""
-        try:
-            return [
-                anchor
-                for anchor in self.output_anchors
-                if anchor.name == output_anchor_name
-            ][0]
-        except IndexError:
-            raise AnchorNotFoundException(f"{output_anchor_name} not found.")
-
-    def update_sys_path(self) -> None:
-        """
-        Update the sys.path to fix SDK issues.
-
-        The sys.path must be updated to include:
-        - The venv path
-        - The tool directory
-
-        in order for inline imports to work due to base SDK sys.path manipulation issues.
-        """
-        install_metadata = self.tool_config_loader.get_tool_install_metadata()
-
-        for path in [
-            install_metadata.venv_path / "Lib" / "site-packages",
-            install_metadata.install_path,
-        ]:
-            sys.path.append(str(path))
-
-    @property
-    def tool_name(self) -> str:
-        """Getter for the tool name."""
-        return self.user_plugin_class.__name__
-
-    @property
-    def callback_strategy(self) -> "ConnectionCallbackStrategy":
-        """Generate the callback strategy for the tool."""
-        return (
-            UpdateOnlyConnectionCallbackStrategy(self)
-            if self.environment.update_only
-            else WorkflowRunConnectionCallbackStrategy(self)
-        )
-
-    @property
-    def log_directory(self) -> Path:
-        """Get the log directory."""
-        if sys.platform == "win32":
-            log_directory = Path(os.environ["localappdata"]) / "Alteryx" / "Log"
-        else:
-            # Required for CI/CD pipelines running in linux environment
-            # + future proofing
-            log_directory = Path.home() / ".Alteryx" / "Log"
-
-        log_directory.mkdir(parents=True, exist_ok=True)
-        return log_directory
-
-    @property
-    def log_filepath(self) -> Path:
-        """Get the log filename."""
-        return self.log_directory / f"{self.tool_name}{self.tool_id}.log"
-
-    @property
-    def all_required_connections_connected(self) -> bool:
-        """Getter that indicates if all required connections are connected."""
-        return all(
-            [len(anchor.connections) > 0 for anchor in self.required_input_anchors]
-        )
-
-    @property
-    def all_connections_initialized(self) -> bool:
-        """Getter that indicates if all input connections are initialized."""
-        return all(
-            [
-                connection.status != ConnectionStatus.CREATED
-                for anchor in self.input_anchors
-                for connection in anchor.connections
-            ]
-        )
-
-    @property
-    def all_connections_closed(self) -> bool:
-        """Getter that indicates if all input connections are closed."""
-        return all(
-            [
-                connection.status == ConnectionStatus.CLOSED
-                for anchor in self.input_anchors
-                for connection in anchor.connections
-            ]
-        )
-
-    @property
-    def required_input_anchors(self) -> List[E1InputAnchorProxy]:
-        """Get the list of required input anchors for this tool."""
-        return [anchor for anchor in self.input_anchors if not anchor.optional]
-
-    @property
-    def logger(self) -> logging.Logger:
-        """Get logger."""
-        return logging.getLogger(f"{self.tool_name}{self.tool_id}")
-
-    @property
-    def io(self) -> E1IO:
-        """Get the IO object from this provider."""
-        return self.__io
-
-    @property
-    def environment(self) -> E1Environment:
-        """Get the Environment object from this provider."""
-        return self.__environment

build/lib/another_ayx_python_sdk/providers/e1_provider/e1_provider.py

@@ -1,71 +0,0 @@
-# Copyright (C) 2022 Alteryx, Inc. All rights reserved.
-#
-# Licensed under the ALTERYX SDK AND API LICENSE AGREEMENT;
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    https://www.alteryx.com/alteryx-sdk-and-api-license-agreement
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""E1 SDK Provider Class."""
-from logging import Logger
-from typing import Any, TYPE_CHECKING
-
-from another_ayx_python_sdk.core.doc_utilities import inherit_docs
-from another_ayx_python_sdk.core.provider_base import ProviderBase
-from another_ayx_python_sdk.providers.e1_provider import E1InputAnchor
-from another_ayx_python_sdk.providers.e1_provider.e1_output_anchor import E1OutputAnchor
-
-if TYPE_CHECKING:
-    from another_ayx_python_sdk.providers.e1_provider.workflow_config import (
-        WorkflowConfiguration,
-    )
-    from another_ayx_python_sdk.providers.e1_provider.e1_environment import E1Environment
-    from another_ayx_python_sdk.providers.e1_provider.e1_plugin_proxy import E1PluginProxy
-    from another_ayx_python_sdk.providers.e1_provider.e1_io import E1IO
-    from another_ayx_python_sdk.providers.e1_provider.e1_dcm import E1ProviderDCM
-
-
-@inherit_docs
-class E1Provider(ProviderBase):
-    """Provides resources generated from the E1 Python SDK."""
-
-    def __init__(
-        self, plugin_proxy: "E1PluginProxy", workflow_config: "WorkflowConfiguration"
-    ):
-        """Construct the E1Provider."""
-        self._plugin_proxy = plugin_proxy
-        self._workflow_config = workflow_config
-
-    @property
-    def tool_config(self) -> Any:
-        """Get config XML."""
-        return self._workflow_config.data
-
-    @property
-    def logger(self) -> Logger:  # noqa: D102
-        return self._plugin_proxy.logger
-
-    @property
-    def io(self) -> "E1IO":  # noqa: D102
-        return self._plugin_proxy.io
-
-    @property
-    def dcm(self) -> "E1ProviderDCM":  # noqa: D102
-        return self._plugin_proxy.dcm
-
-    @property
-    def environment(self) -> "E1Environment":  # noqa: D102
-        return self._plugin_proxy.environment
-
-    def get_input_anchor(self, name: str) -> E1InputAnchor:  # noqa: D102
-        return E1InputAnchor(self._plugin_proxy.get_input_anchor(name))
-
-    def get_output_anchor(self, name: str) -> E1OutputAnchor:  # noqa: D102
-        return E1OutputAnchor(
-            self._plugin_proxy.get_output_anchor(name), self._plugin_proxy.engine
-        )

build/lib/another_ayx_python_sdk/providers/e1_provider/e1_record_packet.py

@@ -1,21 +0,0 @@
-# Copyright (C) 2022 Alteryx, Inc. All rights reserved.
-#
-# Licensed under the ALTERYX SDK AND API LICENSE AGREEMENT;
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    https://www.alteryx.com/alteryx-sdk-and-api-license-agreement
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""E1 SDK Record Packet Definition."""
-from another_ayx_python_sdk.core.doc_utilities import inherit_docs
-from another_ayx_python_sdk.core.record_packet import RecordPacket
-
-
-@inherit_docs
-class E1RecordPacket(RecordPacket):
-    """E1 SDK Record Packet definition."""

build/lib/another_ayx_python_sdk/providers/e1_provider/events.py

@@ -1,36 +0,0 @@
-# Copyright (C) 2022 Alteryx, Inc. All rights reserved.
-#
-# Licensed under the ALTERYX SDK AND API LICENSE AGREEMENT;
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    https://www.alteryx.com/alteryx-sdk-and-api-license-agreement
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Observable event definitions."""
-from enum import Enum
-
-
-class ConnectionEvents(Enum):
-    """Events for connection objects."""
-
-    CONNECTION_INITIALIZED = "connection_initialized"
-    RECORD_RECEIVED = "record_received"
-    PROGRESS_UPDATE = "progress_update"
-    CONNECTION_CLOSED = "connection_closed"
-
-
-class PluginEvents:
-    """Events for plugin objects."""
-
-    PLUGIN_INITIALIZED = "plugin_initialized"
-    PI_INIT = "pi_init"
-    INCOMING_CONNECTION_ADDED = "pi_add_incoming_connection"
-    OUTGOING_CONNECTION_ADDED = "pi_add_outgoing_connection"
-    PI_CLOSE = "pi_close"
-    PI_PUSH_ALL_RECORDS = "pi_push_all_records"
-    PLUGIN_FAILURE = "plugin_failure"

build/lib/another_ayx_python_sdk/providers/e1_provider/mock_e1_sdk/AlteryxPythonSDK/__init__.py

@@ -1,37 +0,0 @@
-# Copyright (C) 2022 Alteryx, Inc. All rights reserved.
-#
-# Licensed under the ALTERYX SDK AND API LICENSE AGREEMENT;
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    https://www.alteryx.com/alteryx-sdk-and-api-license-agreement
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Mocks for testing."""
-from .alteryx_engine import AlteryxEngine
-from .constants import EngineMessageType, FieldType, Status
-from .field import Field
-from .output_anchor import OutputAnchor
-from .output_anchor_manager import OutputAnchorManager
-from .record_copier import RecordCopier
-from .record_creator import RecordCreator
-from .record_info import RecordInfo
-from .record_ref import RecordRef
-
-__all__ = [
-    "AlteryxEngine",
-    "EngineMessageType",
-    "FieldType",
-    "Status",
-    "Field",
-    "RecordInfo",
-    "RecordCopier",
-    "RecordCreator",
-    "RecordRef",
-    "OutputAnchor",
-    "OutputAnchorManager",
-]

build/lib/another_ayx_python_sdk/providers/e1_provider/mock_e1_sdk/AlteryxPythonSDK/alteryx_engine.py

@@ -1,105 +0,0 @@
-# Copyright (C) 2022 Alteryx, Inc. All rights reserved.
-#
-# Licensed under the ALTERYX SDK AND API LICENSE AGREEMENT;
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    https://www.alteryx.com/alteryx-sdk-and-api-license-agreement
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Mock alteryx engine class definition."""
-from collections import defaultdict
-from typing import DefaultDict, Dict, Iterable
-
-import deprecation
-
-from .constants import EngineMessageType, Status
-from .tool_execution_info import ToolExecutionInfo
-
-
-class AlteryxEngine:
-    """Alteryx Engine mock."""
-
-    def __init__(self) -> None:
-        """Construct an engine."""
-        self.init_vars: Dict[str, str] = {
-            "ActionApplies": "False",
-            "AllowDesktopInteraction": "False",
-            "DefaultDir": ".",
-            "EnablePerformanceProfiling": "False",
-            "NumThreads": "1",
-            "OutputRecordCounts": "False",
-            "RunMode": "Standard",
-            "RunningAsWizard": "False",
-            "RuntimeDataPath": ".",
-            "SerialNumber": "MockSerial#123",
-            "SettingsPath": ".",
-            "TempPath": "./temp_dir/",
-            "UpdateMode": "",
-            "UpdateOnly": "False",
-            "Version": "2020.1",
-        }
-
-        self.tool_execution_info: DefaultDict[int, ToolExecutionInfo] = defaultdict(
-            ToolExecutionInfo
-        )
-
-    @staticmethod
-    def create_temp_file_name(extension: str = "tmp", options: int = 0) -> str:
-        """Create temp file."""
-        import tempfile
-
-        return tempfile.NamedTemporaryFile(suffix="." + extension).name
-
-    @deprecation.deprecated(
-        deprecated_in="1.0.3",
-        removed_in="2.0.0",
-        details="Use functions of provider's dcm property instead",
-    )  # type: ignore
-    def decrypt_password(self, encrypted_password: str, mode: int) -> str:
-        """Decrypt password."""
-        if mode == 0:
-            return encrypted_password + "_decrypted"
-        raise NotImplementedError()
-
-    def get_constant(self, tool_id: int, which: int) -> None:
-        """Get constant."""
-        raise NotImplementedError()
-
-    def get_init_var(self, tool_id: int, var_name: str) -> str:
-        """Get initialization variable."""
-        return self.init_vars[var_name]
-
-    def output_message(self, tool_id: int, status: int, message: str) -> int:
-        """Output message."""
-        execution_info = self.tool_execution_info[tool_id]
-
-        {
-            EngineMessageType.error: execution_info.add_error,
-            EngineMessageType.warning: execution_info.add_warning,
-            EngineMessageType.info: execution_info.add_info,
-            Status.update_output_config_xml: execution_info.set_output_workflow_xml,
-        }[status](message)
-
-        return 0
-
-    def output_tool_progress(self, tool_id: int, percent_progress: float) -> None:
-        """Output tool progress."""
-        self.tool_execution_info[tool_id].progress = percent_progress
-
-    def pre_sort(
-        self,
-        incoming_connection_type: str,
-        incoming_connection_name: str,
-        sort_info: str,
-    ) -> None:
-        """Presort records."""
-        raise NotImplementedError()
-
-    def xmsg(self, msg: str, *args: Iterable[str]) -> str:
-        """Translate a message string."""
-        return msg

build/lib/another_ayx_python_sdk/providers/e1_provider/mock_e1_sdk/AlteryxPythonSDK/constants.py

@@ -1,50 +0,0 @@
-# Copyright (C) 2022 Alteryx, Inc. All rights reserved.
-#
-# Licensed under the ALTERYX SDK AND API LICENSE AGREEMENT;
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    https://www.alteryx.com/alteryx-sdk-and-api-license-agreement
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""SDK constants."""
-
-
-class Status:
-    """Status constants."""
-
-    update_output_config_xml = 0
-
-
-class EngineMessageType:
-    """Engine output message types."""
-
-    error = 100
-    warning = 101
-    info = 102
-
-
-class FieldType:
-    """SDK field types."""
-
-    blob = "blob"
-    byte = "byte"
-    int16 = "int16"
-    int32 = "int32"
-    int64 = "int64"
-    float = "float"
-    double = "double"
-    date = "date"
-    time = "time"
-    datetime = "datetime"
-    bool = "bool"
-    string = "string"
-    v_string = "v_string"
-    v_wstring = "v_wstring"
-    wstring = "wstring"
-    fixeddecimal = "fixeddecimal"
-    spatialobj = "spatialobj"