Interoperability On Python update async support

It's been a while since my last IoP update. Let's catch up!

Significant enhancements have been added to the IoP command-line interface:

• Name Change: The grongier.pex module has been renamed to iop to align with the project's new branding.
• Asynchronous Support: IoP now fully supports asynchronous functions and coroutines.

Project Renaming

The grongier.pex module remains accessible for backward compatibility but will be removed in a future release. Use the iop module for new development.

Asynchronous Functionalities

While IoP has long supported asynchronous calls, direct use of async functions and coroutines was previously unavailable. Before exploring this new feature, let's review how asynchronous calls function within InterSystems IRIS and examine two examples.

Legacy Asynchronous Calls

This illustrates the traditional approach:

from iop import BusinessProcess
from msg import MyMessage


class MyBP(BusinessProcess):

    def on_message(self, request):
        msg_one = MyMessage(message="Message1")
        msg_two = MyMessage(message="Message2")

        self.send_request_async("Python.MyBO", msg_one, completion_key="1")
        self.send_request_async("Python.MyBO", msg_two, completion_key="2")

    def on_response(self, request, response, call_request, call_response, completion_key):
        if completion_key == "1":
            self.response_one = call_response
        elif completion_key == "2":
            self.response_two = call_response

    def on_complete(self, request, response):
        self.log_info(f"Received response one: {self.response_one.message}")
        self.log_info(f"Received response two: {self.response_two.message}")

This mirrors the asynchronous call behavior in IRIS. send_request_async sends a request to a Business Operation, and on_response handles the received response. completion_key differentiates responses.

Synchronous Multi-Request Functionality

While not entirely new, the ability to send multiple synchronous requests concurrently is noteworthy:

from iop import BusinessProcess
from msg import MyMessage


class MyMultiBP(BusinessProcess):

    def on_message(self, request):
        msg_one = MyMessage(message="Message1")
        msg_two = MyMessage(message="Message2")

        tuple_responses = self.send_multi_request_sync([("Python.MyMultiBO", msg_one),
                                                        ("Python.MyMultiBO", msg_two)])

        self.log_info("All requests have been processed")
        for target, request, response, status in tuple_responses:
            self.log_info(f"Received response: {response.message}")

This example concurrently sends two requests to the same Business Operation. The response is a tuple containing target, request, response, and status for each call. This is particularly useful when request order is unimportant.

Asynchronous Functions and Coroutines

Here's how to leverage async functions and coroutines in IoP:

import asyncio

from iop import BusinessProcess
from msg import MyMessage


class MyAsyncNGBP(BusinessProcess):

    def on_message(self, request):

        results = asyncio.run(self.await_response(request))

        for result in results:
            print(f"Received response: {result.message}")

    async def await_response(self, request):
        msg_one = MyMessage(message="Message1")
        msg_two = MyMessage(message="Message2")

        tasks = [self.send_request_async_ng("Python.MyAsyncNGBO", msg_one),
                 self.send_request_async_ng("Python.MyAsyncNGBO", msg_two)]

        return await asyncio.gather(*tasks)

This concurrently sends multiple requests using send_request_async_ng. asyncio.gather ensures all responses are awaited concurrently.

If you've followed along this far, please comment "Boomerang"! It would mean a lot. Thanks!

await_response is a coroutine that sends multiple requests and waits for all responses.

The advantages of using async functions and coroutines include improved performance through parallel requests, enhanced readability and maintainability, increased flexibility using the asyncio module, and better exception and timeout handling.

Comparison of Asynchronous Methods

What are the key differences between send_request_async, send_multi_request_sync, and send_request_async_ng?

• send_request_async: Sends a request and waits for a response only if on_response is implemented and completion_key is used. Simple but less scalable for parallel requests.
• send_multi_request_sync: Sends multiple requests concurrently and waits for all responses. Easy to use, but response order isn't guaranteed.
• send_request_async_ng: Sends multiple requests concurrently and waits for all responses, maintaining response order. Requires async functions and coroutines.

Happy multithreading!

The above is the detailed content of Interoperability On Python update async support. For more information, please follow other related articles on the PHP Chinese website!