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

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

@@ -1,306 +0,0 @@
-# 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.
-"""Test harness implementation of the SDK Engine service."""
-import asyncio
-import logging
-
-from another_ayx_python_sdk.core.constants import Anchor
-from another_ayx_python_sdk.providers.amp_provider.amp_driver import AMPDriver
-from another_ayx_python_sdk.providers.amp_provider.resources.generated.sdk_tool_service_v2_pb2 import (
-    ControlOut,
-    RecordTransferOut,
-)
-from another_ayx_python_sdk.providers.amp_provider.resources.generated.sdk_tool_service_v2_pb2_grpc import (
-    SdkToolV2Servicer,
-)
-
-
-class SdkToolServiceV2(SdkToolV2Servicer):
-    """Implementation of the SDK Engine V2 service."""
-
-    logger = logging.getLogger()
-    driver = AMPDriver()
-    init_data: asyncio.Future = asyncio.Future()
-    driver_guard: asyncio.Lock = asyncio.Lock()
-    cond_teardown = asyncio.Condition(lock=driver_guard)
-    record_teardown = asyncio.Condition(lock=driver_guard)
-    curr_driver_fn = None
-    ready_for_records: asyncio.Event = asyncio.Event()
-    record_batch_received: asyncio.Event = asyncio.Event()
-
-    async def Control(self, request_iterator, context):  # type: ignore  # noqa: N802
-        """
-        Handle Control messages.
-
-        Initialize plugin on initialize ControlIn, then send any ControlOut messages
-        to the client as needed, while monitoring for client responses.
-        """
-        try:
-            # Start read/writes and a worker to handle any callbacks for the driver
-            tasks = [
-                asyncio.create_task(
-                    self._ctrl_read(request_iterator), name="_ctrl_read"
-                ),
-                asyncio.create_task(self._ctrl_write(context), name="_ctrl_write"),
-                asyncio.create_task(
-                    self._driver_callback_worker(), name="_driver_callback_worker"
-                ),
-                asyncio.create_task(
-                    self._user_callback_worker(), name="_user_callback_worker"
-                ),
-            ]
-
-            # Clean up tasks
-            async with self.cond_teardown:
-                self.logger.debug("Control waiting on teardown notification")
-                await self.cond_teardown.wait()
-                await asyncio.sleep(0)
-                complete_msg = ControlOut()
-                complete_msg.confirm_complete.SetInParent()
-                self.driver.ctrl_io.ctrl_out.put_nowait(complete_msg)
-                await self.driver.ctrl_io.ctrl_out.join()
-                self.logger.debug("Control starting teardown")
-                await self.driver.ctrl_io.flush()
-                for t in tasks:
-                    t.cancel()
-            self.logger.debug("Control stream waiting for close")
-        except asyncio.CancelledError as e:
-            self.logger.error("ERROR: Client side disconnected from server.")
-            self.logger.error(repr(e))
-
-    async def _ctrl_read(self, request_iterator) -> None:  # type: ignore
-        awaits_response = {"translated_message", "decrypted_password", "dcm_e_response"}
-        async for request in request_iterator:
-            payload = request.WhichOneof("payload")
-            if payload == "plugin_initialization_data":  # TODO update this to const
-                try:
-                    asyncio.create_task(
-                        self.driver._initialize_plugin(
-                            request, self.ready_for_records, self.record_batch_received
-                        )
-                    )
-                except Exception as e:
-                    self.logger.error("%s", repr(e))
-            elif payload == "incoming_connection_complete":
-                conn_info = request.incoming_connection_complete
-                closed_anchor = Anchor(conn_info.anchor_name, conn_info.connection_name)
-                self.logger.debug("Pushing incoming connection complete")
-                if (
-                    not self.record_batch_received.is_set()
-                ):  # OOP sends incoming_connection_complete without sending any records
-                    self.logger.debug("empty row bug detected")
-                    self.record_batch_received.set()
-                self.driver.ctrl_io.push_driver_callback(
-                    self.driver.incoming_connection_complete_callback, closed_anchor
-                )
-            elif payload in awaits_response:
-                try:
-                    if self.driver.ctrl_io.awaiting_response.get(request.msg_id):
-                        self.driver.ctrl_io.push_callback_action(request)
-                    else:
-                        self.driver.ctrl_io.blocking_awaiting_response[
-                            request.msg_id
-                        ] = getattr(request, payload)
-                except Exception as e:
-                    self.logger.debug(repr(e))
-            elif payload == "notify_complete":
-                # Notify the driver to start completion
-                # The server assumes that the client is done sending RecordIn messages.
-                # Client should have sent any incoming records or otherwise at this point.
-                self.driver.ctrl_io.push_driver_callback(
-                    self.driver.on_complete_callback
-                )
-
-    async def _ctrl_write(self, context) -> None:  # type: ignore
-        while True:
-            msg = await self.driver.ctrl_io.ctrl_out.get()
-            try:
-                await context.write(msg)
-            except Exception as e:  # catch ExecuteBatchError if any
-                self.logger.debug(repr(e))
-            self.driver.ctrl_io.ctrl_out.task_done()
-
-    async def _user_callback_worker(self) -> None:
-        while True:
-            action = await self.driver.ctrl_io.ctrl_user_callback_actions.get()
-            loop = asyncio.get_event_loop()
-            try:
-                fn = action["callback_fn"]
-                if action.get("response_msg"):
-                    fut = loop.run_in_executor(None, fn, action["response_msg"])
-                else:
-                    fut = loop.run_in_executor(None, fn)
-                await fut
-                # Could collect these in order
-                if fut.exception():
-                    raise fut.exception() or BaseException()
-            except Exception as e:
-                report_str = (
-                    f"Failed while calling {action['callback_fn'].__name__}\n {repr(e)}"
-                )
-                self.logger.error(report_str)
-                self.driver.provider.io.error(report_str)
-            finally:
-                self.driver.ctrl_io.ctrl_user_callback_actions.task_done()
-
-    async def _driver_callback_worker(self) -> None:
-        while True:
-            action = await self.driver.ctrl_io.ctrl_driver_actions.get()
-
-            # Make sure we clear any queued user callbacks
-            await asyncio.sleep(0)
-            await self.driver.ctrl_io.ctrl_user_callback_actions.join()
-
-            is_on_complete = action["driver_fn"] == self.driver.on_complete_callback
-            if is_on_complete:
-                self.logger.debug("got on_complete, checking if need to requeue")
-                self.logger.debug(
-                    f"ready for on_complete: {self._ready_for_on_complete()}, record_batch_received.is_set(): {self.record_batch_received.is_set()}"
-                )
-                if (
-                    not self._ready_for_on_complete()
-                    or not self.record_batch_received.is_set()
-                ):
-                    self.logger.debug("requeue on_complete")
-                    try:
-                        await self._requeue_action(
-                            action, self.driver.ctrl_io.ctrl_driver_actions
-                        )
-                    except Exception as e:
-                        self.logger.error(e)
-                    continue
-                elif self.driver.provider.environment.update_only:
-                    async with self.record_teardown:
-                        self.record_teardown.notify_all()
-                    return
-            loop = asyncio.get_running_loop()
-            if action["args"]:
-                fut = loop.run_in_executor(None, action["driver_fn"], *action["args"])
-            else:
-                # Other plugin methods have no args
-                fut = loop.run_in_executor(None, action["driver_fn"])
-            # Handle any generated work from calling method
-            while fut.done() is False:
-                await asyncio.sleep(0.1)
-            action["event_cb_complete"].set()
-            if fut.exception():
-                #  Driver functions still use an error handling wrapper
-                #  So we don't have to log here, just teardown
-                async with self.record_teardown:
-                    self.record_teardown.notify_all()
-                raise fut.exception()  # type: ignore
-            if is_on_complete:
-                async with self.record_teardown:
-                    self.record_teardown.notify_all()
-                return
-
-    async def _requeue_action(self, action: dict, queue: asyncio.Queue) -> None:
-        #  Put action back on to passed queue.
-        await asyncio.sleep(0)
-        await queue.put(action)
-        queue.task_done()
-
-    def _ready_for_on_complete(self) -> bool:
-        pre_complete_actions = self.driver.ctrl_io.ctrl_driver_actions.empty()
-        pending_record_batches = self.driver.record_io.completed_streams.empty()
-        awaiting_responses = len(self.driver.ctrl_io.awaiting_response) < 1
-        return all([pre_complete_actions, pending_record_batches, awaiting_responses])
-
-    async def RecordTransfer(self, request_iterator, context):  # type: ignore  # noqa: N802
-        """
-        Definition for gRPC RecordTransfer.
-
-        Consumes any data sent by the client, then send any pending RecordTransferOut messages.
-        """
-        self.logger.debug("Record Transfer stream starting.")
-        tasks = [
-            asyncio.create_task(
-                self._record_read(request_iterator), name="_record_read"
-            ),
-            asyncio.create_task(self._record_write(context), name="_record_write"),
-            asyncio.create_task(
-                self._record_driver_actions(), name="_record_driver_actions"
-            ),
-        ]
-        async with self.record_teardown:
-            self.logger.debug("Waiting on teardown notification")
-            await self.record_teardown.wait()
-            await asyncio.sleep(0)
-            self.logger.debug("Received teardown notice. Cancelling tasks")
-            try:
-                for _, anchor in self.driver.provider.outgoing_anchors.items():
-                    if (
-                        anchor["num_connections"] > 0 or anchor.get("metadata")
-                    ) and not self.driver.provider.environment.update_only:
-                        rec_out_chunk_end = RecordTransferOut()
-                        rec_out_chunk_end.close_outgoing_anchor.name = anchor["name"]
-                        self.driver.record_io.pending_writes.put_nowait(
-                            {
-                                "write_type": "close_outgoing_anchor",
-                                "message": rec_out_chunk_end,
-                            }
-                        )
-
-                await self.driver.record_io.flush()
-                for t in tasks:
-                    t.cancel()
-            except Exception as e:
-                self.logger.debug(repr(e))
-        async with self.cond_teardown:
-            self.cond_teardown.notify_all()
-        self.logger.debug("Exiting RecordTransfer...")
-
-    async def _record_read(self, request_iterator) -> None:  # type: ignore
-        """Receive any RecordTransferIn messages from the client."""
-        async for req in request_iterator:
-            payload = req.WhichOneof("payload")
-            if payload == "incoming_records":
-                self.driver.record_io.receive_chunk(req)
-
-    async def _record_write(self, context) -> None:  # type: ignore
-        """Write and send RecordTransferOut.outgoing_records from write queue."""
-        while True:
-            # If user has written to buffer, send records
-            to_write = await self.driver.record_io.pending_writes.get()
-            if to_write["write_type"] == "outgoing_records":
-                for msg in self.driver.record_io.get_stream_msgs(to_write):
-                    await context.write(msg)
-            else:
-                try:
-                    anchor = self.driver.provider.outgoing_anchors[
-                        to_write["message"].close_outgoing_anchor.name
-                    ]
-                    if (
-                        anchor["num_connections"] > 0
-                        and not anchor.get("metadata", False)
-                    ) and not self.driver.provider.environment.update_only:
-                        self.logger.debug("Wrote close anchor")
-                    await context.write(to_write["message"])
-                except Exception as e:
-                    self.logger.error("Failed during record_write: %s", repr(e))
-            self.driver.record_io.pending_writes.task_done()
-
-    async def _record_driver_actions(self) -> None:
-        """Handle events related to receiving or sending batches."""
-        while True:
-            batch_item = await self.driver.record_io.completed_streams.get()
-            self.logger.debug(f"Got a msg from completed_streams queue: {batch_item}")
-            await self.ready_for_records.wait()  # wait for plugin_init to finish before calling on_record_batch
-            self.driver.ctrl_io.push_driver_callback(
-                self.driver.record_batch_received,
-                batch_item["record_batch"],
-                batch_item["anchor"],
-            )
-            self.record_batch_received.set()
-            self.driver.record_io.completed_streams.task_done()

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

