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

another_ayx_python_sdk/providers/amp_provider/repositories/input_anchor_repository.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.
+"""Class that implements the Input Anchor repository singleton."""
+import logging
+from typing import Dict, List, TYPE_CHECKING, cast
+
+from another_ayx_python_sdk.providers.amp_provider.builders.input_anchor_builder import (
+    InputAnchorBuilder,
+)
+from another_ayx_python_sdk.providers.amp_provider.repositories.input_connection_repository import (
+    InputConnectionRepository,
+)
+from another_ayx_python_sdk.providers.amp_provider.repositories.singleton import Singleton
+
+if TYPE_CHECKING:
+    from another_ayx_python_sdk.providers.amp_provider.amp_input_anchor import AMPInputAnchor
+    from another_ayx_python_sdk.providers.amp_provider.resources.generated.incoming_anchor_pb2 import (
+        IncomingAnchor as ProtobufInputAnchor,
+    )
+
+
+logger = logging.getLogger(__name__)
+
+
+class InputAnchorRepository(metaclass=Singleton):
+    """Class defines methods and properties to read/write/delete input anchors."""
+
+    def __init__(self) -> None:
+        self._repository: Dict[str, "AMPInputAnchor"] = {}
+
+    def save_grpc_anchor(self, input_anchor: "ProtobufInputAnchor") -> None:
+        """
+        Convert an Input Anchor from Protobuf to AMP and saves it to the repository.
+
+        Parameters
+        ----------
+        input_anchor
+            The protobuf representation of an input anchor to be saved.
+        """
+        core_input_anchor = InputAnchorBuilder.from_protobuf(input_anchor)
+        self.save_anchor(core_input_anchor)
+
+    def save_anchor(self, anchor: "AMPInputAnchor") -> None:
+        """
+        Save AMP input anchor to repository.
+
+        Parameters
+        ----------
+        anchor
+            The AMPInputAnchor to be saved.
+        """
+        from another_ayx_python_sdk.providers.amp_provider import AMPInputConnection
+
+        logger.debug("Saving Input Anchor %s to repository", anchor.name)
+        self._repository[anchor.name] = anchor
+        logger.debug("Current InputAnchorRepository State: %s", self._repository)
+
+        connections = cast(List[AMPInputConnection], anchor.connections)
+        for connection in connections:
+            InputConnectionRepository().save_connection(anchor.name, connection)
+
+    def get_anchor(self, anchor_name: str) -> "AMPInputAnchor":
+        """
+        Retrieve InputAnchor object associated with the anchor name.
+
+        Parameters
+        ----------
+        anchor_name
+            The name of the anchor to fetch from the repository.
+
+        Returns
+        -------
+            The input anchor object with corresponding name.
+        """
+        if anchor_name in self._repository:
+            return self._repository[anchor_name]
+        else:
+            raise ValueError(f"Anchor {anchor_name} does not exist")
+
+    def delete_anchor(self, anchor_name: str) -> None:
+        """
+        Delete InputAnchor object associated with the anchor name.
+
+        Parameters
+        ----------
+        anchor_name
+            The name of the anchor to delete from the repository.
+        """
+        if anchor_name in self._repository:
+            logger.debug("Removing Input Anchor %s from repository", anchor_name)
+            del self._repository[anchor_name]
+            logger.debug("Current InputAnchorRepository State: %s", self._repository)
+        else:
+            raise ValueError(f"Anchor {anchor_name} does not exist")
+
+    def clear_repository(self) -> None:
+        """Delete all data in the repository."""
+        logger.debug("Clearing InputAnchorRepository")
+        self._repository = {}

another_ayx_python_sdk/providers/amp_provider/repositories/input_connection_repository.py

