automatic code refactor

Author: crazyeng

wolframclient/evaluation/cloud/asynccloudsession.py

@@ -86,7 +86,8 @@ 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"})
+                        headers={"User-Agent": "WolframClientForPython/1.0"}
+                    )
                 if not self.anonymous():
                     await self._authenticate()
         except Exception as e:

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/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)

wolframclient/evaluation/pool.py

@@ -3,7 +3,6 @@
 import itertools
 import logging
 from asyncio import CancelledError
-from wolframclient.utils.asyncio import get_event_loop
 
 from wolframclient.evaluation.base import WolframAsyncEvaluator
 from wolframclient.evaluation.kernel.asyncsession import WolframLanguageAsyncSession
@@ -71,7 +70,9 @@ def __init__(
     ):
         super().__init__()
         if poolsize <= 0:
-            raise ValueError("Invalid pool size value %i. Expecting a positive integer." % poolsize)
+            raise ValueError(
+                "Invalid pool size value %i. Expecting a positive integer." % poolsize
+            )
         self._queue = asyncio.Queue(load_factor * poolsize)
         self.async_language_session_class = async_language_session_class
         self._evaluators = set()
@@ -94,9 +95,7 @@ def __init__(
 
     def _add_evaluator(self, evaluator, **kwargs):
         if evaluator is None or isinstance(evaluator, six.string_types):
-            self._evaluators.add(
-                self.async_language_session_class(kernel=evaluator, **kwargs)
-            )
+            self._evaluators.add(self.async_language_session_class(kernel=evaluator, **kwargs))
         elif isinstance(evaluator, WolframAsyncEvaluator):
             if evaluator in self._evaluators:
                 self._evaluators.add(evaluator.duplicate())
@@ -167,7 +166,9 @@ async def _async_start_kernel(self, kernel):
                     )
                 await kernel.stop()
             except asyncio.CancelledError:
-                logger.info("Cancelled signal during kernel termination following a failed start.")
+                logger.info(
+                    "Cancelled signal during kernel termination following a failed start."
+                )
             except Exception as e2:
                 logger.info("Exception raised during clean-up after failed start: %s", e2)
 
@@ -193,7 +194,8 @@ async def start(self):
         self.stopped = False
         # keep track of the init tasks. We have to wait before terminating.
         self._kernel_start_tasks = {
-            asyncio.ensure_future(self._async_start_kernel(kernel)) for kernel in self._evaluators
+            asyncio.ensure_future(self._async_start_kernel(kernel))
+            for kernel in self._evaluators
         }
         # uninitialized kernels are removed if they failed to start
         # if they do start, the task is added to _kernel_evaluation_loop_tasks.
@@ -205,7 +207,9 @@ async def start(self):
             _, self._kernel_start_tasks = await asyncio.wait(
                 self._kernel_start_tasks, return_when=asyncio.FIRST_COMPLETED
             )
-        logger.info("Pool initialized with %i running kernels", len(self._kernel_evaluation_loop_tasks))
+        logger.info(
+            "Pool initialized with %i running kernels", len(self._kernel_evaluation_loop_tasks)
+        )
 
     async def stop(self):
 
@@ -288,6 +292,7 @@ def parallel_evaluate(expressions, evaluator_spec=None, max_evaluators=4):
     Note that each evaluation should be independent and not rely on any previous one. There is no guarantee that two
     given expressions evaluate on the same kernel.
     """
+
     async def cor():
         async with WolframEvaluatorPool(evaluator_spec, poolsize=max_evaluators) as pool:
             return await pool.evaluate_all(expressions)

wolframclient/language/decorators.py

@@ -15,9 +15,7 @@
 }
 
 
-def safe_wl_execute(
-    function, args=(), opts={}, export_opts={}, exception_class=None
-):
+def safe_wl_execute(function, args=(), opts={}, export_opts={}, exception_class=None):
 
     __traceback_hidden_variables__ = True
 

wolframclient/serializers/base.py

@@ -165,8 +165,6 @@ def _serialize_external_object(self, o):
         yield "IsMethod", inspect.ismethod(o),
         yield "IsCallable", callable(o),
 
-
-
     def serialize_external_object(self, obj):
         return self.serialize_function(
             self.serialize_symbol(callable(obj) and b"ExternalFunction" or b"ExternalObject"),

wolframclient/serializers/wxfencoder/streaming.py

@@ -32,7 +32,6 @@ class ExactSizeReader(object):
     def __init__(self, reader):
         self._reader = reader
 
-    
     def read(self, size=-1):
         """Read from an underlying readable object.
 
@@ -60,6 +59,7 @@ def _read_rest(self, data, size=-1):
             yield chunk
             out_len += len(chunk)
 
+
 class ZipCompressedReader(object):
     """A buffer implementation reading zip compressed data from a source buffer and returning uncompressed data.
 

wolframclient/utils/asyncio.py

@@ -3,8 +3,6 @@
 import asyncio
 import functools
 
-from wolframclient.utils.functional import first, iterate
-
 
 def run_in_loop(cor, loop=None):
     @functools.wraps(cor)
@@ -23,9 +21,10 @@ def get_event_loop(loop=None):
         return loop
 
 
-if hasattr(asyncio, 'run'):
+if hasattr(asyncio, "run"):
     run = asyncio.run
 else:
+
     def run(main):
         loop = get_event_loop()
         return loop.run_until_complete(main)

wolframclient/utils/externalevaluate.py

@@ -92,6 +92,7 @@ def __init__(self, socket):
     def write(self, bytes):
         self.socket.send(zmq.Frame(bytes))
 
+
 class StdoutProxy:
 
     keep_listening = wl.ExternalEvaluate.Private.ExternalEvaluateKeepListening