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/e1_io.py

@@ -0,0 +1,71 @@
+# 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 SDK IO."""
+from pathlib import Path
+from typing import Any, cast
+
+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.io_base import IoBase
+
+import deprecation
+
+
+@inherit_docs
+class E1IO(IoBase):
+    """Class that wraps all IO communication with Alteryx Designer."""
+
+    __slots__ = ["_engine", "_tool_id"]
+
+    def __init__(self, engine: Sdk.AlteryxEngine, tool_id: int) -> None:
+        self._engine = engine
+        self._tool_id = tool_id
+
+    def error(self, error_msg: str) -> None:  # noqa: D102
+        self._engine.output_message(
+            self._tool_id, Sdk.EngineMessageType.error, str(error_msg)
+        )
+
+    def warn(self, warn_msg: str) -> None:  # noqa: D102
+        self._engine.output_message(
+            self._tool_id, Sdk.EngineMessageType.warning, str(warn_msg)
+        )
+
+    def info(self, info_msg: str) -> None:  # noqa: D102
+        self._engine.output_message(
+            self._tool_id, Sdk.EngineMessageType.info, str(info_msg)
+        )
+
+    def translate_msg(self, msg: str, *args: Any) -> str:  # noqa: D102
+        stringified_args = [str(arg) for arg in args]
+        translated_msg: str = self._engine.xmsg(msg, *stringified_args)
+        return translated_msg
+
+    def update_progress(self, percent: float) -> None:  # noqa: D102
+        self._engine.output_tool_progress(self._tool_id, percent)
+
+    def create_temp_file(
+        self, extension: str = "tmp", options: int = 0
+    ) -> Path:  # noqa: D102
+        return Path(str(self._engine.create_temp_file_name(extension, options)))
+
+    @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, password: str) -> str:  # noqa: D102
+        # mode 0 being passed here means decryption
+        return cast(str, self._engine.decrypt_password(password, 0))

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