@@ -1,14 +0,0 @@
-# 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.
-"""Resources to be consumed by the amp provider."""

build/lib/another_ayx_python_sdk/providers/amp_provider/utilities/constants.py

@@ -1,22 +0,0 @@
-# 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.
-"""Workspace constant definitions."""
-from enum import Enum
-
-
-class ToolEnvType(str, Enum):
-    """YXI installation types."""
-
-    Desktop = "Desktop"
-    Service = "Service"

build/lib/another_ayx_python_sdk/providers/amp_provider/utilities/conversions.py

@@ -1,55 +0,0 @@
-# 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.
-"""Conversion methods for AMP Provider classes."""
-from datetime import date, datetime, timedelta
-
-from another_ayx_python_sdk.providers.amp_provider.amp_provider_v2 import AMPProviderV2
-
-import deprecation
-
-from pyarrow import Date32Scalar, int32
-
-
-# Alteryx Epoch is based closely on Excel's, not UNIX
-ALTERYX_DATE32_EPOCH = datetime(1900, 1, 1, 0, 0)
-
-
-@deprecation.deprecated(
-    deprecated_in="2.1.1",
-    details="This function is no more necessary since version 2022.2 of Designer",
-)  # type: ignore
-def arrow_scalar_date32_to_py(
-    provider: AMPProviderV2, arrow_date: Date32Scalar
-) -> date:
-    """
-    Convert a Arrow Date32Scalar to a Python datetime object.
-
-    Parameters
-    ----------
-    provider
-        AMPProviderV2 context, necessary for Designer version
-    arrow_date
-        An Arrow date represented as days since Epoch.
-
-    Returns
-    -------
-    date
-        The converted date value.
-    """
-    if provider.environment.designer_version < "2022.2":
-        return (
-            ALTERYX_DATE32_EPOCH + timedelta(arrow_date.cast(int32()).as_py() - 2)
-        ).date()
-    else:
-        return arrow_date.as_py()

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

