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

another_ayx_python_sdk/cli/workspace.py

@@ -0,0 +1,266 @@
+# 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.
+"""Configurations for managing the workspace."""
+import copy
+import json
+import os
+import shutil
+import string
+import xml.etree.ElementTree as Et
+from pathlib import Path
+from typing import Any, Dict, List
+
+from another_ayx_python_sdk.cli.utilities import get_install_dir
+from another_ayx_python_sdk.cli.yxi_builder import YxiBuilder
+
+from pydantic import BaseModel
+
+import xmltodict
+
+
+WORKSPACE_CONFIGURATION_FILE_NAME = "ayx_workspace.json"
+
+
+class WorkspaceError(Exception):
+    """Exception for workspace errors."""
+
+    pass
+
+
+class Workspace(BaseModel):
+    """Class that wraps all workspace configurations and handles basic workspace functions."""
+
+    workspace_dir: Path
+    tools: List[str]
+    yxi_name: str
+    tool_family_name: str
+
+    @classmethod
+    def build_workspace(
+        cls, workspace_directory: Path, allow_creation: bool = False
+    ) -> "Workspace":
+        """Create a workspace instance that wraps the configurations for the given workspace_directory."""
+        if not workspace_directory.is_dir():
+            if allow_creation:
+                Workspace._create_workspace_directory(workspace_directory)
+            else:
+                raise WorkspaceError("Workspace directory not found.")
+
+        workspace_config_path = workspace_directory / WORKSPACE_CONFIGURATION_FILE_NAME
+
+        if not workspace_config_path.exists():
+            raise WorkspaceError(
+                "ERROR: Specified workspace_directory isn't a workspace directory, "
+                f"since a {WORKSPACE_CONFIGURATION_FILE_NAME} file doesn't exist."
+                "Please use an existing workspace, or specify a directory that doesn't exist yet."
+            )
+
+        with open(
+            str(workspace_directory / WORKSPACE_CONFIGURATION_FILE_NAME), "r"
+        ) as f:
+            raw_data = json.load(f)
+            migrated_data = cls.migrate_raw_workspace_config(raw_data)
+
+            workspace = cls(workspace_dir=workspace_directory, **migrated_data)
+
+            if migrated_data != raw_data:
+                workspace.write()
+
+            return workspace
+
+    @classmethod
+    def _create_workspace_directory(cls, workspace_directory: Path) -> None:
+        """Copy the base configs to the tool directory."""
+        cls._copy_base_workspace_config(workspace_directory)
+
+        workspace = cls(
+            workspace_dir=workspace_directory,
+            yxi_name=workspace_directory.resolve().name,
+            tool_family_name=workspace_directory.resolve().name,
+            tools=[],
+        )
+        workspace.write()
+
+    @staticmethod
+    def _copy_base_workspace_config(workspace_directory: Path) -> None:
+        install_dir = get_install_dir()
+        shutil.copytree(
+            str(install_dir / "assets" / "base_tool_config"),
+            str(workspace_directory),
+        )
+        shutil.copy(
+            str(install_dir / "examples" / "requirements.txt"),
+            str(workspace_directory),
+        )
+
+    @classmethod
+    def migrate_raw_workspace_config(cls, data: Dict) -> Dict:
+        """Migrate raw JSON from old format to new format."""
+        migrated_data = copy.deepcopy(data)
+
+        if "tools" in data:
+            tools = migrated_data["tools"]
+
+            if not isinstance(tools, list):
+                raise WorkspaceError(
+                    "tools field in config file not properly formatted."
+                )
+
+            migrated_data["tools"] = [cls._migrate_tool(tool) for tool in tools]
+        else:
+            migrated_data["tools"] = []
+
+        return migrated_data
+
+    @staticmethod
+    def _migrate_tool(tool: Any) -> str:
+        # We migrated from a tools object, to just a simple list of tool names
+        if isinstance(tool, str):
+            return tool
+
+        if isinstance(tool, dict):
+            if "name" not in tool:
+                raise WorkspaceError(
+                    f"Couldn't find tool name in tool {tool} during migration."
+                )
+
+            name: str = tool["name"]
+            return name
+
+        raise WorkspaceError(
+            f"Couldn't parse tool {tool} during migration. "
+            "It should be a string, or an object with a 'name' key"
+        )
+
+    def add_tool_from_template(self, tool_name: str, template_tool_name: str) -> None:
+        """Add a tool to the workspace."""
+        tool_name_without_whitespace = remove_whitespace(tool_name)
+
+        if not tool_name_without_whitespace.isalnum():
+            raise WorkspaceError(f"The tool name is not alpha numeric: {tool_name}.")
+
+        new_tool_directory = (
+            self.workspace_dir / tool_name_without_whitespace
+        ).resolve()
+        if new_tool_directory.is_dir():
+            raise WorkspaceError(
+                f"The plugin '{tool_name_without_whitespace}' already exists in the workspace."
+            )
+
+        example_tool_directory = get_install_dir() / "examples" / template_tool_name
+        shutil.copytree(str(example_tool_directory), str(new_tool_directory))
+
+        self._update_config_file(template_tool_name, tool_name)
+        self._update_main_py(template_tool_name, tool_name_without_whitespace)
+
+        self.tools.append(tool_name_without_whitespace)
+        self.write()
+
+    def _update_config_file(self, example_tool_name: str, new_tool_name: str) -> None:
+        new_tool_name_no_whitespace = remove_whitespace(new_tool_name)
+        old_config_path = (
+            self.workspace_dir
+            / new_tool_name_no_whitespace
+            / f"{example_tool_name}Config.xml"
+        )
+        new_config_path = (
+            old_config_path.parent / f"{new_tool_name_no_whitespace}Config.xml"
+        )
+
+        os.rename(str(old_config_path), str(new_config_path))
+
+        with open(str(new_config_path)) as f:
+            config = xmltodict.parse(f.read())
+
+        config["AlteryxJavaScriptPlugin"]["Properties"]["MetaInfo"][
+            "Name"
+        ] = new_tool_name
+
+        with open(str(new_config_path), "w") as f:
+            f.write(xmltodict.unparse(config, pretty=True))
+
+    def _update_main_py(self, example_tool_name: str, new_tool_name: str) -> None:
+        """Update the name of the tool in the main.py file."""
+        main_filepath = self.workspace_dir / new_tool_name / "main.py"
+        with open(str(main_filepath), "r") as f:
+            content = f.read()
+
+        content = content.replace(example_tool_name, new_tool_name)
+        with open(str(main_filepath), "w") as f:
+            f.write(content)
+
+    def delete_tool(self, tool_name: str) -> None:
+        """Remove a tool from the workspace."""
+        tool_name_without_whitespace = remove_whitespace(tool_name)
+        if tool_name_without_whitespace not in self.tools:
+            raise WorkspaceError(
+                f"No tool folder found for {tool_name_without_whitespace}"
+            )
+
+        tool_path = self.workspace_dir / tool_name_without_whitespace
+        shutil.rmtree(tool_path, ignore_errors=True)
+        self.tools.remove(tool_name_without_whitespace)
+        self.write()
+
+    def build_yxi(
+        self, output_yxi_path: Path, package_requirements: bool = True
+    ) -> None:
+        """Build a YXI for the workspace."""
+        if not self.tools:
+            raise WorkspaceError("No tools have been added yet.")
+
+        self._set_tool_family()
+        YxiBuilder(
+            self.workspace_dir, output_yxi_path, self.tools[0], package_requirements
+        ).build_yxi()
+
+    def _set_tool_family(self) -> None:
+        """Ensure the workspace Config.xml and sub tools contains the tool family."""
+        xml_paths = [self.workspace_dir / "Config.xml"] + [
+            self.workspace_dir / tool / f"{tool}Config.xml" for tool in self.tools
+        ]
+
+        for path in xml_paths:
+            with open(str(path), "r") as config_file:
+                tree = Et.parse(config_file)
+                root_node = tree.getroot()
+                engine_settings = root_node.find("EngineSettings")
+
+                if engine_settings is None:
+                    raise ValueError("Config XML doesn't contain EngineSettings tag.")
+
+            engine_settings.attrib["ToolFamily"] = self.tool_family_name
+            tree.write(str(path))
+
+    def write(self) -> None:
+        """Write the workspace configurations to the workspace directory."""
+        workspace_config_path = self.workspace_dir / WORKSPACE_CONFIGURATION_FILE_NAME
+        with open(str(workspace_config_path), "w") as workspace_config_file:
+            workspace_config_file.write(
+                self.json(
+                    exclude={
+                        "workspace_dir": ...,
+                        "tools": {"__all__": {"ToolDirectory"}},
+                    },
+                    indent=2,
+                )
+            )
+
+
+def remove_whitespace(s: str) -> str:
+    """Remove whitespace from a string."""
+    for whitespace_char in string.whitespace:
+        s = s.replace(whitespace_char, "")
+
+    return s

