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

build/lib/another_ayx_python_sdk/providers/amp_provider/amp_provider_v2.py

@@ -0,0 +1,128 @@
+# 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: SDK Provider class definition."""
+
+# from AyxPythonSdk.ayx_python_sdk.providers.amp_provider.amp_environment import AMPEnvironment
+import logging
+from collections import defaultdict
+from typing import Any, Dict, TYPE_CHECKING
+
+from another_ayx_python_sdk.providers.amp_provider.amp_environment_v2 import AMPEnvironmentV2
+from another_ayx_python_sdk.providers.amp_provider.amp_io_components import (
+    ControlIOBuffer,
+    StreamIOBuffer,
+)
+from another_ayx_python_sdk.providers.amp_provider.grpc_helpers.control_msgs import (
+    new_ctrl_out_metadata_msg,
+    new_ctrl_out_save_config,
+)
+
+import xmltodict
+
+if TYPE_CHECKING:
+    from another_ayx_python_sdk.providers.amp_provider.resources.generated.sdk_tool_service_v2_pb2 import (
+        ControlIn,
+    )
+
+    from pyarrow import Schema
+
+# Update for docs needed since we're not inheriting from legacy ProviderBase now.
+
+
+class AMPProviderV2:
+    """Class that provides resources to plugins that are run with the AMP Provider."""
+
+    def __init__(self) -> None:
+        """Initialize the AMP resource provider."""
+        self.__environment: AMPEnvironmentV2 = AMPEnvironmentV2()
+        self.__ctrl_io: "ControlIOBuffer" = ControlIOBuffer()
+        self.__record_transfer_io: StreamIOBuffer = StreamIOBuffer()
+        self.incoming_anchors: defaultdict = defaultdict(dict)
+        self.outgoing_anchors: dict = {}
+        self.logger = logging.getLogger()
+
+    @property
+    def io(self) -> "ControlIOBuffer":  # noqa: D102
+        return self.__ctrl_io
+
+    @property
+    def environment(self) -> "AMPEnvironmentV2":  # noqa: D102
+        return self.__environment
+
+    @property
+    def record_io(self) -> "StreamIOBuffer":  # noqa: D102
+        return self.__record_transfer_io
+
+    @property
+    def dcm(self) -> "ControlIOBuffer":  # noqa: D102
+        return self.__ctrl_io
+
+    @property
+    def tool_config(self) -> Dict:
+        """
+        Get the tool config from the tool's config UI in Designer.
+
+        Returns
+        -------
+        Dict[str, Any]
+            The Tool Config associated with the current plugin, in the form of a Python dictionary.
+        """
+        return self.environment.tool_config
+
+    def save_tool_config(self, tool_config: Dict[str, Any]) -> None:  # noqa: D102
+        """
+        Encode the tool configuration as a Python dictionary and send it to Designer.
+
+        Parameters
+        ----------
+        tool_config
+            Dictionary form of the Tool Config XML.
+        """
+        unparsed: str = xmltodict.unparse(
+            {"Configuration": tool_config}, short_empty_elements=True
+        )
+        msg = new_ctrl_out_save_config(unparsed)
+        try:
+            self.__ctrl_io.push_ctrl_out(msg)
+            self.__environment.update_tool_config(tool_config)
+            self.logger.debug(self.__environment.tool_config)
+        except Exception as e:
+            self.__ctrl_io.warn("Failed to update tool config.")
+            self.logger.warn("tool_config save exception was: %s", repr(e))
+
+    def push_outgoing_metadata(
+        self, anchor_name: str, metadata: "Schema"
+    ) -> None:  # noqa: D102
+        metadata_msg = new_ctrl_out_metadata_msg(anchor_name, metadata)
+        self.__ctrl_io.push_ctrl_out(metadata_msg)
+
+    def write_to_anchor(self, name: str, data: object) -> None:  # noqa: D102
+        self.__record_transfer_io.write_to_buffer(name, data)
+
+    def close_outgoing_anchor(self, name: str) -> None:  # noqa: D102
+        self.__record_transfer_io.push_close_anchor_msg(name)
+
+    def set_anchors(self, init_request: "ControlIn") -> None:  # noqa: D102
+        for anchor in init_request.plugin_initialization_data.incomingAnchors:
+            for conn in anchor.connections:
+                self.incoming_anchors[anchor.name][conn.name] = {
+                    "name": conn.name,
+                    "metadata": conn.metadata,
+                }
+        for anchor in init_request.plugin_initialization_data.outgoingAnchors:
+            self.outgoing_anchors[anchor.name] = {
+                "name": anchor.name,
+                "metadata": anchor.metadata,
+                "num_connections": anchor.num_connections,
+            }

