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

build/lib/build/lib/another_ayx_python_sdk/providers/file_provider/__init__.py

@@ -0,0 +1,32 @@
+# 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 Python SDK - File Adapter for standalone testing."""
+
+from .file_adapter import FileAdapter
+from .file_provider import FileProvider
+from .file_provider_input_anchor import FileProviderInputAnchor
+from .file_provider_input_connection import FileProviderInputConnection
+from .file_provider_output_anchor import FileProviderOutputAnchor
+from .tool_input import AnchorDefinition, ToolDefinition, ToolInput
+
+__all__ = [
+    "AnchorDefinition",
+    "FileAdapter",
+    "FileProvider",
+    "FileProviderInputAnchor",
+    "FileProviderInputConnection",
+    "FileProviderOutputAnchor",
+    "ToolDefinition",
+    "ToolInput",
+]

build/lib/build/lib/another_ayx_python_sdk/providers/file_provider/environment.py

@@ -0,0 +1,131 @@
+# 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.
+"""File provider runtime environment information."""
+import os
+from pathlib import Path
+from typing import Optional
+
+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
+
+
+@inherit_docs
+class Environment(EnvironmentBase):
+    """Environment information for the file provider."""
+
+    def __init__(self, update_config_path: Optional[Path] = None) -> None:
+        """
+        Instantiate the file provider environment information.
+
+        Parameters
+        ----------
+        update_config_path
+            The path to use if the tool config file should be updated.
+        """
+        self.__update_config_path = update_config_path
+
+    @property
+    def update_only(self) -> bool:
+        """
+        Check if the file provider is running in update-only mode.
+
+        Returns
+        -------
+        bool
+            False in the file provider because update-only mode is not implemented.
+        """
+        # TODO change this when update only mode gets implemented
+        return False
+
+    @property
+    def update_mode(self) -> UpdateMode:
+        """
+        Return NO_UPDATE_MODE because update-only mode is not implemented in the file provider.
+
+        Returns
+        -------
+        UpdateMode
+            Returns NO_UPDATE_MODE.
+        """
+        # TODO change this when update only mode gets implemented
+        return UpdateMode.NO_UPDATE_MODE
+
+    @property
+    def designer_version(self) -> str:
+        """
+        Return 0.0.0.0 because Designer is not being used.
+
+        Returns
+        -------
+        str
+            0.0.0.0
+        """
+        return "0.0.0.0"
+
+    @property
+    def workflow_dir(self) -> Path:  # noqa: D102
+        return Path(os.getcwd())
+
+    @property
+    def workflow_id(self) -> str:  # noqa: D102
+        return ""
+
+    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
+        )
+
+    def get_settings_conf(
+        self, keys: list, version_override: str = ""
+    ) -> dict:  # noqa: D102
+        """Parse xml to retrieve settings for a given designer version."""
+        return super().get_settings_conf(keys, version_override)
+
+    @property
+    def proxy_configuration(self) -> dict:  # noqa: D102
+        """Retrieve proxy config from UserSettings.xml."""
+        keys = ["AlteryxSettings", "GloablSettings", "ProxyConfiguration"]
+        return self.get_settings_conf(keys)
+
+    @property
+    def alteryx_install_dir(self) -> Path:
+        """File provider does not use Designer, so this should raise NotImplementedError."""
+        raise NotImplementedError()
+
+    @property
+    def alteryx_locale(self) -> Locale:
+        """File provider does not use Designer, so automatically return English."""
+        return "en"
+
+    @property
+    def tool_id(self) -> int:  # noqa: D102
+        return -1
+
+    def update_tool_config(self, new_config: dict) -> None:  # noqa: D102
+        if self.__update_config_path:
+            xml = xmltodict.unparse(
+                input_dict={"Configuration": new_config},
+                pretty=True,
+                short_empty_elements=True,
+            )
+            with open(self.__update_config_path, "w") as fd:
+                fd.write(xml + "\n")

build/lib/build/lib/another_ayx_python_sdk/providers/file_provider/file_adapter.py