@@ -0,0 +1,157 @@
+# 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 output anchor definition."""
+from enum import Enum, unique
+from typing import Iterator, Optional, TYPE_CHECKING
+
+import another_ayx_python_sdk.providers.e1_provider.mock_e1_sdk.AlteryxPythonSDK as Sdk
+
+
+from another_ayx_python_sdk.core import OutputAnchorBase
+from another_ayx_python_sdk.core.doc_utilities import inherit_docs
+from another_ayx_python_sdk.core.metadata import Metadata
+from another_ayx_python_sdk.core.record_packet import RecordPacket
+from another_ayx_python_sdk.providers.e1_provider.e1_output_anchor_proxy import (
+    E1OutputAnchorProxy,
+)
+from another_ayx_python_sdk.providers.e1_provider.e1_record_packet import E1RecordPacket
+from another_ayx_python_sdk.providers.e1_provider.proxies.field_proxy import FieldProxy
+from another_ayx_python_sdk.providers.e1_provider.utilities import (
+    convert_metadata_to_record_info,
+    fill_df_nulls_with_blackbird_nulls,
+)
+
+if TYPE_CHECKING:
+    from another_ayx_python_sdk.core.record_packet_base import RecordPacketBase
+    import pandas as pd
+
+
+@unique
+class OutputAnchorStatus(Enum):
+    """Output anchor status enumeration."""
+
+    CREATED = 0
+    OPEN = 1
+    CLOSED = 2
+
+
+@inherit_docs
+class E1OutputAnchor(OutputAnchorBase):
+    """Output anchor definition."""
+
+    __slots__ = ["_output_anchor_proxy", "_engine", "_metadata", "_status"]
+
+    def __init__(
+        self,
+        output_anchor_proxy: E1OutputAnchorProxy,
+        engine: Sdk.AlteryxEngine,
+    ) -> None:
+        """Initialize an output anchor."""
+        self._output_anchor_proxy = output_anchor_proxy
+        self._engine = engine
+        self._metadata: Optional[Metadata] = None
+        self._status = OutputAnchorStatus.CREATED
+
+    @property
+    def name(self) -> str:  # noqa: D102
+        return self._output_anchor_proxy.name
+
+    @property
+    def allow_multiple(self) -> bool:  # noqa: D102
+        return self._output_anchor_proxy.allow_multiple
+
+    @property
+    def optional(self) -> bool:  # noqa: D102
+        return self._output_anchor_proxy.optional
+
+    @property
+    def num_connections(self) -> int:  # noqa: D102
+        return self._output_anchor_proxy.num_connections
+
+    @property
+    def is_open(self) -> bool:
+        """Get status indicating if the anchor is open."""
+        return self._status == OutputAnchorStatus.OPEN
+
+    @property
+    def metadata(self) -> Optional["Metadata"]:
+        """Get the anchor metadata."""
+        return self._metadata
+
+    def open(self, metadata: Metadata) -> None:  # noqa: D102
+        if self._status.value > OutputAnchorStatus.CREATED.value:
+            raise RuntimeError("Output anchor has already been opened.")
+
+        self._metadata = metadata
+        self._output_anchor_proxy.record_info = convert_metadata_to_record_info(
+            metadata, self._engine
+        )
+        self._output_anchor_proxy.push_metadata()
+        self._status = OutputAnchorStatus.OPEN
+
+    def write(self, record_packet: "RecordPacketBase") -> None:  # noqa: D102
+        if self._status != OutputAnchorStatus.OPEN:
+            raise RuntimeError("Anchor must be opened before it can be written to.")
+
+        if isinstance(record_packet, E1RecordPacket) or isinstance(
+            record_packet, RecordPacket
+        ):
+            self._output_anchor_proxy.push_records(
+                generate_records_from_df(
+                    record_packet.to_dataframe(), self._output_anchor_proxy.record_info
+                )
+            )
+        else:
+            raise ValueError(
+                "The E1 SDK Provider only supports E1RecordPacket and "
+                "RecordPacket implementations of RecordPacketBase."
+            )
+
+    def flush(self) -> None:  # noqa: D102
+        # The E1 Provider doesn't support flush, so just pass
+        pass
+
+    def close(self) -> None:  # noqa: D102
+        if self._status != OutputAnchorStatus.OPEN:
+            raise RuntimeError("Output anchor is not open, so it cannot be closed.")
+
+        self._output_anchor_proxy.close()
+        self._status = OutputAnchorStatus.CLOSED
+
+    def update_progress(self, percent: float) -> None:  # noqa: D102
+        if self._status != OutputAnchorStatus.OPEN:
+            raise RuntimeError(
+                "Output anchor must be open before progress can be written."
+            )
+        self._output_anchor_proxy.update_progress(percent)
+
+
+def generate_records_from_df(
+    df: "pd.DataFrame", record_info: Sdk.RecordInfo
+) -> Iterator[Sdk.RecordCreator]:
+    """Generate record creators from a dataframe."""
+    fill_df_nulls_with_blackbird_nulls(df)
+    columns = list(df)
+    field_map = {field.name: FieldProxy(field) for field in record_info}
+    fields = [field_map[column_name] for column_name in columns]
+
+    record_creator = record_info.construct_record_creator()
+
+    col_range = range(len(fields))
+    for row in df.itertuples():
+        record_creator.reset()
+        for col_idx in col_range:
+            fields[col_idx].set(record_creator, row[col_idx + 1])
+
+        yield record_creator

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

