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

another_ayx_python_sdk/providers/amp_provider/grpc_helpers/control_msgs.py

@@ -0,0 +1,189 @@
+# 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.
+"""Helper functions to create record transfer message types."""
+import logging
+from functools import wraps
+from typing import Callable, Dict, TYPE_CHECKING
+from uuid import uuid4
+
+from another_ayx_python_sdk.providers.amp_provider.resources.generated.outgoing_metadata_push_pb2 import (
+    OutgoingMetadataPush,
+)
+from another_ayx_python_sdk.providers.amp_provider.resources.generated.output_message_data_pb2 import (
+    OutputMessageData,
+    OutputMessageTypes,
+)
+from another_ayx_python_sdk.providers.amp_provider.resources.generated.password_data_pb2 import (
+    PasswordData,
+)
+from another_ayx_python_sdk.providers.amp_provider.resources.generated.sdk_tool_service_v2_pb2 import (
+    ControlOut,
+)
+from another_ayx_python_sdk.providers.amp_provider.resources.generated.translate_message_data_pb2 import (
+    TranslateMessageData,
+)
+from another_ayx_python_sdk.providers.amp_provider.resources.generated.update_progress_pb2 import (
+    UpdateProgress,
+)
+
+if TYPE_CHECKING:
+    from pyarrow import Schema  # noqa F401
+
+
+OUTPUT_MSG = "output_message"
+TRANSLATED_MSG = "translated_message"
+TRANSLATE_MSG = "translate_message"
+DECRYPT_PW = "decrypt_password"
+DCME_REQ = "dcm_e_request"
+METADATA_MSG = "outgoing_metadata"
+UPDATE_MSG = "update_progress"
+
+ACCEPTED_PAYLOADS = set(
+    [OUTPUT_MSG, TRANSLATE_MSG, DECRYPT_PW, DCME_REQ, METADATA_MSG, UPDATE_MSG]
+)
+
+logger = logging.getLogger()
+
+
+def ctrl_out_wrapper(which_payload: str, set_id: bool = False) -> Callable:
+    """Wrap a payload, returned by the decorated function, in a ControlOut message."""
+
+    def _inner(func: Callable) -> Callable:
+        @wraps(func)
+        def set_payload(*args: tuple, **kwargs: dict) -> ControlOut:
+            if which_payload not in ACCEPTED_PAYLOADS:
+                logger.error("Can not assign CtrlOut payload %s", which_payload)
+                raise AttributeError
+            msg = ControlOut()
+            if set_id:
+                msg.msg_id = str(uuid4())
+            ptr_msg_payload = getattr(msg, which_payload)
+            ptr_msg_payload.CopyFrom(func(*args, **kwargs))
+            return msg
+
+        return set_payload
+
+    return _inner
+
+
+def _output_msg_data(control_values: Dict) -> ControlOut:
+    return ControlOut(output_message=OutputMessageData(**control_values))
+
+
+def _translate_msg(control_values: Dict) -> ControlOut:
+    ctrl_out_msg = ControlOut(translate_message=TranslateMessageData(**control_values))
+    ctrl_out_msg.msg_id = str(uuid4())
+    return ctrl_out_msg
+
+
+def _decrypt_password(control_values: Dict) -> ControlOut:
+    msg = ControlOut(decrypt_password=PasswordData(**control_values))
+    msg.msg_id = str(uuid4())
+    return msg
+
+
+def _confirm_complete() -> ControlOut:
+    msg = ControlOut()
+    msg.confirm_complete.SetInParent()
+    return msg
+
+
+ctrl_out_payload_fn = {
+    OUTPUT_MSG: _output_msg_data,
+    TRANSLATE_MSG: _translate_msg,
+    DECRYPT_PW: _decrypt_password,
+}
+
+
+def new_control_out_msg(control_values: dict, oneof_key: str) -> ControlOut:
+    """Create a ControlOut msg from passed values and payload key."""
+    if oneof_key == "confirm_complete":
+        return _confirm_complete()
+    new_msg_w_payload = ctrl_out_payload_fn[oneof_key]
+    return new_msg_w_payload(control_values)
+
+
+@ctrl_out_wrapper(OUTPUT_MSG)
+def new_ctrl_out_error_msg(err_msg: str, priority: int) -> ControlOut:
+    """Create a message with the Error type flag."""
+    msg_data = {
+        "message_type": OutputMessageTypes.OMT_Error,
+        "message": err_msg,
+        "priority": priority,
+    }
+    return OutputMessageData(**msg_data)
+
+
+@ctrl_out_wrapper(OUTPUT_MSG)
+def new_ctrl_out_info_msg(info_msg: str, priority: int) -> ControlOut:
+    """Create a message with the Info type flag."""
+    msg_data = {
+        "message_type": OutputMessageTypes.OMT_Info,
+        "message": info_msg,
+        "priority": priority,
+    }
+    return OutputMessageData(**msg_data)
+
+
+@ctrl_out_wrapper(OUTPUT_MSG)
+def new_ctrl_out_warn_msg(warn_msg: str, priority: int) -> ControlOut:
+    """Create a message with the Warn type flag."""
+    msg_data = {
+        "message_type": OutputMessageTypes.OMT_Warning,
+        "message": warn_msg,
+        "priority": priority,
+    }
+    return OutputMessageData(**msg_data)
+
+
+@ctrl_out_wrapper(OUTPUT_MSG)
+def new_ctrl_out_save_config(tool_config: str) -> ControlOut:
+    """Create a message with the Warn type flag."""
+    msg_data = {
+        "message_type": OutputMessageTypes.OMT_UpdateOutputConfigXml,
+        "message": tool_config,
+    }
+    return OutputMessageData(**msg_data)
+
+
+@ctrl_out_wrapper(TRANSLATE_MSG, set_id=True)
+def new_ctrl_out_translate_msg(msg: str, *args) -> ControlOut:  # type: ignore
+    """Create a ControlOut.translate_message."""
+    msg_data = {
+        "unlocalized_string": msg,
+        "interpolation_data": [str(arg) for arg in args] if len(args) > 0 else [],
+    }
+    return TranslateMessageData(**msg_data)
+
+
+@ctrl_out_wrapper(DECRYPT_PW, set_id=True)
+def new_ctrl_out_decrypt_msg(pw: str) -> ControlOut:
+    """Create ControlOut.decrypt_password."""
+    return PasswordData(password=pw)
+
+
+@ctrl_out_wrapper(METADATA_MSG)
+def new_ctrl_out_metadata_msg(anchor_name: str, metadata: "Schema") -> ControlOut:
+    """Create ControlOut.outgoing_metadata_push."""
+    as_bytes = metadata.serialize().to_pybytes()
+    return OutgoingMetadataPush(output_anchor_name=anchor_name, schema=as_bytes)
+
+
+@ctrl_out_wrapper(UPDATE_MSG)
+def new_ctrl_out_update_progress_msg(progress: float) -> ControlOut:
+    """Create ControlOut.outgoing_metadata_push."""
+    msg_data = {
+        "value": progress,
+    }
+    return UpdateProgress(**msg_data)

