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

build/lib/build/lib/another_ayx_python_sdk/providers/amp_provider/repositories/input_record_packet_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/retrieves input record packets."""
+import logging
+from typing import Dict, List, TYPE_CHECKING, Tuple
+
+from another_ayx_python_sdk.core.input_connection_base import InputConnectionStatus
+from another_ayx_python_sdk.providers.amp_provider.amp_record_packet import AMPRecordPacket
+from another_ayx_python_sdk.providers.amp_provider.builders.record_packet_builder import (
+    RecordPacketBuilder,
+)
+from another_ayx_python_sdk.providers.amp_provider.repositories.input_connection_repository import (
+    InputConnectionRepository,
+)
+from another_ayx_python_sdk.providers.amp_provider.repositories.input_metadata_repository import (
+    InputMetadataRepository,
+)
+from another_ayx_python_sdk.providers.amp_provider.repositories.singleton import Singleton
+
+
+if TYPE_CHECKING:
+    from another_ayx_python_sdk.core.metadata import Metadata
+    from another_ayx_python_sdk.core.record_packet_base import RecordPacketBase
+    from another_ayx_python_sdk.providers.amp_provider.resources.generated.record_packet_pb2 import (
+        RecordPacket as ProtobufRecordPacket,
+    )
+
+    import pandas as pd  # noqa: F401
+
+logger = logging.getLogger(__name__)
+
+
+class UnfinishedRecordPacketException(Exception):
+    """Exception to be raised to indicate that a record packet isn't ready to be returned."""
+
+    pass
+
+
+class EmptyRecordPacketRepositoryException(Exception):
+    """Exception to be raised after the final record packet has been returned."""
+
+    pass
+
+
+class InputRecordPacketRepository(metaclass=Singleton):
+    """Repository that stores input record packets."""
+
+    _record_packet_builder = RecordPacketBuilder()
+    _input_connection_repo = InputConnectionRepository()
+
+    def __init__(self) -> None:
+        """Initialize the input record packet repository."""
+        self._record_packet_cache: Dict[
+            str, Dict[str, Tuple["pd.DataFrame", "pd.DataFrame", int]]
+        ] = {}
+        self._records_list: Dict[str, Dict[str, List["pd.DataFrame"]]] = {}
+
+    def push_record_packet(
+        self, anchor_name: str, connection_name: str, record_packet: "RecordPacketBase"
+    ) -> None:
+        """Save a record packet."""
+        logger.debug(
+            "Saving record packet (%r) for anchor %s on connection %s",
+            record_packet,
+            anchor_name,
+            connection_name,
+        )
+        self._records_list.setdefault(anchor_name, {})
+        self._records_list[anchor_name].setdefault(connection_name, [])
+
+        self._record_packet_cache.setdefault(anchor_name, {})
+
+        self._records_list[anchor_name][connection_name].append(
+            record_packet.to_dataframe()
+        )
+
+    def save_grpc_record_packet(
+        self,
+        anchor_name: str,
+        connection_name: str,
+        grpc_record_packet: "ProtobufRecordPacket",
+        metadata: "Metadata",
+    ) -> None:
+        """Save a record packet from its protobuffer format."""
+        record_packet, _, _ = self._record_packet_builder.from_protobuf(
+            grpc_record_packet, metadata
+        )
+        self.push_record_packet(anchor_name, connection_name, record_packet)
+
+    def _reshape_packets(
+        self, anchor_name: str, connection_name: str
+    ) -> Tuple["pd.DataFrame", "pd.DataFrame", int]:
+        """
+        Reshape packets based on number of requested rows.
+
+        Concatenate record packets from the queue into a single dataframe,
+        then return that dataframe and the number of record packets to remove from the queue.
+
+        Parameters
+        ----------
+        anchor_name
+            The name of the input anchor that the metadata is associated with.
+        connection_name
+            The name of the input connection that the metadata is associated with.
+
+        Returns
+        -------
+        Tuple["pd.DataFrame", "pd.DataFrame", int]
+            A tuple containing:
+            Dataframe containing the correct number of packets,
+            the remainder of the original dataframe, and
+            number of packets to remove from internal queue
+        """
+        import numpy as np  # noqa: F811
+        import pandas as pd  # noqa: F811
+
+        if anchor_name not in self._records_list:
+            raise ValueError(f"Anchor {anchor_name} not found in repository.")
+
+        if connection_name not in self._records_list[anchor_name]:
+            raise ValueError(
+                f"Connection {connection_name} not found in repository for anchor {anchor_name}."
+            )
+
+        if connection_name in self._record_packet_cache[anchor_name]:
+            return self._record_packet_cache[anchor_name][connection_name]
+
+        max_packet_size = self._input_connection_repo.get_connection(
+            anchor_name, connection_name
+        ).max_packet_size
+
+        if len(self._records_list[anchor_name][connection_name]) == 0:
+            raise EmptyRecordPacketRepositoryException
+
+        if max_packet_size is None:
+            self._record_packet_cache[anchor_name][connection_name] = (
+                pd.concat(self._records_list[anchor_name][connection_name]),
+                pd.DataFrame(),
+                len(self._records_list[anchor_name][connection_name]),
+            )
+            return self._record_packet_cache[anchor_name][connection_name]
+
+        cumulative_lengths: np.ndarray = np.cumsum(
+            [len(packet) for packet in self._records_list[anchor_name][connection_name]]
+        )
+        if (
+            cumulative_lengths[-1] < max_packet_size
+            and not InputConnectionRepository().get_connection_status(
+                anchor_name, connection_name
+            )
+            == InputConnectionStatus.CLOSED
+        ):
+            raise UnfinishedRecordPacketException
+
+        packets = [
+            idx
+            for idx, element in enumerate(cumulative_lengths)
+            if element > max_packet_size and idx > 0
+        ] + [len(cumulative_lengths)]
+        num_packets_to_merge = packets[0]
+
+        df = pd.concat(
+            self._records_list[anchor_name][connection_name][:num_packets_to_merge]
+        )
+        right_size_dataframe = df.iloc[:max_packet_size]
+        overflow_dataframe = df.iloc[max_packet_size:]
+        self._record_packet_cache[anchor_name][connection_name] = (
+            right_size_dataframe,
+            overflow_dataframe,
+            num_packets_to_merge,
+        )
+        return self._record_packet_cache[anchor_name][connection_name]
+
+    def peek_record_packet(
+        self, anchor_name: str, connection_name: str
+    ) -> "RecordPacketBase":
+        """
+        Get the next record packet without popping from the queue.
+
+        Parameters
+        ----------
+        anchor_name
+            The name of the input anchor that the metadata is associated with.
+        connection_name
+            The name of the input connection that the metadata is associated with.
+
+        Returns
+        -------
+        RecordPacketBase
+            The AMPRecordPacket at the front of the internal queue.
+        """
+        self._record_packet_cache.setdefault(anchor_name, {})
+        right_size_dataframe, _, _ = self._reshape_packets(anchor_name, connection_name)
+        return AMPRecordPacket(
+            InputMetadataRepository().get_metadata(anchor_name, connection_name),
+            right_size_dataframe,
+        )
+
+    def pop_record_packet(
+        self, anchor_name: str, connection_name: str
+    ) -> "RecordPacketBase":
+        """
+        Retrieve record packet if there are enough records to meet the max packet size criteria.
+
+        Parameters
+        ----------
+        anchor_name
+            The name of the input anchor that the metadata is associated with.
+        connection_name
+            The name of the input connection that the metadata is associated with.
+
+        Returns
+        -------
+        RecordPacketBase
+            The AMPRecordPacket that was popped off the internal queue.
+        """
+        (
+            right_size_dataframe,
+            remainder_packet,
+            packets_to_remove,
+        ) = self._reshape_packets(anchor_name, connection_name)
+
+        self._records_list[anchor_name][connection_name] = self._records_list[
+            anchor_name
+        ][connection_name][packets_to_remove:]
+        if connection_name in self._record_packet_cache[anchor_name]:
+            del self._record_packet_cache[anchor_name][connection_name]
+
+        if not remainder_packet.empty:
+            self._records_list[anchor_name][connection_name].insert(0, remainder_packet)
+
+        return AMPRecordPacket(
+            InputMetadataRepository().get_metadata(anchor_name, connection_name),
+            right_size_dataframe,
+        )
+
+    def clear_repository(self) -> None:
+        """Delete all data in the repository."""
+        logger.debug("Clearing InputRecordPacketRepository")
+        self._records_list = {}
+        self._record_packet_cache = {}

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

