--- a/libervia/server/tasks.py	Tue Aug 13 09:39:33 2019 +0200
+++ b/libervia/server/tasks.py	Tue Aug 13 19:12:31 2019 +0200
@@ -32,7 +32,7 @@
 
 class TasksManager(object):
     """Handle tasks of a Libervia site"""
-    FILE_EXTS = {u'py'}
+    FILE_EXTS = {'py'}
 
     def __init__(self, host, site_resource):
         """
@@ -67,41 +67,41 @@
 
     @property
     def task_data(self):
-        return self.tasks[self._current_task][u'data']
+        return self.tasks[self._current_task]['data']
 
     def validateData(self, data):
         """Check values in data"""
 
-        for var, default, allowed in ((u"ON_ERROR", u"stop", (u"continue", u"stop")),
-                                      (u"LOG_OUTPUT", True, bool),
-                                      (u"WATCH_DIRS", [], list)):
+        for var, default, allowed in (("ON_ERROR", "stop", ("continue", "stop")),
+                                      ("LOG_OUTPUT", True, bool),
+                                      ("WATCH_DIRS", [], list)):
             value = data.setdefault(var, default)
             if isinstance(allowed, type):
                 if not isinstance(value, allowed):
                     raise ValueError(
-                        _(u"Unexpected value for {var}, {allowed} is expected.")
+                        _("Unexpected value for {var}, {allowed} is expected.")
                         .format(var = var, allowed = allowed))
             else:
                 if not value in allowed:
-                    raise ValueError(_(u"Unexpected value for {var}: {value}").format(
+                    raise ValueError(_("Unexpected value for {var}: {value}").format(
                         var = var, value = value))
 
-        for var, default, allowed in [[u"ON_ERROR", u"stop", (u"continue", u"stop")]]:
+        for var, default, allowed in [["ON_ERROR", "stop", ("continue", "stop")]]:
             value = data.setdefault(var, default)
             if not value in allowed:
-                raise ValueError(_(u"Unexpected value for {var}: {value}").format(
+                raise ValueError(_("Unexpected value for {var}: {value}").format(
                     var = var, value = value))
 
     def parseTasks(self):
         if not os.path.isdir(self.tasks_dir):
-            log.debug(_(u"{name} has no task to launch.").format(
-                name = self.resource.site_name or u"default site"))
+            log.debug(_("{name} has no task to launch.").format(
+                name = self.resource.site_name or "default site"))
             return
         filenames = os.listdir(self.tasks_dir)
         filenames.sort()
         for filename in filenames:
             filepath = os.path.join(self.tasks_dir, filename)
-            if not filename.startswith(u'task_') or not os.path.isfile(filepath):
+            if not filename.startswith('task_') or not os.path.isfile(filepath):
                 continue
             task_name, ext = os.path.splitext(filename)
             task_name = task_name[5:].lower().strip()
@@ -111,15 +111,15 @@
                 continue
             if task_name in self.tasks:
                 raise exceptions.ConflictError(
-                    u"A task with the name [{name}] already exists".format(
+                    "A task with the name [{name}] already exists".format(
                         name=task_name))
-            task_data = {u"__name__": "{site_name}.task.{name}".format(
+            task_data = {"__name__": "{site_name}.task.{name}".format(
                 site_name=self.site_name, name=task_name)}
             self.tasks[task_name] = {
-                u'path': filepath,
-                u'data': task_data,
+                'path': filepath,
+                'data': task_data,
             }
-            execfile(filepath, task_data)
+            exec(compile(open(filepath, "rb").read(), filepath, 'exec'), task_data)
             # we launch prepare, which is a method used to prepare
             # data at runtime (e.g. set WATCH_DIRS using config)
             try:
@@ -150,28 +150,28 @@
         """
         task_value = self.tasks[task_name]
         self._current_task = task_name
-        log.info(_(u'== running task "{task_name}" for {site_name} =='.format(
+        log.info(_('== running task "{task_name}" for {site_name} =='.format(
             task_name=task_name, site_name=self.site_name)))
-        data = task_value[u'data']
+        data = task_value['data']
         os.chdir(self.site_path)
         try:
             yield data['start'](self)
         except Exception as e:
-            on_error = data[u'ON_ERROR']
-            if on_error == u'stop':
+            on_error = data['ON_ERROR']
+            if on_error == 'stop':
                 raise e
-            elif on_error == u'continue':
-                log.warning(_(u'Task "{task_name}" failed for {site_name}: {reason}')
+            elif on_error == 'continue':
+                log.warning(_('Task "{task_name}" failed for {site_name}: {reason}')
                     .format(task_name=task_name, site_name=self.site_name, reason=e))
             else:
-                raise exceptions.InternalError(u"we should never reach this point")
+                raise exceptions.InternalError("we should never reach this point")
         self._current_task = None
 
     @defer.inlineCallbacks
     def runTasks(self):
         """Run all the tasks found"""
         old_path = os.getcwd()
-        for task_name, task_value in self.tasks.iteritems():
+        for task_name, task_value in self.tasks.items():
             yield self.runTask(task_name)
         os.chdir(old_path)
 
@@ -186,14 +186,14 @@
         names = (name,) + args
         for n in names:
             try:
-                cmd_path = which(n)[0].encode('utf-8')
+                cmd_path = which(n)[0]
             except IndexError:
                 pass
             else:
                 return cmd_path
         raise exceptions.NotFound(_(
-            u"Can't find {name} command, did you install it?").format(name=name))
+            "Can't find {name} command, did you install it?").format(name=name))
 
     def runCommand(self, command, *args, **kwargs):
-        kwargs['verbose'] = self.task_data[u"LOG_OUTPUT"]
+        kwargs['verbose'] = self.task_data["LOG_OUTPUT"]
         return async_process.CommandProtocol.run(command, *args, **kwargs)