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

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

@@ -0,0 +1,155 @@
+# 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.
+"""Connection callback strategy definitions."""
+from abc import ABC, abstractmethod
+from typing import Any, TYPE_CHECKING
+
+from .connection_interface import ConnectionInterface
+
+if TYPE_CHECKING:
+    from another_ayx_python_sdk.providers.e1_provider.e1_plugin_proxy import E1PluginProxy
+
+
+class ConnectionCallbackStrategy(ABC):
+    """ABC for callback strategy."""
+
+    __slots__ = ["plugin_proxy"]
+
+    def __init__(self, plugin_proxy: "E1PluginProxy") -> None:
+        """Construct a callback strategy."""
+        self.plugin_proxy = plugin_proxy
+
+    def update_progress_callback(self, **_: Any) -> None:
+        """Update input progress percentage."""
+        import numpy as np
+
+        percent = float(
+            np.mean(
+                [
+                    connection.progress_percentage
+                    for anchor in self.plugin_proxy.input_anchors
+                    for connection in anchor.connections
+                ]
+            )
+        )
+
+        self.plugin_proxy.io.update_progress(percent)
+
+        for anchor in self.plugin_proxy.output_anchors:
+            anchor.update_progress(percent)
+
+    def connection_initialized_callback(
+        self, connection: ConnectionInterface, **_: Any
+    ) -> None:
+        """Run callback for connection initialization."""
+        try:
+            if not self.plugin_proxy.all_required_connections_connected:
+                self.plugin_proxy.raise_missing_inputs()
+
+            if (
+                not self.plugin_proxy.initialized
+                and not self.plugin_proxy.failure_occurred
+            ):
+                if self.plugin_proxy.plugin_driver is None:
+                    raise ValueError("Record provider must be initialized.")
+                self.plugin_proxy.plugin_driver.initialize_plugin()
+                self.plugin_proxy.initialized = True
+
+            if not self.plugin_proxy.failure_occurred:
+                if self.plugin_proxy.plugin_driver is None:
+                    raise ValueError("Record provider must be initialized.")
+                self.plugin_proxy.plugin_driver.initialize_connection(connection)
+
+        except Exception as e:
+            self.plugin_proxy.handle_plugin_error(e)
+
+    @abstractmethod
+    def record_received_callback(
+        self, connection: ConnectionInterface, **_: Any
+    ) -> None:
+        """Run callback for when a record is received."""
+        pass
+
+    @abstractmethod
+    def connection_closed_callback(self, **_: Any) -> None:
+        """Run callback for connection closing."""
+        pass
+
+
+class WorkflowRunConnectionCallbackStrategy(ConnectionCallbackStrategy):
+    """Callback strategy for workflow runs."""
+
+    def record_received_callback(
+        self, connection: ConnectionInterface, **_: Any
+    ) -> None:
+        """Process single records by batch size."""
+        batch_size = connection.record_batch_size
+
+        if batch_size is None:
+            return
+
+        if (
+            len(connection.record_containers[0].records) >= batch_size
+            and not self.plugin_proxy.failure_occurred
+        ):
+            try:
+                if self.plugin_proxy.plugin_driver is None:
+                    raise ValueError("Record provider must be initialized.")
+                self.plugin_proxy.plugin_driver.on_record_packet(connection)
+
+            except Exception as e:
+                self.plugin_proxy.handle_plugin_error(e)
+
+    def connection_closed_callback(self, **_: Any) -> None:
+        """Process any remaining records and finalize."""
+        if (
+            self.plugin_proxy.all_connections_closed
+            and not self.plugin_proxy.failure_occurred
+        ):
+            try:
+                if self.plugin_proxy.plugin_driver is None:
+                    raise ValueError("Record provider must be initialized.")
+                for anchor in self.plugin_proxy.input_anchors:
+                    for connection in anchor.connections:
+                        if any(
+                            len(container.records) > 0
+                            for container in connection.record_containers
+                        ):
+                            self.plugin_proxy.plugin_driver.on_record_packet(connection)
+                self.plugin_proxy.plugin_driver.on_complete()
+                self.plugin_proxy.close_output_anchors()
+
+            except Exception as e:
+                self.plugin_proxy.handle_plugin_error(e)
+
+
+class UpdateOnlyConnectionCallbackStrategy(ConnectionCallbackStrategy):
+    """Callback strategy for update only runs."""
+
+    def record_received_callback(
+        self, connection: ConnectionInterface, **_: Any
+    ) -> None:
+        """Raise error since this should never be called in update only mode."""
+        raise RuntimeError("Record received in update only mode.")
+
+    def connection_closed_callback(self, **_: Any) -> None:
+        """Close all anchors."""
+        if (
+            self.plugin_proxy.all_connections_closed
+            and not self.plugin_proxy.failure_occurred
+        ):
+            try:
+                self.plugin_proxy.close_output_anchors()
+            except Exception as e:
+                self.plugin_proxy.handle_plugin_error(e)

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

