Merge pull request #221 in LCL/wolframclientforpython from feature/async-eval-remove-loop to master

* commit '516e260df3329354c9444daccc39edd289f3e5d8': (21 commits)
  drop 4 async generators.
  automatic code fix
  adding buffer types for force_text
  Use annotation on coroutine in parallele eval
  adding tests
  using dispatch to implement force_bytes and force_text
  adding comment for py2
  adding a custom rule for memoryview
  fixing six
  need to add encoding for py2
  simplify asyncio
  automatic code refactor
  update version
  update changelog
  update duplicated test
  Pool now use asyncio.run
  update utils asyncio
  Removing loop parameter in asynchronous evaluators
  Simplify parallel evaluate code.
  Minor rephrasing in pool code
  ...

Author: Dorian Birraux

CHANGELOG.md

@@ -1,3 +1,7 @@
+# Version 1.1.3
+- Update asynchronous evaluator classes. Remove the `loop` parameter. Most optional loop parameters are deprecated in the Python standart library `asyncio` and in most libraries, mainly because it is misleading and lead to misuses and bugs. The loop parameter is useful when instantiating asynchronous evaluators outside the scope of an event loop. It's implementation was not good enough and was relying on usages deprecated in 3.8.
+- Removing four asynchronous generators in asynchronous evaluation result classes: `iter_messages`, `iter_messages_name`, `iter_messages_tuple` and `iter_output`. These coroutines are only working on python 3.6+ and are not critical enough to drop support for 3.5. Asynchronous properties: `messages`, `messages_name` and `output` provide the same information.
+
 # Version 1.1.2
 - Fix a backward incompatible change introduced in 12.1. Make sure the library works with any kernel version starting with 11.3.
 - Minor changes and tweaks.

PacletInfo.m

