Apply black changes.

Author: vrvencislavov

setup.py

@@ -11,47 +11,48 @@ def get_version(package):
     """
     Return package version as listed in `__version__` in `init.py`.
     """
-    init_py = open(os.path.join(package, '__init__.py')).read()
+    init_py = open(os.path.join(package, "__init__.py")).read()
     return re.search("__version__ = ['\"]([^'\"]+)['\"]", init_py).group(1)
 
 
 def get_packages(package):
     """
     Return root package and all sub-packages.
     """
-    return [dirpath
-            for dirpath, dirnames, filenames in os.walk(package)
-            if os.path.exists(os.path.join(dirpath, '__init__.py'))]
+    return [
+        dirpath
+        for dirpath, dirnames, filenames in os.walk(package)
+        if os.path.exists(os.path.join(dirpath, "__init__.py"))
+    ]
 
 
 def get_package_data(package):
     """
     Return all files under the root package, that are not in a
     package themselves.
     """
-    walk = [(dirpath.replace(package + os.sep, '', 1), filenames)
-            for dirpath, dirnames, filenames in os.walk(package)
-            if not os.path.exists(os.path.join(dirpath, '__init__.py'))]
+    walk = [
+        (dirpath.replace(package + os.sep, "", 1), filenames)
+        for dirpath, dirnames, filenames in os.walk(package)
+        if not os.path.exists(os.path.join(dirpath, "__init__.py"))
+    ]
 
     filepaths = []
     for base, filenames in walk:
-        filepaths.extend([os.path.join(base, filename)
-                          for filename in filenames])
+        filepaths.extend([os.path.join(base, filename) for filename in filenames])
     return {package: filepaths}
 
 
-version = get_version('taskflow')
+version = get_version("taskflow")
 
 
 setup(
-    name='taskflow',
+    name="taskflow",
     version=version,
-    url='https://git@github.com/Vectorworks/taskflow.git',
-    description='A simple workflow library.',
-    packages=get_packages('taskflow'),
-    package_data=get_package_data('taskflow'),
-    install_requires=[
-    ],
-    dependency_links=[
-    ]
+    url="https://git@github.com/Vectorworks/taskflow.git",
+    description="A simple workflow library.",
+    packages=get_packages("taskflow"),
+    package_data=get_package_data("taskflow"),
+    install_requires=[],
+    dependency_links=[],
 )

taskflow/__init__.py

@@ -1,5 +1,5 @@
-__title__ = 'Taskflow'
-__version__ = '0.2.0'
+__title__ = "Taskflow"
+__version__ = "0.2.0"
 
 from .flow import *  # noqa
 from .tasks import *  # noqa

taskflow/flow.py

@@ -8,7 +8,7 @@
 class Flow(object):
     def __init__(self, task: BaseTask, uid=None, friendly_name=None):
         self.uid = uid or uuid4()
-        self.friendly_name = friendly_name or ''
+        self.friendly_name = friendly_name or ""
         self.root_task = BaseTask.find_root(task)
 
         # when deserializing, tasks will already have ids, that we want to preserve
@@ -92,13 +92,14 @@ def from_list(cls, task_list: list, uid=None, friendly_name=None):
 
         while remaining_tasks:
             for task_data in remaining_tasks:
-                task_depends_on = ([task_data['prev']] if task_data['prev'] else []) + \
-                                  (task_data.get('sub_tasks') or [])
+                task_depends_on = ([task_data["prev"]] if task_data["prev"] else []) + (
+                    task_data.get("sub_tasks") or []
+                )
 
                 if all(depends_on in created for depends_on in task_depends_on):
-                    task_type = type_from_string(task_data['class'])
-                    task_data['sub_tasks'] = [created[task_id] for task_id in (task_data.get('sub_tasks') or [])]
-                    task_data['prev'] = created[task_data['prev']] if task_data['prev'] else None
+                    task_type = type_from_string(task_data["class"])
+                    task_data["sub_tasks"] = [created[task_id] for task_id in (task_data.get("sub_tasks") or [])]
+                    task_data["prev"] = created[task_data["prev"]] if task_data["prev"] else None
 
                     last_created = task_type.from_data(task_data)
 