another_ayx_python_sdk/cli/yxi_builder.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.
+"""Class for building YXIs."""
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import uuid
+from pathlib import Path
+
+
+class YxiBuilder:
+    """YXI Builder class."""
+
+    def __init__(
+        self,
+        workspace_dir: Path,
+        output_yxi_path: Path,
+        requirements_tool: str,
+        package_requirements: bool = True,
+    ) -> None:
+        """Construct a YXI Builder."""
+        self._workspace_dir = workspace_dir
+        self._output_yxi_path = output_yxi_path
+        self._requirements_tool = requirements_tool
+        self._package_requirements = package_requirements
+
+    def build_yxi(self) -> None:
+        """Build the YXI."""
+        zip_path = Path(f"{uuid.uuid4()}.zip")
+
+        with tempfile.TemporaryDirectory() as yxi_temp_folder:
+            yxi_temp_path = Path(yxi_temp_folder) / "temp"
+            self._copy_workspace(yxi_temp_path)
+
+            if self._package_requirements:
+                self._handle_requirements(yxi_temp_path)
+
+            self._delete_pycache_directories(yxi_temp_path)
+
+            shutil.make_archive(zip_path.stem, "zip", str(yxi_temp_path))
+
+        shutil.move(str(zip_path), str(self._output_yxi_path))
+
+    def _copy_workspace(self, dest_dir: Path) -> None:
+        shutil.copytree(str(self._workspace_dir), str(dest_dir))
+
+    def _handle_requirements(self, temp_yxi_dir: Path) -> None:
+        workspace_requirements_path = self._workspace_dir / "requirements.txt"
+        temp_tools_requirements_path = (
+            temp_yxi_dir / self._requirements_tool / "requirements.txt"
+        )
+
+        # Copy requirements to requirements tool
+        shutil.copy(str(workspace_requirements_path), str(temp_tools_requirements_path))
+
+        # E1 Provider ships wheels inside of a tool, so we must link to them in the
+        # requirements.txt so that the pip install finds the wheels offline
+        self._add_link_wheels_to_requirements(temp_tools_requirements_path)
+
+        # Download wheels to the requirements tool wheels directory
+        self._download_pip_packages(
+            temp_yxi_dir / self._requirements_tool / "wheels",
+            workspace_requirements_path,
+        )
+
+    def _add_link_wheels_to_requirements(self, requirements_path: Path) -> None:
+        user_install_wheels = f'--find-links "${{APPDATA}}/Alteryx/Tools/{self._requirements_tool}/wheels"\n'
+        admin_install_wheels = f'--find-links "${{ALLUSERSPROFILE}}/Alteryx/Tools/{self._requirements_tool}/wheels"\n'
+
+        with requirements_path.open(mode="r") as requirements_file:
+            requirements = requirements_file.readlines()
+
+        full_requirements_list = [
+            user_install_wheels,
+            admin_install_wheels,
+        ] + requirements
+
+        with requirements_path.open(mode="w") as requirements_file:
+            requirements_file.writelines(full_requirements_list)
+
+    @staticmethod
+    def _download_pip_packages(dest_dir: Path, requirements_path: Path) -> None:
+        """Download the pip wheels and store in dest_dir."""
+        dest_dir.mkdir()
+
+        commands = [
+            sys.executable,
+            "-m",
+            "pip",
+            "download",
+            "--platform",
+            "win_amd64",
+            "--no-deps",
+            "-r",
+            f"{requirements_path}",
+            "-d",
+            f"{dest_dir}",
+        ]
+
+        subprocess.run(commands)
+
+    @staticmethod
+    def _delete_pycache_directories(root_dir: Path) -> None:
+        """Delete all the pycache subdirectories of a given root."""
+        pycache_dirs = [
+            Path(root) / directory
+            for root, directories, _ in os.walk(str(root_dir))
+            for directory in directories
+            if directory == "__pycache__"
+        ]
+        for directory in pycache_dirs:
+            shutil.rmtree(str(directory), ignore_errors=True)

