Switch to black

Author: Viktor Dick

perfact/__init__.py

@@ -1,2 +1,3 @@
 from pkgutil import extend_path
+
 __path__ = extend_path(__path__, __name__)

perfact/zodbsync/__init__.py

@@ -3,9 +3,9 @@
 from .helpers import obj_modtime, db_modtime
 
 __all__ = [
-    'mod_read',
-    'mod_write',
-    'obj_modtime',
-    'db_modtime',
-    'extedit_launch',
+    "mod_read",
+    "mod_write",
+    "obj_modtime",
+    "db_modtime",
+    "extedit_launch",
 ]

perfact/zodbsync/commands/checkout.py

@@ -4,48 +4,54 @@
 
 
 class Checkout(SubCommand):
-    '''Switch to another branch'''
+    """Switch to another branch"""
+
     @staticmethod
     def add_args(parser):
         parser.add_argument(
-            '--skip-errors', action='store_true', default=False,
-            help='Skip failed objects and continue',
-        )
-        parser.add_argument(
-            '--dry-run', action='store_true', default=False,
-            help='Only check for conflicts and roll back at the end.',
+            "--skip-errors",
+            action="store_true",
+            default=False,
+            help="Skip failed objects and continue",
         )
         parser.add_argument(
-            '-b', action='store_true', default=False,
-            help='Create branch.',
+            "--dry-run",
+            action="store_true",
+            default=False,
+            help="Only check for conflicts and roll back at the end.",
         )
         parser.add_argument(
-            '-t', '--track', type=str, help='Set up upstream configuration.'
+            "-b",
+            action="store_true",
+            default=False,
+            help="Create branch.",
         )
         parser.add_argument(
-            '--reset', type=str,
-            help='Reset branch onto given commit.',
+            "-t", "--track", type=str, help="Set up upstream configuration."
         )
         parser.add_argument(
-            '--rebase', type=str,
-            help='Rebase branch onto given commit.',
+            "--reset",
+            type=str,
+            help="Reset branch onto given commit.",
         )
         parser.add_argument(
-            'branch', type=str,
-            help='''Branch name'''
+            "--rebase",
+            type=str,
+            help="Rebase branch onto given commit.",
         )
+        parser.add_argument("branch", type=str, help="""Branch name""")
 
     @SubCommand.gitexec
     def run(self):
-        self.logger.info('Checking out %s.' % self.args.branch)
-        cmd = ['checkout']
+        self.logger.info("Checking out %s." % self.args.branch)
+        cmd = ["checkout"]
         if self.args.b:
-            cmd.append('-b')
+            cmd.append("-b")
         cmd.append(self.args.branch)
         if self.args.b and self.args.track:
-            cmd.extend(['--track', self.args.track])
+            cmd.extend(["--track", self.args.track])
         self.gitcmd_run(*cmd)
         if self.args.reset:
-            self.gitcmd_run('reset', '--hard', self.args.reset)
+            self.gitcmd_run("reset", "--hard", self.args.reset)
         if self.args.rebase:
-            self.gitcmd_run('rebase', self.args.rebase)
+            self.gitcmd_run("rebase", self.args.rebase)

perfact/zodbsync/commands/execute.py

@@ -6,25 +6,30 @@
 
 
 class Exec(SubCommand):
-    '''Execute a command and play back any paths changed between old and new
-    HEAD'''
+    """Execute a command and play back any paths changed between old and new
+    HEAD"""
+
     @staticmethod
     def add_args(parser):
         parser.add_argument(
-            '--skip-errors', action='store_true', default=False,
-            help='Skip failed objects and continue',
-        )
-        parser.add_argument(
-            '--dry-run', action='store_true', default=False,
-            help='Only check for conflicts and roll back at the end.',
+            "--skip-errors",
+            action="store_true",
+            default=False,
+            help="Skip failed objects and continue",
         )
         parser.add_argument(
-            '--nocd', action='store_true', default=False,
-            help='Do not cd to git repo for command',
+            "--dry-run",
+            action="store_true",
+            default=False,
+            help="Only check for conflicts and roll back at the end.",
         )
         parser.add_argument(
-            'cmd', type=str, help='''command to be executed'''
+            "--nocd",
+            action="store_true",
+            default=False,
+            help="Do not cd to git repo for command",
         )
+        parser.add_argument("cmd", type=str, help="""command to be executed""")
 
     @SubCommand.gitexec
     def run(self):