build/lib/another_ayx_python_sdk/providers/amp_provider/amp_record_packet.py

@@ -0,0 +1,21 @@
+# 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: Record Packet class definition."""
+from another_ayx_python_sdk.core import RecordPacket
+from another_ayx_python_sdk.core.doc_utilities import inherit_docs
+
+
+@inherit_docs
+class AMPRecordPacket(RecordPacket):
+    """AMP Provider: Record Packet class definition."""

build/lib/another_ayx_python_sdk/providers/amp_provider/builders/__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.
+"""Builder methods for converting between core and protobuf objects."""
+
+from .input_anchor_builder import InputAnchorBuilder
+from .input_connection_builder import InputConnectionBuilder
+from .metadata_builder import MetadataBuilder
+from .output_anchor_builder import OutputAnchorBuilder
+from .record_builder import RecordBuilder
+from .record_packet_builder import RecordPacketBuilder
+from .tool_config_builder import ToolConfigBuilder
+
+__all__ = [
+    "InputAnchorBuilder",
+    "InputConnectionBuilder",
+    "MetadataBuilder",
+    "RecordBuilder",
+    "RecordPacketBuilder",
+    "OutputAnchorBuilder",
+    "ToolConfigBuilder",
+]

build/lib/another_ayx_python_sdk/providers/amp_provider/builders/input_anchor_builder.py

@@ -0,0 +1,123 @@
+# 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 implements serialization/deserialization for Input Anchors to and from protobuf message format."""
+import logging
+from enum import Enum
+
+from another_ayx_python_sdk.providers.amp_provider.amp_input_anchor import AMPInputAnchor
+from another_ayx_python_sdk.providers.amp_provider.builders.input_connection_builder import (
+    InputConnectionBuilder,
+)
+from another_ayx_python_sdk.providers.amp_provider.resources.generated.incoming_anchor_pb2 import (
+    IncomingAnchor as ProtobufInputAnchor,
+)
+
+
+class AnchorOptionsBitmask(Enum):
+    """Bitfield values for anchor flags."""
+
+    NONE = 0
+    REQUIRED = 1
+    ALLOW_MULTIPLE = 2
+    REQUIRES_SEQUENCE = 4
+    REQUEST_SEQUENCE = 8
+
+
+logger = logging.getLogger(__name__)
+
+
+class InputAnchorBuilder:
+    """RPC Builder for converting protobuf Input Anchors to AMP Input Anchors and vice-versa."""
+
+    _input_connection_builder = InputConnectionBuilder()
+
+    @classmethod
+    def to_protobuf(cls, amp_input_anchor: "AMPInputAnchor") -> ProtobufInputAnchor:
+        """
+        Serialize AMP input anchor to protobuf objects.
+
+        Parameters
+        ----------
+        amp_input_anchor
+            An AMPInputAnchor object to serialize into protobuf.
+
+        Returns
+        -------
+        ProtobufInputAnchor
+            The Protobuf representation of the passed in AMPInputAnchor.
+        """
+        protobuf_input_anchor = ProtobufInputAnchor()
+        protobuf_input_anchor.name = amp_input_anchor.name
+        logger.debug("Serializing input anchor %s to protobuf", amp_input_anchor.name)
+        for connection in amp_input_anchor.connections:
+            protobuf_connection = cls._input_connection_builder.to_protobuf(connection)
+            protobuf_input_anchor.connections.append(protobuf_connection)
+            logger.debug("Serializing connection %s to protobuf", connection.name)
+
+        protobuf_input_anchor.sequencing = 0
+        if not amp_input_anchor.optional:
+            protobuf_input_anchor.sequencing |= AnchorOptionsBitmask.REQUIRED.value
+        if amp_input_anchor.allow_multiple:
+            protobuf_input_anchor.sequencing |= (
+                AnchorOptionsBitmask.ALLOW_MULTIPLE.value
+            )
+
+        # For now, we only support REQUIRES_SEQUENCE
+        protobuf_input_anchor.sequencing |= AnchorOptionsBitmask.REQUIRES_SEQUENCE.value
+        logger.debug(
+            "Input anchor %s has sequencing options %s",
+            amp_input_anchor.name,
+            bin(protobuf_input_anchor.sequencing),
+        )
+        return protobuf_input_anchor
+
+    @classmethod
+    def from_protobuf(
+        cls, protobuf_input_anchor: ProtobufInputAnchor
+    ) -> AMPInputAnchor:
+        """
+        Deserialize protobuf objects into AMP input anchor.
+
+        Parameters
+        ----------
+        protobuf_input_anchor
+            Protobuf object to be serialized into an AMPInputAnchor.
+
+        Returns
+        -------
+        AMPInputAnchor
+            The AMPInputAnchor representation of the protobuf object.
+        """
+        logger.debug("Deserializing input anchor %s", protobuf_input_anchor.name)
+        allow_multiple = bool(
+            protobuf_input_anchor.sequencing & AnchorOptionsBitmask.ALLOW_MULTIPLE.value
+        )
+        optional = not bool(
+            protobuf_input_anchor.sequencing & AnchorOptionsBitmask.REQUIRED.value
+        )
+
+        amp_input_anchor = AMPInputAnchor(
+            name=protobuf_input_anchor.name,
+            allow_multiple=allow_multiple,
+            optional=optional,
+        )
+
+        for connection in protobuf_input_anchor.connections:
+            input_connection = cls._input_connection_builder.from_protobuf(
+                connection, amp_input_anchor
+            )
+            amp_input_anchor.connections.append(input_connection)
+            logger.debug("Deserialized input connection %s", input_connection.name)
+
+        return amp_input_anchor