@@ -0,0 +1,286 @@
+# 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.
+"""Converts file provider classes to and from XML and CSV files."""
+from pathlib import Path
+from typing import Any, Dict, List, Set
+from xml.parsers.expat import ExpatError
+
+from another_ayx_python_sdk.core.field import FieldType
+from another_ayx_python_sdk.core.metadata import Metadata
+from another_ayx_python_sdk.providers.file_provider.file_provider_input_anchor import (
+    FileProviderInputAnchor,
+)
+from another_ayx_python_sdk.providers.file_provider.file_provider_output_anchor import (
+    FileProviderOutputAnchor,
+)
+
+import pandas as pd
+
+import xmltodict
+
+
+class FileAdapter:
+    """
+    File adapter class definition.
+
+    This class converts input files into file provider objects and
+    then also converts file provider objects back into output files.
+    """
+
+    def __init__(self, tool_config: Path, workflow_config: Path):
+        """
+        Instantiate a file adapter.
+
+        Parameters
+        ----------
+        tool_config
+            The path to the XML file that contains the tool configuration.
+        workflow_config
+            The path to the XML file that contains the anchor configurations.
+        """
+        config = self.convert_to_dict(tool_config)
+        self.tool_config: Dict[str, Any] = config["Configuration"]
+        self.workflow_config = self.convert_to_dict(workflow_config)
+        tool_info = self.workflow_config["AlteryxJavaScriptPlugin"]["Properties"][
+            "MetaInfo"
+        ]
+        self.name = tool_info["Name"]
+        self.description = tool_info["Description"]
+        self.use_append: Set = set()
+
+    def convert_to_dict(self, xml_file: Path) -> Dict[str, Any]:
+        """
+        Convert a XML file to a Python dictionary.
+
+        Parameters
+        ----------
+        xml_file
+            The XML file that should be converted to a Python dictionary.
+
+        Returns
+        -------
+        Dict[str, Any]
+            The anchor configuration information.
+        """
+        try:
+            with open(xml_file) as fd:
+                return dict(xmltodict.parse(fd.read(), strip_whitespace=True))
+        except ExpatError:
+            raise RuntimeError(
+                f"Error while parsing file {xml_file}, make sure that this file is well-formed"
+            )
+
+    def csv_to_dataframe(self, input_file: Path) -> pd.DataFrame:
+        """
+        Convert a CSV file to a pandas dataframe.
+
+        Parameters
+        ----------
+        input_file
+            The input CSV file that should be converted to a pandas dataframe.
+
+        Returns
+        -------
+        pandas.Dataframe
+            The pandas dataframe that contains the input records.
+        """
+        return pd.read_csv(input_file)
+
+    def xml_to_metadata(self, xml_file: Path) -> Metadata:
+        """
+        Convert an XML file to record metadata.
+
+        Parameters
+        ----------
+        xml_file
+            The XML file that should be converted to Metadata.
+
+        Returns
+        -------
+        Metadata
+            The metadata information from the incoming XML file.
+        """
+        try:
+            metadata = Metadata()
+            metadata_dict = self.convert_to_dict(xml_file)
+            # Iterate through each element of the XML called "Field"
+            fields = metadata_dict["RecordInfo"]["Field"]
+            for field in fields:
+                name = field["@name"]  # required
+                field_type = FieldType(field["@type"])  # required
+                size = int(field.get("@size", 0))
+                scale = int(field.get("@scale", 0))
+                source = field.get("@source", "")
+                desc = field.get("@description", "")
+                metadata.add_field(
+                    name=name,
+                    field_type=field_type,
+                    size=size,
+                    scale=scale,
+                    source=source,
+                    description=desc,
+                )
+
+            return metadata
+        # Add additional context to why KeyError occured
+        except KeyError:
+            # TODO: log error messages (all of them not just this function) instead of printing it when logging goes into file provider
+            print("Metadata XML is missing attributes.")
+            print(
+                "The Metadata XML must have a 'RecordInfo' element as the root element, with 'Field' elements as its children."
+            )
+            print(
+                "Each 'Field' element in the metadata file must have the following attributes: 'name', 'size', 'type'."
+            )
+            raise
+
+    # TODO Remove duplicate code in build_input_anchors and build_output_anchors
+    def build_input_anchors(self) -> List[FileProviderInputAnchor]:
+        """
+        Build the input anchors based on anchor configuration settings.
+
+        Returns
+        -------
+        List[FileProviderInputAnchor]
+            The list of file provider input anchor information.
+        """
+        try:
+            anchor_settings = self.workflow_config["AlteryxJavaScriptPlugin"][
+                "GuiSettings"
+            ]
+
+            input_anchors = anchor_settings.get("InputConnections")
+            if not input_anchors:
+                input_anchor_configs = []
+            else:
+                input_anchor_configs_raw = input_anchors["Connection"]
+                if not isinstance(input_anchor_configs_raw, list):
+                    input_anchor_configs = [input_anchor_configs_raw]
+                else:
+                    input_anchor_configs = input_anchor_configs_raw
+
+            return [
+                FileProviderInputAnchor(
+                    name=config["@Name"],
+                    allow_multiple=config["@AllowMultiple"].lower() == "true",
+                    optional=config["@Optional"].lower() == "true",
+                )
+                for config in input_anchor_configs
+            ]
+        # error to add more context to KeyError
+        except KeyError:
+            print("Tool's workflow config XML is missing attributes.")
+            print(
+                "Each Connection in the config file must have the following attributes: 'Name', 'AllowMultiple', 'Optional'"
+            )
+            raise
+
+    def build_output_anchors(self) -> List[FileProviderOutputAnchor]:
+        """
+        Build the output anchors based on tool config settings.
+
+        Returns
+        -------
+        List[FileProviderOutputAnchor]
+            The list of file provider output anchor information.
+        """
+        try:
+            anchor_settings = self.workflow_config["AlteryxJavaScriptPlugin"][
+                "GuiSettings"
+            ]
+
+            output_anchors = anchor_settings.get("OutputConnections")
+
+            if not output_anchors:
+                output_anchor_configs = []
+            else:
+                output_anchor_configs_raw = output_anchors["Connection"]
+                if not isinstance(output_anchor_configs_raw, list):
+                    output_anchor_configs = [output_anchor_configs_raw]
+                else:
+                    output_anchor_configs = output_anchor_configs_raw
+
+            return [
+                FileProviderOutputAnchor(
+                    name=config["@Name"],
+                    allow_multiple=False,
+                    optional=config["@Optional"].lower() == "true",
+                )
+                for config in output_anchor_configs
+            ]
+        # Add more context to why KeyError occured
+        except KeyError:
+            # TODO: Add logging instead of printing
+            print("Tool's workflow config XML is missing attributes.")
+            print(
+                "Each Connection in the config file must have the following attributes: 'Name', 'AllowMultiple', 'Optional'"
+            )
+            raise
+
+    def dataframe_to_csv(self, output_file: Path, dataframe: pd.DataFrame) -> None:
+        """
+        Convert a pandas dataframe to an output CSV file.
+
+        Parameters
+        ----------
+        output_file
+            The path for the output file where the dataframe values should be held.
+        dataframe
+            The pandas dataframe that should be converted to a CSV file.
+        """
+        # TODO Add error handling for to_csv
+        dataframe.to_csv(
+            output_file,
+            index=False,
+            mode="a" if output_file in self.use_append else "w",
+            header=False if output_file in self.use_append else True,
+        )
+        self.use_append.add(output_file)
+
+    def metadata_to_xml(self, output_file: Path, metadata: Metadata) -> None:
+        """
+        Convert record metadata to a XML file.
+
+        Parameters
+        ----------
+        output_file
+            The path for the output file where the metadata information should be held.
+        metadata
+            The Metadata that should be converted to a XML file.
+        """
+        # Record each field in record metadata to a different row in an XML file
+        field_list = []
+        for field in metadata.fields:
+            field_dict = {
+                "@name": field.name,
+                "@type": field.type.value,
+            }
+            if field.size:
+                field_dict["@size"] = field.size
+            if field.description:
+                field_dict["@description"] = field.description
+            if field.scale:
+                field_dict["@scale"] = field.scale
+            if field.source:
+                field_dict["@source"] = field.source
+            field_list.append(field_dict)
+        fields_dict = {"Field": field_list}
+        to_xml = {"RecordInfo": fields_dict}
+
+        # Create the output XML file
+        xml = xmltodict.unparse(
+            input_dict=to_xml, pretty=True, short_empty_elements=True
+        )
+        with open(output_file, "w") as fd:
+            fd.write(xml + "\n")