@@ -0,0 +1,276 @@
+# 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 input connection information given the associated anchor."""
+import logging
+from typing import Dict, List, Optional, TYPE_CHECKING
+
+from another_ayx_python_sdk.core.input_connection_base import InputConnectionStatus
+from another_ayx_python_sdk.providers.amp_provider.builders import InputConnectionBuilder
+from another_ayx_python_sdk.providers.amp_provider.repositories.singleton import Singleton
+
+if TYPE_CHECKING:
+    from another_ayx_python_sdk.providers.amp_provider import (
+        AMPInputAnchor,
+        AMPInputConnection,
+    )
+    from another_ayx_python_sdk.providers.amp_provider.resources.generated.incoming_connection_pb2 import (
+        IncomingConnection as ProtobufInputConnection,
+    )
+
+
+logger = logging.getLogger(__name__)
+
+
+class InputConnectionRepository(metaclass=Singleton):
+    """Repository that stores input connection information."""
+
+    _input_connection_builder = InputConnectionBuilder()
+
+    def __init__(self) -> None:
+        """Initialize the input connection repository."""
+        self._anchor_connection_map: Dict[str, List["AMPInputConnection"]] = {}
+        self._connection_status_map: Dict[str, Dict[str, "InputConnectionStatus"]] = {}
+        self._packet_size_map: Dict[str, Dict[str, Optional[int]]] = {}
+
+    def save_connection(
+        self, anchor_name: str, connection: "AMPInputConnection"
+    ) -> None:
+        """
+        Save input connection information for the assoiciated anchor name.
+
+        Parameters
+        ----------
+        anchor_name
+            The name of the input anchor object that the connection is associated with.
+        connection
+            The AMPInputConnection object itself, to be saved to the repository.
+        """
+        self._anchor_connection_map.setdefault(anchor_name, [])
+        logger.debug(
+            "Adding connection %s to InputConnectionRepository for anchor %s",
+            connection.name,
+            anchor_name,
+        )
+        self._anchor_connection_map[anchor_name].append(connection)
+        logger.debug(
+            "Current InputConnectionRepository: %s", self._anchor_connection_map
+        )
+        if connection.metadata is None:
+            raise ValueError(f"Input Connection {connection.name} is not open")
+        from another_ayx_python_sdk.providers.amp_provider.repositories.input_metadata_repository import (
+            InputMetadataRepository,
+        )
+
+        InputMetadataRepository().save_metadata(
+            anchor_name, connection.name, connection.metadata
+        )
+
+    def save_grpc_connection(
+        self, anchor: "AMPInputAnchor", connection: "ProtobufInputConnection"
+    ) -> None:
+        """
+        Save input connection object given a protobuf object.
+
+        Parameters
+        ----------
+        anchor
+            The input anchor object that the connection is associated with.
+        connection
+            The protobuf representation of the input connection, to be serialized into AMP and saved to the repository.
+        """
+        amp_connection = self._input_connection_builder.from_protobuf(
+            connection, anchor
+        )
+        self.save_connection(anchor.name, amp_connection)
+
+    def get_all_connections(self, anchor_name: str) -> List["AMPInputConnection"]:
+        """Get the connections associated with the given anchor name."""
+        connections = self._anchor_connection_map.get(anchor_name)
+        logger.debug(
+            "Current InputConnectionRepository: %s", self._anchor_connection_map
+        )
+        if connections is None:
+            raise ValueError(f"Anchor {anchor_name} not found in repository.")
+
+        return connections
+
+    def get_connection(
+        self, anchor_name: str, connection_name: str
+    ) -> "AMPInputConnection":
+        """
+        Get the connection associated with the given anchor name and connection name.
+
+        Parameters
+        ----------
+        anchor_name
+            The name of the anchor that the connection is associated with.
+        connection_name
+            The name of the input connection to retrieve.
+        """
+        connections = self.get_all_connections(anchor_name)
+        logger.debug(
+            "Searching connections on anchor %s for connection %s",
+            anchor_name,
+            connection_name,
+        )
+        for connection in connections:
+            if connection.name == connection_name:
+                return connection
+
+        raise ValueError(
+            f"Input connection {connection_name} not found in repository for anchor {anchor_name}."
+        )
+
+    def delete_connection(self, anchor_name: str, connection_name: str) -> None:
+        """
+        Delete the connection associated with the given anchor name and connection name.
+
+        Parameters
+        ----------
+        anchor_name
+            The name of the anchor that the connection is associated with.
+        connection_name
+            The name of the input connection to delete.
+        """
+        connections = self.get_all_connections(anchor_name)
+        for idx, connection in enumerate(connections):
+            if connection.name == connection_name:
+                logger.debug(
+                    "Removing connection %s from anchor %s in InputConnectionRepository",
+                    connection_name,
+                    anchor_name,
+                )
+                connections.pop(idx)
+                if len(connections) == 0:
+                    del self._anchor_connection_map[anchor_name]
+                    logger.debug(
+                        "Removing anchor %s from InputConnectionRepository", anchor_name
+                    )
+                return
+
+        raise ValueError(
+            f"Input connection {connection_name} not found in repository for anchor {anchor_name}."
+        )
+
+    def clear_repository(self) -> None:
+        """Delete all data in the repository."""
+        logger.debug("Clearing InputConnectionRepository")
+        self._anchor_connection_map = {}
+        self._packet_size_map = {}
+        self._connection_status_map = {}
+        logger.debug(
+            "Current InputConnectionRepository: %s", self._anchor_connection_map
+        )
+
+    def save_connection_status(
+        self, anchor_name: str, connection_name: str, status: "InputConnectionStatus"
+    ) -> None:
+        """
+        Save input connection status associated with a given input connection/anchor name.
+
+        Parameters
+        ----------
+        anchor_name
+            The name of the anchor that the connection is associated with.
+        connection_name
+            The name of the input connection to set the status of.
+        status
+            Enumeration value (1,2,3, or 4) that corresponds to the status
+            of this connection. (Created, Initialized, Receiving records, Closed)
+        """
+        logger.debug(
+            "Updating connection status of anchor %s connection %s",
+            anchor_name,
+            connection_name,
+        )
+        self._connection_status_map.setdefault(anchor_name, {})
+        self._connection_status_map[anchor_name][connection_name] = status
+
+    def get_connection_status(
+        self, anchor_name: str, connection_name: str
+    ) -> "InputConnectionStatus":
+        """
+        Retrieve input connection status associated with a given input connection/anchor name.
+
+        Parameters
+        ----------
+        anchor_name
+            The name of the anchor that the connection is associated with.
+        connection_name
+            The name of the input connection to get the status of.
+
+        Returns
+        -------
+        InputConnectionStatus
+            Enumeration value (1,2,3, or 4) that corresponds to the status
+            of this connection. (Created, Initialized, Receiving records, Closed)
+        """
+        if anchor_name not in self._connection_status_map:
+            raise ValueError(f"Anchor {anchor_name} not found in repository")
+        if connection_name not in self._connection_status_map[anchor_name]:
+            raise ValueError(
+                f"Status for connection {connection_name} not found in repository for anchor {anchor_name}."
+            )
+        status = self._connection_status_map[anchor_name][connection_name]
+        return status
+
+    def save_connection_packet_size(
+        self, anchor_name: str, connection_name: str, size: Optional[int]
+    ) -> None:
+        """
+        Save packet size associated with a given input connection/anchor name.
+
+        Parameters
+        ----------
+        anchor_name
+            The name of the anchor that the connection is associated with.
+        connection_name
+            The name of the input connection.
+        size
+            The max number of packets allowed.
+        """
+        logger.debug(
+            "Updating packet size for anchor %s connection %s",
+            anchor_name,
+            connection_name,
+        )
+        self._packet_size_map.setdefault(anchor_name, {})
+        self._packet_size_map[anchor_name][connection_name] = size
+
+    def get_connection_packet_size(
+        self, anchor_name: str, connection_name: str
+    ) -> Optional[int]:
+        """
+        Retrieve packet size associated with a given input connection/anchor name.
+
+        Parameters
+        ----------
+        anchor_name
+            The name of the anchor that the connection is associated with.
+        connection_name
+            The name of the input connection to get the status of.
+
+        Returns
+        -------
+        int, optional
+            The max packet size on the conenction, if set, otherwise None.
+        """
+        if anchor_name not in self._packet_size_map:
+            raise ValueError(f"Anchor {anchor_name} not found in repository")
+        if connection_name not in self._packet_size_map[anchor_name]:
+            raise ValueError(
+                f"Packet size for connection {connection_name} not found in repository for anchor {anchor_name}."
+            )
+        size = self._packet_size_map[anchor_name][connection_name]
+        return size