build/lib/another_ayx_python_sdk/providers/amp_provider/builders/input_connection_builder.py

@@ -0,0 +1,95 @@
+# 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 implements the serialization/deserialization for input connection protobuf objects."""
+import logging
+from typing import TYPE_CHECKING
+
+from another_ayx_python_sdk.providers.amp_provider.amp_input_connection import (
+    AMPInputConnection,
+)
+from another_ayx_python_sdk.providers.amp_provider.builders.metadata_builder import (
+    MetadataBuilder,
+)
+from another_ayx_python_sdk.providers.amp_provider.resources.generated.incoming_connection_pb2 import (
+    IncomingConnection as ProtobufIncomingConnection,
+)
+
+
+if TYPE_CHECKING:
+    from another_ayx_python_sdk.providers import AMPInputAnchor
+    from another_ayx_python_sdk.core import InputConnectionBase
+
+logger = logging.getLogger(__name__)
+
+
+class InputConnectionBuilder:
+    """RPC Builder for transforming InputConnection into Protobuf messages and vice versa."""
+
+    metadata_builder = MetadataBuilder()
+
+    @classmethod
+    def to_protobuf(
+        cls, amp_input_connection: "InputConnectionBase"
+    ) -> ProtobufIncomingConnection:
+        """
+        Serialize an AMPInputConnection object (amp_provider.amp_input_connection) into a Protobuf object.
+
+        Parameters
+        ----------
+        amp_input_connection
+            An AMPInputConnection object to serialize into protobuf.
+
+        Returns
+        -------
+        ProtobufIncomingConnection
+            The Protobuf representation of the passed in AMPInputConnection.
+        """
+        name = amp_input_connection.name
+        if amp_input_connection.metadata is None:
+            raise RuntimeError(
+                "Input connection must be open in order to convert it to a Protobuf message."
+            )
+
+        logger.debug("Serializing %s to protobuf", amp_input_connection.metadata)
+        metadata = cls.metadata_builder.to_protobuf(amp_input_connection.metadata)
+        return ProtobufIncomingConnection(name=name, metadata=metadata)
+
+    @classmethod
+    def from_protobuf(
+        cls,
+        protobuf_input_connection: ProtobufIncomingConnection,
+        amp_input_anchor: "AMPInputAnchor",
+    ) -> AMPInputConnection:
+        """
+        Deserialize a Protobuf object into an AMPInputConnection object (amp_provider.amp_input_connection).
+
+        Parameters
+        ----------
+        protobuf_input_connection
+            Protobuf object to be serialized into an AMPInputAnchor.
+        amp_input_anchor
+            The AMPInputAnchor that the connection is associated with.
+
+        Returns
+        -------
+        AMPInputConnection
+            The AMPInputConnection representation of the protobuf object.
+        """
+        name = protobuf_input_connection.name
+        logger.debug("Deserializing connection %s from protobuf", name)
+        metadata = cls.metadata_builder.from_protobuf(
+            protobuf_input_connection.metadata
+        )
+        logger.debug("Deserialized %s from protobuf", metadata)
+        return AMPInputConnection(name, metadata, amp_input_anchor)