another_ayx_python_sdk/providers/amp_provider/grpc_helpers/dcme_msgs.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.
+"""AMP Provider: Proxy class for DCM API."""
+import datetime as dt
+from typing import Dict, Optional
+
+from another_ayx_python_sdk.core.exceptions import DcmEError, DcmEException
+from another_ayx_python_sdk.providers.amp_provider.resources.generated.dcm_e_pb2 import (
+    DcmERequest,
+    DcmEResponse,
+)
+
+from google.protobuf import json_format
+from google.protobuf.struct_pb2 import Struct
+
+from .control_msgs import DCME_REQ, ctrl_out_wrapper
+
+
+@ctrl_out_wrapper(DCME_REQ, set_id=True)
+def get_connection_msg(connection_id: str) -> DcmERequest:  # noqa: D102
+    """Create a connection request message."""
+    req = DcmERequest()
+    req.v2.get_connection.connection_id = connection_id
+    return req
+
+
+@ctrl_out_wrapper(DCME_REQ, set_id=True)
+def get_write_lock_msg(
+    connection_id: str,
+    role: str,
+    secret_type: str,
+    expires_in: Optional[dt.datetime] = None,
+) -> DcmERequest:  # noqa: D102
+    """Create a LockSecret message."""
+    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()
+    return req
+
+
+@ctrl_out_wrapper(DCME_REQ, set_id=True)
+def free_write_lock_msg(
+    connection_id: str, role: str, secret_type: str, lock_id: str
+) -> DcmERequest:  # noqa: D102
+    """Create a UnlockSecret message."""
+    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
+    return req
+
+
+@ctrl_out_wrapper(DCME_REQ, set_id=True)
+def update_connection_secret_msg(
+    connection_id: str,
+    lock_id: str,
+    role: str,
+    secret_type: str,
+    value: str,
+    expires_on: Optional[dt.datetime],
+    parameters: Optional[Dict[str, str]],
+) -> DcmERequest:  # noqa: D102
+    """Create UpdateSecret message."""
+    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()
+    return req
+
+
+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():
+                response_dict["dcme_exception"] = DcmEException(
+                    "Dcm.E Error!",
+                    DcmEError(
+                        response_dict["message"],
+                        int(response_dict["errorCode"]),
+                        response_dict["detail"],
+                    ),
+                )
+            else:
+                response_dict["dcme_exception"] = DcmEException(
+                    "Dcm.E Error!",
+                    DcmEError(
+                        response_dict["message"], int(response_dict["errorCode"])
+                    ),
+                )
+        else:
+            response_dict["dcme_exception"] = DcmEException(
+                "Dcm.E Error!", DcmEError(res.response, 10003)
+            )
+    return response_dict

