cgitize 8.0.1__tar.gz → 8.0.2__tar.gz

cgitize-8.0.2/.git-blame-ignore-revs

@@ -0,0 +1 @@
+ebbab9207fc3ec5dcf2df9011d945a8de2617983

{cgitize-8.0.1 → cgitize-8.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgitize
-Version: 8.0.1
+Version: 8.0.2
 Summary: Self-host your repositories using cgit
 Author-email: Egor Tensin <egor@tensin.name>
 License-Expression: MIT

{cgitize-8.0.1 → cgitize-8.0.2}/cgitize/bitbucket.py

@@ -17,10 +17,10 @@ class Bitbucket:
 
     def get_repo(self, repo):
         try:
-            parts = repo.id.split('/')
+            parts = repo.id.split("/")
             if len(parts) != 2:
                 raise ValueError(
-                    f'repository ID must be in the USER/NAME format: {repo.id}'
+                    f"repository ID must be in the USER/NAME format: {repo.id}"
                 )
             user, name = parts
             return self._impl.repositories.get(user, name)

{cgitize-8.0.1 → cgitize-8.0.2}/cgitize/cgit.py

@@ -27,20 +27,20 @@ class CGitRCWriter:
 
     @staticmethod
     def get_path(repo_dir):
-        return os.path.join(repo_dir, 'cgitrc')
+        return os.path.join(repo_dir, "cgitrc")
 
     def write(self, repo_dir, repo):
-        with open(self.get_path(repo_dir), 'w') as fd:
-            self._write_field(fd, 'clone-url', self._build_clone_url(repo))
-            self._write_field(fd, 'owner', repo.owner)
-            self._write_field(fd, 'desc', repo.desc)
-            self._write_field(fd, 'homepage', repo.homepage)
+        with open(self.get_path(repo_dir), "w") as fd:
+            self._write_field(fd, "clone-url", self._build_clone_url(repo))
+            self._write_field(fd, "owner", repo.owner)
+            self._write_field(fd, "desc", repo.desc)
+            self._write_field(fd, "homepage", repo.homepage)
 
     @staticmethod
     def _write_field(fd, field, value):
         if value is None:
             return
-        fd.write(f'{field}={value}\n')
+        fd.write(f"{field}={value}\n")
 
     def _build_clone_url(self, repo):
         clone_urls = []
@@ -51,7 +51,7 @@ class CGitRCWriter:
             clone_urls.append(repo.clone_url)
         if not clone_urls:
             return None
-        clone_urls = ' '.join(clone_urls)
+        clone_urls = " ".join(clone_urls)
         return clone_urls
 
 
@@ -61,8 +61,8 @@ class AgeFile:
         timestamp = AgeFile.get_age(repo_dir)
         if timestamp:
             os.makedirs(AgeFile.get_dir(repo_dir), exist_ok=True)
-            with open(AgeFile.get_path(repo_dir), mode='w') as fd:
-                fd.write(f'{timestamp}')
+            with open(AgeFile.get_path(repo_dir), mode="w") as fd:
+                fd.write(f"{timestamp}")
 
     @staticmethod
     def get_age(repo_dir):
@@ -71,10 +71,10 @@ class AgeFile:
         # represents activity.
         with chdir(repo_dir):
             success, output = Git.capture(
-                'for-each-ref',
-                '--sort=-committerdate',
-                '--count=1',
-                '--format=%(committerdate:iso8601)',
+                "for-each-ref",
+                "--sort=-committerdate",
+                "--count=1",
+                "--format=%(committerdate:iso8601)",
             )
             if not success:
                 logging.error(
@@ -86,11 +86,11 @@ class AgeFile:
 
     @staticmethod
     def get_dir(repo_dir):
-        return os.path.join(repo_dir, 'info', 'web')
+        return os.path.join(repo_dir, "info", "web")
 
     @staticmethod
     def get_path(repo_dir):
-        return os.path.join(AgeFile.get_dir(repo_dir), 'last-modified')
+        return os.path.join(AgeFile.get_dir(repo_dir), "last-modified")
 
 
 class CGitRepositories:
@@ -123,16 +123,16 @@ class CGitRepositories:
             return self._mirror(repo)
 
         with chdir(repo_dir):
-            success, output = Git.capture('rev-parse', '--is-inside-work-tree')
+            success, output = Git.capture("rev-parse", "--is-inside-work-tree")
             if not success:
                 # Overwrite the existing directory if it's not a Git repository.
                 logging.warning(
-                    'Local directory is not a repository, going to overwrite it: %s',
+                    "Local directory is not a repository, going to overwrite it: %s",
                     repo_dir,
                 )
                 return self._mirror(repo)
 
-            success, output = Git.capture('config', '--get', 'remote.origin.url')
+            success, output = Git.capture("config", "--get", "remote.origin.url")
             if not success:
                 # Every repository managed by this script should have the
                 # 'origin' remote. If it doesn't, it's trash. Overwrite the
@@ -143,7 +143,7 @@ class CGitRepositories:
                 )
                 return self._mirror(repo)
 
-            if f'{repo.clone_url}\n' != output:
+            if f"{repo.clone_url}" != output:
                 # Jeez, there's a proper local repository in the target
                 # directory already with a different upstream; something's
                 # wrong, fix it manually.
@@ -172,16 +172,16 @@ class CGitRepositories:
                 logging.exception(e)
                 return False
         with Git.setup_auth(repo):
-            return Git.check('clone', '--mirror', '--quiet', repo.clone_url, repo_dir)
+            return Git.check("clone", "--mirror", "--quiet", repo.clone_url, repo_dir)
 
     def _fix_upstream_url(self, repo):
         repo_dir = self.get_repo_dir(repo)
         with chdir(repo_dir):
-            return Git.check('remote', 'set-url', 'origin', repo.clone_url)
+            return Git.check("remote", "set-url", "origin", repo.clone_url)
 
     def _update_existing(self, repo):
         logging.info("Updating repository '%s'", repo.name)
         repo_dir = self.get_repo_dir(repo)
         with chdir(repo_dir):
             with Git.setup_auth(repo):
-                return Git.check('remote', 'update', '--prune')
+                return Git.check("remote", "update", "--prune")

{cgitize-8.0.1 → cgitize-8.0.2}/cgitize/config.py

@@ -22,7 +22,7 @@ class Section:
     def _get_config_value(self, key, required=True, default=None):
         if required and default is None:
             if not key in self.impl:
-                raise RuntimeError(f'configuration value is missing: {key}')
+                raise RuntimeError(f"configuration value is missing: {key}")
         return self.impl.get(key, default)
 
     def _get_config_path(self, *args, **kwargs):
@@ -38,36 +38,36 @@ class Section:
 
 
 class MainSection(Section):
-    DEFAULT_OUTPUT_DIR = '/mnt/cgitize'
+    DEFAULT_OUTPUT_DIR = "/mnt/cgitize"
 
     @property
     def output_dir(self):
         return self._get_config_path(
-            'output_dir', default=MainSection.DEFAULT_OUTPUT_DIR
+            "output_dir", default=MainSection.DEFAULT_OUTPUT_DIR
         )
 
     @property
     def error_header_path(self):
-        return os.path.join(self.output_dir, 'error.html')
+        return os.path.join(self.output_dir, "error.html")
 
     @property
     def clone_url(self):
-        return self._get_config_value('clone_url', required=False)
+        return self._get_config_value("clone_url", required=False)
 
     @property
     def clone_via_ssh(self):
-        return self._get_config_value('clone_via_ssh', default=True)
+        return self._get_config_value("clone_via_ssh", default=True)
 
     @property
     def default_owner(self):
-        return self._get_config_value('owner', required=False)
+        return self._get_config_value("owner", required=False)
 
 
 class ServiceSection(Section, ABC):
     def __init__(self, impl):
         super().__init__(impl)
-        self.repositories = RepositoriesSection(self.impl.get('repositories', {}))
-        self.users = UsersSection(self.impl.get('users', {}))
+        self.repositories = RepositoriesSection(self.impl.get("repositories", {}))
+        self.users = UsersSection(self.impl.get("users", {}))
 
     def _enum_explicit_repositories(self, cfg, api):
         for r in self.repositories.enum_repositories():
@@ -99,15 +99,15 @@ class ServiceSection(Section, ABC):
 class GitHubSection(ServiceSection):
     def __init__(self, impl):
         super().__init__(impl)
-        self.orgs = OrgsSection(self.impl.get('organizations', {}))
+        self.orgs = OrgsSection(self.impl.get("organizations", {}))
 
     @property
     def token(self):
-        return self._get_config_or_env('token', 'CGITIZE_GITHUB_TOKEN')
+        return self._get_config_or_env("token", "CGITIZE_GITHUB_TOKEN")
 
     @property
     def username(self):
-        return self._get_config_or_env('username', 'CGITIZE_GITHUB_USERNAME')
+        return self._get_config_or_env("username", "CGITIZE_GITHUB_USERNAME")
 
     @property
     def url_auth(self):
@@ -131,7 +131,7 @@ class GitHubSection(ServiceSection):
         token = self.token
         if (username is None) != (token is None):
             raise RuntimeError(
-                'please set either both the GitHub username & token, or neither'
+                "please set either both the GitHub username & token, or neither"
             )
         return GitHub(username, token)
 
@@ -139,11 +139,11 @@ class GitHubSection(ServiceSection):
 class BitbucketSection(ServiceSection):
     @property
     def token(self):
-        return self._get_config_or_env('token', 'CGITIZE_BITBUCKET_TOKEN')
+        return self._get_config_or_env("token", "CGITIZE_BITBUCKET_TOKEN")
 
     @property
     def username(self):
-        return self._get_config_or_env('email', 'CGITIZE_BITBUCKET_EMAIL')
+        return self._get_config_or_env("email", "CGITIZE_BITBUCKET_EMAIL")
 
     @property
     def url_auth(self):
@@ -154,7 +154,7 @@ class BitbucketSection(ServiceSection):
         token = self.token
         if (username is None) != (token is None):
             raise RuntimeError(
-                'please set either both the Bitbucket username & token, or neither'
+                "please set either both the Bitbucket username & token, or neither"
             )
         return Bitbucket(username, token)
 
@@ -162,11 +162,11 @@ class BitbucketSection(ServiceSection):
 class GitLabSection(ServiceSection):
     @property
     def token(self):
-        return self._get_config_or_env('token', 'CGITIZE_GITLAB_TOKEN')
+        return self._get_config_or_env("token", "CGITIZE_GITLAB_TOKEN")
 
     @property
     def username(self):
-        return self._get_config_or_env('username', 'CGITIZE_GITLAB_USERNAME')
+        return self._get_config_or_env("username", "CGITIZE_GITLAB_USERNAME")
 
     @property
     def url_auth(self):
@@ -177,7 +177,7 @@ class GitLabSection(ServiceSection):
         token = self.token
         if (username is None) != (token is None):
             raise RuntimeError(
-                'please set either both the GitLab username & token, or neither'
+                "please set either both the GitLab username & token, or neither"
             )
         return GitLab(token)
 
@@ -200,56 +200,56 @@ class RepositoriesSection(Section):
 class Entity(ABC):
     @property
     def name(self):
-        return self._impl['name']
+        return self._impl["name"]
 
     @property
     def dir(self):
-        return self._impl.get('dir')
+        return self._impl.get("dir")
 
     @property
     def skip(self):
-        return self._impl.get('skip', [])
+        return self._impl.get("skip", [])
 
 
 class User(Entity):
     def __init__(self, impl):
-        if 'name' not in impl:
+        if "name" not in impl:
             raise ValueError("every user must have a 'name'")
         self._impl = impl
 
     @property
     def public_repos(self):
-        return self._impl.get('public', True)
+        return self._impl.get("public", True)
 
     @property
     def private_repos(self):
-        return self._impl.get('private', False)
+        return self._impl.get("private", False)
 
 
 class Org(Entity):
     def __init__(self, impl):
-        if 'name' not in impl:
+        if "name" not in impl:
             raise ValueError("every organization must have a 'name'")
         self._impl = impl
 
 
 class HostedRepo:
     def __init__(self, impl):
-        if 'id' not in impl:
+        if "id" not in impl:
             raise ValueError("every hosted repository must have 'id'")
         self._impl = impl
 
     @property
     def id(self):
-        return self._impl['id']
+        return self._impl["id"]
 
     @property
     def dir(self):
-        return self._impl.get('dir')
+        return self._impl.get("dir")
 
 
 class Config:
-    DEFAULT_PATH = '/etc/cgitize/cgitize.toml'
+    DEFAULT_PATH = "/etc/cgitize/cgitize.toml"
 
     @staticmethod
     def read(path):
@@ -257,13 +257,13 @@ class Config:
 
     def __init__(self, path):
         self.path = os.path.abspath(path)
-        with open(self.path, 'rb') as f:
+        with open(self.path, "rb") as f:
             self.impl = tomli.load(f)
         self.main = MainSection(self.impl)
-        self.repositories = RepositoriesSection(self.impl.get('repositories', {}))
-        self.github = GitHubSection(self.impl.get('github', {}))
-        self.bitbucket = BitbucketSection(self.impl.get('bitbucket', {}))
-        self.gitlab = GitLabSection(self.impl.get('gitlab', {}))
+        self.repositories = RepositoriesSection(self.impl.get("repositories", {}))
+        self.github = GitHubSection(self.impl.get("github", {}))
+        self.bitbucket = BitbucketSection(self.impl.get("bitbucket", {}))
+        self.gitlab = GitLabSection(self.impl.get("gitlab", {}))
 
     def _parse_explicit_repositories(self):
         for r in self.repositories.enum_repositories():

{cgitize-8.0.1 → cgitize-8.0.2}/cgitize/git.py

@@ -9,8 +9,8 @@ import os
 from cgitize import utils
 
 GIT_ENV = os.environ.copy()
-GIT_ENV['GIT_SSH_COMMAND'] = (
-    'ssh -oBatchMode=yes -oLogLevel=QUIET -oStrictHostKeyChecking=no -oUserKnownHostsFile=/dev/null'
+GIT_ENV["GIT_SSH_COMMAND"] = (
+    "ssh -oBatchMode=yes -oLogLevel=QUIET -oStrictHostKeyChecking=no -oUserKnownHostsFile=/dev/null"
 )
 
 
@@ -21,15 +21,15 @@ class Config:
     def exists(self):
         return os.path.exists(self.path)
 
-    def open(self, mode='r'):
-        return open(self.path, mode=mode, encoding='utf-8')
+    def open(self, mode="r"):
+        return open(self.path, mode=mode, encoding="utf-8")
 
     def read(self):
-        with self.open(mode='r') as fd:
+        with self.open(mode="r") as fd:
             return fd.read()
 
     def write(self, contents):
-        with self.open(mode='w') as fd:
+        with self.open(mode="w") as fd:
             fd.write(contents)
 
     @contextmanager
@@ -52,12 +52,12 @@ class Config:
         @staticmethod
         def validate_name(name):
             if not name:
-                raise RuntimeError('section names cannot be empty')
+                raise RuntimeError("section names cannot be empty")
             for c in name:
-                if c.isalnum() or c == '-' or c == '.':
+                if c.isalnum() or c == "-" or c == ".":
                     continue
                 raise RuntimeError(
-                    f'section names must only contain alphanumeric characters, . or -: {name}'
+                    f"section names must only contain alphanumeric characters, . or -: {name}"
                 )
 
         @staticmethod
@@ -65,8 +65,8 @@ class Config:
             return name
 
         def format(self):
-            result = f'[{self.format_name(self.name)}]\n'
-            result += ''.join((var.format() for var in self.variables))
+            result = f"[{self.format_name(self.name)}]\n"
+            result += "".join((var.format() for var in self.variables))
             return result
 
     class Subsection:
@@ -79,23 +79,23 @@ class Config:
 
         @staticmethod
         def validate_name(name):
-            if '\n' in name:
-                raise RuntimeError(f'subsection names cannot contain newlines: {name}')
+            if "\n" in name:
+                raise RuntimeError(f"subsection names cannot contain newlines: {name}")
 
         def format_name(self):
             name = self.name
             # Escape the backslashes:
-            name = name.replace('\\', r'\\')
+            name = name.replace("\\", r"\\")
             # Escape the quotes:
-            name = name.replace('"', r'\"')
+            name = name.replace('"', r"\"")
             # Put in quotes:
             return f'"{name}"'
 
         def format(self):
             result = (
-                f'[{Config.Section.format_name(self.section)} {self.format_name()}]\n'
+                f"[{Config.Section.format_name(self.section)} {self.format_name()}]\n"
             )
-            result += ''.join((var.format() for var in self.variables))
+            result += "".join((var.format() for var in self.variables))
             return result
 
     class Variable:
@@ -108,16 +108,16 @@ class Config:
         @staticmethod
         def validate_name(name):
             if not name:
-                raise RuntimeError('variable names cannot be empty')
+                raise RuntimeError("variable names cannot be empty")
             for c in name:
-                if c.isalnum() or c == '-':
+                if c.isalnum() or c == "-":
                     continue
                 raise RuntimeError(
-                    f'variable name can only contain alphanumeric characters or -: {name}'
+                    f"variable name can only contain alphanumeric characters or -: {name}"
                 )
             if not name[0].isalnum():
                 raise RuntimeError(
-                    f'variable name must start with an alphanumeric character: {name}'
+                    f"variable name must start with an alphanumeric character: {name}"
                 )
 
         @staticmethod
@@ -130,23 +130,23 @@ class Config:
         def format_value(self):
             value = self.value
             # Escape the backslashes:
-            value = value.replace('\\', r'\\')
+            value = value.replace("\\", r"\\")
             # Escape the supported escape sequences (\n, \t and \b):
-            value = value.replace('\n', r'\n')
-            value = value.replace('\t', r'\t')
-            value = value.replace('\b', r'\b')
+            value = value.replace("\n", r"\n")
+            value = value.replace("\t", r"\t")
+            value = value.replace("\b", r"\b")
             # Escape the quotes:
-            value = value.replace('"', r'\"')
+            value = value.replace('"', r"\"")
             # Put in quotes:
             value = f'"{value}"'
             return value
 
         def format(self):
-            return f'    {self.format_name()} = {self.format_value()}\n'
+            return f"    {self.format_name()} = {self.format_value()}\n"
 
 
 class Git:
-    EXE = 'git'
+    EXE = "git"
 
     @staticmethod
     def check(*args, **kwargs):
@@ -158,7 +158,7 @@ class Git:
 
     @staticmethod
     def get_global_config():
-        return Config(os.path.expanduser('~/.gitconfig'))
+        return Config(os.path.expanduser("~/.gitconfig"))
 
     @staticmethod
     @contextmanager
@@ -169,10 +169,10 @@ class Git:
         config = Git.get_global_config()
         with utils.protected_file(config.path):
             with config.backup() as old_contents:
-                variables = [Config.Variable('insteadOf', repo.clone_url)]
+                variables = [Config.Variable("insteadOf", repo.clone_url)]
                 subsection = Config.Subsection(
-                    'url', repo.clone_url_with_auth, variables
+                    "url", repo.clone_url_with_auth, variables
                 )
-                new_contents = f'{old_contents}\n{subsection.format()}'
+                new_contents = f"{old_contents}\n{subsection.format()}"
                 config.write(new_contents)
                 yield

{cgitize-8.0.1 → cgitize-8.0.2}/cgitize/github.py

@@ -34,13 +34,13 @@ class GitHub:
         # None makes no difference.
         kwargs = {}
         if visibility is not None:
-            kwargs['visibility'] = visibility
+            kwargs["visibility"] = visibility
 
         try:
             if user.name == self._username:
                 # To get private repositories, get_user() must be called
                 # without arguments:
-                return self._impl.get_user().get_repos(affiliation='owner', **kwargs)
+                return self._impl.get_user().get_repos(affiliation="owner", **kwargs)
             else:
                 return self._impl.get_user(user.name).get_repos(**kwargs)
         except GithubException:

{cgitize-8.0.1 → cgitize-8.0.2}/cgitize/gitlab.py

@@ -13,7 +13,7 @@ from cgitize.repo import Repo, Visibility
 
 class GitLab:
     def __init__(self, token):
-        self._impl = Gitlab('https://gitlab.com', private_token=token)
+        self._impl = Gitlab("https://gitlab.com", private_token=token)
 
     def get_repo(self, repo):
         try:

{cgitize-8.0.1 → cgitize-8.0.2}/cgitize/header.py

@@ -5,14 +5,14 @@
 
 
 def update(path, success, error=None):
-    with open(path, 'w') as file:
-        contents = ''
+    with open(path, "w") as file:
+        contents = ""
         if not success:
             contents = (
-                '''<p style="text-align: center; color: red; font-weight: bold;">'''
+                """<p style="text-align: center; color: red; font-weight: bold;">"""
             )
-            contents += '''Some repositories couldn't be updated, please check application logs for details.'''
+            contents += """Some repositories couldn't be updated, please check application logs for details."""
             if error is not None:
-                contents += f'''<br>{type(error).__name__}: {error}'''
-            contents += '''</p>\n'''
+                contents += f"""<br>{type(error).__name__}: {error}"""
+            contents += """</p>\n"""
         file.write(contents)

{cgitize-8.0.1 → cgitize-8.0.2}/cgitize/main.py

@@ -19,23 +19,23 @@ def parse_args(argv=None):
         argv = sys.argv[1:]
     parser = ArgumentParser()
     parser.add_argument(
-        '--config',
-        '-c',
-        metavar='PATH',
+        "--config",
+        "-c",
+        metavar="PATH",
         default=Config.DEFAULT_PATH,
-        help='config file path',
+        help="config file path",
     )
     parser.add_argument(
-        '--repo', metavar='REPO_ID', nargs='*', dest='repos', help='repos to pull'
+        "--repo", metavar="REPO_ID", nargs="*", dest="repos", help="repos to pull"
     )
     parser.add_argument(
-        '--force', '-f', action='store_true', help='overwrite existing repositories'
+        "--force", "-f", action="store_true", help="overwrite existing repositories"
     )
     parser.add_argument(
-        '--verbose', '-v', action='store_true', help='verbose log output'
+        "--verbose", "-v", action="store_true", help="verbose log output"
     )
     parser.add_argument(
-        '--version', '-V', action='version', version=f'%(prog)s {__version__}'
+        "--version", "-V", action="version", version=f"%(prog)s {__version__}"
     )
     return parser.parse_args(argv)
 
@@ -60,15 +60,15 @@ def main(argv=None):
             error = e
 
         if success:
-            logging.info('All repositories were updated successfully')
+            logging.info("All repositories were updated successfully")
         else:
             logging.warning("Some repositories couldn't be updated!")
             if error is not None:
-                logging.warning('Error: %s', error)
+                logging.warning("Error: %s", error)
 
         update_header(config.main.error_header_path, success, error)
         return int(not success)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main())