Better fix for broken async variables and attributes after Python 3.7 migration

platypush/backend/http/__init__.py

@@ -239,7 +239,7 @@ class HttpBackend(Backend):
 
             if isinstance(msg, Request):
                 try:
-                    response = msg.execute(async=False)
+                    response = msg.execute(_async=False)
                 except PermissionError:
                     abort(401)
 

platypush/config/__init__.py

@@ -148,10 +148,10 @@ class Config(object):
                 self.cronjobs[cron_name] = self._config[key]
             elif key.startswith('procedure.'):
                 tokens = key.split('.')
-                async = True if tokens[1] == 'async' else False
+                _async = True if tokens[1] == 'async' else False
                 procedure_name = '.'.join(tokens[2:])
                 self.procedures[procedure_name] = {
-                    'async': async,
+                    '_async': _async,
                     'actions': self._config[key]
                 }
             else:

platypush/cron/scheduler.py

@@ -27,7 +27,7 @@ class Cronjob(Thread):
         context = {}
 
         for action in self.actions:
-            response = action.execute(async=False, **context)
+            response = action.execute(_async=False, **context)
             logger.info('Response from cronjob {}: {}'.format(self.name, response))
 
 

platypush/message/request/__init__.py

@@ -71,7 +71,7 @@ class Request(Message):
         proc_name = self.action.split('.')[-1]
         proc_config = Config.get_procedures()[proc_name]
         proc = Procedure.build(name=proc_name, requests=proc_config['actions'],
-                               async=proc_config['async'],
+                               _async=proc_config['_async'],
                                backend=self.backend, id=self.id)
 
         return proc.execute(*args, **kwargs)
@@ -159,12 +159,12 @@ class Request(Message):
                         'origin attached: {}'.format(response))
 
 
-    def execute(self, n_tries=1, async=True, **context):
+    def execute(self, n_tries=1, _async=True, **context):
         """
         Execute this request and returns a Response object
         Params:
             n_tries -- Number of tries in case of failure before raising a RuntimeError
-            async   -- If True, the request will be run asynchronously and the
+            _async   -- If True, the request will be run asynchronously and the
                        response posted on the bus when available (default),
                        otherwise the current thread will wait for the response
                        to be returned synchronously.
@@ -212,7 +212,7 @@ class Request(Message):
             if self.token is None or get_hash(self.token) != token_hash:
                 raise PermissionError()
 
-        if async:
+        if _async:
             Thread(target=_thread_func, args=(n_tries,)).start()
         else:
             return _thread_func(n_tries)

platypush/procedure/__init__.py

@@ -11,17 +11,17 @@ logger = logging.getLogger(__name__)
 class Procedure(object):
     """ Procedure class. A procedure is a pre-configured list of requests """
 
-    def __init__(self, name, async, requests, backend=None):
+    def __init__(self, name, _async, requests, backend=None):
         """
         Params:
             name     -- Procedure name
-            async    -- Whether the actions in the procedure are supposed to
+            _async    -- Whether the actions in the procedure are supposed to
                         be executed sequentially or in parallel (True or False)
             requests -- List of platylist.message.request.Request objects
         """
 
         self.name     = name
-        self.async    = async
+        self._async   = _async
         self.requests = requests
         self.backend  = backend
 
@@ -30,7 +30,7 @@ class Procedure(object):
 
 
     @classmethod
-    def build(cls, name, async, requests, backend=None, id=None, **kwargs):
+    def build(cls, name, _async, requests, backend=None, id=None, **kwargs):
         reqs = []
         loop_count = 0
         if_count = 0
@@ -47,11 +47,11 @@ class Procedure(object):
 
                     # A 'for' loop is synchronous. Declare a 'fork' loop if you
                     # want to process the elements in the iterable in parallel
-                    async = True if m.group(1) == 'fork' else False
+                    _async = True if m.group(1) == 'fork' else False
                     iterator_name = m.group(2)
                     iterable = m.group(3)
 
-                    loop = LoopProcedure.build(name=loop_name, async=async,
+                    loop = LoopProcedure.build(name=loop_name, _async=_async,
                                                requests=request_config[key],
                                                backend=backend, id=id,
                                                iterator_name=iterator_name,
@@ -87,7 +87,7 @@ class Procedure(object):
             request = Request.build(request_config)
             reqs.append(request)
 
-        return cls(name=name, async=async, requests=reqs, backend=backend, **kwargs)
+        return cls(name=name, _async=_async, requests=reqs, backend=backend, **kwargs)
 
 
     def execute(self, n_tries=1, **context):
@@ -105,10 +105,10 @@ class Procedure(object):
             if token:
                 request.token = token
 
-            context['async'] = self.async; context['n_tries'] = n_tries
+            context['_async'] = self._async; context['n_tries'] = n_tries
             response = request.execute(**context)
 
-            if not self.async:
+            if not self._async:
                 if isinstance(response.output, dict):
                     for (k,v) in response.output.items():
                         context[k] = v
@@ -145,15 +145,15 @@ class LoopProcedure(Procedure):
 
     context = {}
 
-    def __init__(self, name, iterator_name, iterable, requests, async=False, backend=None, **kwargs):
+    def __init__(self, name, iterator_name, iterable, requests, _async=False, backend=None, **kwargs):
-        super(). __init__(name=name, async=async, requests=requests, backend=None, **kwargs)
+        super(). __init__(name=name, _async=_async, requests=requests, backend=None, **kwargs)
 
         self.iterator_name = iterator_name
         self.iterable = iterable
         self.requests = requests
 
 
-    def execute(self, async=None, **context):
+    def execute(self, _async=None, **context):
         iterable = Request.expand_value_from_context(self.iterable, **context)
         response = Response()
 
@@ -192,7 +192,7 @@ class IfProcedure(Procedure):
     context = {}
 
     def __init__(self, name, condition, requests, else_branch=[], backend=None, id=None, **kwargs):
-        kwargs['async'] = False
+        kwargs['_async'] = False
         self.condition = condition
         self.else_branch = []
         reqs = []