another_ayx_python_sdk/providers/amp_provider/grpc_helpers/record_transfer_msgs.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.
+"""Helper functions to create record transfer message types."""
+
+from another_ayx_python_sdk.providers.amp_provider.resources.generated.sdk_tool_service_v2_pb2 import (
+    OutgoingRecords,
+    RecordTransferOut,
+    WantRecords,
+)
+
+
+def new_record_transfer_out_msg(
+    record_values: dict, oneof_key: str
+) -> RecordTransferOut:
+    """Create a RecordTransferOut msg from passed values and payload key."""
+    msg = RecordTransferOut()
+    if oneof_key == "outgoing_records":
+        msg = RecordTransferOut(outgoing_records=OutgoingRecords(**record_values))
+    else:
+        msg = RecordTransferOut(want_records=WantRecords(record_values["anchor_name"]))
+    return msg

another_ayx_python_sdk/providers/amp_provider/grpc_util.py

@@ -0,0 +1,161 @@
+# 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.
+"""Utility methods and classes for use with gRPC."""
+import logging
+import sys
+from concurrent import futures
+from typing import Any
+
+from another_ayx_python_sdk.providers.amp_provider.resources.generated.sdk_engine_service_pb2_grpc import (
+    SdkEngineStub,
+)
+from another_ayx_python_sdk.providers.amp_provider.resources.generated.sdk_tool_service_v2_pb2_grpc import (
+    SdkToolV2Stub,
+    add_SdkToolV2Servicer_to_server,
+)
+from another_ayx_python_sdk.providers.amp_provider.sdk_tool_service_v2 import SdkToolServiceV2
+
+import grpc
+
+if sys.platform == "win32":
+    from another_ayx_python_sdk.providers.amp_provider.cng_certs import read_windows_store_chain
+
+logger = logging.getLogger(__name__)
+
+
+def build_sdk_tool_server(sdk_tool_address: str):  # type: ignore
+    """
+    Build the SDK Tool Server.
+
+    Parameters
+    ----------
+    sdk_tool_address: str
+        A socket address that corresponds to the sdk tool.
+
+    Returns
+    -------
+    server
+        An instance of the SDK Tool Service gRPC server.
+
+    sdk_tool_address
+        A copy of the sdk_tool_address parameter, modified to point at server's open port.
+    """
+    server = grpc.aio.server(
+        futures.ThreadPoolExecutor(max_workers=10),
+        options=[
+            ("grpc.max_send_message_length", -1),
+            ("grpc.max_receive_message_length", -1),
+        ],
+    )
+    add_SdkToolV2Servicer_to_server(SdkToolServiceV2(), server)
+    # we are doing because fips() builtin exists only in Python FIPS special build
+    try:
+        fipsok: bool = fips()  # type: ignore # noqa
+    except Exception:
+        fipsok = False
+    if fipsok and sys.platform == "win32":
+        chain_pair = read_windows_store_chain("grpcio_alteryx_ssl")  # type: ignore
+        server_credentials = grpc.ssl_server_credentials([chain_pair])
+        port = server.add_secure_port(sdk_tool_address, server_credentials)
+        logger.debug("FIPS mode enabled")
+    else:
+        port = server.add_insecure_port(sdk_tool_address)
+    logger.debug(f"gRPC port: {port}")
+    return server, port
+
+
+def build_sdk_engine_client(sdk_engine_address: "SocketAddress") -> SdkToolV2Stub:
+    """
+    Build the SDK Engine Client.
+
+    Parameters
+    ----------
+    sdk_engine_address: SocketAddress
+        A socket address that corresponds to the sdk engine.
+
+    Returns
+    -------
+    client
+        An instance of the SDK Engine client
+    """
+    channel = grpc.insecure_channel(
+        sdk_engine_address.address,
+        options=[
+            ("grpc.max_send_message_length", -1),
+            ("grpc.max_receive_message_length", -1),
+        ],
+    )
+    client = SdkEngineStub(channel)
+    return client
+
+
+class SocketAddress:
+    """Class for tracking host and port information."""
+
+    @classmethod
+    def from_address_str(cls, address_str: str) -> "SocketAddress":
+        """
+        Construct a socket address from an address string.
+
+        Parameters
+        ----------
+        address_str: str
+            A string consisting of host and port, separated by a colon, such as "localhost:8000".
+
+        Returns
+        -------
+        SocketAddress
+            A new instance of the SocketAddress class.
+        """
+        host, port = address_str.split(":")
+        return cls(host, int(port))
+
+    def __init__(self, host: str, port: int) -> None:
+        """
+        Construct a socket address.
+
+        Parameters
+        ----------
+        host: str
+            The address hostname.
+
+        port: int
+            The address port.
+
+        Returns
+        -------
+        SocketAddress
+            A new instance of the SocketAddress class.
+        """
+        self.host = host
+        self.port = port
+
+    @property
+    def address(self) -> str:
+        """
+        Get the address string that contains both host and port.
+
+        Returns
+        -------
+        address: str
+            The address string in the form "host:port"
+        """
+        return f"{self.host}:{self.port}"
+
+    def __eq__(self, other: Any) -> bool:
+        """Compare if 2 socket addresses are equal."""
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+
+        return self.address == other.address

