Reformat code using Black

As discussed over the mailing list, reformat code using Black. This is a
one-off change to reformat all our codebase. Moving forward, we
shouldn't expect such blanket reformats. Rather, we expect each change
to already comply with the Black formatting style.

1 files changed, 33 insertions, 39 deletions

diff --git a/src/buildstream/scriptelement.py b/src/buildstream/scriptelement.py
index e78049b4a..f8deff28e 100644
--- a/src/buildstream/scriptelement.py
+++ b/src/buildstream/scriptelement.py
@@ -48,8 +48,8 @@ class ScriptElement(Element):
     __install_root = "/"
     __cwd = "/"
     __root_read_only = False
-    __commands = None   # type: OrderedDict[str, List[str]]
-    __layout = []   # type: List[Dict[str, Optional[str]]]
+    __commands = None  # type: OrderedDict[str, List[str]]
+    __layout = []  # type: List[Dict[str, Optional[str]]]
 
     # The compose element's output is its dependencies, so
     # we must rebuild if the dependencies change even when
@@ -149,8 +149,7 @@ class ScriptElement(Element):
         #
         if not self.__layout:
             self.__layout = []
-        self.__layout.append({"element": element,
-                              "destination": destination})
+        self.__layout.append({"element": element, "destination": destination})
 
     def add_commands(self, group_name: str, command_list: List[str]) -> None:
         """Adds a list of commands under the group-name.
@@ -183,11 +182,11 @@ class ScriptElement(Element):
 
     def get_unique_key(self):
         return {
-            'commands': self.__commands,
-            'cwd': self.__cwd,
-            'install-root': self.__install_root,
-            'layout': self.__layout,
-            'root-read-only': self.__root_read_only
+            "commands": self.__commands,
+            "cwd": self.__cwd,
+            "install-root": self.__install_root,
+            "layout": self.__layout,
+            "root-read-only": self.__root_read_only,
         }
 
     def configure_sandbox(self, sandbox):
@@ -206,14 +205,14 @@ class ScriptElement(Element):
 
         # Mark the artifact directories in the layout
         for item in self.__layout:
-            destination = item['destination']
+            destination = item["destination"]
             was_artifact = directories.get(destination, False)
-            directories[destination] = item['element'] or was_artifact
+            directories[destination] = item["element"] or was_artifact
 
         for directory, artifact in directories.items():
             # Root does not need to be marked as it is always mounted
             # with artifact (unless explicitly marked non-artifact)
-            if directory != '/':
+            if directory != "/":
                 sandbox.mark_directory(directory, artifact=artifact)
 
     def stage(self, sandbox):
@@ -222,8 +221,7 @@ class ScriptElement(Element):
         if not self.__layout:
             # if no layout set, stage all dependencies into /
             for build_dep in self.dependencies(Scope.BUILD, recurse=False):
-                with self.timed_activity("Staging {} at /"
-                                         .format(build_dep.name), silent_nested=True):
+                with self.timed_activity("Staging {} at /".format(build_dep.name), silent_nested=True):
                     build_dep.stage_dependency_artifacts(sandbox, Scope.RUN, path="/")
 
             with sandbox.batch(SandboxFlags.NONE):
@@ -236,35 +234,33 @@ class ScriptElement(Element):
             for item in self.__layout:
 
                 # Skip layout members which dont stage an element
-                if not item['element']:
+                if not item["element"]:
                     continue
 
-                element = self.search(Scope.BUILD, item['element'])
-                if item['destination'] == '/':
-                    with self.timed_activity("Staging {} at /".format(element.name),
-                                             silent_nested=True):
+                element = self.search(Scope.BUILD, item["element"])
+                if item["destination"] == "/":
+                    with self.timed_activity("Staging {} at /".format(element.name), silent_nested=True):
                         element.stage_dependency_artifacts(sandbox, Scope.RUN)
                 else:
-                    with self.timed_activity("Staging {} at {}"
-                                             .format(element.name, item['destination']),
-                                             silent_nested=True):
+                    with self.timed_activity(
+                        "Staging {} at {}".format(element.name, item["destination"]), silent_nested=True
+                    ):
                         virtual_dstdir = sandbox.get_virtual_directory()
-                        virtual_dstdir.descend(*item['destination'].lstrip(os.sep).split(os.sep), create=True)
-                        element.stage_dependency_artifacts(sandbox, Scope.RUN, path=item['destination'])
+                        virtual_dstdir.descend(*item["destination"].lstrip(os.sep).split(os.sep), create=True)
+                        element.stage_dependency_artifacts(sandbox, Scope.RUN, path=item["destination"])
 
             with sandbox.batch(SandboxFlags.NONE):
                 for item in self.__layout:
 
                     # Skip layout members which dont stage an element
-                    if not item['element']:
+                    if not item["element"]:
                         continue
 
-                    element = self.search(Scope.BUILD, item['element'])
+                    element = self.search(Scope.BUILD, item["element"])
 
                     # Integration commands can only be run for elements staged to /
-                    if item['destination'] == '/':
-                        with self.timed_activity("Integrating {}".format(element.name),
-                                                 silent_nested=True):
+                    if item["destination"] == "/":
+                        with self.timed_activity("Integrating {}".format(element.name), silent_nested=True):
                             for dep in element.dependencies(Scope.RUN):
                                 dep.integrate(sandbox)
 
@@ -283,9 +279,7 @@ class ScriptElement(Element):
                     for cmd in commands:
                         # Note the -e switch to 'sh' means to exit with an error
                         # if any untested command fails.
-                        sandbox.run(['sh', '-c', '-e', cmd + '\n'],
-                                    flags,
-                                    label=cmd)
+                        sandbox.run(["sh", "-c", "-e", cmd + "\n"], flags, label=cmd)
 
         # Return where the result can be collected from
         return self.__install_root
@@ -297,18 +291,18 @@ class ScriptElement(Element):
     def __validate_layout(self):
         if self.__layout:
             # Cannot proceeed if layout is used, but none are for "/"
-            root_defined = any([(entry['destination'] == '/') for entry in self.__layout])
+            root_defined = any([(entry["destination"] == "/") for entry in self.__layout])
             if not root_defined:
-                raise ElementError("{}: Using layout, but none are staged as '/'"
-                                   .format(self))
+                raise ElementError("{}: Using layout, but none are staged as '/'".format(self))
 
             # Cannot proceed if layout specifies an element that isn't part
             # of the dependencies.
             for item in self.__layout:
-                if item['element']:
-                    if not self.search(Scope.BUILD, item['element']):
-                        raise ElementError("{}: '{}' in layout not found in dependencies"
-                                           .format(self, item['element']))
+                if item["element"]:
+                    if not self.search(Scope.BUILD, item["element"]):
+                        raise ElementError(
+                            "{}: '{}' in layout not found in dependencies".format(self, item["element"])
+                        )
 
 
 def setup():