@@ -0,0 +1,188 @@
+# 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 IO information."""
+import logging
+import uuid
+from pathlib import Path
+from typing import Any, cast
+
+from another_ayx_python_sdk.core.exceptions import WorkflowRuntimeError
+from another_ayx_python_sdk.providers.amp_provider.repositories import EnvironmentRepository
+from another_ayx_python_sdk.providers.amp_provider.repositories import GrpcRepository
+from another_ayx_python_sdk.providers.amp_provider.repositories.singleton import Singleton
+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.translate_message_data_pb2 import (
+    TranslateMessageData,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class IORepository(metaclass=Singleton):
+    """Repository that stores IO information."""
+
+    def __init__(self) -> None:
+        """Initialize the IO repository."""
+
+    @staticmethod
+    def save_error(error_msg: str) -> None:
+        """
+        Display an error message in the Results window.
+
+        Parameters
+        ----------
+        error_msg
+            The error message to be output.
+        """
+        GrpcRepository().get_sdk_engine_client().OutputMessage(
+            OutputMessageData(
+                message_type=OutputMessageTypes.OMT_Error, message=error_msg
+            )
+        )
+
+    @staticmethod
+    def save_warn(warn_msg: str) -> None:
+        """
+        Display a warning message in the Results window.
+
+        Parameters
+        ----------
+        warn_msg
+            The warning message to be output.
+        """
+        GrpcRepository().get_sdk_engine_client().OutputMessage(
+            OutputMessageData(
+                message_type=OutputMessageTypes.OMT_Warning, message=warn_msg
+            )
+        )
+
+    @staticmethod
+    def save_info(info_msg: str) -> None:
+        """
+        Display an info message in the Results window.
+
+        Parameters
+        ----------
+        info_msg
+            The info message to be output.
+        """
+        GrpcRepository().get_sdk_engine_client().OutputMessage(
+            OutputMessageData(
+                message_type=OutputMessageTypes.OMT_Info, message=info_msg
+            )
+        )
+
+    @staticmethod
+    def get_translate_msg(msg: str, *args: Any) -> str:
+        """
+        Translate a message to the current locale.
+
+        Parameters
+        ----------
+        msg
+            Message to translate.
+        *args
+            Interpolation data for the string.
+
+        Returns
+        -------
+        str
+            The message, translated into the locale.
+        """
+        interpolation_data = [str(arg) for arg in args] if len(args) > 0 else []
+        res = (
+            GrpcRepository()
+            .get_sdk_engine_client()
+            .TranslateMessage(
+                TranslateMessageData(
+                    unlocalized_string=msg, interpolation_data=interpolation_data
+                )
+            )
+        )
+
+        return cast(str, res.translated_message)
+
+    @staticmethod
+    def update_progress(percent: float) -> None:
+        """
+        Update tool progress.
+
+        Parameters
+        ----------
+        percent
+            The progress (how close the connection is to processing all records) as a percentage.
+        """
+        # TODO
+
+    @staticmethod
+    def get_temp_file(extension: str = "tmp") -> "Path":
+        """
+        Create a temporary file managed by Designer.
+
+        Parameters
+        ----------
+        extension
+            The file extension of the temp file.
+
+        Returns
+        -------
+        Path
+            The path to where the temp file is.
+        """
+        temp_file_name = f"temp-file-{str(uuid.uuid4())}.{str(extension)}"
+        engine_temp_dir = EnvironmentRepository().get_temp_dir()
+        temp_file_path = Path(engine_temp_dir) / (temp_file_name)
+        try:
+            temp_file_path.touch()
+        except FileNotFoundError:
+            # path does not exist
+            logger.error("Engine.TempFilePath (%s) does not exist", engine_temp_dir)
+        except IOError:
+            # path exists but no write permissions
+            logger.error("No write permissions for directory %s", engine_temp_dir)
+
+        return Path(temp_file_path)
+
+    @staticmethod
+    def decrypt_password(password: str) -> str:  # noqa: D102
+        """
+        Decrypt password.
+
+        Parameters
+        ----------
+        password
+            The password to decrypt.
+
+        Returns
+        -------
+        str
+            The decrypted password.
+        """
+        import grpc
+
+        try:
+            decrypted = (
+                GrpcRepository()
+                .get_sdk_engine_client()
+                .DecryptPassword(PasswordData(password=password))
+            )
+        except grpc.RpcError:
+            raise WorkflowRuntimeError("Error decrypting password")
+        return cast(str, decrypted.password)

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

@@ -0,0 +1,117 @@
+# 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 output anchor GRPC."""
+import logging
+from typing import Dict, List, TYPE_CHECKING
+
+from another_ayx_python_sdk.providers.amp_provider.builders.output_anchor_builder import (
+    OutputAnchorBuilder,
+)
+from another_ayx_python_sdk.providers.amp_provider.repositories.singleton import Singleton
+
+
+if TYPE_CHECKING:
+    from another_ayx_python_sdk.providers.amp_provider.amp_output_anchor import (
+        AMPOutputAnchor as CoreOutputAnchor,
+    )
+    from another_ayx_python_sdk.providers.amp_provider.resources.generated.outgoing_anchor_pb2 import (
+        OutgoingAnchor as GrpcOutputAnchor,
+    )
+
+
+logger = logging.getLogger(__name__)
+
+
+class OutputAnchorRepository(metaclass=Singleton):
+    """Repository class, output anchors."""
+
+    _output_anchor_builder = OutputAnchorBuilder()
+
+    def __init__(self) -> None:
+        self._repository: Dict[str, "CoreOutputAnchor"] = {}
+
+    def save_anchor(self, anchor: "CoreOutputAnchor") -> None:
+        """
+        Save an AMPOutputAnchor object to the repository.
+
+        Parameters
+        ----------
+        anchor
+            The AMP output anchor to save to the repository.
+        """
+        logger.debug("Adding anchor %s to OutputAnchorRepository", anchor.name)
+        self._repository[anchor.name] = anchor
+        logger.debug("Current OutputAnchorRepository State: %s", self._repository)
+
+    def get_anchor(self, anchor_name: str) -> "CoreOutputAnchor":
+        """
+        Retrieve an AMPOutputAnchor object from the repository if it's already been saved.
+
+        Parameters
+        ----------
+        anchor_name
+            The name of the output anchor to get from the repository.
+
+        Returns
+        -------
+        CoreOutputAnchor
+            The retrieved output anchor that corresponds to the anchor name.
+        """
+        if anchor_name not in self._repository:
+            raise ValueError(f"Anchor {anchor_name} does not exist")
+        return self._repository[anchor_name]
+
+    def delete_anchor(self, anchor_name: str) -> None:
+        """
+        Remove an AMPOutputAnchor object from the repository if it's already been saved.
+
+        Parameters
+        ----------
+        anchor_name
+            The name of the output anchor to delete from the repository.
+        """
+        if anchor_name not in self._repository:
+            raise ValueError(f"Anchor {anchor_name} can't be deleted, it doesn't exist")
+        logger.debug("Removing anchor %s from OutputAnchorRepository", anchor_name)
+        del self._repository[anchor_name]
+        logger.debug("Current OutputAnchorRepository State: %s", self._repository)
+
+    def save_grpc_anchor(self, anchor: "GrpcOutputAnchor") -> None:
+        """
+        Save a protobuf Output Anchor to the repository.
+
+        Parameters
+        ----------
+        anchor
+            The grpc representation of the output anchor.
+        """
+        core_anchor = self._output_anchor_builder.from_protobuf(anchor)
+        self.save_anchor(anchor=core_anchor)
+
+    def clear_repository(self) -> None:
+        """Delete all data in the repository."""
+        logger.debug("Clearing OutputAnchorRepository")
+        self._repository = {}
+        logger.debug("Current OutputAnchorRepository State: %s", self._repository)
+
+    def get_all_anchor_names(self) -> List[str]:
+        """
+        Pull a list of all anchor names in the repository.
+
+        Returns
+        -------
+        List[str]
+            List of all anchor names that exist in the repository.
+        """
+        return list(self._repository.keys())

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

@@ -0,0 +1,129 @@
+# 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 output metadata information given the associated anchor name."""
+import logging
+from typing import Dict, TYPE_CHECKING
+
+from another_ayx_python_sdk.providers.amp_provider.builders.metadata_builder import (
+    MetadataBuilder,
+)
+from another_ayx_python_sdk.providers.amp_provider.repositories import GrpcRepository
+from another_ayx_python_sdk.providers.amp_provider.repositories.singleton import Singleton
+from another_ayx_python_sdk.providers.amp_provider.resources.generated.outgoing_metadata_push_pb2 import (
+    OutgoingMetadataPush,
+)
+
+if TYPE_CHECKING:
+    from another_ayx_python_sdk.core.metadata import Metadata as CoreMetadata
+    from another_ayx_python_sdk.providers.amp_provider.resources.generated.metadata_pb2 import (
+        Metadata as ProtobufMetadata,
+    )
+
+
+logger = logging.getLogger(__name__)
+
+
+class OutputMetadataRepository(metaclass=Singleton):
+    """Repository that stores output metadata information."""
+
+    _metadata_builder = MetadataBuilder()
+
+    def __init__(self) -> None:
+        """Initialize the output metadata repository."""
+        self._metadata_map: Dict[str, "CoreMetadata"] = {}
+
+    def save_metadata(self, anchor_name: str, metadata: "CoreMetadata") -> None:
+        """
+        Save output metadata information for the associated anchor name.
+
+        Parameters
+        ----------
+        anchor_name
+            The name of the anchor.
+        metadata
+            The metadata of the record packets that will be associated with this anchor.
+        """
+        logger.debug("Saving metadata %s to anchor %s", metadata, anchor_name)
+        self._metadata_map[anchor_name] = metadata
+        logger.debug("Current OutputMetadataRepository State: %s", self._metadata_map)
+
+        try:
+            client = GrpcRepository().get_sdk_engine_client()
+        except ValueError:
+            pass
+        else:
+            client.PushOutgoingMetadata(
+                OutgoingMetadataPush(
+                    output_anchor_name=anchor_name,
+                    metadata=self.get_grpc_metadata(anchor_name),
+                )
+            )
+
+    def get_metadata(self, anchor_name: str) -> "CoreMetadata":
+        """
+        Get the output metadata associated with the given anchor name.
+
+        Parameters
+        ----------
+        anchor_name
+            The name of the anchor.
+
+        Returns
+        -------
+        CoreMetadata
+            Retrieves the metadata that is associatd with the specified anchor.
+        """
+        if anchor_name not in self._metadata_map:
+            raise ValueError(f"Anchor {anchor_name} not found in repository.")
+
+        return self._metadata_map[anchor_name]
+
+    def get_grpc_metadata(self, anchor_name: str) -> "ProtobufMetadata":
+        """
+        Get the output Protobuf metadata message associated with the given anchor name.
+
+        Parameters
+        ----------
+        anchor_name
+            The name of the anchor.
+
+        Returns
+        -------
+        ProtobufMetadata
+            The metadata of the record packets that will be associated with this anchor as a protobuf object.
+        """
+        metadata = self.get_metadata(anchor_name)
+
+        return self._metadata_builder.to_protobuf(metadata)
+
+    def delete_metadata(self, anchor_name: str) -> None:
+        """
+        Delete the output metadata associated with the given anchor name.
+
+        Parameters
+        ----------
+        anchor_name
+            The name of the anchor to delete.
+        """
+        if anchor_name not in self._metadata_map:
+            raise ValueError(f"Anchor {anchor_name} not found in repository.")
+        logger.debug("Removing metadata associated with anchor %s", anchor_name)
+        self._metadata_map.pop(anchor_name)
+        logger.debug("Current OutputAnchorRepository State: %s", self._metadata_map)
+
+    def clear_repository(self) -> None:
+        """Delete all data in the repository."""
+        logger.debug("Clearing OutputAnchorRepository")
+        self._metadata_map = {}
+        logger.debug("Current OutputAnchorRepository State: %s", self._metadata_map)