@@ -0,0 +1,97 @@
+# 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 output anchor definition."""
+from typing import Callable, Iterable, Optional
+
+import another_ayx_python_sdk.providers.e1_provider.mock_e1_sdk.AlteryxPythonSDK as Sdk
+
+
+class E1OutputAnchorProxy:
+    """Output anchor definition."""
+
+    __slots__ = [
+        "engine_anchor_ref",
+        "_metadata_pushed",
+        "__record_info",
+        "name",
+        "allow_multiple",
+        "optional",
+        "num_connections",
+        "push_records",
+    ]
+
+    def __init__(
+        self,
+        name: str,
+        allow_multiple: bool,
+        optional: bool,
+        output_anchor_mgr: Sdk.OutputAnchorManager,
+        record_info: Optional[Sdk.RecordInfo] = None,
+    ) -> None:
+        """Initialize an output anchor."""
+        engine_anchor_ref_optional = output_anchor_mgr.get_output_anchor(name)
+        if engine_anchor_ref_optional is None:
+            raise RuntimeError(f"Can't find output anchor: {name}")
+        else:
+            self.engine_anchor_ref: Sdk.OutputAnchor = engine_anchor_ref_optional
+
+        self._metadata_pushed: bool = False
+        self.__record_info = record_info
+        self.name = name
+        self.allow_multiple = allow_multiple
+        self.optional = optional
+        self.num_connections: int = 0
+        self.push_records: Callable = self._raise_metadata_error
+
+    @property
+    def record_info(self) -> Optional[Sdk.RecordInfo]:
+        """Getter for record info."""
+        return self.__record_info
+
+    @record_info.setter
+    def record_info(self, value: Sdk.RecordInfo) -> None:
+        """Setter for record info."""
+        if self._metadata_pushed:
+            raise RuntimeError("Can't reassign record_info after it has been pushed.")
+
+        self.__record_info = value
+
+    def update_progress(self, percent: float) -> None:
+        """Push the progress to downstream tools."""
+        self.engine_anchor_ref.update_progress(percent)
+
+    def push_metadata(self) -> None:
+        """Push metadata to downstream tools."""
+        if self.record_info is None:
+            raise ValueError("record_info must be set before metadata can be pushed.")
+
+        if not self._metadata_pushed:
+            self.engine_anchor_ref.init(self.record_info)
+            self._metadata_pushed = True
+            self.push_records = self._push_records
+        else:
+            raise RuntimeError("Metadata is trying to be pushed a second time.")
+
+    def _raise_metadata_error(self, _: Iterable[Sdk.RecordCreator]) -> None:
+        """Push records out."""
+        raise RuntimeError("Must run push_metadata before push_records can be called.")
+
+    def _push_records(self, record_creators: Iterable[Sdk.RecordCreator]) -> None:
+        """Push all records passed from iterable."""
+        for record_creator in record_creators:
+            self.engine_anchor_ref.push_record(record_creator.finalize_record(), False)
+
+    def close(self) -> None:
+        """Close the output anchor."""
+        self.engine_anchor_ref.close()

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

@@ -0,0 +1,63 @@
+# 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 Driver Class."""
+from typing import Optional, TYPE_CHECKING, Type
+
+from another_ayx_python_sdk.providers.e1_provider.e1_input_connection import E1InputConnection
+from another_ayx_python_sdk.providers.e1_provider.records import ParsedRecordContainer
+
+if TYPE_CHECKING:
+    from another_ayx_python_sdk.core.plugin import Plugin  # noqa: F401
+    from another_ayx_python_sdk.core.provider_base import ProviderBase
+    from another_ayx_python_sdk.providers.e1_provider.connection_interface import (
+        ConnectionInterface,
+    )
+
+
+class E1PluginDriver:
+    """Wrapper around the plugin to expose only interfaces defined for a provider."""
+
+    def __init__(self, user_plugin_class: Type["Plugin"], provider: "ProviderBase"):
+        """Construct the E1Provider."""
+        self._provider = provider
+        self._user_plugin_class = user_plugin_class
+        self._user_plugin: Optional["Plugin"] = None
+
+    def initialize_plugin(self) -> None:
+        """Initialize plugin."""
+        self._user_plugin = self._user_plugin_class(self._provider)
+
+    def initialize_connection(self, connection: "ConnectionInterface") -> None:
+        """Initialize a connection."""
+        if connection.record_info is None:
+            raise RuntimeError("Record info must be present before setting containers.")
+
+        if self._user_plugin is None:
+            raise ValueError("user_plugin hasn't been set.")
+
+        connection.add_record_container(ParsedRecordContainer(connection.record_info))
+        self._user_plugin.on_input_connection_opened(E1InputConnection(connection))
+
+    def on_record_packet(self, connection: "ConnectionInterface") -> None:
+        """Handle the record packet received through the input connection."""
+        if self._user_plugin is None:
+            raise ValueError("user_plugin hasn't been set.")
+
+        self._user_plugin.on_record_packet(E1InputConnection(connection))
+
+    def on_complete(self) -> None:
+        """Close plugin code after all records have finished streaming."""
+        if self._user_plugin is None:
+            raise ValueError("user_plugin hasn't been set.")
+        self._user_plugin.on_complete()