@@ -1,63 +0,0 @@
-# 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 for AMP Provider classes."""
-import logging
-import os
-import uuid
-from pathlib import Path
-
-
-from another_ayx_python_sdk.providers.amp_provider.utilities.constants import ToolEnvType
-
-logger = logging.getLogger()
-
-
-def tool_type() -> ToolEnvType:
-    """Determine the Tool Environment Type based on TOOL_SERVICE_ADDRESS env var."""
-    return (
-        ToolEnvType.Service
-        if "TOOL_SERVICE_ADDRESS" in os.environ
-        else ToolEnvType.Desktop
-    )
-
-
-def get_temp_file(extension: str = "tmp", temp_dir: str = "./") -> "Path":
-    """
-    Create a temporary file managed by Designer.
-
-    Parameters
-    ----------
-    extension
-        The file extension of the temp file.
-    temp_dir
-        Directory in which to place 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 = 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)

build/lib/another_ayx_python_sdk/providers/e1_provider/__init__.py

@@ -1,36 +0,0 @@
-# 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.
-"""E1 SDK Provider interface."""
-# flake8: noqa
-
-from .cache_e1_sdk_import import cache_e1_sdk_import
-
-cache_e1_sdk_import()
-
-from .e1_environment import E1Environment
-from .e1_input_anchor import E1InputAnchor
-from .e1_io import E1IO
-from .e1_output_anchor import E1OutputAnchor
-from .e1_plugin_proxy import E1PluginProxy
-from .e1_provider import E1Provider
-
-
-__all__ = [
-    "E1PluginProxy",
-    "E1Environment",
-    "E1InputAnchor",
-    "E1IO",
-    "E1OutputAnchor",
-    "E1Provider",
-]

build/lib/another_ayx_python_sdk/providers/e1_provider/anchor_builder.py

@@ -1,95 +0,0 @@
-# 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.
-"""Alteryx tool configuration definition."""
-from typing import Any, Dict, List
-
-from another_ayx_python_sdk.providers.e1_provider.mock_e1_sdk.AlteryxPythonSDK import OutputAnchorManager
-
-from another_ayx_python_sdk.providers.e1_provider.e1_input_anchor_proxy import (
-    E1InputAnchorProxy,
-)
-from another_ayx_python_sdk.providers.e1_provider.e1_output_anchor_proxy import (
-    E1OutputAnchorProxy,
-)
-
-
-class AnchorBuilder:
-    """Anchor builder definition."""
-
-    __slots__ = ["tool_config", "output_anchor_mgr"]
-
-    def __init__(
-        self, tool_config: Dict[str, Any], output_anchor_mgr: OutputAnchorManager
-    ):
-        """Initialize a tool configuration."""
-        self.tool_config = tool_config
-        self.output_anchor_mgr = output_anchor_mgr
-
-    def build_input_anchors(self) -> List[E1InputAnchorProxy]:
-        """Build the input anchors based on tool config settings."""
-        anchor_settings = self.tool_config["AlteryxJavaScriptPlugin"]["GuiSettings"]
-
-        input_anchors = anchor_settings.get("InputConnections")
-        if not isinstance(input_anchors, dict):
-            input_anchor_configs: List[Dict] = []
-        else:
-            input_anchor_configs_raw = input_anchors.get("Connection")
-            if not isinstance(input_anchor_configs_raw, dict) and not isinstance(
-                input_anchor_configs_raw, list
-            ):
-                input_anchor_configs = []
-            else:
-                if not isinstance(input_anchor_configs_raw, list):
-                    input_anchor_configs = [input_anchor_configs_raw]
-                else:
-                    input_anchor_configs = input_anchor_configs_raw
-
-        return [
-            E1InputAnchorProxy(
-                config["@Name"],
-                config.get("@AllowMultiple", "false").lower() == "true",
-                config["@Optional"].lower() == "true",
-            )
-            for config in input_anchor_configs
-        ]
-
-    def build_output_anchors(self) -> List[E1OutputAnchorProxy]:
-        """Build the output anchors based on tool config settings."""
-        anchor_settings = self.tool_config["AlteryxJavaScriptPlugin"]["GuiSettings"]
-
-        output_anchors = anchor_settings.get("OutputConnections")
-
-        if not isinstance(output_anchors, dict):
-            output_anchor_configs: List[Dict] = []
-        else:
-            output_anchor_configs_raw = output_anchors.get("Connection")
-            if not isinstance(output_anchor_configs_raw, dict) and not isinstance(
-                output_anchor_configs_raw, list
-            ):
-                output_anchor_configs = []
-            else:
-                if not isinstance(output_anchor_configs_raw, list):
-                    output_anchor_configs = [output_anchor_configs_raw]
-                else:
-                    output_anchor_configs = output_anchor_configs_raw
-
-        return [
-            E1OutputAnchorProxy(
-                config["@Name"],
-                config.get("@AllowMultiple", "true").lower() == "true",
-                config["@Optional"].lower() == "true",
-                self.output_anchor_mgr,
-            )
-            for config in output_anchor_configs
-        ]

build/lib/another_ayx_python_sdk/providers/e1_provider/cache_e1_sdk_import.py

@@ -1,31 +0,0 @@
-# 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.
-"""Get the E1 package."""
-import sys
-from pathlib import Path
-
-
-def cache_e1_sdk_import() -> None:
-    """
-    Cache the import for the E1 SDK.
-
-    This is necessary in order to remove the dependency on the
-    AlteryxPythonSDK package.
-    """
-    try:
-        import another_ayx_python_sdk.providers.e1_provider.mock_e1_sdk.AlteryxPythonSDK as AlteryxPythonSDK  # noqa: F401
-    except ModuleNotFoundError:
-        mock_e1_sdk_package_dir = Path(__file__).parent / "mock_e1_sdk"
-        sys.path.append(str(mock_e1_sdk_package_dir))
-        import another_ayx_python_sdk.providers.e1_provider.mock_e1_sdk.AlteryxPythonSDK as AlteryxPythonSDK  # noqa: F401