taskflow/tasks.py

@@ -5,10 +5,10 @@
 
 
 class BaseTask(object):
-    STATUS_PENDING = 'pending'
-    STATUS_RUNNING = 'running'
-    STATUS_HALTED = 'halted'
-    STATUS_COMPLETE = 'complete'
+    STATUS_PENDING = "pending"
+    STATUS_RUNNING = "running"
+    STATUS_HALTED = "halted"
+    STATUS_COMPLETE = "complete"
 
     is_standalone = True
 
@@ -131,7 +131,8 @@ def find_root(cls, task):
     def then(self, task):
         if self._next:
             raise RuntimeError(
-                'Unsupported operation. Multiple then operations are not support. Use a CompositeTask instead.')
+                "Unsupported operation. Multiple then operations are not support. Use a CompositeTask instead."
+            )
 
         task = task.local_root
         self._next = task
@@ -140,23 +141,25 @@ def then(self, task):
 
     def _get_task_data(self):
         return {
-            'class': type_to_string(type(self)),
-            'max_runs': self.max_runs,
-            'id': self._id,
-            'name': self._name,
-            'needs_prev_result': self._needs_prev_result,
-            'runs': self._runs,
-            'status': self._status,
-            'result': self._result,
-            'is_standalone': self.is_standalone
+            "class": type_to_string(type(self)),
+            "max_runs": self.max_runs,
+            "id": self._id,
+            "name": self._name,
+            "needs_prev_result": self._needs_prev_result,
+            "runs": self._runs,
+            "status": self._status,
+            "result": self._result,
+            "is_standalone": self.is_standalone,
         }
 
     def to_list(self):
         result = [self._get_task_data()]
-        result[0].update({
-            'prev': self._prev.id if self._prev else None,
-            'next': self._next.id if self._next else None,
-        })
+        result[0].update(
+            {
+                "prev": self._prev.id if self._prev else None,
+                "next": self._next.id if self._next else None,
+            }
+        )
 
         if self._next:
             result.extend(self._next.to_list())
@@ -167,16 +170,16 @@ def to_list(self):
     def from_data(cls, task_data):
         result = cls()
 
-        result.max_runs = task_data['max_runs']
-        result._runs = task_data['runs']
-        result._status = task_data['status']
-        result._result = task_data['result']
-        result._id = task_data['id']
-        result._name = task_data['name']
-        result._needs_prev_result = task_data['needs_prev_result']
+        result.max_runs = task_data["max_runs"]
+        result._runs = task_data["runs"]
+        result._status = task_data["status"]
+        result._result = task_data["result"]
+        result._id = task_data["id"]
+        result._name = task_data["name"]
+        result._needs_prev_result = task_data["needs_prev_result"]
 
-        if task_data['prev']:
-            task_data['prev'].then(result)
+        if task_data["prev"]:
+            task_data["prev"].then(result)
 
         return result
 
@@ -216,22 +219,19 @@ def run(self, **kwargs):
             self._exc_info = sys.exc_info()
 
     def __str__(self):
-        return self._name if self._name else f'{function_to_string(self._func)}:{self._args}'
+        return self._name if self._name else f"{function_to_string(self._func)}:{self._args}"
 
     def _get_task_data(self):
         result = super()._get_task_data()
-        result.update({
-            'func': function_to_string(self._func),
-            'args': self._args
-        })
+        result.update({"func": function_to_string(self._func), "args": self._args})
 
         return result
 
     @classmethod
     def from_data(cls, task_data):
         result = super().from_data(task_data)
-        result._func = function_from_string(task_data['func'])
-        result._args = task_data['args']
+        result._func = function_from_string(task_data["func"])
+        result._args = task_data["args"]
         return result
 
     @classmethod