perfact/zodbsync/commands/fastforward.py

@@ -4,26 +4,28 @@
 
 
 class FF(SubCommand):
-    '''
+    """
     Perform a fast-forward merge to the target commit and apply changed paths
-    '''
+    """
+
     @staticmethod
     def add_args(parser):
         parser.add_argument(
-            '--skip-errors', action='store_true', default=False,
-            help='Skip failed objects and continue',
-        )
-        parser.add_argument(
-            '--dry-run', action='store_true', default=False,
-            help='Only check for conflicts and roll back at the end.',
+            "--skip-errors",
+            action="store_true",
+            default=False,
+            help="Skip failed objects and continue",
         )
         parser.add_argument(
-            'commit', type=str,
-            help='''Target commit'''
+            "--dry-run",
+            action="store_true",
+            default=False,
+            help="Only check for conflicts and roll back at the end.",
         )
+        parser.add_argument("commit", type=str, help="""Target commit""")
 
     @SubCommand.gitexec
     def run(self):
         target = self.args.commit
-        self.logger.info('Attempting fast-forward merge to %s.' % target)
-        self.gitcmd_run('merge', '--ff-only', target)
+        self.logger.info("Attempting fast-forward merge to %s." % target)
+        self.gitcmd_run("merge", "--ff-only", target)

perfact/zodbsync/commands/freeze.py

@@ -5,19 +5,22 @@
 
 
 class Freeze(SubCommand):
-    '''Mark paths as frozen and record them'''
+    """Mark paths as frozen and record them"""
+
     @staticmethod
     def add_args(parser):
         parser.add_argument(
-            'path', type=str, nargs='*',
-            help='Sub-Path in Data.fs to be frozen',
+            "path",
+            type=str,
+            nargs="*",
+            help="Sub-Path in Data.fs to be frozen",
         )
 
     @SubCommand.with_lock
     def run(self):
         for path in self.args.path:
             fullpath = self.sync.fs_path(path)
             os.makedirs(fullpath, exist_ok=True)
-            with open('{}/__frozen__'.format(fullpath), 'w'):
+            with open("{}/__frozen__".format(fullpath), "w"):
                 pass
         self.sync.record(paths=self.args.path, recurse=True)

perfact/zodbsync/commands/layer_init.py

@@ -8,29 +8,30 @@
 class LayerInit(SubCommand):
     """Register layers from source to work_dir, assuming objects are already in
     the Data.FS, but are now to be provided by a new layer."""
-    subcommand = 'layer-init'
+
+    subcommand = "layer-init"
 
     @staticmethod
     def add_args(parser):
         parser.add_argument(
-            'ident', type=str, nargs='*',
-            help='Layer identifier(s). May be * for all',
+            "ident",
+            type=str,
+            nargs="*",
+            help="Layer identifier(s). May be * for all",
         )
 
     @SubCommand.with_lock
     def run(self):
-        layers = {layer['ident']: layer
-                  for layer in self.sync.layers
-                  if layer['ident']}
+        layers = {layer["ident"]: layer for layer in self.sync.layers if layer["ident"]}
         idents = self.args.ident
-        if idents == ['*']:
+        if idents == ["*"]:
             idents = layers.keys()
         for ident in idents:
             assert ident in layers, "Invalid ident"
         for ident in idents:
             layer = layers[ident]
-            source = layer['source']
-            target = layer['workdir']
+            source = layer["source"]
+            target = layer["workdir"]
             self.unpack_source(source, target)
-            sp.run(['git', 'add', '.'], cwd=target)
-            sp.run(['git', 'commit', '-m', 'zodbsync layer-init'], cwd=target)
+            sp.run(["git", "add", "."], cwd=target)
+            sp.run(["git", "commit", "-m", "zodbsync layer-init"], cwd=target)

perfact/zodbsync/commands/layer_update.py

@@ -8,91 +8,94 @@
 
 class LayerUpdate(SubCommand):
     """Update layers."""
-    subcommand = 'layer-update'
+
+    subcommand = "layer-update"
 
     @staticmethod
     def add_args(parser):
         parser.add_argument(
-            '--dry-run', action='store_true', default=False,
-            help='Only check for conflicts and roll back at the end.',
+            "--dry-run",
+            action="store_true",
+            default=False,
+            help="Only check for conflicts and roll back at the end.",
         )
         parser.add_argument(
-            '--skip-errors', action='store_true',
+            "--skip-errors",
+            action="store_true",
             help="Skip failed objects and continue",
-            default=False
+            default=False,
         )
         parser.add_argument(
-            '--message', '-m', type=str, default='zodbsync layer-update',
+            "--message",
+            "-m",
+            type=str,
+            default="zodbsync layer-update",
             help="Commit message base",
         )
         parser.add_argument(
-            'ident', type=str, nargs='*',
-            help='Layer identifier(s). May be * for all',
+            "ident",
+            type=str,
+            nargs="*",
+            help="Layer identifier(s). May be * for all",
         )
 
     def commit_all(self, target, msg):
         """Commit all unstaged changes in target, returning the commit ID or
         None if there is no change."""
-        sp.run(['git', 'add', '.'], cwd=target)
-        if sp.run(['git', 'commit', '-m', msg], cwd=target).returncode == 0:
-            return sp.check_output(['git', 'rev-parse', 'HEAD'],
-                                   cwd=target, text=True).strip()
+        sp.run(["git", "add", "."], cwd=target)
+        if sp.run(["git", "commit", "-m", msg], cwd=target).returncode == 0:
+            return sp.check_output(
+                ["git", "rev-parse", "HEAD"], cwd=target, text=True
+            ).strip()
 
     def run_layer(self, layer):
         """
         For given layer, commit any unstaged changes, update work_dir from
         source, commit that and play back any changes.
         """
-        source = layer['source']
-        target = layer['workdir']
+        source = layer["source"]
+        target = layer["workdir"]
         msg = self.args.message
-        precommit = self.commit_all(target, f'{msg} (pre)')
+        precommit = self.commit_all(target, f"{msg} (pre)")
         self.unpack_source(source, target)
         changes = [
-            line[3:] for line in sp.check_output(
-                ['git', 'status', '--porcelain', '-u', '--no-renames'],
+            line[3:]
+            for line in sp.check_output(
+                ["git", "status", "--porcelain", "-u", "--no-renames"],
                 cwd=target,
                 text=True,
-            ).split('\n')
+            ).split("\n")
             if line
         ]
         commit = None
         if changes:
             commit = self.commit_all(target, msg)
-        self.restore[layer['ident']] = (precommit, commit)
+        self.restore[layer["ident"]] = (precommit, commit)
         return {
-            os.path.dirname(line[len('__root__'):])
+            os.path.dirname(line[len("__root__") :])
             for line in changes
-            if line.startswith('__root__/')
+            if line.startswith("__root__/")
         }
 
     def restore_layer(self, layer):
         """
         Restore layer for dry-run or in case of failure
         """
-        (precommit, commit) = self.restore[layer['ident']]
-        target = layer['workdir']
+        precommit, commit = self.restore[layer["ident"]]
+        target = layer["workdir"]
         if commit:
-            sp.run(
-                ['git', 'reset', '--hard', f'{commit}~'],
-                cwd=target, check=True
-            )
+            sp.run(["git", "reset", "--hard", f"{commit}~"], cwd=target, check=True)
         if precommit:
-            sp.run(
-                ['git', '-reset', f'{precommit}~'],
-                cwd=target, check=True
-            )
+            sp.run(["git", "-reset", f"{precommit}~"], cwd=target, check=True)
 
     @SubCommand.with_lock
     def run(self):
         "Process given layers"
         self.restore = {}  # Info for restoring for dry-run
         paths = set()
-        layers = {layer['ident']: layer
-                  for layer in self.sync.layers
-                  if layer['ident']}
+        layers = {layer["ident"]: layer for layer in self.sync.layers if layer["ident"]}
         idents = self.args.ident
-        if idents == ['*']:
+        if idents == ["*"]:
             idents = layers.keys()
         for ident in idents:
             assert ident in layers, "Invalid ident"
@@ -122,10 +125,9 @@ def run(self):
             for ident in idents:
                 self.restore_layer(layers[ident])
         else:
-            self.sync.record(paths, recurse=False, skip_errors=True,
-                             ignore_removed=True)
+            self.sync.record(
+                paths, recurse=False, skip_errors=True, ignore_removed=True
+            )
             for path in paths:
-                if self.sync.fs_pathinfo(path)['layeridx'] == 0:
-                    self.logger.warning(
-                        'Conflict with object in custom layer: ' + path
-                    )
+                if self.sync.fs_pathinfo(path)["layeridx"] == 0:
+                    self.logger.warning("Conflict with object in custom layer: " + path)