another_ayx_python_sdk/cli/yxi_installer.py

@@ -0,0 +1,45 @@
+# 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.
+"""Wrappers to handle interactions with YXI Installer."""
+from pathlib import Path
+from typing import List
+
+
+class YxiInstaller:
+    """Class that wraps install commands from the YXI Installer executable."""
+
+    def __init__(
+        self,
+        yxi_paths: List[Path],
+        alteryx_path: Path,
+        clean: bool = False,
+        update_venv: bool = False,
+    ) -> None:
+        if len(yxi_paths) < 1:
+            raise ValueError("At least one yxi path is required for the yxi installer.")
+
+        self.yxi_paths = yxi_paths
+        self.alteryx_path = alteryx_path
+        self.clean = clean
+        self.update_venv = update_venv
+
+    @staticmethod
+    def _get_installer_artifact_path() -> Path:
+        """Get the path to the YXI Installer excutable."""
+        curr_dir = Path(__file__).parent.parent.resolve()
+        return curr_dir / "assets" / "executables" / "yxi-installer.pyz"
+
+    def _get_yxi_paths(self) -> str:
+        """Get the paths to the YXIs as a CLI string."""
+        return " ".join([str(path) for path in self.yxi_paths])

another_ayx_python_sdk/core/__init__.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 Python SDK: Core classes and interfaces."""
+
+from .constants import Anchor, NULL_VALUE_PLACEHOLDER
+from .dcm_base import DcmBase
+from .environment_base import EnvironmentBase, UpdateMode
+from .field import Field, FieldType
+from .input_anchor_base import InputAnchorBase
+from .input_connection_base import InputConnectionBase
+from .io_base import IoBase
+from .metadata import Metadata
+from .output_anchor_base import OutputAnchorBase
+from .plugin import Plugin
+from .plugin_v2 import PluginV2
+from .provider_base import ProviderBase
+from .record_packet import RecordPacket
+from .record_packet_base import RecordPacketBase
+from .register_plugin import register_plugin
+
+__all__ = [
+    "Anchor",
+    "EnvironmentBase",
+    "UpdateMode",
+    "DcmBase",
+    "Field",
+    "FieldType",
+    "InputAnchorBase",
+    "InputConnectionBase",
+    "IoBase",
+    "Metadata",
+    "OutputAnchorBase",
+    "RecordPacket",
+    "RecordPacketBase",
+    "Plugin",
+    "PluginV2",
+    "ProviderBase",
+    "register_plugin",
+    "NULL_VALUE_PLACEHOLDER",
+]

another_ayx_python_sdk/core/constants.py

@@ -0,0 +1,25 @@
+# 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.
+"""Constant definitions."""
+from collections import namedtuple
+
+AWAIT_TIMEOUT = 5.0
+
+NULL_VALUE_PLACEHOLDER = "AYX_SDK_NULL_VALUE_PLACEHOLDER"
+
+AYX_PROXY_USERNAME_KEY = "ProxyCommonUserName"
+AYX_PROXY_PASSWORD_KEY = "ProxyCommonPassword"
+AYX_PROXY_CRED_REQ_KEY = "ProxyRequiresCredentials"
+
+Anchor = namedtuple("Anchor", ["name", "connection"])

another_ayx_python_sdk/core/dcm_base.py

@@ -0,0 +1,115 @@
+# 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.
+"""DCM API base class definition."""
+import datetime as dt
+from abc import ABC, abstractmethod
+from typing import Dict, Optional
+
+
+class DcmBase(ABC):
+    """
+    Dcm base class.
+
+    This base class provides API to work with engine's DCM objects .
+    """
+
+    @abstractmethod
+    def get_connection(self, connection_id: str) -> Dict:
+        """
+        Retrieve connection information including secrets by connection ID.
+
+        Parameters
+        ----------
+        connection_id
+            string with UUID of connection
+        """
+        raise NotImplementedError()
+
+    @abstractmethod
+    def get_write_lock(
+        self,
+        connection_id: str,
+        role: str,
+        secret_type: str,
+        expires_in: Optional[dt.datetime],
+    ) -> Dict:
+        """
+        Attempt to acquire an exclusive write lock.
+
+        Parameters
+        ----------
+        connection_id
+            string with UUID of connection
+        role
+            A role such as ?oauth?
+        secret_type
+            A secret type such as ?oauth_token?
+        expires_in
+            (Optional) A DateTime value in which to ask for the lock to be held for in milliseconds.
+            Defaults to 0.
+        """
+        raise NotImplementedError()
+
+    @abstractmethod
+    def free_write_lock(
+        self, connection_id: str, role: str, secret_type: str, lock_id: str
+    ) -> None:
+        """
+        Free a lock obtained from a previous call to get_write_lock().
+
+        Parameters
+        ----------
+        connection_id
+            string with UUID of connection
+        role
+            A role such as ?oauth?
+        secret_type
+            A secret type such as ?oauth_token?
+        lock_id
+            A lock_id acquired from a previous call to get_write_lock()
+        """
+        raise NotImplementedError()
+
+    @abstractmethod
+    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:
+        """
+        Update a single secret for role and secret_type to value as well as the optional expires_on and parameters.
+
+        Parameters
+        ----------
+        connection_id
+            A connection ID
+        lock_id
+            A lock ID acquired from get_write_lock()
+        role
+            A role such as ?oauth?
+        secret_type
+            A secret type such as ?oauth_token?
+        value
+            The new value to store for the secret
+        expires_on
+            (Optional) DateTime of expiration of this secret
+        parameters
+            Dict of parameter values for this secret (this is arbitrary user data stored as JSON)
+        """
+        raise NotImplementedError()