build/lib/build/lib/another_ayx_python_sdk/providers/file_provider/file_provider.py

@@ -0,0 +1,185 @@
+# 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.
+"""File provider for testing a tool outside of Designer."""
+from logging import Logger
+from pathlib import Path
+from typing import Dict, List, Optional, TYPE_CHECKING, Type
+
+from another_ayx_python_sdk.core.doc_utilities import inherit_docs
+from another_ayx_python_sdk.core.plugin import Plugin
+from another_ayx_python_sdk.core.provider_base import ProviderBase
+from another_ayx_python_sdk.core.record_packet import RecordPacket
+from another_ayx_python_sdk.providers.file_provider.environment import Environment
+from another_ayx_python_sdk.providers.file_provider.file_adapter import FileAdapter
+from another_ayx_python_sdk.providers.file_provider.file_provider_dcm import FileProviderDCM
+from another_ayx_python_sdk.providers.file_provider.file_provider_input_connection import (
+    FileProviderInputConnection,
+)
+from another_ayx_python_sdk.providers.file_provider.iox import IO
+
+import deprecation
+
+if TYPE_CHECKING:
+    from another_ayx_python_sdk.providers.file_provider.file_provider_input_anchor import (
+        FileProviderInputAnchor,
+    )
+    from another_ayx_python_sdk.providers.file_provider.file_provider_output_anchor import (
+        FileProviderOutputAnchor,
+    )
+    from another_ayx_python_sdk.providers.file_provider.tool_input import AnchorDefinition
+
+
+user_plugin_class: Optional[Type[Plugin]] = None
+
+
+@deprecation.deprecated(
+    deprecated_in="1.0.3",
+    removed_in="2.0.0",
+    details="Use the Plugin CLI's test harness instead.",
+)
+@inherit_docs
+class FileProvider(ProviderBase):
+    """
+    File provider implementation.
+
+    The file provider will instantiate input and output connections for the
+    tool from input files and pass information along to the tool plugin.
+    """
+
+    def __init__(
+        self,
+        tool_config: Path,
+        workflow_config: Path,
+        inputs: "List[AnchorDefinition]",
+        outputs: "List[AnchorDefinition]",
+        update_tool_config: Optional[Path],
+    ):
+        """
+        Instantiate the file provider.
+
+        Parameters
+        ----------
+        tool_config
+            Tool configuration file.
+        workflow_config
+            Configuration file for anchor information.
+        inputs
+            The incoming input information.
+        outputs
+            The information that says where to store the outgoing information.
+        update_tool_config
+            An optional path that indicates whether to update the tool's config. If it is set,
+            the config will be updated at the specified path.
+        """
+        super().__init__()
+        self.__logger = Logger("File Provider")
+        self.__io = IO()
+        self.__dcm = FileProviderDCM()
+        self.__environment = Environment(update_tool_config)
+
+        self.adapter = FileAdapter(tool_config, workflow_config)
+        self.input_anchors = self.adapter.build_input_anchors()
+        self.output_anchors = self.adapter.build_output_anchors()
+
+        for input in inputs:
+            name = input.anchor_name
+            metadata_file = Path(input.metadata)
+            csv_file = Path(input.records)
+            self.__add_input_connection_to_anchor(name, metadata_file, csv_file)
+        # Add file information to the output anchors
+        for output in outputs:
+            name = output.anchor_name
+            metadata_file = Path(output.metadata)
+            csv_file = Path(output.records)
+            self.__populate_output_anchor(name, metadata_file, csv_file)
+
+    @property
+    def tool_config(self) -> Dict:  # noqa: D102
+        return self.adapter.tool_config
+
+    @property
+    def io(self) -> IO:  # noqa: D102
+        return self.__io
+
+    @property
+    def dcm(self) -> FileProviderDCM:  # noqa: D102
+        return self.__dcm
+
+    @property
+    def environment(self) -> Environment:  # noqa: D102
+        return self.__environment
+
+    @property
+    def logger(self) -> "Logger":  # noqa: D102
+        return self.__logger
+
+    def __add_input_connection_to_anchor(
+        self, name: str, metadata_file: Path, csv_file: Path
+    ) -> None:
+        """
+        Build an input connection from the provided metadata and record files.
+
+        Parameters
+        ----------
+        name
+            The input anchor the connection is associated with.
+        metadata_file
+            The input metadata associated with this connection.
+        csv_file
+            The input record info associated with this connection.
+        """
+        metadata = self.adapter.xml_to_metadata(metadata_file)
+        dataframe = self.adapter.csv_to_dataframe(csv_file)
+        # TODO deal with max_packet_size
+        record_packet = RecordPacket.from_dataframe(metadata, dataframe)
+        input_anchor = self.get_input_anchor(name)
+        # TODO figure out better input connection name
+        input_connection = FileProviderInputConnection(
+            self.adapter.name, metadata, record_packet, input_anchor
+        )
+        input_anchor.connections.append(input_connection)
+
+    def __populate_output_anchor(
+        self, name: str, metadata_file: Path, csv_file: Path
+    ) -> None:
+        """
+        Add the required file information to the output anchor.
+
+        Parameters
+        ----------
+        name
+            The output anchor the file information should be added to.
+        metadata_file
+            The output metadata file associated with this anchor.
+        csv_file
+            The output record info file associated with this connection.
+        """
+        output_anchor = self.get_output_anchor(name)
+        output_anchor.metadata_file = metadata_file
+        output_anchor.record_file = csv_file
+        output_anchor.file_adapter = self.adapter
+
+    def get_input_anchor(self, name: str) -> "FileProviderInputAnchor":  # noqa: D102
+        for input_anchor in self.input_anchors:
+            if name == input_anchor.name:
+                return input_anchor
+
+        raise RuntimeError("There was no input anchor found with name {}".format(name))
+
+    def get_output_anchor(self, name: str) -> "FileProviderOutputAnchor":  # noqa: D102
+        for output_anchor in self.output_anchors:
+            if name == output_anchor.name:
+                return output_anchor
+
+        raise RuntimeError("There was no output anchor found with name {}".format(name))

build/lib/build/lib/another_ayx_python_sdk/providers/file_provider/file_provider_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.
+"""File 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 FileProviderDCM(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()