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

build/lib/another_ayx_python_sdk/providers/amp_provider/repositories/__init__.py

@@ -0,0 +1,67 @@
+# 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.
+"""Repository classes that store information coming from the out of process manager."""
+from typing import Iterable, Optional
+
+from .dcm_repository import DCMRepository
+from .environment_repository import EnvironmentRepository
+from .grpc_repository import GrpcRepository
+from .input_anchor_repository import InputAnchorRepository
+from .input_connection_repository import InputConnectionRepository
+from .input_metadata_repository import InputMetadataRepository
+from .input_record_packet_repository import InputRecordPacketRepository
+from .io_repository import IORepository
+from .output_anchor_repository import OutputAnchorRepository
+from .output_metadata_repository import OutputMetadataRepository
+from .output_record_packet_repository import OutputRecordPacketRepository
+from .plugin_class_repository import PluginClassRepository
+from .singleton import Singleton
+from .tool_config_repository import ToolConfigRepository
+
+
+def clear_repositories(exclude: Optional[Iterable] = None) -> None:
+    """Clear all repositories."""
+    exclude = exclude or {}
+
+    repos = [
+        var()
+        for name, var in globals().items()
+        if "repository" in name.lower()
+        and callable(var)
+        and hasattr(var(), "clear_repository")
+        and callable(var().clear_repository)
+        and var() not in exclude
+    ]
+
+    for repo in repos:
+        repo.clear_repository()
+
+
+__all__ = [
+    "DCMRepository",
+    "EnvironmentRepository",
+    "GrpcRepository",
+    "InputAnchorRepository",
+    "InputConnectionRepository",
+    "InputMetadataRepository",
+    "InputRecordPacketRepository",
+    "IORepository",
+    "OutputAnchorRepository",
+    "OutputMetadataRepository",
+    "OutputRecordPacketRepository",
+    "PluginClassRepository",
+    "Singleton",
+    "ToolConfigRepository",
+    "clear_repositories",
+]

build/lib/another_ayx_python_sdk/providers/amp_provider/repositories/dcm_repository.py