@@ -0,0 +1,125 @@
+# 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.
+"""Connection class definitions."""
+from enum import IntEnum
+from typing import Any, List, Optional, TYPE_CHECKING
+
+from another_ayx_python_sdk.providers.e1_provider.mock_e1_sdk.AlteryxPythonSDK import RecordInfo, RecordRef
+
+from another_ayx_python_sdk.core.observable_mixin import ObservableMixin
+from another_ayx_python_sdk.providers.e1_provider.events import (
+    ConnectionEvents,
+    PluginEvents,
+)
+from another_ayx_python_sdk.providers.e1_provider.records import BaseRecordContainer
+
+if TYPE_CHECKING:
+    from another_ayx_python_sdk.providers.e1_provider.e1_input_anchor_proxy import (
+        E1InputAnchorProxy,
+    )
+    from another_ayx_python_sdk.providers.e1_provider.e1_plugin_proxy import E1PluginProxy
+
+
+ConnectionStatus = IntEnum(
+    "ConnectionStatus", "CREATED INITIALIZED RECEIVING_RECORDS CLOSED"
+)
+
+
+class ConnectionInterface(ObservableMixin):
+    """Connection interface definition."""
+
+    __slots__ = [
+        "name",
+        "record_containers",
+        "__record_info",
+        "progress_percentage",
+        "status",
+        "plugin_failed",
+        "anchor",
+        "record_batch_size",
+        "plugin_proxy",
+    ]
+
+    def __init__(
+        self,
+        plugin_proxy: "E1PluginProxy",
+        connection_name: str,
+        anchor: "E1InputAnchorProxy",
+    ) -> None:
+        """Instantiate a connection interface."""
+        super().__init__()
+        self.name = connection_name
+        self.__record_info: Optional[RecordInfo] = None
+        self.progress_percentage = 0.0
+        self.status = ConnectionStatus.CREATED
+        self.plugin_failed = False
+        self.record_containers: List[BaseRecordContainer] = []
+        self.anchor = anchor
+        self.record_batch_size: Optional[int] = None
+        self.plugin_proxy = plugin_proxy
+        self.plugin_proxy.subscribe(
+            PluginEvents.PLUGIN_FAILURE, self.plugin_failure_callback
+        )
+
+    @property
+    def record_info(self) -> Optional[RecordInfo]:
+        """Getter for record info."""
+        return self.__record_info
+
+    def add_record_container(self, container: BaseRecordContainer) -> None:
+        """Add a new record container."""
+        self.record_containers.append(container)
+
+    def clear_records(self) -> None:
+        """Clear all records for this connection's containers."""
+        for container in self.record_containers:
+            container.clear_records()
+
+    def plugin_failure_callback(self, **_: Any) -> None:
+        """Set failed status from plugin."""
+        self.plugin_failed = True
+
+    def ii_init(self, record_info: RecordInfo) -> bool:
+        """Initialize the connection."""
+        # 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.plugin_proxy.update_sys_path()
+        self.status = ConnectionStatus.INITIALIZED
+        self.__record_info = record_info
+        self.notify_topic(ConnectionEvents.CONNECTION_INITIALIZED, connection=self)
+
+        return not self.plugin_failed
+
+    def ii_push_record(self, record: RecordRef) -> bool:
+        """Receive a record."""
+        self.status = ConnectionStatus.RECEIVING_RECORDS
+
+        for container in self.record_containers:
+            container.add_record(record)
+
+        self.notify_topic(ConnectionEvents.RECORD_RECEIVED, connection=self)
+
+        return not self.plugin_failed
+
+    def ii_update_progress(self, d_percent: float) -> None:
+        """Update progress of incoming data."""
+        self.progress_percentage = max(d_percent, 0)
+        self.notify_topic(
+            ConnectionEvents.PROGRESS_UPDATE, connection=self, percent=d_percent
+        )
+
+    def ii_close(self) -> None:
+        """Close the connection."""
+        self.status = ConnectionStatus.CLOSED
+        self.notify_topic(ConnectionEvents.CONNECTION_CLOSED, connection=self)

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