another_ayx_python_sdk/providers/amp_provider/logger_config.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.
+"""Logger configuration utilities."""
+import logging
+import os
+from pathlib import Path
+
+
+def configure_logger() -> None:
+    """Configure the logger for the Python SDK."""
+    logging.raiseExceptions = False
+    env_dir = os.environ.get("LOCALAPPDATA") or os.environ.get("HOME")
+    if env_dir is None:
+        raise ValueError(
+            "LOCALAPPDATA or HOME environment variables should be set for logging."
+        )
+    log_dir = Path(env_dir) / "Alteryx" / "Log"
+    log_dir.mkdir(parents=True, exist_ok=True)
+
+    log_file = log_dir / "PythonSDK.log"
+
+    logger = logging.getLogger()
+    lg_level = logging.DEBUG if os.environ.get("AYX_SDK_VERBOSE") else logging.INFO
+    logger.setLevel(lg_level)
+
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+
+    file_handler = logging.FileHandler(str(log_file), encoding="utf-8")
+    file_handler.setFormatter(formatter)
+    logger.addHandler(file_handler)
+
+    # TODO: Figure how to make python not choke on full stdout buffer
+    # stream_handler = logging.StreamHandler(sys.stdout)
+    # stream_handler.setFormatter(formatter)
+    # logger.addHandler(stream_handler)
+
+
+def get_plugin_logger(plugin_handle: str, root_log_dir: Path) -> logging.Logger:
+    """Configure a file logger for a plugin."""
+    root_log_dir.mkdir(parents=True, exist_ok=True)
+    log_file = root_log_dir / f"{plugin_handle}.log"
+    logger = logging.getLogger(plugin_handle)
+    handler = logging.FileHandler(log_file)
+
+    formatter = logging.Formatter("%(asctime)s %(levelname)s %(message)s")
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    _level = logging.DEBUG if os.environ.get("AYX_SDK_VERBOSE", False) else logging.INFO
+    logger.setLevel(_level)
+    return logger

another_ayx_python_sdk/providers/amp_provider/plugin_class_loader.py

@@ -0,0 +1,77 @@
+# 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.
+"""Plugin class loader logic."""
+import importlib
+from typing import Type, cast
+
+from another_ayx_python_sdk.core.plugin import Plugin
+from another_ayx_python_sdk.core.plugin_v2 import PluginV2
+
+
+class PluginNotFoundError(Exception):
+    """Plugin not found exception."""
+
+    pass
+
+
+class PluginClassError(Exception):
+    """Plugin class error."""
+
+    pass
+
+
+def load_plugin_class(plugins_package: str, tool_name: str) -> Type[Plugin]:
+    """
+    Dynamically load the plugin class.
+
+    Parameters
+    ----------
+    plugins_package: str
+        Path to the plugins to load from.
+
+    tool_name: str
+        Name of the tool to load.
+
+    Returns
+    -------
+    plugin_class: Type[Plugin]
+
+    Raises
+    ------
+    ModuleNotFoundError
+        If module couldn't be found
+
+    PluginNotFoundError
+        If the module doesn't contain the specified tool
+
+    PluginClassError
+        If the specified tool isn't a Plugin.
+    """
+    try:
+        plugins_module = importlib.import_module(plugins_package)
+    except ModuleNotFoundError:
+        raise ModuleNotFoundError(
+            f"ERROR: Couldn't find module {plugins_package} for loading plugins."
+        )
+    try:
+        plugin_class = getattr(plugins_module, tool_name)
+    except AttributeError:
+        raise PluginNotFoundError(
+            f"ERROR: Plugin module {plugins_package} doesn't contain a tool named {tool_name}."
+        )
+    if not (issubclass(plugin_class, Plugin) or issubclass(plugin_class, PluginV2)):
+        raise PluginClassError(
+            f"ERROR: {tool_name} class from {plugins_package} module is not a Plugin."
+        )
+    return cast(Type[Plugin], plugin_class)