@@ -0,0 +1,252 @@
+# 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 that saves and retrieves AMP DCM information."""
+import datetime as dt
+import logging
+from typing import Dict, Optional
+
+from another_ayx_python_sdk.core.exceptions import DcmEError, DcmEException
+from another_ayx_python_sdk.providers.amp_provider.repositories.singleton import Singleton
+from another_ayx_python_sdk.providers.amp_provider.resources.generated.dcm_e_pb2 import (
+    DcmERequest,
+    DcmEResponse,
+)
+
+from google.protobuf import json_format
+
+import grpc
+
+logger = logging.getLogger(__name__)
+
+
+class DCMRepository(metaclass=Singleton):
+    """Repository that stores DCM information."""
+
+    from another_ayx_python_sdk.providers.amp_provider.resources.generated.sdk_engine_service_pb2_grpc import (
+        SdkEngineStub,
+    )
+
+    @staticmethod
+    def __get_grpc_client() -> "SdkEngineStub":
+        """
+        Get grpc sdk engine client.
+
+        Parameters
+        ----------
+        -
+        """
+        from another_ayx_python_sdk.providers.amp_provider.repositories.grpc_repository import (
+            GrpcRepository,
+        )
+
+        try:
+            return GrpcRepository().get_sdk_engine_client()
+        except ValueError:
+            raise DcmEException(
+                "Error getting GRPC client!",
+                DcmEError("Error getting GRPC client!", 10001),
+            )
+
+    @staticmethod
+    def __handle_response(res: DcmEResponse) -> Dict:
+        """Handle DcmE response."""
+        response_dict = json_format.MessageToDict(res.response)
+        if not res.success:
+            if (
+                "message" in response_dict.keys()
+                and "errorCode" in response_dict.keys()
+            ):
+                if "detail" in response_dict.keys():
+                    raise DcmEException(
+                        "Dcm.E Error!",
+                        DcmEError(
+                            response_dict["message"],
+                            int(response_dict["errorCode"]),
+                            response_dict["detail"],
+                        ),
+                    )
+                else:
+                    raise DcmEException(
+                        "Dcm.E Error!",
+                        DcmEError(
+                            response_dict["message"], int(response_dict["errorCode"])
+                        ),
+                    )
+            else:
+                raise DcmEException("Dcm.E Error!", DcmEError(res.response, 10003))
+
+        return response_dict
+
+    @staticmethod
+    def get_connection(connection_id: str) -> Dict:
+        """
+        Retrieve connection information including secrets by connection ID.
+
+        Parameters
+        ----------
+        connection_id
+            string with UUID of connection
+        """
+        logger.debug("Getting DCM connection for " + str(connection_id))
+        client = DCMRepository.__get_grpc_client()
+
+        try:
+            req = DcmERequest()
+            req.v2.get_connection.connection_id = connection_id
+            res = client.Dcm(req)
+        except grpc.RpcError:
+            raise DcmEException(
+                "Error getting DCM connection!",
+                DcmEError("Error getting DCM connection!"),
+                10002,
+            )
+        return DCMRepository.__handle_response(res)
+
+    @staticmethod
+    def update_connection_secret(
+        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 expiration of this secret
+        parameters
+            Dict of parameter values for this secret (this is arbitrary user data stored as JSON)
+        """
+        from google.protobuf.struct_pb2 import Struct
+
+        logger.debug("Updating DCM connection secret for " + str(connection_id))
+        client = DCMRepository.__get_grpc_client()
+
+        try:
+            req = DcmERequest()
+            req.v2.update_secret.connection_id = connection_id
+            req.v2.update_secret.lock_id = lock_id
+            req.v2.update_secret.credential_role = role
+            req.v2.update_secret.secret_type = secret_type
+            req.v2.update_secret.value = value
+            if parameters:
+                st = Struct()
+                st.update(parameters)
+                req.v2.update_secret.parameters.CopyFrom(st)
+            if expires_on:
+                req.v2.update_secret.expires_on = expires_on.isoformat()
+            res = client.Dcm(req)
+        except grpc.RpcError:
+            raise DcmEException(
+                "Error getting DCM connection!",
+                DcmEError("Error getting DCM connection!"),
+                10002,
+            )
+        return DCMRepository.__handle_response(res)
+
+    @staticmethod
+    def get_write_lock(
+        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.
+        """
+        logger.debug("Getting DCM write lock for " + str(connection_id))
+        client = DCMRepository.__get_grpc_client()
+
+        try:
+            req = DcmERequest()
+            req.v2.lock_secret.connection_id = connection_id
+            req.v2.lock_secret.credential_role = role
+            req.v2.lock_secret.secret_type = secret_type
+            if expires_in:
+                req.v2.lock_secret.expires_in = expires_in.isoformat()
+            res = client.Dcm(req)
+        except grpc.RpcError:
+            raise DcmEException(
+                "Error getting DCM connection!",
+                DcmEError("Error getting DCM connection!"),
+                10002,
+            )
+        return DCMRepository.__handle_response(res)
+
+    @staticmethod
+    def free_write_lock(
+        connection_id: str, role: str, secret_type: str, lock_id: str
+    ) -> None:
+        """
+        Frees 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()
+        """
+        logger.debug(
+            "Freeing DCM write lock for "
+            + str(connection_id)
+            + " lock_id: "
+            + str(lock_id)
+        )
+        client = DCMRepository.__get_grpc_client()
+
+        try:
+            req = DcmERequest()
+            req.v2.unlock_secret.connection_id = connection_id
+            req.v2.unlock_secret.credential_role = role
+            req.v2.unlock_secret.secret_type = secret_type
+            req.v2.unlock_secret.lock_id = lock_id
+            res = client.Dcm(req)
+        except grpc.RpcError:
+            raise DcmEException(
+                "Error getting DCM connection!",
+                DcmEError("Error getting DCM connection!"),
+                10002,
+            )
+        DCMRepository.__handle_response(res)

build/lib/another_ayx_python_sdk/providers/amp_provider/repositories/environment_repository.py

@@ -0,0 +1,212 @@
+# 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 that saves and retrieves AMP environment information."""
+import logging
+from pathlib import Path
+from typing import Dict, Optional, TYPE_CHECKING
+
+from another_ayx_python_sdk.core.environment_base import UpdateMode
+from another_ayx_python_sdk.core.exceptions import WorkflowRuntimeError
+from another_ayx_python_sdk.providers.amp_provider.repositories.singleton import Singleton
+from another_ayx_python_sdk.providers.amp_provider.resources.generated.plugin_initialization_data_pb2 import (
+    UpdateMode as Protobuf_UpdateMode,
+)
+
+if TYPE_CHECKING:
+    from another_ayx_python_sdk.core.environment_base import Locale
+
+logger = logging.getLogger()
+
+
+class EnvironmentRepository(metaclass=Singleton):
+    """Repository that stores environment information."""
+
+    def __init__(self) -> None:
+        """Initialize the environment repository."""
+        self._designer_version: Optional[str] = None
+        self._workflow_dir: Optional[Path] = None
+        self._alteryx_install_dir: Optional[Path] = None
+        self._temp_dir: Optional[str] = None
+        self._update_mode: Optional["UpdateMode"] = None
+        self._update_only: Optional[bool] = None
+        self._proxy_configuration: dict = {}
+
+    def get_update_only(self) -> bool:
+        """
+        Check if the tool is running in update only mode.
+
+        Returns
+        -------
+        bool
+            True if workflow isn't being run.
+        """
+        if self._update_only is None:
+            raise RuntimeError("Update Only has not been determined yet.")
+        return self._update_only
+
+    def get_update_mode(self) -> UpdateMode:
+        """
+        Get the type of tool update running.
+
+        Returns
+        -------
+        UpdateMode
+            Enum corresponding to the type of update mode designer is running in. (Quick, Full, No Update)
+        """
+        if self._update_mode is None:
+            raise RuntimeError("Update Mode has not been determined yet.")
+        return self._update_mode
+
+    def get_designer_version(self) -> str:
+        """
+        Get the version of designer that is running the tool.
+
+        Returns
+        -------
+        str
+            A version in the format of 1.2.3.4
+        """
+        if self._designer_version is None:
+            raise RuntimeError(
+                "Environment repository has not received the 'designer_version' engine constant yet."
+            )
+        return self._designer_version
+
+    def get_alteryx_install_dir(self) -> Path:
+        """
+        Get the directory where designer is stored.
+
+        Returns
+        -------
+        Path
+            The Alteryx install directory as a Path object.
+        """
+        if self._alteryx_install_dir is None:
+            raise RuntimeError(
+                "Environment repository has not received the 'alteryx_install_dir' engine constant yet."
+            )
+        return self._alteryx_install_dir
+
+    def get_temp_dir(self) -> str:
+        """
+        Get the directory where designer-managed temp files are created.
+
+        Returns
+        -------
+        str
+            The path to the directory where temporary files are stored.
+        """
+        if self._temp_dir is None:
+            raise RuntimeError(
+                "Environment repository has not received the 'temp_dir' engine constant yet."
+            )
+        return self._temp_dir
+
+    def get_alteryx_locale(self) -> "Locale":
+        """
+        Get the locale code from Alteryx user settings.
+
+        Returns
+        -------
+        Locale
+            The language / region that Alteryx is using to display messages.
+        """
+        # TODO
+        return "en"
+
+    def get_tool_id(self) -> int:
+        """
+        Get the ID of the tool.
+
+        Returns
+        -------
+        int
+            Tool's ID (specified by developer).
+        """
+        # TODO
+        return 0
+
+    def save_tool_config(self, new_config: dict) -> None:
+        """
+        Update the tool's configuration file.
+
+        Parameters
+        ----------
+        new_config
+            The new configuration to set for the tool.
+        """
+        from another_ayx_python_sdk.providers.amp_provider.repositories.tool_config_repository import (
+            ToolConfigRepository,
+        )
+
+        ToolConfigRepository().save_tool_config(new_config)
+
+    def get_proxy_configuration(self) -> dict:  # noqa: D102
+        return self._proxy_configuration
+
+    def save_engine_constants(self, constants: Dict[str, str]) -> None:
+        """
+        Save engine constants to repo.
+
+        Parameters
+        ----------
+        constants
+            The dictionary of engine constants received through gRPC
+        """
+        try:
+            self._designer_version = constants["Engine.Version"]
+            self._alteryx_install_dir = Path(constants["AlteryxExecutable"])
+            self._workflow_dir = Path(constants["Engine.WorkflowDirectory"])
+            self._temp_dir = constants["Engine.TempFilePath"]
+
+        except KeyError:
+            raise WorkflowRuntimeError(
+                "One or more Engine Constants missing from dictionary."
+            )
+        # The proxy config keys are not always present, so technically an optional kwarg here.
+        self._proxy_configuration = {}
+        if constants.get("ProxyConfiguration"):
+            for key_val_pair in constants["ProxyConfiguration"].split("\n"):
+                keyval = key_val_pair.split("=", 1)
+                # might have a blank or unset key
+                if len(keyval) > 1:
+                    self._proxy_configuration[keyval[0]] = keyval[1]
+
+    def save_update_mode(self, update_mode: int) -> None:
+        """
+        Save the passed in update mode.
+
+        Parameters
+        ----------
+        update_mode
+            An int that corresponds to the protobuf enumeration for the update mode that designer is running in.
+        """
+        if update_mode == Protobuf_UpdateMode.UM_Run:
+            self._update_mode = UpdateMode.NO_UPDATE_MODE
+            self._update_only = False
+        if update_mode == Protobuf_UpdateMode.UM_Full:
+            self._update_mode = UpdateMode.FULL
+            self._update_only = True
+        if update_mode == Protobuf_UpdateMode.UM_Quick:
+            self._update_mode = UpdateMode.QUICK
+            self._update_only = True
+
+    def clear_repository(self) -> None:
+        """Clear the repository."""
+        self._designer_version = None
+        self._workflow_dir = None
+        self._alteryx_install_dir = None
+        self._temp_dir = None
+        self._update_mode = None
+        self._update_only = None

build/lib/another_ayx_python_sdk/providers/amp_provider/repositories/grpc_repository.py

@@ -0,0 +1,119 @@
+# 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.
+"""Repository for gRPC objects."""
+from typing import Optional, TYPE_CHECKING
+
+from another_ayx_python_sdk.providers.amp_provider.repositories.singleton import Singleton
+
+if TYPE_CHECKING:
+    from grpc import Server
+    from another_ayx_python_sdk.providers.amp_provider.grpc_util import SocketAddress
+    from another_ayx_python_sdk.providers.amp_provider.resources.generated.sdk_engine_service_pb2_grpc import (
+        SdkEngineStub,
+    )
+
+
+class GrpcRepository(metaclass=Singleton):
+    """Class used to get the grpc client/server."""
+
+    def __init__(self) -> None:
+        """Construct the repository."""
+        self._client: Optional["SdkEngineStub"] = None
+        self._server: Optional["Server"] = None
+        self._server_address: Optional["SocketAddress"] = None
+
+    def save_sdk_engine_client(self, client: "SdkEngineStub") -> None:
+        """
+        Save the client.
+
+        Parameters
+        ----------
+        client
+            gRPC SdkEngineClient that can make calls to the services defined in the SdkEngineServicer.
+        """
+        self._client = client
+
+    def get_sdk_engine_client(self) -> "SdkEngineStub":
+        """
+        Get the client.
+
+        Returns
+        -------
+        SdkEngineStub
+            The SdkEngineClient to make calls with.
+        """
+        if self._client is None:
+            raise ValueError("Client has not been saved.")
+
+        return self._client
+
+    def save_sdk_tool_server(self, server: "Server") -> None:
+        """
+        Save the server.
+
+        Parameters
+        ----------
+        server
+            The SdkToolServer that is running on the Python process.
+        """
+        self._server = server
+
+    def get_sdk_tool_server(self) -> "Server":
+        """
+        Get the server.
+
+        Returns
+        -------
+        Server
+            The SdkToolServer.
+        """
+        if self._server is None:
+            raise ValueError("Server has not been saved.")
+
+        return self._server
+
+    def save_sdk_tool_server_address(self, address: "SocketAddress") -> None:
+        """
+        Save the server address.
+
+        Parameters
+        ----------
+        address
+            The IP address and port that the server is listening on.
+        """
+        self._server_address = address
+
+    def get_sdk_tool_server_address(self) -> "SocketAddress":
+        """
+        Get the server address.
+
+        Returns
+        -------
+        SocketAddress
+            The IP address and port that the server is listening on.
+        """
+        if self._server_address is None:
+            raise ValueError("Server address has not been saved.")
+
+        return self._server_address
+
+    def clear_sdk_engine_client(self) -> None:
+        """Clear the client."""
+        self._client = None
+
+    def clear_repository(self) -> None:
+        """Clear the repo."""
+        self._client = None
+        self._server = None
+        self._server_address = None