@@ -0,0 +1,53 @@
+# 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 Provider: Proxy class for DCM API."""
+import datetime as dt
+from typing import Dict, Optional
+
+from another_ayx_python_sdk.core import DcmBase
+from another_ayx_python_sdk.core.doc_utilities import inherit_docs
+
+
+@inherit_docs
+class E1ProviderDCM(DcmBase):
+    """Class that wraps  DCM API work."""
+
+    def get_connection(self, connection_id: str) -> Dict:  # noqa: D102
+        raise NotImplementedError()
+
+    def get_write_lock(
+        self,
+        connection_id: str,
+        role: str,
+        secret_type: str,
+        expires_in: Optional[dt.datetime],
+    ) -> Dict:  # noqa: D102
+        raise NotImplementedError()
+
+    def free_write_lock(
+        self, connection_id: str, role: str, secret_type: str, lock_id: str
+    ) -> None:  # noqa: D102
+        raise NotImplementedError()
+
+    def update_connection_secret(
+        self,
+        connection_id: str,
+        lock_id: str,
+        role: str,
+        secret_type: str,
+        value: str,
+        expires_on: Optional[dt.datetime],
+        parameters: Optional[Dict[str, str]],
+    ) -> Dict:  # noqa: D102
+        raise NotImplementedError()

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