@@ -1,6 +1,6 @@
 Paclet[
     Name -> "WolframClientForPython",
-    Version -> "1.1.2",
+    Version -> "1.1.3",
     MathematicaVersion -> "11.3+",
     Loading -> Automatic,
     Extensions -> {}

wolframclient/about.py

@@ -2,6 +2,6 @@
 
 __name__ = "wolframclient"
 __description__ = "A Python library with various tools to interact with the Wolfram Language and the Wolfram Cloud."
-__version__ = "1.1.2"
+__version__ = "1.1.3"
 __author__ = "Wolfram Research"
 __author_email__ = "support@wolfram.com, dorianb@wolfram.com, riccardod@wolfram.com"

wolframclient/deserializers/wxf/wxfparser.py

@@ -14,26 +14,29 @@
 
 wxf_input_to_buffer = Dispatch()
 
+
 @wxf_input_to_buffer.dispatch((six.binary_type, six.buffer_types))
 def encode_buffer(wxf_input):
     return six.BytesIO(wxf_input)
 
+
 if six.PY2:
-    @wxf_input_to_buffer.dispatch(memoryview, replace_existing = True)
+
+    @wxf_input_to_buffer.dispatch(memoryview, replace_existing=True)
     def encode_buffer(wxf_input):
-        return six.BytesIO(wxf_input.tobytes())    
+        return six.BytesIO(wxf_input.tobytes())
+
 
 @wxf_input_to_buffer.dispatch(object)
 def encode_default(wxf_input):
-    if hasattr(wxf_input, 'read'):
+    if hasattr(wxf_input, "read"):
         return wxf_input
     raise TypeError(
         "Class %s neither implements a read method nor is a binary type."
         % wxf_input.__class__.__name__
     )
 
 
-
 class WXFParser(object):
     """Parse a WXF input.
 
@@ -80,7 +83,7 @@ def __init__(self, wxf_input):
         """WXF parser returning Python object from a WXF encoded byte sequence.
         """
         self.context = SerializationContext()
-        self.reader  = wxf_input_to_buffer(wxf_input)
+        self.reader = wxf_input_to_buffer(wxf_input)
 
         version, compress = self.parse_header()
         if compress == True:

wolframclient/evaluation/base.py

@@ -143,21 +143,20 @@ def __exit__(self, type, value, traceback):
 
 class WolframAsyncEvaluator(WolframEvaluatorBase):
     """ Asynchronous evaluators are similar to synchronous ones except that they make heavy use of coroutines
-    and need an event loop. 
+    and need to run in an event loop.
     
-    Most methods from this class are similar to their counterpart from :class:`~wolframclient.evaluation.base.WolframEvaluator`,
-    except that they are coroutines. """
+    Most methods from this class are similar to their counterpart from
+    :class:`~wolframclient.evaluation.base.WolframEvaluator`, except that they are coroutines. """
 
-    def __init__(self, loop=None, **kwargs):
-        self._loop = loop or asyncio.get_event_loop()
+    def __init__(self, **kwargs):
         super().__init__(**kwargs)
 
     async def evaluate(self, expr):
         result = await self.evaluate_wrap(expr)
         return await result.get()
 
     async def evaluate_many(self, expr_list):
-        return await asyncio.gather(*map(self.evaluate, expr_list), loop=self._loop)
+        return await asyncio.gather(*map(self.evaluate, expr_list))
 
     async def evaluate_wrap(self, expr):
         raise NotImplementedError
@@ -215,7 +214,13 @@ async def __aexit__(self, type, value, traceback):
 
     def __del__(self, _warnings=warnings):
         super().__del__(_warnings=warnings)
-        if not self.stopped and self._loop and not self._loop.is_closed():
-            self._loop.call_exception_handler(
-                {self.__class__.__name__: self, "message": "Unclosed evaluator."}
-            )
+        if not self.stopped:
+            loop = None
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                pass
+            if loop and not loop.is_closed():
+                loop.call_exception_handler(
+                    {self.__class__.__name__: self, "message": "Unclosed evaluator."}
+                )

wolframclient/evaluation/cloud/asynccloudsession.py

@@ -38,8 +38,6 @@ class WolframCloudAsyncSession(WolframAsyncEvaluator):
         async with WolframCloudAsyncSession() as session:
             await session.call(...)
 
-    An event loop can be explicitly passed using the named parameter `loop`; otherwise, the one
-    returned by :func:`~asyncio.get_event_loop` is used.
     The initialization options of the class :class:`~wolframclient.evaluation.WolframCloudSession` are also supported by
     this class.
     """
@@ -48,14 +46,13 @@ def __init__(
         self,
         credentials=None,
         server=None,
-        loop=None,
         inputform_string_evaluation=True,
         oauth_session_class=None,
         xauth_session_class=None,
         http_sessionclass=None,
         ssl_context_class=None,
     ):
-        super().__init__(loop, inputform_string_evaluation=inputform_string_evaluation)
+        super().__init__(inputform_string_evaluation=inputform_string_evaluation)
         self.server = server or WOLFRAM_PUBLIC_CLOUD_SERVER
         self.http_session = None
         self.http_sessionclass = http_sessionclass or aiohttp.ClientSession
@@ -76,7 +73,6 @@ def duplicate(self):
         return self.__class__(
             credentials=self.credentials,
             server=self.server,
-            loop=self._loop,
             inputform_string_evaluation=self.inputform_string_evaluation,
             oauth_session_class=self.oauth_session_class,
             xauth_session_class=self.xauth_session_class,
@@ -90,7 +86,7 @@ async def start(self):
             if not self.started:
                 if self.http_session is None or self.http_session.closed:
                     self.http_session = self.http_sessionclass(
-                        headers={"User-Agent": "WolframClientForPython/1.0"}, loop=self._loop
+                        headers={"User-Agent": "WolframClientForPython/1.0"}
                     )
                 if not self.anonymous():
                     await self._authenticate()

wolframclient/evaluation/cloud/oauth.py

@@ -202,7 +202,7 @@ def authenticate(self):
         params = {
             "x_auth_username": self.xauth_credentials.user,
             "x_auth_password": self.xauth_credentials.password,
-            "x_auth_mode": "client_auth"
+            "x_auth_mode": "client_auth",
         }
 
         # avoid dumping password in log files.

wolframclient/evaluation/kernel/asyncsession.py

@@ -22,10 +22,7 @@ class WolframLanguageAsyncSession(WolframAsyncEvaluator, WolframLanguageSession)
         async with WolframLanguageAsyncSession() as session:
             await session.evaluate('Now')
 
-    An event loop can be explicitly passed using the named parameter `loop`; otherwise, the one
-    returned by :func:`~asyncio.get_event_loop` is used.
-
-    Coroutines all run in a unique thread. Since a Wolfram kernel is single threaded, there can
+    Coroutines all run in their own thread. Since a Wolfram kernel is single threaded, there can
     be only one evaluation at a time. In a sense, from the event loop point of view, evaluations 
     are atomic operations. Even when many asynchronous sessions are started, the number of 
     threads equals the number of kernel instances running and should not be problematic. Ensuring 
@@ -37,7 +34,6 @@ def __init__(
         self,
         kernel=None,
         consumer=None,
-        loop=None,
         initfile=None,
         kernel_loglevel=logging.NOTSET,
         stdin=PIPE,
@@ -55,14 +51,12 @@ def __init__(
             stdout=stdout,
             stderr=stderr,
             inputform_string_evaluation=inputform_string_evaluation,
-            loop=loop,
             **kwargs
         )
 
     def duplicate(self):
         return self.__class__(
             kernel=self.kernel,
-            loop=self._loop,
             consumer=self.consumer,
             initfile=self.initfile,
             kernel_loglevel=self.kernel_loglevel,
@@ -77,7 +71,7 @@ async def do_evaluate_future(self, expr, result_update_callback=None, **kwargs):
         future = super().do_evaluate_future(
             expr, result_update_callback=result_update_callback, **kwargs
         )
-        return asyncio.wrap_future(future, loop=self._loop)
+        return asyncio.wrap_future(future)
 
     async def evaluate_future(self, expr, **kwargs):
         await self.ensure_started()
@@ -138,7 +132,7 @@ async def start(self):
         
         This method is a coroutine."""
         future = super().start_future()
-        await asyncio.wrap_future(future, loop=self._loop)
+        await asyncio.wrap_future(future)
 
     async def stop(self):
         """Asynchronously stop the session (graceful termination).
@@ -155,4 +149,4 @@ async def terminate(self):
     async def _async_terminate(self, gracefully):
         logger.info("Terminating asynchronous kernel session.")
         future = super().stop_future(gracefully=gracefully)
-        await asyncio.wrap_future(future, loop=self._loop)
+        await asyncio.wrap_future(future)

wolframclient/evaluation/kernel/kernelcontroller.py

@@ -592,8 +592,7 @@ def _cancel_tasks(self):
 
     def __repr__(self):
         if self.started:
-            return '<%s[%s ✅], "%s", pid:%i, kernel sockets: (in:%s, out:%s)>'\
-                   % (
+            return '<%s[%s ✅], "%s", pid:%i, kernel sockets: (in:%s, out:%s)>' % (
                 self.__class__.__name__,
                 self.name,
                 self.kernel,

wolframclient/evaluation/kernel/localsession.py

@@ -283,7 +283,4 @@ def set_parameter(self, parameter_name, parameter_value):
     set_parameter.__doc__ = WolframKernelController.set_parameter.__doc__
 
     def __repr__(self):
-        return "<%s: %s>" % (
-            self.__class__.__name__,
-            self.kernel_controller,
-        )
+        return "<%s: %s>" % (self.__class__.__name__, self.kernel_controller)