another_ayx_python_sdk/providers/amp_provider/repositories/input_metadata_repository.py

@@ -0,0 +1,144 @@
+# 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 input metadata information given the associated anchor name and connection 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.singleton import Singleton
+
+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 InputMetadataRepository(metaclass=Singleton):
+    """Repository that stores input metadata information."""
+
+    _metadata_builder = MetadataBuilder()
+
+    def __init__(self) -> None:
+        """Initialize the input metadata repository."""
+        self._metadata_map: Dict[str, Dict[str, "CoreMetadata"]] = {}
+
+    def save_metadata(
+        self, anchor_name: str, connection_name: str, metadata: "CoreMetadata"
+    ) -> None:
+        """
+        Save input metadata information for the associated anchor name and connection name.
+
+        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.
+        metadata
+            The metadata information for the anchor and connection.
+        """
+        logger.debug(
+            "Adding metadata to InputMetadataRepository for anchor %s/connection %s",
+            anchor_name,
+            connection_name,
+        )
+        self._metadata_map.setdefault(anchor_name, {})[connection_name] = metadata
+        logger.debug("Current InputMetadataRepository State: %s", self._metadata_map)
+
+    def save_grpc_metadata(
+        self, anchor_name: str, connection_name: str, metadata: "ProtobufMetadata"
+    ) -> None:
+        """
+        Save input metadata information for the associated anchor name and connection name given a Protobuf metadata message.
+
+        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.
+        metadata
+            The protobuf metadata information for the anchor and connection.
+        """
+        self.save_metadata(
+            anchor_name, connection_name, self._metadata_builder.from_protobuf(metadata)
+        )
+
+    def get_metadata(
+        self,
+        anchor_name: str,
+        connection_name: str,
+    ) -> "CoreMetadata":
+        """
+        Get the input metadata associated with the given anchor name and connection name.
+
+        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
+        -------
+        CoreMetadata
+            The metadata information for the anchor and connection.
+        """
+        if anchor_name not in self._metadata_map:
+            raise ValueError(f"Anchor {anchor_name} not found in repository.")
+
+        if connection_name not in self._metadata_map[anchor_name]:
+            raise ValueError(
+                f"Connection {connection_name} not found in repository for anchor {anchor_name}."
+            )
+
+        return self._metadata_map[anchor_name][connection_name]
+
+    def delete_metadata(
+        self,
+        anchor_name: str,
+        connection_name: str,
+    ) -> None:
+        """
+        Delete the input metadata associated with the given anchor name and connection name.
+
+        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.
+        """
+        if anchor_name not in self._metadata_map:
+            raise ValueError(f"Anchor {anchor_name} not found in repository.")
+
+        if self._metadata_map[anchor_name].pop(connection_name, None) is None:
+            raise ValueError(
+                f"Connection {connection_name} not found in repository for anchor {anchor_name}."
+            )
+        logger.debug("Removing metadata for %s", anchor_name)
+        if not self._metadata_map[anchor_name]:
+            self._metadata_map.pop(anchor_name)
+        logger.debug("Current InputMetadataRepository State: %s", self._metadata_map)
+
+    def clear_repository(self) -> None:
+        """Delete all data in the repository."""
+        logger.debug("Clearing InputMetadataRepository")
+        self._metadata_map = {}
+        logger.debug("Current InputMetadataRepository State: %s", self._metadata_map)