@@ -0,0 +1,127 @@
+# 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.
+"""Proxy Class for managing SDK Environment."""
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import another_ayx_python_sdk.providers.e1_provider.mock_e1_sdk.AlteryxPythonSDK as Sdk
+
+from another_ayx_python_sdk.core.doc_utilities import inherit_docs
+from another_ayx_python_sdk.core.environment_base import (
+    EnvironmentBase,
+    Locale,
+    UpdateMode,
+)
+
+
+import xmltodict
+
+
+if TYPE_CHECKING:
+    from another_ayx_python_sdk.providers.e1_provider.e1_plugin_proxy import E1PluginProxy
+
+
+@inherit_docs
+class E1Environment(EnvironmentBase):
+    """Environment variables for Designer."""
+
+    __slots__ = ["_engine", "_tool_id", "_plugin_proxy", "_workflow_id"]
+
+    def __init__(
+        self, engine: Sdk.AlteryxEngine, tool_id: int, plugin_proxy: "E1PluginProxy"
+    ) -> None:
+        """Instantiate the Designer environment information."""
+        self._engine = engine
+        self._tool_id = tool_id
+        self._plugin_proxy = plugin_proxy
+        self._workflow_id = ""
+
+    @property
+    def update_only(self) -> bool:  # noqa: D102
+        return bool(self._engine.get_init_var(self._tool_id, "UpdateOnly") == "True")
+
+    @property
+    def update_mode(self) -> UpdateMode:  # noqa: D102
+        return UpdateMode(self._engine.get_init_var(self._tool_id, "UpdateMode"))
+
+    @property
+    def designer_version(self) -> str:  # noqa: D102
+        return str(self._engine.get_init_var(self._tool_id, "Version"))
+
+    @property
+    def workflow_dir(self) -> Path:  # noqa: D102
+        return Path(self._engine.get_init_var(self._tool_id, "DefaultDir"))
+
+    @property
+    def workflow_id(self) -> str:  # noqa: D102
+        return str(self._engine.get_init_var(self._tool_id, "WorkflowRunGuid"))
+
+    @property
+    def alteryx_install_dir(self) -> Path:  # noqa: D102
+        return (
+            Path(self._engine.get_init_var(self._tool_id, "RuntimeDataPath"))
+            .resolve()
+            .parent.parent
+        )
+
+    @property
+    def alteryx_locale(self) -> Locale:  # noqa: D102
+        designer_version = self.designer_version[0:6]
+        user_settings_path = (
+            Path(os.environ["APPDATA"])
+            / "Alteryx"
+            / "Engine"
+            / designer_version
+            / "UserSettings.xml"
+        )
+
+        with open(user_settings_path) as f:
+            user_settings = xmltodict.parse(f.read())
+            locale: Locale = user_settings["AlteryxSettings"]["GloablSettings"][
+                "HelpLanguage"
+            ]["#text"]
+            return locale
+
+    def get_settings_conf(
+        self, keys: list, version_override: str = ""
+    ) -> dict:  # noqa: D102
+        """Parse xml to retrieve settings."""
+        return super().get_settings_conf(keys, version_override)
+
+    def parse_settings_key_value(
+        self, settings_str: str, line_delimiter: str = "\n", key_delimiter: str = "="
+    ) -> dict:  # noqa: D102
+        return super().parse_settings_key_value(
+            settings_str, line_delimiter=line_delimiter, key_delimiter=key_delimiter
+        )
+
+    @property
+    def proxy_configuration(self) -> dict:  # noqa: D102
+        """Retrieve proxy config from UserSettings.xml."""
+        keys = ["AlteryxSettings", "GloablSettings", "ProxyConfiguration"]
+        conf = self.get_settings_conf(keys).get("#text", "")
+        return self.parse_settings_key_value(conf)
+
+    @property
+    def tool_id(self) -> int:  # noqa: D102
+        return self._tool_id
+
+    def update_tool_config(self, new_config: dict) -> None:  # noqa: D102
+        if self._plugin_proxy.workflow_config.original_data != new_config:
+            self._engine.output_message(
+                self._tool_id,
+                Sdk.Status.update_output_config_xml,
+                xmltodict.unparse({"Configuration": new_config}),
+            )

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

@@ -0,0 +1,51 @@
+# 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.
+"""Alteryx plugin input anchor definition."""
+from typing import List
+
+from another_ayx_python_sdk.core.doc_utilities import inherit_docs
+from another_ayx_python_sdk.core.input_anchor_base import InputAnchorBase
+from another_ayx_python_sdk.core.input_connection_base import InputConnectionBase
+from another_ayx_python_sdk.providers.e1_provider.e1_input_anchor_proxy import (
+    E1InputAnchorProxy,
+)
+from another_ayx_python_sdk.providers.e1_provider.e1_input_connection import E1InputConnection
+
+
+@inherit_docs
+class E1InputAnchor(InputAnchorBase):
+    """Input anchor to the tool."""
+
+    def __init__(self, input_anchor_proxy: E1InputAnchorProxy) -> None:
+        """Instantiate an input anchor."""
+        self._input_anchor_proxy = input_anchor_proxy
+
+    @property
+    def name(self) -> str:  # noqa: D102
+        return self._input_anchor_proxy.name
+
+    @property
+    def allow_multiple(self) -> bool:  # noqa: D102
+        return self._input_anchor_proxy.allow_multiple
+
+    @property
+    def optional(self) -> bool:  # noqa: D102
+        return self._input_anchor_proxy.optional
+
+    @property
+    def connections(self) -> List[InputConnectionBase]:  # noqa: D102
+        return [
+            E1InputConnection(connection)
+            for connection in self._input_anchor_proxy.connections
+        ]

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