build/lib/another_ayx_python_sdk/providers/amp_provider/builders/metadata_builder.py

@@ -0,0 +1,118 @@
+# 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 implements the serialization/deserialization for Metadata protobuf objects."""
+import logging
+
+from another_ayx_python_sdk.core.field import FieldType
+from another_ayx_python_sdk.core.metadata import Metadata
+from another_ayx_python_sdk.providers.amp_provider.resources.generated.metadata_pb2 import (
+    FieldType as ProtobufFieldType,
+    Metadata as ProtobufMetadata,
+)
+
+_protobuf_to_core_field_type = {
+    "FT_BOOL": FieldType.bool.value,
+    "FT_BYTE": FieldType.byte.value,
+    "FT_INT16": FieldType.int16.value,
+    "FT_INT32": FieldType.int32.value,
+    "FT_INT64": FieldType.int64.value,
+    "FT_FIXED_DECIMAL": FieldType.fixeddecimal.value,
+    "FT_FLOAT": FieldType.float.value,
+    "FT_DOUBLE": FieldType.double.value,
+    "FT_STRING": FieldType.string.value,
+    "FT_WSTRING": FieldType.wstring.value,
+    "FT_V_STRING": FieldType.v_string.value,
+    "FT_V_WSTRING": FieldType.v_wstring.value,
+    "FT_DATE": FieldType.date.value,
+    "FT_TIME": FieldType.time.value,
+    "FT_DATETIME": FieldType.datetime.value,
+    "FT_BLOB": FieldType.blob.value,
+    "FT_SPATIALOBJ": FieldType.spatialobj.value,
+}
+
+_core_to_protobuf_field_type = {
+    core_name: protobuf_name
+    for protobuf_name, core_name in _protobuf_to_core_field_type.items()
+}
+
+
+logger = logging.getLogger(__name__)
+
+
+class MetadataBuilder:
+    """RPC Builder for transforming Metadata into Protobufs and vice versa."""
+
+    @staticmethod
+    def to_protobuf(amp_metadata: Metadata) -> ProtobufMetadata:
+        """
+        Serialize a Metadata (core.metadata) object into a protobuf.
+
+        Parameters
+        ----------
+        amp_metadata
+            AMP Metadata object to be serialized into protobuf.
+
+        Returns
+        -------
+        ProtobufMetadata
+            The Protobuf representation of the AMP Metadata object.
+        """
+        protobuf_metadata = ProtobufMetadata()
+        for field in amp_metadata.fields:
+            logger.debug("Serializing metadata field %s", field)
+            f = protobuf_metadata.fields.add()
+            f.name = field.name
+            f.size = field.size
+            f.scale = field.scale
+            f.source = field.source
+            f.description = field.description
+            f.type = ProtobufFieldType.Value(
+                _core_to_protobuf_field_type[field.type.value]
+            )
+        return protobuf_metadata
+
+    @staticmethod
+    def from_protobuf(protobuf_metadata: ProtobufMetadata) -> Metadata:
+        """
+        Deserialize a protobuf into a Metadata object (core.metadata).
+
+        Parameters
+        ----------
+        protobuf_metadata
+            Protobuf object to be serialized into an AMP metadata.
+
+        Returns
+        -------
+        Metadata
+            The AMP Metadata representation of the protobuf object.
+        """
+        amp_metadata = Metadata()
+        for field in protobuf_metadata.fields:
+            name = field.name
+            field_type = FieldType(
+                _protobuf_to_core_field_type[ProtobufFieldType.Name(field.type)]
+            )
+            size = field.size or 0
+            scale = field.scale or 0
+            source = field.source or ""
+            description = field.description or ""
+            amp_metadata.add_field(
+                name=name,
+                field_type=field_type,
+                size=size,
+                scale=scale,
+                source=source,
+                description=description,
+            )
+        return amp_metadata