@@ -282,24 +282,22 @@ def get_all_tasks(self):
         return self._sub_tasks[:]
 
     def run(self, **kwargs):
-        raise RuntimeError('Composite tasks cannot be run directly')
+        raise RuntimeError("Composite tasks cannot be run directly")
 
     def to_list(self):
         result = []
         for sub_task in self._sub_tasks:
             result += sub_task.to_list()
 
         base_list = super().to_list()
-        base_list[0].update({
-            'sub_tasks': [sub_task.id for sub_task in self._sub_tasks]
-        })
+        base_list[0].update({"sub_tasks": [sub_task.id for sub_task in self._sub_tasks]})
 
         return result + base_list
 
     @classmethod
     def from_data(cls, task_data):
         result = super().from_data(task_data)
-        result._sub_tasks = [sub_task.local_root for sub_task in task_data['sub_tasks'] or []]
+        result._sub_tasks = [sub_task.local_root for sub_task in task_data["sub_tasks"] or []]
         for sub_task in result._sub_tasks:
             sub_task._parent = result
 

taskflow/test/test_flow.py

@@ -9,16 +9,16 @@
 
 class TestFlow(object):
     def test_init(self, mocker):
-        mocker.patch('taskflow.tasks.BaseTask.set_ids')
+        mocker.patch("taskflow.tasks.BaseTask.set_ids")
 
         uid = uuid4()
         root = BaseTask()
 
-        flow = Flow(root.then(BaseTask()), uid=uid, friendly_name='test-flow')
+        flow = Flow(root.then(BaseTask()), uid=uid, friendly_name="test-flow")
 
         assert flow.root_task == root
         assert flow.uid == uid
-        assert flow.friendly_name == 'test-flow'
+        assert flow.friendly_name == "test-flow"
         root.set_ids.assert_called_once_with()
 
     def test_is_halted(self):
@@ -87,7 +87,7 @@ def before_task_run(self, task):
             return False
 
         flow = Flow(root.then(leaf))
-        mocker.patch('taskflow.flow.Flow._before_task_run', before_task_run)
+        mocker.patch("taskflow.flow.Flow._before_task_run", before_task_run)
 
         result = flow.step()
         assert not flow.is_complete
@@ -139,34 +139,24 @@ def test_get_next(self):
 
     def test_to_list(self):
         task1 = Task(Handlers.repeat, args=(1,))
-        flow = Flow(task1.then(
-            Task(Handlers.repeat)
-        ).then(
-            CompositeTask(
-                Task(Handlers.repeat),
-                Task(Handlers.repeat)
-            )
-        ).then(
-            Task(Handlers.repeat)
-        ))
+        flow = Flow(
+            task1.then(Task(Handlers.repeat))
+            .then(CompositeTask(Task(Handlers.repeat), Task(Handlers.repeat)))
+            .then(Task(Handlers.repeat))
+        )
 
         assert task1.to_list() == flow.to_list()
 
     def test_from_list(self):
         task1 = Task(Handlers.repeat, args=(1,))
-        flow1 = Flow(task1.then(
-            Task(Handlers.repeat)
-        ).then(
-            CompositeTask(
-                Task(Handlers.repeat),
-                Task(Handlers.repeat)
-            )
-        ).then(
-            Task(Handlers.repeat)
-        ))
+        flow1 = Flow(
+            task1.then(Task(Handlers.repeat))
+            .then(CompositeTask(Task(Handlers.repeat), Task(Handlers.repeat)))
+            .then(Task(Handlers.repeat))
+        )
 
         data_list = flow1.to_list()
         shuffle(data_list)
-        flow2 = Flow.from_list(data_list, uid=uuid4(), friendly_name='Copy')
+        flow2 = Flow.from_list(data_list, uid=uuid4(), friendly_name="Copy")
 
         assert flow2.to_list() == flow1.to_list()