@@ -0,0 +1,33 @@
+# 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.
+"""Alteryx plugin input anchor definition."""
+from typing import List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from another_ayx_python_sdk.providers.e1_provider.connection_interface import (
+        ConnectionInterface,
+    )
+
+
+class E1InputAnchorProxy:
+    """Input anchor to the tool."""
+
+    __slots__ = ["name", "allow_multiple", "optional", "connections"]
+
+    def __init__(self, name: str, allow_multiple: bool, optional: bool):
+        """Instantiate an input anchor."""
+        self.name = name
+        self.allow_multiple = allow_multiple
+        self.optional = optional
+        self.connections: List[ConnectionInterface] = []

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

@@ -0,0 +1,87 @@
+# 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 Input Connection class."""
+from typing import Optional, TYPE_CHECKING
+
+from another_ayx_python_sdk.core.doc_utilities import inherit_docs
+from another_ayx_python_sdk.core.input_connection_base import InputConnectionBase
+from another_ayx_python_sdk.providers.e1_provider.connection_interface import (
+    ConnectionInterface,
+)
+from another_ayx_python_sdk.providers.e1_provider.e1_record_packet import E1RecordPacket
+from another_ayx_python_sdk.providers.e1_provider.utilities import (
+    convert_record_info_to_metadata,
+)
+
+if TYPE_CHECKING:
+    from another_ayx_python_sdk.core.metadata import Metadata  # noqa: F401
+    from another_ayx_python_sdk.core.record_packet import RecordPacket
+    from another_ayx_python_sdk.providers.e1_provider.e1_input_anchor import E1InputAnchor
+
+
+@inherit_docs
+class E1InputConnection(InputConnectionBase):
+    """Class for managing Inputs in E1 SDK."""
+
+    def __init__(self, conn_interface: "ConnectionInterface") -> None:
+        """Instantiate the input connection."""
+        self._conn_interface = conn_interface
+
+    @property
+    def name(self) -> str:  # noqa: D102
+        return self._conn_interface.name
+
+    @property
+    def metadata(self) -> Optional["Metadata"]:  # noqa: D102
+        if self._conn_interface.record_info is None:
+            return None
+
+        return convert_record_info_to_metadata(self._conn_interface.record_info)
+
+    @property
+    def anchor(self) -> "E1InputAnchor":  # noqa: D102
+        from another_ayx_python_sdk.providers.e1_provider import E1InputAnchor
+
+        return E1InputAnchor(self._conn_interface.anchor)
+
+    def read(self) -> "RecordPacket":  # noqa: D102
+        if self.metadata is None:
+            raise RuntimeError("Input connection has not been opened yet.")
+
+        record_dataframe = self._conn_interface.record_containers[0].build_dataframe()
+
+        packet = E1RecordPacket.from_dataframe(self.metadata, record_dataframe)
+        self._conn_interface.clear_records()
+        return packet
+
+    def _get_max_packet_size(self) -> Optional[int]:
+        return self._conn_interface.record_batch_size
+
+    def _set_max_packet_size(self, value: Optional[int]) -> None:
+        if value and value <= 0:
+            raise ValueError(
+                "max_packet_size must be None or an integer greater than 0."
+            )
+
+        self._conn_interface.record_batch_size = value
+
+    @property
+    def progress(self) -> float:  # noqa: D102
+        return self._conn_interface.progress_percentage
+
+    @progress.setter
+    def progress(self, value: float) -> None:  # noqa: D102
+        if value < 0:
+            raise ValueError("Progress percentage must be greater than 0.")
+        self._conn_interface.progress_percentage = value