build/lib/another_ayx_python_sdk/providers/amp_provider/builders/output_anchor_builder.py

@@ -0,0 +1,110 @@
+# 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.
+"""Builder file for Output Anchor."""
+import logging
+import sys
+from typing import TYPE_CHECKING
+
+from another_ayx_python_sdk.providers.amp_provider.builders.metadata_builder import (
+    MetadataBuilder,
+)
+from another_ayx_python_sdk.providers.amp_provider.resources.generated.outgoing_anchor_pb2 import (
+    OutgoingAnchor as ProtobufOutputAnchor,
+)
+
+if TYPE_CHECKING:
+    from another_ayx_python_sdk.providers import AMPOutputAnchor
+
+
+logger = logging.getLogger(__name__)
+
+
+class OutputAnchorBuilder:
+    """Builder class for serializing and deserializing output anchors."""
+
+    @staticmethod
+    def from_protobuf(
+        protobuf_output_anchor: ProtobufOutputAnchor,
+    ) -> "AMPOutputAnchor":
+        """
+        Given an AMPOutputAnchor as a protobuf, return its Python object.
+
+        Parameters
+        ----------
+        protobuf_output_anchor
+            Protobuf object to be serialized into an AMP metadata.
+
+        Returns
+        -------
+        AMPOutputAnchor
+            The AMP Metadata representation of the protobuf object.
+        """
+        from another_ayx_python_sdk.providers.amp_provider.amp_output_anchor import (
+            AMPOutputAnchor,
+        )
+
+        logger.debug(
+            "Deserializing Output Anchor %s from protobuf", protobuf_output_anchor.name
+        )
+        core_output_anchor = AMPOutputAnchor(
+            protobuf_output_anchor.name,
+            num_connections=protobuf_output_anchor.num_connections or 0,
+        )
+
+        if (
+            protobuf_output_anchor.options
+            != ProtobufOutputAnchor.OutgoingAnchorOptions.ORDERED
+        ):
+            raise ValueError("Only ordered output anchors are supported.")
+        logger.debug("Deserialized Output Anchor %s from protobuf", core_output_anchor)
+        return core_output_anchor
+
+    @staticmethod
+    def to_protobuf(
+        output_anchor: "AMPOutputAnchor",
+        anchor_options: ProtobufOutputAnchor.OutgoingAnchorOptions = ProtobufOutputAnchor.OutgoingAnchorOptions.ORDERED,
+        record_limit: int = sys.maxsize,
+    ) -> ProtobufOutputAnchor:
+        """
+        Given an AMPOutputAnchor, return a protobuf representation.
+
+        Parameters
+        ----------
+        output_anchor
+            AMP Output Anchor object to be serialized into protobuf.
+        anchor_options
+            Anchor must receive packets in the order that they came in.
+        record_limit
+            Max number of records the anchor can receive.
+
+        Returns
+        -------
+        ProtobufMetadata
+            The Protobuf representation of the AMP Metadata object.
+        """
+        metadata = (
+            MetadataBuilder.to_protobuf(output_anchor.metadata)
+            if output_anchor.is_open
+            else None
+        )
+        logger.debug("Serialized metadata %s to protobuf", metadata)
+        protobuf_output_anchor = ProtobufOutputAnchor(
+            name=output_anchor.name,
+            num_connections=output_anchor.num_connections,
+            metadata=metadata,
+            options=anchor_options,
+            record_limit=record_limit,
+        )
+        logger.debug("Serialized Ouptut Anchor %s to protobuf", output_anchor.name)
+        return protobuf_output_anchor