libs: more python3 reformats

rhodecode/lib/vcs/__init__.py

@@ -1,190 +1,188 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Various version Control System version lib (vcs) management abstraction layer
 for Python. Build with server client architecture.
 """
 import io
 import atexit
 import logging
 
 import rhodecode
 from rhodecode.lib.str_utils import safe_bytes
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.lib.vcs.backends import get_vcs_instance, get_backend
 from rhodecode.lib.vcs.exceptions import (
     VCSError, RepositoryError, CommitError, VCSCommunicationError)
 
 __all__ = [
     'get_vcs_instance', 'get_backend',
     'VCSError', 'RepositoryError', 'CommitError', 'VCSCommunicationError'
 ]
 
 log = logging.getLogger(__name__)
 
 # The pycurl library directly accesses C API functions and is not patched by
 # gevent. This will potentially lead to deadlocks due to incompatibility to
 # gevent. Therefore we check if gevent is active and import a gevent compatible
 # wrapper in that case.
 try:
     from gevent import monkey
     if monkey.is_module_patched('__builtin__'):
         import geventcurl as pycurl
         log.debug('Using gevent comapatible pycurl: %s', pycurl)
     else:
         import pycurl
 except ImportError:
     import pycurl
 
 
 def connect_http(server_and_port):
     log.debug('Initialized VCSServer connections to %s.', server_and_port)
 
     from rhodecode.lib.vcs import connection, client_http
     from rhodecode.lib.middleware.utils import scm_app
 
     session_factory = client_http.ThreadlocalSessionFactory()
 
     connection.Git = client_http.RemoteVCSMaker(
         server_and_port, '/git', 'git', session_factory)
     connection.Hg = client_http.RemoteVCSMaker(
         server_and_port, '/hg', 'hg', session_factory)
     connection.Svn = client_http.RemoteVCSMaker(
         server_and_port, '/svn', 'svn', session_factory)
     connection.Service = client_http.ServiceConnection(
         server_and_port, '/_service', session_factory)
 
     scm_app.HG_REMOTE_WSGI = client_http.VcsHttpProxy(
         server_and_port, '/proxy/hg')
     scm_app.GIT_REMOTE_WSGI = client_http.VcsHttpProxy(
         server_and_port, '/proxy/git')
 
     @atexit.register
     def free_connection_resources():
         connection.Git = None
         connection.Hg = None
         connection.Svn = None
         connection.Service = None
 
 
 def connect_vcs(server_and_port, protocol):
     """
     Initializes the connection to the vcs server.
 
     :param server_and_port: str, e.g. "localhost:9900"
     :param protocol: str or "http"
     """
     if protocol == 'http':
         connect_http(server_and_port)
     else:
-        raise Exception('Invalid vcs server protocol "{}"'.format(protocol))
+        raise Exception(f'Invalid vcs server protocol "{protocol}"')
 
 
 class CurlSession(object):
     """
     Modeled so that it provides a subset of the requests interface.
 
     This has been created so that it does only provide a minimal API for our
     needs. The parts which it provides are based on the API of the library
     `requests` which allows us to easily benchmark against it.
 
     Please have a look at the class :class:`requests.Session` when you extend
     it.
     """
     CURL_UA = f'RhodeCode HTTP {rhodecode.__version__}'
 
     def __init__(self):
         curl = pycurl.Curl()
         # TODO: johbo: I did test with 7.19 of libcurl. This version has
         # trouble with 100 - continue being set in the expect header. This
         # can lead to massive performance drops, switching it off here.
 
         curl.setopt(curl.TCP_NODELAY, True)
         curl.setopt(curl.PROTOCOLS, curl.PROTO_HTTP)
         curl.setopt(curl.USERAGENT, safe_bytes(self.CURL_UA))
         curl.setopt(curl.SSL_VERIFYPEER, 0)
         curl.setopt(curl.SSL_VERIFYHOST, 0)
         self._curl = curl
 
     def post(self, url, data, allow_redirects=False, headers=None):
         headers = headers or {}
         # format is ['header_name1: header_value1', 'header_name2: header_value2'])
         headers_list = [b"Expect:"] + [safe_bytes('{}: {}'.format(k, v)) for k, v in headers.items()]
         response_buffer = io.BytesIO()
 
         curl = self._curl
         curl.setopt(curl.URL, url)
         curl.setopt(curl.POST, True)
         curl.setopt(curl.POSTFIELDS, data)
         curl.setopt(curl.FOLLOWLOCATION, allow_redirects)
         curl.setopt(curl.WRITEDATA, response_buffer)
         curl.setopt(curl.HTTPHEADER, headers_list)
         curl.perform()
 
         status_code = curl.getinfo(pycurl.HTTP_CODE)
         content_type = curl.getinfo(pycurl.CONTENT_TYPE)
         return CurlResponse(response_buffer, status_code, content_type)
 
 
 class CurlResponse(object):
     """
     The response of a request, modeled after the requests API.
 
     This class provides a subset of the response interface known from the
     library `requests`. It is intentionally kept similar, so that we can use
     `requests` as a drop in replacement for benchmarking purposes.
     """
 
     def __init__(self, response_buffer, status_code, content_type=''):
         self._response_buffer = response_buffer
         self._status_code = status_code
         self._content_type = content_type
 
     def __repr__(self):
         return f'CurlResponse(code={self._status_code}, content_type={self._content_type})'
 
     @property
     def content(self):
         try:
             return self._response_buffer.getvalue()
         finally:
             self._response_buffer.close()
 
     @property
     def status_code(self):
         return self._status_code
 
     @property
     def content_type(self):
         return self._content_type
 
     def iter_content(self, chunk_size):
         self._response_buffer.seek(0)
         while 1:
             chunk = self._response_buffer.read(chunk_size)
             if not chunk:
                 break
             yield chunk
 
 
 def _create_http_rpc_session():
     session = CurlSession()
     return session

rhodecode/lib/vcs/backends/__init__.py

@@ -1,95 +1,93 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 VCS Backends module
 """
 
 import os
 import logging
 
 from rhodecode import typing
 
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.lib.vcs.exceptions import VCSError
 from rhodecode.lib.vcs.utils.helpers import get_scm
 from rhodecode.lib.vcs.utils.imports import import_class
 
 
 log = logging.getLogger(__name__)
 
 
 def get_vcs_instance(repo_path, *args, **kwargs) -> typing.VCSRepo | None:
     """
     Given a path to a repository an instance of the corresponding vcs backend
     repository class is created and returned. If no repository can be found
     for the path it returns None. Arguments and keyword arguments are passed
     to the vcs backend repository class.
     """
     from rhodecode.lib.utils2 import safe_str
 
     explicit_vcs_alias = kwargs.pop('_vcs_alias', None)
     try:
         vcs_alias = safe_str(explicit_vcs_alias or get_scm(repo_path)[0])
         log.debug(
             'Creating instance of %s repository from %s', vcs_alias,
             safe_str(repo_path))
         backend = get_backend(vcs_alias)
 
         if explicit_vcs_alias:
             # do final verification of existence of the path, this does the
             # same as get_scm() call which we skip in explicit_vcs_alias
             if not os.path.isdir(repo_path):
                 raise VCSError(f"Given path {repo_path} is not a directory")
     except VCSError:
         log.exception(
             'Perhaps this repository is in db and not in '
             'filesystem run rescan repositories with '
             '"destroy old data" option from admin panel')
         return None
 
     return backend(repo_path=repo_path, *args, **kwargs)
 
 
 def get_backend(alias) -> typing.VCSRepoClass:
     """
     Returns ``Repository`` class identified by the given alias or raises
     VCSError if alias is not recognized or backend class cannot be imported.
     """
     if alias not in settings.BACKENDS:
         raise VCSError(
             f"Given alias '{alias}' is not recognized! "
             f"Allowed aliases:{settings.BACKENDS.keys()}")
     backend_path = settings.BACKENDS[alias]
     klass = import_class(backend_path)
     return klass
 
 
 def get_supported_backends():
     """
     Returns list of aliases of supported backends.
     """
     return settings.BACKENDS.keys()
 
 
 def get_vcsserver_service_data():
     from rhodecode.lib.vcs import connection
     return connection.Service.get_vcsserver_service_data()
 

rhodecode/lib/vcs/backends/base.py

@@ -1,1989 +1,1987 b''
 
 
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Base module for all VCS systems
 """
 import os
 import re
 import time
 import shutil
 import datetime
 import fnmatch
 import itertools
 import logging
 import dataclasses
 import warnings
 
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 
 import rhodecode
 from rhodecode.translation import lazy_ugettext
 from rhodecode.lib.utils2 import safe_str, CachedProperty
 from rhodecode.lib.vcs.utils import author_name, author_email
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.lib.vcs.exceptions import (
     CommitError, EmptyRepositoryError, NodeAlreadyAddedError,
     NodeAlreadyChangedError, NodeAlreadyExistsError, NodeAlreadyRemovedError,
     NodeDoesNotExistError, NodeNotChangedError, VCSError,
     ImproperArchiveTypeError, BranchDoesNotExistError, CommitDoesNotExistError,
     RepositoryError)
 
 
 log = logging.getLogger(__name__)
 
 
 FILEMODE_DEFAULT = 0o100644
 FILEMODE_EXECUTABLE = 0o100755
 EMPTY_COMMIT_ID = '0' * 40
 
 
 @dataclasses.dataclass
 class Reference:
     type: str
     name: str
     commit_id: str
 
     def __iter__(self):
         yield self.type
         yield self.name
         yield self.commit_id
 
     @property
     def branch(self):
         if self.type == 'branch':
             return self.name
 
     @property
     def bookmark(self):
         if self.type == 'book':
             return self.name
 
     @property
     def to_str(self):
         return reference_to_unicode(self)
 
     def asdict(self):
         return dict(
             type=self.type,
             name=self.name,
             commit_id=self.commit_id
         )
 
 
 def unicode_to_reference(raw: str):
     """
     Convert a unicode (or string) to a reference object.
     If unicode evaluates to False it returns None.
     """
     if raw:
         refs = raw.split(':')
         return Reference(*refs)
     else:
         return None
 
 
 def reference_to_unicode(ref: Reference):
     """
     Convert a reference object to unicode.
     If reference is None it returns None.
     """
     if ref:
         return ':'.join(ref)
     else:
         return None
 
 
 class MergeFailureReason(object):
     """
     Enumeration with all the reasons why the server side merge could fail.
 
     DO NOT change the number of the reasons, as they may be stored in the
     database.
 
     Changing the name of a reason is acceptable and encouraged to deprecate old
     reasons.
     """
 
     # Everything went well.
     NONE = 0
 
     # An unexpected exception was raised. Check the logs for more details.
     UNKNOWN = 1
 
     # The merge was not successful, there are conflicts.
     MERGE_FAILED = 2
 
     # The merge succeeded but we could not push it to the target repository.
     PUSH_FAILED = 3
 
     # The specified target is not a head in the target repository.
     TARGET_IS_NOT_HEAD = 4
 
     # The source repository contains more branches than the target. Pushing
     # the merge will create additional branches in the target.
     HG_SOURCE_HAS_MORE_BRANCHES = 5
 
     # The target reference has multiple heads. That does not allow to correctly
     # identify the target location. This could only happen for mercurial
     # branches.
     HG_TARGET_HAS_MULTIPLE_HEADS = 6
 
     # The target repository is locked
     TARGET_IS_LOCKED = 7
 
     # Deprecated, use MISSING_TARGET_REF or MISSING_SOURCE_REF instead.
     # A involved commit could not be found.
     _DEPRECATED_MISSING_COMMIT = 8
 
     # The target repo reference is missing.
     MISSING_TARGET_REF = 9
 
     # The source repo reference is missing.
     MISSING_SOURCE_REF = 10
 
     # The merge was not successful, there are conflicts related to sub
     # repositories.
     SUBREPO_MERGE_FAILED = 11
 
 
 class UpdateFailureReason(object):
     """
     Enumeration with all the reasons why the pull request update could fail.
 
     DO NOT change the number of the reasons, as they may be stored in the
     database.
 
     Changing the name of a reason is acceptable and encouraged to deprecate old
     reasons.
     """
 
     # Everything went well.
     NONE = 0
 
     # An unexpected exception was raised. Check the logs for more details.
     UNKNOWN = 1
 
     # The pull request is up to date.
     NO_CHANGE = 2
 
     # The pull request has a reference type that is not supported for update.
     WRONG_REF_TYPE = 3
 
     # Update failed because the target reference is missing.
     MISSING_TARGET_REF = 4
 
     # Update failed because the source reference is missing.
     MISSING_SOURCE_REF = 5
 
 
 class MergeResponse(object):
 
     # uses .format(**metadata) for variables
     MERGE_STATUS_MESSAGES = {
         MergeFailureReason.NONE: lazy_ugettext(
             'This pull request can be automatically merged.'),
         MergeFailureReason.UNKNOWN: lazy_ugettext(
             'This pull request cannot be merged because of an unhandled exception. '
             '{exception}'),
         MergeFailureReason.MERGE_FAILED: lazy_ugettext(
             'This pull request cannot be merged because of merge conflicts. {unresolved_files}'),
         MergeFailureReason.PUSH_FAILED: lazy_ugettext(
             'This pull request could not be merged because push to '
             'target:`{target}@{merge_commit}` failed.'),
         MergeFailureReason.TARGET_IS_NOT_HEAD: lazy_ugettext(
             'This pull request cannot be merged because the target '
             '`{target_ref.name}` is not a head.'),
         MergeFailureReason.HG_SOURCE_HAS_MORE_BRANCHES: lazy_ugettext(
             'This pull request cannot be merged because the source contains '
             'more branches than the target.'),
         MergeFailureReason.HG_TARGET_HAS_MULTIPLE_HEADS: lazy_ugettext(
             'This pull request cannot be merged because the target `{target_ref.name}` '
             'has multiple heads: `{heads}`.'),
         MergeFailureReason.TARGET_IS_LOCKED: lazy_ugettext(
             'This pull request cannot be merged because the target repository is '
             'locked by {locked_by}.'),
 
         MergeFailureReason.MISSING_TARGET_REF: lazy_ugettext(
             'This pull request cannot be merged because the target '
             'reference `{target_ref.name}` is missing.'),
         MergeFailureReason.MISSING_SOURCE_REF: lazy_ugettext(
             'This pull request cannot be merged because the source '
             'reference `{source_ref.name}` is missing.'),
         MergeFailureReason.SUBREPO_MERGE_FAILED: lazy_ugettext(
             'This pull request cannot be merged because of conflicts related '
             'to sub repositories.'),
 
         # Deprecations
         MergeFailureReason._DEPRECATED_MISSING_COMMIT: lazy_ugettext(
             'This pull request cannot be merged because the target or the '
             'source reference is missing.'),
 
     }
 
     def __init__(self, possible, executed, merge_ref, failure_reason, metadata=None):
         self.possible = possible
         self.executed = executed
         self.merge_ref = merge_ref
         self.failure_reason = failure_reason
         self.metadata = metadata or {}
 
     def __repr__(self):
-        return '<MergeResponse:{} {}>'.format(self.label, self.failure_reason)
+        return f'<MergeResponse:{self.label} {self.failure_reason}>'
 
     def __eq__(self, other):
         same_instance = isinstance(other, self.__class__)
         return same_instance \
                and self.possible == other.possible \
                and self.executed == other.executed \
                and self.failure_reason == other.failure_reason
 
     @property
     def label(self):
         label_dict = dict((v, k) for k, v in MergeFailureReason.__dict__.items() if
                           not k.startswith('_'))
         return label_dict.get(self.failure_reason)
 
     @property
     def merge_status_message(self):
         """
         Return a human friendly error message for the given merge status code.
         """
         msg = safe_str(self.MERGE_STATUS_MESSAGES[self.failure_reason])
 
         try:
             return msg.format(**self.metadata)
         except Exception:
             log.exception('Failed to format %s message', self)
             return msg
 
     def asdict(self):
         data = {}
         for k in ['possible', 'executed', 'merge_ref', 'failure_reason',
                   'merge_status_message']:
             data[k] = getattr(self, k)
         return data
 
 
 class TargetRefMissing(ValueError):
     pass
 
 
 class SourceRefMissing(ValueError):
     pass
 
 
 class BaseRepository(object):
     """
     Base Repository for final backends
 
     .. attribute:: DEFAULT_BRANCH_NAME
 
        name of default branch (i.e. "trunk" for svn, "master" for git etc.
 
     .. attribute:: commit_ids
 
        list of all available commit ids, in ascending order
 
     .. attribute:: path
 
        absolute path to the repository
 
     .. attribute:: bookmarks
 
        Mapping from name to :term:`Commit ID` of the bookmark. Empty in case
        there are no bookmarks or the backend implementation does not support
        bookmarks.
 
     .. attribute:: tags
 
        Mapping from name to :term:`Commit ID` of the tag.
 
     """
 
     DEFAULT_BRANCH_NAME = None
-    DEFAULT_CONTACT = u"Unknown"
-    DEFAULT_DESCRIPTION = u"unknown"
+    DEFAULT_CONTACT = "Unknown"
+    DEFAULT_DESCRIPTION = "unknown"
     EMPTY_COMMIT_ID = '0' * 40
     COMMIT_ID_PAT = re.compile(r'[0-9a-fA-F]{40}')
 
     path = None
 
     _is_empty = None
     _commit_ids = {}
 
     def __init__(self, repo_path, config=None, create=False, **kwargs):
         """
         Initializes repository. Raises RepositoryError if repository could
         not be find at the given ``repo_path`` or directory at ``repo_path``
         exists and ``create`` is set to True.
 
         :param repo_path: local path of the repository
         :param config: repository configuration
         :param create=False: if set to True, would try to create repository.
         :param src_url=None: if set, should be proper url from which repository
           would be cloned; requires ``create`` parameter to be set to True -
           raises RepositoryError if src_url is set and create evaluates to
           False
         """
         raise NotImplementedError
 
     def __repr__(self):
-        return '<%s at %s>' % (self.__class__.__name__, self.path)
+        return '<{} at {}>'.format(self.__class__.__name__, self.path)
 
     def __len__(self):
         return self.count()
 
     def __eq__(self, other):
         same_instance = isinstance(other, self.__class__)
         return same_instance and other.path == self.path
 
     def __ne__(self, other):
         return not self.__eq__(other)
 
     def get_create_shadow_cache_pr_path(self, db_repo):
         path = db_repo.cached_diffs_dir
         if not os.path.exists(path):
             os.makedirs(path, 0o755)
         return path
 
     @classmethod
     def get_default_config(cls, default=None):
         config = Config()
         if default and isinstance(default, list):
             for section, key, val in default:
                 config.set(section, key, val)
         return config
 
     @LazyProperty
     def _remote(self):
         raise NotImplementedError
 
     def _heads(self, branch=None):
         return []
 
     @LazyProperty
     def EMPTY_COMMIT(self):
         return EmptyCommit(self.EMPTY_COMMIT_ID)
 
     @LazyProperty
     def alias(self):
         for k, v in settings.BACKENDS.items():
             if v.split('.')[-1] == str(self.__class__.__name__):
                 return k
 
     @LazyProperty
     def name(self):
         return safe_str(os.path.basename(self.path))
 
     @LazyProperty
     def description(self):
         raise NotImplementedError
 
     def refs(self):
         """
         returns a `dict` with branches, bookmarks, tags, and closed_branches
         for this repository
         """
         return dict(
             branches=self.branches,
             branches_closed=self.branches_closed,
             tags=self.tags,
             bookmarks=self.bookmarks
         )
 
     @LazyProperty
     def branches(self):
         """
         A `dict` which maps branch names to commit ids.
         """
         raise NotImplementedError
 
     @LazyProperty
     def branches_closed(self):
         """
         A `dict` which maps tags names to commit ids.
         """
         raise NotImplementedError
 
     @LazyProperty
     def bookmarks(self):
         """
         A `dict` which maps tags names to commit ids.
         """
         raise NotImplementedError
 
     @LazyProperty
     def tags(self):
         """
         A `dict` which maps tags names to commit ids.
         """
         raise NotImplementedError
 
     @LazyProperty
     def size(self):
         """
         Returns combined size in bytes for all repository files
         """
         tip = self.get_commit()
         return tip.size
 
     def size_at_commit(self, commit_id):
         commit = self.get_commit(commit_id)
         return commit.size
 
     def _check_for_empty(self):
         no_commits = len(self._commit_ids) == 0
         if no_commits:
             # check on remote to be sure
             return self._remote.is_empty()
         else:
             return False
 
     def is_empty(self):
         if rhodecode.is_test:
             return self._check_for_empty()
 
         if self._is_empty is None:
             # cache empty for production, but not tests
             self._is_empty = self._check_for_empty()
 
         return self._is_empty
 
     @staticmethod
     def check_url(url, config):
         """
         Function will check given url and try to verify if it's a valid
         link.
         """
         raise NotImplementedError
 
     @staticmethod
     def is_valid_repository(path):
         """
         Check if given `path` contains a valid repository of this backend
         """
         raise NotImplementedError
 
     # ==========================================================================
     # COMMITS
     # ==========================================================================
 
     @CachedProperty
     def commit_ids(self):
         raise NotImplementedError
 
     def append_commit_id(self, commit_id):
         if commit_id not in self.commit_ids:
             self._rebuild_cache(self.commit_ids + [commit_id])
 
         # clear cache
         self._invalidate_prop_cache('commit_ids')
         self._is_empty = False
 
     def get_commit(self, commit_id=None, commit_idx=None, pre_load=None,
                    translate_tag=None, maybe_unreachable=False, reference_obj=None):
         """
         Returns instance of `BaseCommit` class. If `commit_id` and `commit_idx`
         are both None, most recent commit is returned.
 
         :param pre_load: Optional. List of commit attributes to load.
 
         :raises ``EmptyRepositoryError``: if there are no commits
         """
         raise NotImplementedError
 
     def __iter__(self):
         for commit_id in self.commit_ids:
             yield self.get_commit(commit_id=commit_id)
 
     def get_commits(
             self, start_id=None, end_id=None, start_date=None, end_date=None,
             branch_name=None, show_hidden=False, pre_load=None, translate_tags=None):
         """
         Returns iterator of `BaseCommit` objects from start to end
         not inclusive. This should behave just like a list, ie. end is not
         inclusive.
 
         :param start_id: None or str, must be a valid commit id
         :param end_id: None or str, must be a valid commit id
         :param start_date:
         :param end_date:
         :param branch_name:
         :param show_hidden:
         :param pre_load:
         :param translate_tags:
         """
         raise NotImplementedError
 
     def __getitem__(self, key):
         """
         Allows index based access to the commit objects of this repository.
         """
         pre_load = ["author", "branch", "date", "message", "parents"]
         if isinstance(key, slice):
             return self._get_range(key, pre_load)
         return self.get_commit(commit_idx=key, pre_load=pre_load)
 
     def _get_range(self, slice_obj, pre_load):
         for commit_id in self.commit_ids.__getitem__(slice_obj):
             yield self.get_commit(commit_id=commit_id, pre_load=pre_load)
 
     def count(self):
         return len(self.commit_ids)
 
     def tag(self, name, user, commit_id=None, message=None, date=None, **opts):
         """
         Creates and returns a tag for the given ``commit_id``.
 
         :param name: name for new tag
         :param user: full username, i.e.: "Joe Doe <[e-mail]>"
         :param commit_id: commit id for which new tag would be created
         :param message: message of the tag's commit
         :param date: date of tag's commit
 
         :raises TagAlreadyExistError: if tag with same name already exists
         """
         raise NotImplementedError
 
     def remove_tag(self, name, user, message=None, date=None):
         """
         Removes tag with the given ``name``.
 
         :param name: name of the tag to be removed
         :param user: full username, i.e.: "Joe Doe <[e-mail]>"
         :param message: message of the tag's removal commit
         :param date: date of tag's removal commit
 
         :raises TagDoesNotExistError: if tag with given name does not exists
         """
         raise NotImplementedError
 
     def get_diff(
             self, commit1, commit2, path=None, ignore_whitespace=False,
             context=3, path1=None):
         """
         Returns (git like) *diff*, as plain text. Shows changes introduced by
         `commit2` since `commit1`.
 
         :param commit1: Entry point from which diff is shown. Can be
           ``self.EMPTY_COMMIT`` - in this case, patch showing all
           the changes since empty state of the repository until `commit2`
         :param commit2: Until which commit changes should be shown.
         :param path: Can be set to a path of a file to create a diff of that
           file. If `path1` is also set, this value is only associated to
           `commit2`.
         :param ignore_whitespace: If set to ``True``, would not show whitespace
           changes. Defaults to ``False``.
         :param context: How many lines before/after changed lines should be
           shown. Defaults to ``3``.
         :param path1: Can be set to a path to associate with `commit1`. This
           parameter works only for backends which support diff generation for
           different paths. Other backends will raise a `ValueError` if `path1`
           is set and has a different value than `path`.
         :param file_path: filter this diff by given path pattern
         """
         raise NotImplementedError
 
     def strip(self, commit_id, branch=None):
         """
         Strip given commit_id from the repository
         """
         raise NotImplementedError
 
     def get_common_ancestor(self, commit_id1, commit_id2, repo2):
         """
         Return a latest common ancestor commit if one exists for this repo
         `commit_id1` vs `commit_id2` from `repo2`.
 
         :param commit_id1: Commit it from this repository to use as a
            target for the comparison.
         :param commit_id2: Source commit id to use for comparison.
         :param repo2: Source repository to use for comparison.
         """
         raise NotImplementedError
 
     def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None):
         """
         Compare this repository's revision `commit_id1` with `commit_id2`.
 
         Returns a tuple(commits, ancestor) that would be merged from
         `commit_id2`. Doing a normal compare (``merge=False``), ``None``
         will be returned as ancestor.
 
         :param commit_id1: Commit it from this repository to use as a
            target for the comparison.
         :param commit_id2: Source commit id to use for comparison.
         :param repo2: Source repository to use for comparison.
         :param merge: If set to ``True`` will do a merge compare which also
            returns the common ancestor.
         :param pre_load: Optional. List of commit attributes to load.
         """
         raise NotImplementedError
 
     def merge(self, repo_id, workspace_id, target_ref, source_repo, source_ref,
               user_name='', user_email='', message='', dry_run=False,
               use_rebase=False, close_branch=False):
         """
         Merge the revisions specified in `source_ref` from `source_repo`
         onto the `target_ref` of this repository.
 
         `source_ref` and `target_ref` are named tupls with the following
         fields `type`, `name` and `commit_id`.
 
         Returns a MergeResponse named tuple with the following fields
         'possible', 'executed', 'source_commit', 'target_commit',
         'merge_commit'.
 
         :param repo_id: `repo_id` target repo id.
         :param workspace_id: `workspace_id` unique identifier.
         :param target_ref: `target_ref` points to the commit on top of which
             the `source_ref` should be merged.
         :param source_repo: The repository that contains the commits to be
             merged.
         :param source_ref: `source_ref` points to the topmost commit from
             the `source_repo` which should be merged.
         :param user_name: Merge commit `user_name`.
         :param user_email: Merge commit `user_email`.
         :param message: Merge commit `message`.
         :param dry_run: If `True` the merge will not take place.
         :param use_rebase: If `True` commits from the source will be rebased
             on top of the target instead of being merged.
         :param close_branch: If `True` branch will be close before merging it
         """
         if dry_run:
             message = message or settings.MERGE_DRY_RUN_MESSAGE
             user_email = user_email or settings.MERGE_DRY_RUN_EMAIL
             user_name = user_name or settings.MERGE_DRY_RUN_USER
         else:
             if not user_name:
                 raise ValueError('user_name cannot be empty')
             if not user_email:
                 raise ValueError('user_email cannot be empty')
             if not message:
                 raise ValueError('message cannot be empty')
 
         try:
             return self._merge_repo(
                 repo_id, workspace_id, target_ref, source_repo,
                 source_ref, message, user_name, user_email, dry_run=dry_run,
                 use_rebase=use_rebase, close_branch=close_branch)
         except RepositoryError as exc:
             log.exception('Unexpected failure when running merge, dry-run=%s', dry_run)
             return MergeResponse(
                 False, False, None, MergeFailureReason.UNKNOWN,
                 metadata={'exception': str(exc)})
 
     def _merge_repo(self, repo_id, workspace_id, target_ref,
                     source_repo, source_ref, merge_message,
                     merger_name, merger_email, dry_run=False,
                     use_rebase=False, close_branch=False):
         """Internal implementation of merge."""
         raise NotImplementedError
 
     def _maybe_prepare_merge_workspace(
             self, repo_id, workspace_id, target_ref, source_ref):
         """
         Create the merge workspace.
 
         :param workspace_id: `workspace_id` unique identifier.
         """
         raise NotImplementedError
 
     @classmethod
     def _get_legacy_shadow_repository_path(cls, repo_path, workspace_id):
         """
         Legacy version that was used before. We still need it for
         backward compat
         """
         return os.path.join(
             os.path.dirname(repo_path),
-            '.__shadow_%s_%s' % (os.path.basename(repo_path), workspace_id))
+            '.__shadow_{}_{}'.format(os.path.basename(repo_path), workspace_id))
 
     @classmethod
     def _get_shadow_repository_path(cls, repo_path, repo_id, workspace_id):
         # The name of the shadow repository must start with '.', so it is
         # skipped by 'rhodecode.lib.utils.get_filesystem_repos'.
         legacy_repository_path = cls._get_legacy_shadow_repository_path(repo_path, workspace_id)
         if os.path.exists(legacy_repository_path):
             return legacy_repository_path
         else:
             return os.path.join(
                 os.path.dirname(repo_path),
-                '.__shadow_repo_%s_%s' % (repo_id, workspace_id))
+                '.__shadow_repo_{}_{}'.format(repo_id, workspace_id))
 
     def cleanup_merge_workspace(self, repo_id, workspace_id):
         """
         Remove merge workspace.
 
         This function MUST not fail in case there is no workspace associated to
         the given `workspace_id`.
 
         :param workspace_id: `workspace_id` unique identifier.
         """
         shadow_repository_path = self._get_shadow_repository_path(
             self.path, repo_id, workspace_id)
         shadow_repository_path_del = '{}.{}.delete'.format(
             shadow_repository_path, time.time())
 
         # move the shadow repo, so it never conflicts with the one used.
         # we use this method because shutil.rmtree had some edge case problems
         # removing symlinked repositories
         if not os.path.isdir(shadow_repository_path):
             return
 
         shutil.move(shadow_repository_path, shadow_repository_path_del)
         try:
             shutil.rmtree(shadow_repository_path_del, ignore_errors=False)
         except Exception:
             log.exception('Failed to gracefully remove shadow repo under %s',
                           shadow_repository_path_del)
             shutil.rmtree(shadow_repository_path_del, ignore_errors=True)
 
     # ========== #
     # COMMIT API #
     # ========== #
 
     @LazyProperty
     def in_memory_commit(self):
         """
         Returns :class:`InMemoryCommit` object for this repository.
         """
         raise NotImplementedError
 
     # ======================== #
     # UTILITIES FOR SUBCLASSES #
     # ======================== #
 
     def _validate_diff_commits(self, commit1, commit2):
         """
         Validates that the given commits are related to this repository.
 
         Intended as a utility for sub classes to have a consistent validation
         of input parameters in methods like :meth:`get_diff`.
         """
         self._validate_commit(commit1)
         self._validate_commit(commit2)
         if (isinstance(commit1, EmptyCommit) and
                 isinstance(commit2, EmptyCommit)):
             raise ValueError("Cannot compare two empty commits")
 
     def _validate_commit(self, commit):
         if not isinstance(commit, BaseCommit):
             raise TypeError(
                 "%s is not of type BaseCommit" % repr(commit))
         if commit.repository != self and not isinstance(commit, EmptyCommit):
             raise ValueError(
                 "Commit %s must be a valid commit from this repository %s, "
                 "related to this repository instead %s." %
                 (commit, self, commit.repository))
 
     def _validate_commit_id(self, commit_id):
         if not isinstance(commit_id, str):
             raise TypeError(f"commit_id must be a string value got {type(commit_id)} instead")
 
     def _validate_commit_idx(self, commit_idx):
         if not isinstance(commit_idx, int):
             raise TypeError(f"commit_idx must be a numeric value, got {type(commit_idx)}")
 
     def _validate_branch_name(self, branch_name):
         if branch_name and branch_name not in self.branches_all:
-            msg = ("Branch %s not found in %s" % (branch_name, self))
+            msg = ("Branch {} not found in {}".format(branch_name, self))
             raise BranchDoesNotExistError(msg)
 
     #
     # Supporting deprecated API parts
     # TODO: johbo: consider to move this into a mixin
     #
 
     @property
     def EMPTY_CHANGESET(self):
         warnings.warn(
             "Use EMPTY_COMMIT or EMPTY_COMMIT_ID instead", DeprecationWarning)
         return self.EMPTY_COMMIT_ID
 
     @property
     def revisions(self):
         warnings.warn("Use commits attribute instead", DeprecationWarning)
         return self.commit_ids
 
     @revisions.setter
     def revisions(self, value):
         warnings.warn("Use commits attribute instead", DeprecationWarning)
         self.commit_ids = value
 
     def get_changeset(self, revision=None, pre_load=None):
         warnings.warn("Use get_commit instead", DeprecationWarning)
         commit_id = None
         commit_idx = None
         if isinstance(revision, str):
             commit_id = revision
         else:
             commit_idx = revision
         return self.get_commit(
             commit_id=commit_id, commit_idx=commit_idx, pre_load=pre_load)
 
     def get_changesets(
             self, start=None, end=None, start_date=None, end_date=None,
             branch_name=None, pre_load=None):
         warnings.warn("Use get_commits instead", DeprecationWarning)
         start_id = self._revision_to_commit(start)
         end_id = self._revision_to_commit(end)
         return self.get_commits(
             start_id=start_id, end_id=end_id, start_date=start_date,
             end_date=end_date, branch_name=branch_name, pre_load=pre_load)
 
     def _revision_to_commit(self, revision):
         """
         Translates a revision to a commit_id
 
         Helps to support the old changeset based API which allows to use
         commit ids and commit indices interchangeable.
         """
         if revision is None:
             return revision
 
         if isinstance(revision, str):
             commit_id = revision
         else:
             commit_id = self.commit_ids[revision]
         return commit_id
 
     @property
     def in_memory_changeset(self):
         warnings.warn("Use in_memory_commit instead", DeprecationWarning)
         return self.in_memory_commit
 
     def get_path_permissions(self, username):
         """
         Returns a path permission checker or None if not supported
 
         :param username: session user name
         :return: an instance of BasePathPermissionChecker or None
         """
         return None
 
     def install_hooks(self, force=False):
         return self._remote.install_hooks(force)
 
     def get_hooks_info(self):
         return self._remote.get_hooks_info()
 
     def vcsserver_invalidate_cache(self, delete=False):
         return self._remote.vcsserver_invalidate_cache(delete)
 
 
 class BaseCommit(object):
     """
     Each backend should implement it's commit representation.
 
     **Attributes**
 
         ``repository``
             repository object within which commit exists
 
         ``id``
             The commit id, may be ``raw_id`` or i.e. for mercurial's tip
             just ``tip``.
 
         ``raw_id``
             raw commit representation (i.e. full 40 length sha for git
             backend)
 
         ``short_id``
             shortened (if apply) version of ``raw_id``; it would be simple
             shortcut for ``raw_id[:12]`` for git/mercurial backends or same
             as ``raw_id`` for subversion
 
         ``idx``
             commit index
 
         ``files``
             list of ``FileNode`` (``Node`` with NodeKind.FILE) objects
 
         ``dirs``
             list of ``DirNode`` (``Node`` with NodeKind.DIR) objects
 
         ``nodes``
             combined list of ``Node`` objects
 
         ``author``
             author of the commit, as unicode
 
         ``message``
             message of the commit, as unicode
 
         ``parents``
             list of parent commits
 
     """
     repository = None
     branch = None
 
     """
     Depending on the backend this should be set to the branch name of the
     commit. Backends not supporting branches on commits should leave this
     value as ``None``.
     """
 
     _ARCHIVE_PREFIX_TEMPLATE = '{repo_name}-{short_id}'
     """
     This template is used to generate a default prefix for repository archives
     if no prefix has been specified.
     """
 
     def __repr__(self):
         return self.__str__()
 
     def __str__(self):
         return f'<{self.__class__.__name__} at {self.idx}:{self.short_id}>'
 
     def __eq__(self, other):
         same_instance = isinstance(other, self.__class__)
         return same_instance and self.raw_id == other.raw_id
 
     def __json__(self):
         parents = []
         try:
             for parent in self.parents:
                 parents.append({'raw_id': parent.raw_id})
         except NotImplementedError:
             # empty commit doesn't have parents implemented
             pass
 
         return {
             'short_id': self.short_id,
             'raw_id': self.raw_id,
             'revision': self.idx,
             'message': self.message,
             'date': self.date,
             'author': self.author,
             'parents': parents,
             'branch': self.branch
         }
 
     def __getstate__(self):
         d = self.__dict__.copy()
         d.pop('_remote', None)
         d.pop('repository', None)
         return d
 
     def get_remote(self):
         return self._remote
 
     def serialize(self):
         return self.__json__()
 
     def _get_refs(self):
         return {
             'branches': [self.branch] if self.branch else [],
             'bookmarks': getattr(self, 'bookmarks', []),
             'tags': self.tags
         }
 
     @LazyProperty
     def last(self):
         """
         ``True`` if this is last commit in repository, ``False``
         otherwise; trying to access this attribute while there is no
         commits would raise `EmptyRepositoryError`
         """
         if self.repository is None:
             raise CommitError("Cannot check if it's most recent commit")
         return self.raw_id == self.repository.commit_ids[-1]
 
     @LazyProperty
     def parents(self):
         """
         Returns list of parent commits.
         """
         raise NotImplementedError
 
     @LazyProperty
     def first_parent(self):
         """
         Returns list of parent commits.
         """
         return self.parents[0] if self.parents else EmptyCommit()
 
     @property
     def merge(self):
         """
         Returns boolean if commit is a merge.
         """
         return len(self.parents) > 1
 
     @LazyProperty
     def children(self):
         """
         Returns list of child commits.
         """
         raise NotImplementedError
 
     @LazyProperty
     def id(self):
         """
         Returns string identifying this commit.
         """
         raise NotImplementedError
 
     @LazyProperty
     def raw_id(self):
         """
         Returns raw string identifying this commit.
         """
         raise NotImplementedError
 
     @LazyProperty
     def short_id(self):
         """
         Returns shortened version of ``raw_id`` attribute, as string,
         identifying this commit, useful for presentation to users.
         """
         raise NotImplementedError
 
     @LazyProperty
     def idx(self):
         """
         Returns integer identifying this commit.
         """
         raise NotImplementedError
 
     @LazyProperty
     def committer(self):
         """
         Returns committer for this commit
         """
         raise NotImplementedError
 
     @LazyProperty
     def committer_name(self):
         """
         Returns committer name for this commit
         """
 
         return author_name(self.committer)
 
     @LazyProperty
     def committer_email(self):
         """
         Returns committer email address for this commit
         """
 
         return author_email(self.committer)
 
     @LazyProperty
     def author(self):
         """
         Returns author for this commit
         """
 
         raise NotImplementedError
 
     @LazyProperty
     def author_name(self):
         """
         Returns author name for this commit
         """
 
         return author_name(self.author)
 
     @LazyProperty
     def author_email(self):
         """
         Returns author email address for this commit
         """
 
         return author_email(self.author)
 
     def get_file_mode(self, path: bytes):
         """
         Returns stat mode of the file at `path`.
         """
         raise NotImplementedError
 
     def is_link(self, path):
         """
         Returns ``True`` if given `path` is a symlink
         """
         raise NotImplementedError
 
     def is_node_binary(self, path):
         """
         Returns ``True`` is given path is a binary file
         """
         raise NotImplementedError
 
     def node_md5_hash(self, path):
         """
         Returns md5 hash of a node data
         """
         raise NotImplementedError
 
     def get_file_content(self, path) -> bytes:
         """
         Returns content of the file at the given `path`.
         """
         raise NotImplementedError
 
     def get_file_content_streamed(self, path):
         """
         returns a streaming response from vcsserver with file content
         """
         raise NotImplementedError
 
     def get_file_size(self, path):
         """
         Returns size of the file at the given `path`.
         """
         raise NotImplementedError
 
     def get_path_commit(self, path, pre_load=None):
         """
         Returns last commit of the file at the given `path`.
 
         :param pre_load: Optional. List of commit attributes to load.
         """
         commits = self.get_path_history(path, limit=1, pre_load=pre_load)
         if not commits:
             raise RepositoryError(
                 'Failed to fetch history for path {}. '
                 'Please check if such path exists in your repository'.format(
                     path))
         return commits[0]
 
     def get_path_history(self, path, limit=None, pre_load=None):
         """
         Returns history of file as reversed list of :class:`BaseCommit`
         objects for which file at given `path` has been modified.
 
         :param limit: Optional. Allows to limit the size of the returned
            history. This is intended as a hint to the underlying backend, so
            that it can apply optimizations depending on the limit.
         :param pre_load: Optional. List of commit attributes to load.
         """
         raise NotImplementedError
 
     def get_file_annotate(self, path, pre_load=None):
         """
         Returns a generator of four element tuples with
         lineno, sha, commit lazy loader and line
 
         :param pre_load: Optional. List of commit attributes to load.
         """
         raise NotImplementedError
 
     def get_nodes(self, path, pre_load=None):
         """
         Returns combined ``DirNode`` and ``FileNode`` objects list representing
         state of commit at the given ``path``.
 
         :raises ``CommitError``: if node at the given ``path`` is not
           instance of ``DirNode``
         """
         raise NotImplementedError
 
     def get_node(self, path):
         """
         Returns ``Node`` object from the given ``path``.
 
         :raises ``NodeDoesNotExistError``: if there is no node at the given
           ``path``
         """
         raise NotImplementedError
 
     def get_largefile_node(self, path):
         """
         Returns the path to largefile from Mercurial/Git-lfs storage.
         or None if it's not a largefile node
         """
         return None
 
     def archive_repo(self, archive_name_key, kind='tgz', subrepos=None,
                      archive_dir_name=None, write_metadata=False, mtime=None,
                      archive_at_path='/', cache_config=None):
         """
         Creates an archive containing the contents of the repository.
 
         :param archive_name_key: unique key under this archive should be generated
         :param kind: one of following: ``"tbz2"``, ``"tgz"``, ``"zip"``.
         :param archive_dir_name: name of root directory in archive.
             Default is repository name and commit's short_id joined with dash:
             ``"{repo_name}-{short_id}"``.
         :param write_metadata: write a metadata file into archive.
         :param mtime: custom modification time for archive creation, defaults
             to time.time() if not given.
         :param archive_at_path: pack files at this path (default '/')
         :param cache_config: config spec to send to vcsserver to configure the backend to store files
 
         :raise VCSError: If prefix has a problem.
         """
         cache_config = cache_config or {}
         allowed_kinds = [x[0] for x in settings.ARCHIVE_SPECS]
         if kind not in allowed_kinds:
             raise ImproperArchiveTypeError(
                 'Archive kind (%s) not supported use one of %s' %
                 (kind, allowed_kinds))
 
         archive_dir_name = self._validate_archive_prefix(archive_dir_name)
         mtime = mtime is not None or time.mktime(self.date.timetuple())
         commit_id = self.raw_id
 
         return self.repository._remote.archive_repo(
             archive_name_key, kind, mtime, archive_at_path,
             archive_dir_name, commit_id, cache_config)
 
     def _validate_archive_prefix(self, archive_dir_name):
         if archive_dir_name is None:
             archive_dir_name = self._ARCHIVE_PREFIX_TEMPLATE.format(
                 repo_name=safe_str(self.repository.name),
                 short_id=self.short_id)
         elif not isinstance(archive_dir_name, str):
             raise ValueError(f"archive_dir_name is not str object but: {type(archive_dir_name)}")
         elif archive_dir_name.startswith('/'):
             raise VCSError("Prefix cannot start with leading slash")
         elif archive_dir_name.strip() == '':
             raise VCSError("Prefix cannot be empty")
         elif not archive_dir_name.isascii():
             raise VCSError("Prefix cannot contain non ascii characters")
         return archive_dir_name
 
     @LazyProperty
     def root(self):
         """
         Returns ``RootNode`` object for this commit.
         """
         return self.get_node('')
 
     def next(self, branch=None):
         """
         Returns next commit from current, if branch is gives it will return
         next commit belonging to this branch
 
         :param branch: show commits within the given named branch
         """
         indexes = range(self.idx + 1, self.repository.count())
         return self._find_next(indexes, branch)
 
     def prev(self, branch=None):
         """
         Returns previous commit from current, if branch is gives it will
         return previous commit belonging to this branch
 
         :param branch: show commit within the given named branch
         """
         indexes = range(self.idx - 1, -1, -1)
         return self._find_next(indexes, branch)
 
     def _find_next(self, indexes, branch=None):
         if branch and self.branch != branch:
             raise VCSError('Branch option used on commit not belonging '
                            'to that branch')
 
         for next_idx in indexes:
             commit = self.repository.get_commit(commit_idx=next_idx)
             if branch and branch != commit.branch:
                 continue
             return commit
         raise CommitDoesNotExistError
 
     def diff(self, ignore_whitespace=True, context=3):
         """
         Returns a `Diff` object representing the change made by this commit.
         """
         parent = self.first_parent
         diff = self.repository.get_diff(
             parent, self,
             ignore_whitespace=ignore_whitespace,
             context=context)
         return diff
 
     @LazyProperty
     def added(self):
         """
         Returns list of added ``FileNode`` objects.
         """
         raise NotImplementedError
 
     @LazyProperty
     def changed(self):
         """
         Returns list of modified ``FileNode`` objects.
         """
         raise NotImplementedError
 
     @LazyProperty
     def removed(self):
         """
         Returns list of removed ``FileNode`` objects.
         """
         raise NotImplementedError
 
     @LazyProperty
     def size(self):
         """
         Returns total number of bytes from contents of all filenodes.
         """
-        return sum((node.size for node in self.get_filenodes_generator()))
+        return sum(node.size for node in self.get_filenodes_generator())
 
     def walk(self, topurl=''):
         """
         Similar to os.walk method. Insted of filesystem it walks through
         commit starting at given ``topurl``.  Returns generator of tuples
         (top_node, dirnodes, filenodes).
         """
         from rhodecode.lib.vcs.nodes import DirNode
 
         if isinstance(topurl, DirNode):
             top_node = topurl
         else:
             top_node = self.get_node(topurl)
 
         has_default_pre_load = False
         if isinstance(top_node, DirNode):
             # used to inject as we walk same defaults as given top_node
             default_pre_load = top_node.default_pre_load
             has_default_pre_load = True
 
         if not top_node.is_dir():
             return
         yield top_node, top_node.dirs, top_node.files
         for dir_node in top_node.dirs:
             if has_default_pre_load:
                 dir_node.default_pre_load = default_pre_load
-            for tup in self.walk(dir_node):
-                yield tup
+            yield from self.walk(dir_node)
 
     def get_filenodes_generator(self):
         """
         Returns generator that yields *all* file nodes.
         """
         for topnode, dirs, files in self.walk():
-            for node in files:
-                yield node
+            yield from files
 
     #
     # Utilities for sub classes to support consistent behavior
     #
 
     def no_node_at_path(self, path):
         return NodeDoesNotExistError(
             f"There is no file nor directory at the given path: "
             f"`{safe_str(path)}` at commit {self.short_id}")
 
     def _fix_path(self, path: str) -> str:
         """
         Paths are stored without trailing slash so we need to get rid off it if
         needed.
         """
         return safe_str(path).rstrip('/')
 
     #
     # Deprecated API based on changesets
     #
 
     @property
     def revision(self):
         warnings.warn("Use idx instead", DeprecationWarning)
         return self.idx
 
     @revision.setter
     def revision(self, value):
         warnings.warn("Use idx instead", DeprecationWarning)
         self.idx = value
 
     def get_file_changeset(self, path):
         warnings.warn("Use get_path_commit instead", DeprecationWarning)
         return self.get_path_commit(path)
 
 
 class BaseChangesetClass(type):
 
     def __instancecheck__(self, instance):
         return isinstance(instance, BaseCommit)
 
 
 class BaseChangeset(BaseCommit, metaclass=BaseChangesetClass):
 
     def __new__(cls, *args, **kwargs):
         warnings.warn(
             "Use BaseCommit instead of BaseChangeset", DeprecationWarning)
-        return super(BaseChangeset, cls).__new__(cls, *args, **kwargs)
+        return super().__new__(cls, *args, **kwargs)
 
 
 class BaseInMemoryCommit(object):
     """
     Represents differences between repository's state (most recent head) and
     changes made *in place*.
 
     **Attributes**
 
         ``repository``
             repository object for this in-memory-commit
 
         ``added``
             list of ``FileNode`` objects marked as *added*
 
         ``changed``
             list of ``FileNode`` objects marked as *changed*
 
         ``removed``
             list of ``FileNode`` or ``RemovedFileNode`` objects marked to be
             *removed*
 
         ``parents``
             list of :class:`BaseCommit` instances representing parents of
             in-memory commit. Should always be 2-element sequence.
 
     """
 
     def __init__(self, repository):
         self.repository = repository
         self.added = []
         self.changed = []
         self.removed = []
         self.parents = []
 
     def add(self, *filenodes):
         """
         Marks given ``FileNode`` objects as *to be committed*.
 
         :raises ``NodeAlreadyExistsError``: if node with same path exists at
            latest commit
         :raises ``NodeAlreadyAddedError``: if node with same path is already
            marked as *added*
         """
         # Check if not already marked as *added* first
         for node in filenodes:
             if node.path in (n.path for n in self.added):
                 raise NodeAlreadyAddedError(
                     "Such FileNode %s is already marked for addition"
                     % node.path)
         for node in filenodes:
             self.added.append(node)
 
     def change(self, *filenodes):
         """
         Marks given ``FileNode`` objects to be *changed* in next commit.
 
         :raises ``EmptyRepositoryError``: if there are no commits yet
         :raises ``NodeAlreadyExistsError``: if node with same path is already
            marked to be *changed*
         :raises ``NodeAlreadyRemovedError``: if node with same path is already
            marked to be *removed*
         :raises ``NodeDoesNotExistError``: if node doesn't exist in latest
            commit
         :raises ``NodeNotChangedError``: if node hasn't really be changed
         """
         for node in filenodes:
             if node.path in (n.path for n in self.removed):
                 raise NodeAlreadyRemovedError(
                     "Node at %s is already marked as removed" % node.path)
         try:
             self.repository.get_commit()
         except EmptyRepositoryError:
             raise EmptyRepositoryError(
                 "Nothing to change - try to *add* new nodes rather than "
                 "changing them")
         for node in filenodes:
             if node.path in (n.path for n in self.changed):
                 raise NodeAlreadyChangedError(
                     "Node at '%s' is already marked as changed" % node.path)
             self.changed.append(node)
 
     def remove(self, *filenodes):
         """
         Marks given ``FileNode`` (or ``RemovedFileNode``) objects to be
         *removed* in next commit.
 
         :raises ``NodeAlreadyRemovedError``: if node has been already marked to
            be *removed*
         :raises ``NodeAlreadyChangedError``: if node has been already marked to
            be *changed*
         """
         for node in filenodes:
             if node.path in (n.path for n in self.removed):
                 raise NodeAlreadyRemovedError(
                     "Node is already marked to for removal at %s" % node.path)
             if node.path in (n.path for n in self.changed):
                 raise NodeAlreadyChangedError(
                     "Node is already marked to be changed at %s" % node.path)
             # We only mark node as *removed* - real removal is done by
             # commit method
             self.removed.append(node)
 
     def reset(self):
         """
         Resets this instance to initial state (cleans ``added``, ``changed``
         and ``removed`` lists).
         """
         self.added = []
         self.changed = []
         self.removed = []
         self.parents = []
 
     def get_ipaths(self):
         """
         Returns generator of paths from nodes marked as added, changed or
         removed.
         """
         for node in itertools.chain(self.added, self.changed, self.removed):
             yield node.path
 
     def get_paths(self):
         """
         Returns list of paths from nodes marked as added, changed or removed.
         """
         return list(self.get_ipaths())
 
     def check_integrity(self, parents=None):
         """
         Checks in-memory commit's integrity. Also, sets parents if not
         already set.
 
         :raises CommitError: if any error occurs (i.e.
           ``NodeDoesNotExistError``).
         """
         if not self.parents:
             parents = parents or []
             if len(parents) == 0:
                 try:
                     parents = [self.repository.get_commit(), None]
                 except EmptyRepositoryError:
                     parents = [None, None]
             elif len(parents) == 1:
                 parents += [None]
             self.parents = parents
 
         # Local parents, only if not None
         parents = [p for p in self.parents if p]
 
         # Check nodes marked as added
         for p in parents:
             for node in self.added:
                 try:
                     p.get_node(node.path)
                 except NodeDoesNotExistError:
                     pass
                 else:
                     raise NodeAlreadyExistsError(
-                        "Node `%s` already exists at %s" % (node.path, p))
+                        "Node `{}` already exists at {}".format(node.path, p))
 
         # Check nodes marked as changed
         missing = set(self.changed)
         not_changed = set(self.changed)
         if self.changed and not parents:
             raise NodeDoesNotExistError(str(self.changed[0].path))
         for p in parents:
             for node in self.changed:
                 try:
                     old = p.get_node(node.path)
                     missing.remove(node)
                     # if content actually changed, remove node from not_changed
                     if old.content != node.content:
                         not_changed.remove(node)
                 except NodeDoesNotExistError:
                     pass
         if self.changed and missing:
             raise NodeDoesNotExistError(
                 "Node `%s` marked as modified but missing in parents: %s"
                 % (node.path, parents))
 
         if self.changed and not_changed:
             raise NodeNotChangedError(
                 "Node `%s` wasn't actually changed (parents: %s)"
                 % (not_changed.pop().path, parents))
 
         # Check nodes marked as removed
         if self.removed and not parents:
             raise NodeDoesNotExistError(
                 "Cannot remove node at %s as there "
                 "were no parents specified" % self.removed[0].path)
         really_removed = set()
         for p in parents:
             for node in self.removed:
                 try:
                     p.get_node(node.path)
                     really_removed.add(node)
                 except CommitError:
                     pass
         not_removed = set(self.removed) - really_removed
         if not_removed:
             # TODO: johbo: This code branch does not seem to be covered
             raise NodeDoesNotExistError(
                 "Cannot remove node at %s from "
                 "following parents: %s" % (not_removed, parents))
 
     def commit(self, message, author, parents=None, branch=None, date=None, **kwargs):
         """
         Performs in-memory commit (doesn't check workdir in any way) and
         returns newly created :class:`BaseCommit`. Updates repository's
         attribute `commits`.
 
         .. note::
 
            While overriding this method each backend's should call
            ``self.check_integrity(parents)`` in the first place.
 
         :param message: message of the commit
         :param author: full username, i.e. "Joe Doe <[e-mail]>"
         :param parents: single parent or sequence of parents from which commit
            would be derived
         :param date: ``datetime.datetime`` instance. Defaults to
            ``datetime.datetime.now()``.
         :param branch: branch name, as string. If none given, default backend's
            branch would be used.
 
         :raises ``CommitError``: if any error occurs while committing
         """
         raise NotImplementedError
 
 
 class BaseInMemoryChangesetClass(type):
 
     def __instancecheck__(self, instance):
         return isinstance(instance, BaseInMemoryCommit)
 
 
 class BaseInMemoryChangeset(BaseInMemoryCommit, metaclass=BaseInMemoryChangesetClass):
 
     def __new__(cls, *args, **kwargs):
         warnings.warn(
             "Use BaseCommit instead of BaseInMemoryCommit", DeprecationWarning)
-        return super(BaseInMemoryChangeset, cls).__new__(cls, *args, **kwargs)
+        return super().__new__(cls, *args, **kwargs)
 
 
 class EmptyCommit(BaseCommit):
     """
     An dummy empty commit. It's possible to pass hash when creating
     an EmptyCommit
     """
 
     def __init__(
             self, commit_id=EMPTY_COMMIT_ID, repo=None, alias=None, idx=-1,
             message='', author='', date=None):
         self._empty_commit_id = commit_id
         # TODO: johbo: Solve idx parameter, default value does not make
         # too much sense
         self.idx = idx
         self.message = message
         self.author = author
         self.date = date or datetime.datetime.fromtimestamp(0)
         self.repository = repo
         self.alias = alias
 
     @LazyProperty
     def raw_id(self):
         """
         Returns raw string identifying this commit, useful for web
         representation.
         """
 
         return self._empty_commit_id
 
     @LazyProperty
     def branch(self):
         if self.alias:
             from rhodecode.lib.vcs.backends import get_backend
             return get_backend(self.alias).DEFAULT_BRANCH_NAME
 
     @LazyProperty
     def short_id(self):
         return self.raw_id[:12]
 
     @LazyProperty
     def id(self):
         return self.raw_id
 
     def get_path_commit(self, path, pre_load=None):
         return self
 
     def get_file_content(self, path) -> bytes:
         return b''
 
     def get_file_content_streamed(self, path):
         yield self.get_file_content(path)
 
     def get_file_size(self, path):
         return 0
 
 
 class EmptyChangesetClass(type):
 
     def __instancecheck__(self, instance):
         return isinstance(instance, EmptyCommit)
 
 
 class EmptyChangeset(EmptyCommit, metaclass=EmptyChangesetClass):
 
     def __new__(cls, *args, **kwargs):
         warnings.warn(
             "Use EmptyCommit instead of EmptyChangeset", DeprecationWarning)
         return super(EmptyCommit, cls).__new__(cls, *args, **kwargs)
 
     def __init__(self, cs=EMPTY_COMMIT_ID, repo=None, requested_revision=None,
                  alias=None, revision=-1, message='', author='', date=None):
         if requested_revision is not None:
             warnings.warn(
                 "Parameter requested_revision not supported anymore",
                 DeprecationWarning)
-        super(EmptyChangeset, self).__init__(
+        super().__init__(
             commit_id=cs, repo=repo, alias=alias, idx=revision,
             message=message, author=author, date=date)
 
         @property
         def revision(self):
             warnings.warn("Use idx instead", DeprecationWarning)
             return self.idx
 
         @revision.setter
         def revision(self, value):
             warnings.warn("Use idx instead", DeprecationWarning)
             self.idx = value
 
 
 class EmptyRepository(BaseRepository):
     def __init__(self, repo_path=None, config=None, create=False, **kwargs):
         pass
 
     def get_diff(self, *args, **kwargs):
         from rhodecode.lib.vcs.backends.git.diff import GitDiff
         return GitDiff(b'')
 
 
 class CollectionGenerator(object):
 
     def __init__(self, repo, commit_ids, collection_size=None, pre_load=None, translate_tag=None):
         self.repo = repo
         self.commit_ids = commit_ids
         self.collection_size = collection_size
         self.pre_load = pre_load
         self.translate_tag = translate_tag
 
     def __len__(self):
         if self.collection_size is not None:
             return self.collection_size
         return self.commit_ids.__len__()
 
     def __iter__(self):
         for commit_id in self.commit_ids:
             # TODO: johbo: Mercurial passes in commit indices or commit ids
             yield self._commit_factory(commit_id)
 
     def _commit_factory(self, commit_id):
         """
         Allows backends to override the way commits are generated.
         """
         return self.repo.get_commit(
             commit_id=commit_id, pre_load=self.pre_load,
             translate_tag=self.translate_tag)
 
     def __getitem__(self, key):
         """Return either a single element by index, or a sliced collection."""
 
         if isinstance(key, slice):
             commit_ids = self.commit_ids[key.start:key.stop]
 
         else:
             # single item
             commit_ids = self.commit_ids[key]
 
         return self.__class__(
             self.repo, commit_ids, pre_load=self.pre_load,
             translate_tag=self.translate_tag)
 
     def __repr__(self):
         return '<CollectionGenerator[len:%s]>' % (self.__len__())
 
 
 class Config(object):
     """
     Represents the configuration for a repository.
 
     The API is inspired by :class:`ConfigParser.ConfigParser` from the
     standard library. It implements only the needed subset.
     """
 
     def __init__(self):
         self._values = {}
 
     def copy(self):
         clone = Config()
         for section, values in self._values.items():
             clone._values[section] = values.copy()
         return clone
 
     def __repr__(self):
-        return '<Config(%s sections) at %s>' % (
+        return '<Config({} sections) at {}>'.format(
             len(self._values), hex(id(self)))
 
     def items(self, section):
         return self._values.get(section, {}).items()
 
     def get(self, section, option):
         return self._values.get(section, {}).get(option)
 
     def set(self, section, option, value):
         section_values = self._values.setdefault(section, {})
         section_values[option] = value
 
     def clear_section(self, section):
         self._values[section] = {}
 
     def serialize(self):
         """
         Creates a list of three tuples (section, key, value) representing
         this config object.
         """
         items = []
         for section in self._values:
             for option, value in self._values[section].items():
                 items.append(
                     (safe_str(section), safe_str(option), safe_str(value)))
         return items
 
 
 class Diff(object):
     """
     Represents a diff result from a repository backend.
 
     Subclasses have to provide a backend specific value for
     :attr:`_header_re` and :attr:`_meta_re`.
     """
     _meta_re = None
     _header_re: bytes = re.compile(br"")
 
     def __init__(self, raw_diff: bytes):
         if not isinstance(raw_diff, bytes):
             raise Exception(f'raw_diff must be bytes - got {type(raw_diff)}')
 
         self.raw = memoryview(raw_diff)
 
     def get_header_re(self):
         return self._header_re
 
     def chunks(self):
         """
         split the diff in chunks of separate --git a/file b/file chunks
         to make diffs consistent we must prepend with \n, and make sure
         we can detect last chunk as this was also has special rule
         """
 
         diff_parts = (b'\n' + bytes(self.raw)).split(b'\ndiff --git')
 
         chunks = diff_parts[1:]
         total_chunks = len(chunks)
 
         def diff_iter(_chunks):
             for cur_chunk, chunk in enumerate(_chunks, start=1):
                 yield DiffChunk(chunk, self, cur_chunk == total_chunks)
         return diff_iter(chunks)
 
 
 class DiffChunk(object):
 
     def __init__(self, chunk: bytes, diff_obj: Diff, is_last_chunk: bool):
         self.diff_obj = diff_obj
 
         # since we split by \ndiff --git that part is lost from original diff
         # we need to re-apply it at the end, EXCEPT ! if it's last chunk
         if not is_last_chunk:
             chunk += b'\n'
         header_re = self.diff_obj.get_header_re()
         match = header_re.match(chunk)
         self.header = match.groupdict()
         self.diff = chunk[match.end():]
         self.raw = chunk
 
     @property
     def header_as_str(self):
         if self.header:
             def safe_str_on_bytes(val):
                 if isinstance(val, bytes):
                     return safe_str(val)
                 return val
             return {safe_str(k): safe_str_on_bytes(v) for k, v in self.header.items()}
 
     def __repr__(self):
         return f'DiffChunk({self.header_as_str})'
 
 
 class BasePathPermissionChecker(object):
 
     @staticmethod
     def create_from_patterns(includes, excludes):
         if includes and '*' in includes and not excludes:
             return AllPathPermissionChecker()
         elif excludes and '*' in excludes:
             return NonePathPermissionChecker()
         else:
             return PatternPathPermissionChecker(includes, excludes)
 
     @property
     def has_full_access(self):
         raise NotImplementedError()
 
     def has_access(self, path):
         raise NotImplementedError()
 
 
 class AllPathPermissionChecker(BasePathPermissionChecker):
 
     @property
     def has_full_access(self):
         return True
 
     def has_access(self, path):
         return True
 
 
 class NonePathPermissionChecker(BasePathPermissionChecker):
 
     @property
     def has_full_access(self):
         return False
 
     def has_access(self, path):
         return False
 
 
 class PatternPathPermissionChecker(BasePathPermissionChecker):
 
     def __init__(self, includes, excludes):
         self.includes = includes
         self.excludes = excludes
         self.includes_re = [] if not includes else [
             re.compile(fnmatch.translate(pattern)) for pattern in includes]
         self.excludes_re = [] if not excludes else [
             re.compile(fnmatch.translate(pattern)) for pattern in excludes]
 
     @property
     def has_full_access(self):
         return '*' in self.includes and not self.excludes
 
     def has_access(self, path):
         for regex in self.excludes_re:
             if regex.match(path):
                 return False
         for regex in self.includes_re:
             if regex.match(path):
                 return True
         return False

rhodecode/lib/vcs/backends/git/__init__.py

@@ -1,56 +1,54 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 GIT module
 """
 import os
 import logging
 
 from rhodecode.lib.vcs import connection
 from rhodecode.lib.vcs.backends.git.repository import GitRepository
 from rhodecode.lib.vcs.backends.git.commit import GitCommit
 from rhodecode.lib.vcs.backends.git.inmemory import GitInMemoryCommit
 
 
 log = logging.getLogger(__name__)
 
 
 def discover_git_version(raise_on_exc=False):
     """
     Returns the string as it was returned by running 'git --version'
 
     It will return an empty string in case the connection is not initialized
     or no vcsserver is available.
     """
     try:
         return connection.Git.discover_git_version()
     except Exception:
         log.warning("Failed to discover the Git version", exc_info=True)
         if raise_on_exc:
             raise
         return ''
 
 
 def lfs_store(base_location):
     """
     Return a lfs store relative to base_location
     """
     return os.path.join(base_location, '.cache', 'lfs_store')

rhodecode/lib/vcs/backends/git/commit.py

@@ -1,491 +1,488 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 GIT commit module
 """
 
 import stat
 import configparser
 from itertools import chain
 
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from rhodecode.lib.datelib import utcdate_fromtimestamp
 from rhodecode.lib.str_utils import safe_bytes, safe_str
 from rhodecode.lib.vcs.backends import base
 from rhodecode.lib.vcs.exceptions import CommitError, NodeDoesNotExistError
 from rhodecode.lib.vcs.nodes import (
     FileNode, DirNode, NodeKind, RootNode, SubModuleNode,
     ChangedFileNodesGenerator, AddedFileNodesGenerator,
     RemovedFileNodesGenerator, LargeFileNode)
 
 
 class GitCommit(base.BaseCommit):
     """
     Represents state of the repository at single commit id.
     """
 
     _filter_pre_load = [
         # done through a more complex tree walk on parents
         "affected_files",
         # done through subprocess not remote call
         "children",
         # done through a more complex tree walk on parents
         "status",
         # mercurial specific property not supported here
         "_file_paths",
         # mercurial specific property not supported here
         'obsolete',
         # mercurial specific property not supported here
         'phase',
         # mercurial specific property not supported here
         'hidden'
     ]
 
     def __init__(self, repository, raw_id, idx, pre_load=None):
         self.repository = repository
         self._remote = repository._remote
         # TODO: johbo: Tweak of raw_id should not be necessary
         self.raw_id = safe_str(raw_id)
         self.idx = idx
 
         self._set_bulk_properties(pre_load)
 
         # caches
         self._stat_modes = {}  # stat info for paths
         self._paths = {}  # path processed with parse_tree
         self.nodes = {}
         self._submodules = None
 
     def _set_bulk_properties(self, pre_load):
 
         if not pre_load:
             return
         pre_load = [entry for entry in pre_load
                     if entry not in self._filter_pre_load]
         if not pre_load:
             return
 
         result = self._remote.bulk_request(self.raw_id, pre_load)
         for attr, value in result.items():
             if attr in ["author", "message"]:
                 if value:
                     value = safe_str(value)
             elif attr == "date":
                 value = utcdate_fromtimestamp(*value)
             elif attr == "parents":
                 value = self._make_commits(value)
             elif attr == "branch":
                 value = self._set_branch(value)
             self.__dict__[attr] = value
 
     @LazyProperty
     def _commit(self):
         return self._remote[self.raw_id]
 
     @LazyProperty
     def _tree_id(self):
         return self._remote[self._commit['tree']]['id']
 
     @LazyProperty
     def id(self):
         return self.raw_id
 
     @LazyProperty
     def short_id(self):
         return self.raw_id[:12]
 
     @LazyProperty
     def message(self):
         return safe_str(self._remote.message(self.id))
 
     @LazyProperty
     def committer(self):
         return safe_str(self._remote.author(self.id))
 
     @LazyProperty
     def author(self):
         return safe_str(self._remote.author(self.id))
 
     @LazyProperty
     def date(self):
         unix_ts, tz = self._remote.date(self.raw_id)
         return utcdate_fromtimestamp(unix_ts, tz)
 
     @LazyProperty
     def status(self):
         """
         Returns modified, added, removed, deleted files for current commit
         """
         return self.changed, self.added, self.removed
 
     @LazyProperty
     def tags(self):
         tags = [safe_str(name) for name,
                 commit_id in self.repository.tags.items()
                 if commit_id == self.raw_id]
         return tags
 
     @LazyProperty
     def commit_branches(self):
         branches = []
         for name, commit_id in self.repository.branches.items():
             if commit_id == self.raw_id:
                 branches.append(name)
         return branches
 
     def _set_branch(self, branches):
         if branches:
             # actually commit can have multiple branches in git
             return safe_str(branches[0])
 
     @LazyProperty
     def branch(self):
         branches = self._remote.branch(self.raw_id)
         return self._set_branch(branches)
 
     def _get_tree_id_for_path(self, path):
 
         path = safe_str(path)
         if path in self._paths:
             return self._paths[path]
 
         tree_id = self._tree_id
 
         path = path.strip('/')
         if path == '':
             data = [tree_id, "tree"]
             self._paths[''] = data
             return data
 
         tree_id, tree_type, tree_mode = \
             self._remote.tree_and_type_for_path(self.raw_id, path)
         if tree_id is None:
             raise self.no_node_at_path(path)
 
         self._paths[path] = [tree_id, tree_type]
         self._stat_modes[path] = tree_mode
 
         if path not in self._paths:
             raise self.no_node_at_path(path)
 
         return self._paths[path]
 
     def _get_kind(self, path):
         tree_id, type_ = self._get_tree_id_for_path(path)
         if type_ == 'blob':
             return NodeKind.FILE
         elif type_ == 'tree':
             return NodeKind.DIR
         elif type_ == 'link':
             return NodeKind.SUBMODULE
         return None
 
     def _assert_is_path(self, path):
         path = self._fix_path(path)
         if self._get_kind(path) != NodeKind.FILE:
             raise CommitError(f"File does not exist for commit {self.raw_id} at '{path}'")
         return path
 
     def _get_file_nodes(self):
         return chain(*(t[2] for t in self.walk()))
 
     @LazyProperty
     def parents(self):
         """
         Returns list of parent commits.
         """
         parent_ids = self._remote.parents(self.id)
         return self._make_commits(parent_ids)
 
     @LazyProperty
     def children(self):
         """
         Returns list of child commits.
         """
 
         children = self._remote.children(self.raw_id)
         return self._make_commits(children)
 
     def _make_commits(self, commit_ids):
         def commit_maker(_commit_id):
             return self.repository.get_commit(commit_id=_commit_id)
 
         return [commit_maker(commit_id) for commit_id in commit_ids]
 
     def get_file_mode(self, path: bytes):
         """
         Returns stat mode of the file at the given `path`.
         """
         path = self._assert_is_path(path)
 
         # ensure path is traversed
         self._get_tree_id_for_path(path)
 
         return self._stat_modes[path]
 
     def is_link(self, path):
         return stat.S_ISLNK(self.get_file_mode(path))
 
     def is_node_binary(self, path):
         tree_id, _ = self._get_tree_id_for_path(path)
         return self._remote.is_binary(tree_id)
 
     def node_md5_hash(self, path):
         path = self._assert_is_path(path)
         return self._remote.md5_hash(self.raw_id, path)
 
     def get_file_content(self, path):
         """
         Returns content of the file at given `path`.
         """
         tree_id, _ = self._get_tree_id_for_path(path)
         return self._remote.blob_as_pretty_string(tree_id)
 
     def get_file_content_streamed(self, path):
         tree_id, _ = self._get_tree_id_for_path(path)
         stream_method = getattr(self._remote, 'stream:blob_as_pretty_string')
         return stream_method(tree_id)
 
     def get_file_size(self, path):
         """
         Returns size of the file at given `path`.
         """
         tree_id, _ = self._get_tree_id_for_path(path)
         return self._remote.blob_raw_length(tree_id)
 
     def get_path_history(self, path, limit=None, pre_load=None):
         """
         Returns history of file as reversed list of `GitCommit` objects for
         which file at given `path` has been modified.
         """
 
         path = self._assert_is_path(path)
         hist = self._remote.node_history(self.raw_id, path, limit)
         return [
             self.repository.get_commit(commit_id=commit_id, pre_load=pre_load)
             for commit_id in hist]
 
     def get_file_annotate(self, path, pre_load=None):
         """
         Returns a generator of four element tuples with
             lineno, commit_id, commit lazy loader and line
         """
 
         result = self._remote.node_annotate(self.raw_id, path)
 
         for ln_no, commit_id, content in result:
             yield (
                 ln_no, commit_id,
                 lambda: self.repository.get_commit(commit_id=commit_id, pre_load=pre_load),
                 content)
 
     def get_nodes(self, path, pre_load=None):
 
         if self._get_kind(path) != NodeKind.DIR:
             raise CommitError(
                 f"Directory does not exist for commit {self.raw_id} at '{path}'")
         path = self._fix_path(path)
 
         tree_id, _ = self._get_tree_id_for_path(path)
 
         dirnodes = []
         filenodes = []
 
         # extracted tree ID gives us our files...
         bytes_path = safe_str(path)  # libgit operates on bytes
         for name, stat_, id_, type_ in self._remote.tree_items(tree_id):
             if type_ == 'link':
                 url = self._get_submodule_url('/'.join((bytes_path, name)))
                 dirnodes.append(SubModuleNode(
                     name, url=url, commit=id_, alias=self.repository.alias))
                 continue
 
             if bytes_path != '':
                 obj_path = '/'.join((bytes_path, name))
             else:
                 obj_path = name
             if obj_path not in self._stat_modes:
                 self._stat_modes[obj_path] = stat_
 
             if type_ == 'tree':
                 dirnodes.append(DirNode(safe_bytes(obj_path), commit=self))
             elif type_ == 'blob':
                 filenodes.append(FileNode(safe_bytes(obj_path), commit=self, mode=stat_, pre_load=pre_load))
             else:
                 raise CommitError(f"Requested object should be Tree or Blob, is {type_}")
 
         nodes = dirnodes + filenodes
         for node in nodes:
             if node.path not in self.nodes:
                 self.nodes[node.path] = node
         nodes.sort()
         return nodes
 
     def get_node(self, path, pre_load=None):
         path = self._fix_path(path)
         if path not in self.nodes:
             try:
                 tree_id, type_ = self._get_tree_id_for_path(path)
             except CommitError:
                 raise NodeDoesNotExistError(
                     f"Cannot find one of parents' directories for a given "
                     f"path: {path}")
 
             if type_ in ['link', 'commit']:
                 url = self._get_submodule_url(path)
                 node = SubModuleNode(path, url=url, commit=tree_id,
                                      alias=self.repository.alias)
             elif type_ == 'tree':
                 if path == '':
                     node = RootNode(commit=self)
                 else:
                     node = DirNode(safe_bytes(path), commit=self)
             elif type_ == 'blob':
                 node = FileNode(safe_bytes(path), commit=self, pre_load=pre_load)
                 self._stat_modes[path] = node.mode
             else:
                 raise self.no_node_at_path(path)
 
             # cache node
             self.nodes[path] = node
 
         return self.nodes[path]
 
     def get_largefile_node(self, path):
         tree_id, _ = self._get_tree_id_for_path(path)
         pointer_spec = self._remote.is_large_file(tree_id)
 
         if pointer_spec:
             # content of that file regular FileNode is the hash of largefile
             file_id = pointer_spec.get('oid_hash')
             if self._remote.in_largefiles_store(file_id):
                 lf_path = self._remote.store_path(file_id)
                 return LargeFileNode(safe_bytes(lf_path), commit=self, org_path=path)
 
     @LazyProperty
     def affected_files(self):
         """
         Gets a fast accessible file changes for given commit
         """
         added, modified, deleted = self._changes_cache
         return list(added.union(modified).union(deleted))
 
     @LazyProperty
     def _changes_cache(self):
         added = set()
         modified = set()
         deleted = set()
 
         parents = self.parents
         if not self.parents:
             parents = [base.EmptyCommit()]
         for parent in parents:
             if isinstance(parent, base.EmptyCommit):
                 oid = None
             else:
                 oid = parent.raw_id
             _added, _modified, _deleted = self._remote.tree_changes(oid, self.raw_id)
             added = added | set(_added)
             modified = modified | set(_modified)
             deleted = deleted | set(_deleted)
 
         return added, modified, deleted
 
     def _get_paths_for_status(self, status):
         """
         Returns sorted list of paths for given ``status``.
 
         :param status: one of: *added*, *modified* or *deleted*
         """
         added, modified, deleted = self._changes_cache
         return sorted({
             'added': list(added),
             'modified': list(modified),
             'deleted': list(deleted)}[status]
         )
 
     @LazyProperty
     def added(self):
         """
         Returns list of added ``FileNode`` objects.
         """
         if not self.parents:
             return list(self._get_file_nodes())
         return AddedFileNodesGenerator(self.added_paths, self)
 
     @LazyProperty
     def added_paths(self):
         return [n for n in self._get_paths_for_status('added')]
 
     @LazyProperty
     def changed(self):
         """
         Returns list of modified ``FileNode`` objects.
         """
         if not self.parents:
             return []
         return ChangedFileNodesGenerator(self.changed_paths, self)
 
     @LazyProperty
     def changed_paths(self):
         return [n for n in self._get_paths_for_status('modified')]
 
     @LazyProperty
     def removed(self):
         """
         Returns list of removed ``FileNode`` objects.
         """
         if not self.parents:
             return []
         return RemovedFileNodesGenerator(self.removed_paths, self)
 
     @LazyProperty
     def removed_paths(self):
         return [n for n in self._get_paths_for_status('deleted')]
 
     def _get_submodule_url(self, submodule_path):
         git_modules_path = '.gitmodules'
 
         if self._submodules is None:
             self._submodules = {}
 
             try:
                 submodules_node = self.get_node(git_modules_path)
             except NodeDoesNotExistError:
                 return None
 
             # ConfigParser fails if there are whitespaces, also it needs an iterable
             # file like content
             def iter_content(_content):
-                for line in _content.splitlines():
-                    yield line
+                yield from _content.splitlines()
 
             parser = configparser.RawConfigParser()
             parser.read_file(iter_content(submodules_node.content))
 
             for section in parser.sections():
                 path = parser.get(section, 'path')
                 url = parser.get(section, 'url')
                 if path and url:
                     self._submodules[path.strip('/')] = url
 
         return self._submodules.get(submodule_path.strip('/'))

rhodecode/lib/vcs/backends/git/diff.py

@@ -1,49 +1,47 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 GIT diff module
 """
 
 import re
 
 from rhodecode.lib.vcs.backends import base
 
 
 class GitDiff(base.Diff):
 
     _header_re = re.compile(br"""
         #^diff[ ]--git
             [ ]"?a/(?P<a_path>.+?)"?[ ]"?b/(?P<b_path>.+?)"?\n
         (?:^old[ ]mode[ ](?P<old_mode>\d+)\n
            ^new[ ]mode[ ](?P<new_mode>\d+)(?:\n|$))?
         (?:^similarity[ ]index[ ](?P<similarity_index>\d+)%(?:\n|$))?
         (?:^rename[ ]from[ ](?P<rename_from>[^\r\n]+)\n
            ^rename[ ]to[ ](?P<rename_to>[^\r\n]+)(?:\n|$))?
         (?:^copy[ ]from[ ](?P<copy_from>[^\r\n]+)\n
            ^copy[ ]to[ ](?P<copy_to>[^\r\n]+)(?:\n|$))?
         (?:^new[ ]file[ ]mode[ ](?P<new_file_mode>.+)(?:\n|$))?
         (?:^deleted[ ]file[ ]mode[ ](?P<deleted_file_mode>.+)(?:\n|$))?
         (?:^index[ ](?P<a_blob_id>[0-9A-Fa-f]+)
             \.\.(?P<b_blob_id>[0-9A-Fa-f]+)[ ]?(?P<b_mode>.+)?(?:\n|$))?
         (?:^(?P<bin_patch>GIT[ ]binary[ ]patch)(?:\n|$))?
         (?:^---[ ]("?a/(?P<a_file>.+)|/dev/null)(?:\n|$))?
         (?:^\+\+\+[ ]("?b/(?P<b_file>.+)|/dev/null)(?:\n|$))?
     """, re.VERBOSE | re.MULTILINE)

rhodecode/lib/vcs/backends/git/inmemory.py

@@ -1,107 +1,105 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 GIT inmemory module
 """
 
 from rhodecode.lib.datelib import date_to_timestamp_plus_offset
 from rhodecode.lib.str_utils import safe_str, get_default_encodings
 from rhodecode.lib.vcs.backends import base
 
 
 class GitInMemoryCommit(base.BaseInMemoryCommit):
 
     def commit(self, message, author, parents=None, branch=None, date=None, **kwargs):
         """
         Performs in-memory commit (doesn't check workdir in any way) and
         returns newly created `GitCommit`. Updates repository's
         `commit_ids`.
 
         :param message: message of the commit
         :param author: full username, i.e. "Joe Doe <[e-mail]>"
         :param parents: single parent or sequence of parents from which commit
           would be derived
         :param date: `datetime.datetime` instance. Defaults to
           ``datetime.datetime.now()``.
         :param branch: branch name, as string. If none given, default backend's
           branch would be used.
 
         :raises `CommitError`: if any error occurs while committing
         """
         self.check_integrity(parents)
         if branch is None:
             branch = self.repository.DEFAULT_BRANCH_NAME
 
         commit_tree = None
         if self.parents[0]:
             commit_tree = self.parents[0]._commit['tree']
 
         encoding = get_default_encodings()[0]
         updated = []
         for node in self.added + self.changed:
             content = node.content
             # TODO: left for reference pre py3 migration, probably need to be removed
             # if node.is_binary:
             #     content = node.content
             # else:
             #     content = node.content.encode(ENCODING)
 
             updated.append({
                 'path': node.path,
                 'node_path': node.name,
                 'content': content,
                 'mode': node.mode,
             })
 
         removed = [node.path for node in self.removed]
 
         date, tz = date_to_timestamp_plus_offset(date)
 
         author_time = kwargs.pop('author_time', date)
         author_tz = kwargs.pop('author_timezone', tz)
 
         commit_data = {
             'parents': [p._commit['id'] for p in self.parents if p],
             'author': safe_str(author),
             'committer': safe_str(author),
             'encoding': encoding,
             'message': safe_str(message),
 
             'commit_time': int(date),
             'commit_timezone': tz,
 
             'author_time': int(author_time),
             'author_timezone': author_tz,
         }
 
         commit_id = self.repository._remote.commit(
             commit_data, branch, commit_tree, updated, removed)
 
         # Update vcs repository object
         self.repository.append_commit_id(commit_id)
 
         # invalidate parsed refs after commit
         self.repository._refs = self.repository._get_refs()
         self.repository.branches = self.repository._get_branches()
         tip = self.repository.get_commit(commit_id)
 
         self.reset()
         return tip

rhodecode/lib/vcs/backends/git/repository.py

@@ -1,1055 +1,1053 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 GIT repository module
 """
 
 import logging
 import os
 import re
 
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from collections import OrderedDict
 from rhodecode.lib.datelib import (
     utcdate_fromtimestamp, makedate, date_astimestamp)
 from rhodecode.lib.hash_utils import safe_str
 from rhodecode.lib.utils2 import CachedProperty
 from rhodecode.lib.vcs import connection, path as vcspath
 from rhodecode.lib.vcs.backends.base import (
     BaseRepository, CollectionGenerator, Config, MergeResponse,
     MergeFailureReason, Reference)
 from rhodecode.lib.vcs.backends.git.commit import GitCommit
 from rhodecode.lib.vcs.backends.git.diff import GitDiff
 from rhodecode.lib.vcs.backends.git.inmemory import GitInMemoryCommit
 from rhodecode.lib.vcs.exceptions import (
     CommitDoesNotExistError, EmptyRepositoryError,
     RepositoryError, TagAlreadyExistError, TagDoesNotExistError, VCSError, UnresolvedFilesInRepo)
 
 
 SHA_PATTERN = re.compile(r'^([0-9a-fA-F]{12}|[0-9a-fA-F]{40})$')
 
 log = logging.getLogger(__name__)
 
 
 class GitRepository(BaseRepository):
     """
     Git repository backend.
     """
     DEFAULT_BRANCH_NAME = os.environ.get('GIT_DEFAULT_BRANCH_NAME') or 'master'
-    DEFAULT_REF = 'branch:{}'.format(DEFAULT_BRANCH_NAME)
+    DEFAULT_REF = f'branch:{DEFAULT_BRANCH_NAME}'
 
     contact = BaseRepository.DEFAULT_CONTACT
 
     def __init__(self, repo_path, config=None, create=False, src_url=None,
                  do_workspace_checkout=False, with_wire=None, bare=False):
 
         self.path = safe_str(os.path.abspath(repo_path))
         self.config = config if config else self.get_default_config()
         self.with_wire = with_wire or {"cache": False}  # default should not use cache
 
         self._init_repo(create, src_url, do_workspace_checkout, bare)
 
         # caches
         self._commit_ids = {}
 
     @LazyProperty
     def _remote(self):
         repo_id = self.path
         return connection.Git(self.path, repo_id, self.config, with_wire=self.with_wire)
 
     @LazyProperty
     def bare(self):
         return self._remote.bare()
 
     @LazyProperty
     def head(self):
         return self._remote.head()
 
     @CachedProperty
     def commit_ids(self):
         """
         Returns list of commit ids, in ascending order.  Being lazy
         attribute allows external tools to inject commit ids from cache.
         """
         commit_ids = self._get_all_commit_ids()
         self._rebuild_cache(commit_ids)
         return commit_ids
 
     def _rebuild_cache(self, commit_ids):
-        self._commit_ids = dict((commit_id, index)
-                                for index, commit_id in enumerate(commit_ids))
+        self._commit_ids = {commit_id: index
+                                for index, commit_id in enumerate(commit_ids)}
 
     def run_git_command(self, cmd, **opts):
         """
         Runs given ``cmd`` as git command and returns tuple
         (stdout, stderr).
 
         :param cmd: git command to be executed
         :param opts: env options to pass into Subprocess command
         """
         if not isinstance(cmd, list):
             raise ValueError(f'cmd must be a list, got {type(cmd)} instead')
 
         skip_stderr_log = opts.pop('skip_stderr_log', False)
         out, err = self._remote.run_git_command(cmd, **opts)
         if err and not skip_stderr_log:
             log.debug('Stderr output of git command "%s":\n%s', cmd, err)
         return out, err
 
     @staticmethod
     def check_url(url, config):
         """
         Function will check given url and try to verify if it's a valid
         link. Sometimes it may happened that git will issue basic
         auth request that can cause whole API to hang when used from python
         or other external calls.
 
         On failures it'll raise urllib2.HTTPError, exception is also thrown
         when the return code is non 200
         """
         # check first if it's not an url
         if os.path.isdir(url) or url.startswith('file:'):
             return True
 
         if '+' in url.split('://', 1)[0]:
             url = url.split('+', 1)[1]
 
         # Request the _remote to verify the url
         return connection.Git.check_url(url, config.serialize())
 
     @staticmethod
     def is_valid_repository(path):
         if os.path.isdir(os.path.join(path, '.git')):
             return True
         # check case of bare repository
         try:
             GitRepository(path)
             return True
         except VCSError:
             pass
         return False
 
     def _init_repo(self, create, src_url=None, do_workspace_checkout=False,
                    bare=False):
         if create and os.path.exists(self.path):
             raise RepositoryError(
                 "Cannot create repository at %s, location already exist"
                 % self.path)
 
         if bare and do_workspace_checkout:
             raise RepositoryError("Cannot update a bare repository")
         try:
 
             if src_url:
                 # check URL before any actions
                 GitRepository.check_url(src_url, self.config)
 
             if create:
                 os.makedirs(self.path, mode=0o755)
 
                 if bare:
                     self._remote.init_bare()
                 else:
                     self._remote.init()
 
                 if src_url and bare:
                     # bare repository only allows a fetch and checkout is not allowed
                     self.fetch(src_url, commit_ids=None)
                 elif src_url:
                     self.pull(src_url, commit_ids=None,
                               update_after=do_workspace_checkout)
 
             else:
                 if not self._remote.assert_correct_path():
                     raise RepositoryError(
                         'Path "%s" does not contain a Git repository' %
                         (self.path,))
 
         # TODO: johbo: check if we have to translate the OSError here
         except OSError as err:
             raise RepositoryError(err)
 
     def _get_all_commit_ids(self):
         return self._remote.get_all_commit_ids()
 
     def _get_commit_ids(self, filters=None):
         # we must check if this repo is not empty, since later command
         # fails if it is. And it's cheaper to ask than throw the subprocess
         # errors
 
         head = self._remote.head(show_exc=False)
 
         if not head:
             return []
 
         rev_filter = ['--branches', '--tags']
         extra_filter = []
 
         if filters:
             if filters.get('since'):
                 extra_filter.append('--since=%s' % (filters['since']))
             if filters.get('until'):
                 extra_filter.append('--until=%s' % (filters['until']))
             if filters.get('branch_name'):
                 rev_filter = []
                 extra_filter.append(filters['branch_name'])
         rev_filter.extend(extra_filter)
 
             # if filters.get('start') or filters.get('end'):
             #     # skip is offset, max-count is limit
             #     if filters.get('start'):
             #         extra_filter += ' --skip=%s' % filters['start']
             #     if filters.get('end'):
             #         extra_filter += ' --max-count=%s' % (filters['end'] - (filters['start'] or 0))
 
         cmd = ['rev-list', '--reverse', '--date-order'] + rev_filter
         try:
             output, __ = self.run_git_command(cmd)
         except RepositoryError:
             # Can be raised for empty repositories
             return []
         return output.splitlines()
 
     def _lookup_commit(self, commit_id_or_idx, translate_tag=True, maybe_unreachable=False, reference_obj=None):
 
         def is_null(value):
             return len(value) == commit_id_or_idx.count('0')
 
         if commit_id_or_idx in (None, '', 'tip', 'HEAD', 'head', -1):
             return self.commit_ids[-1]
 
         commit_missing_err = "Commit {} does not exist for `{}`".format(
             *map(safe_str, [commit_id_or_idx, self.name]))
 
         is_bstr = isinstance(commit_id_or_idx, str)
         is_branch = reference_obj and reference_obj.branch
 
         lookup_ok = False
         if is_bstr:
             # Need to call remote to translate id for tagging scenarios,
             # or branch that are numeric
             try:
                 remote_data = self._remote.get_object(commit_id_or_idx,
                                                       maybe_unreachable=maybe_unreachable)
                 commit_id_or_idx = remote_data["commit_id"]
                 lookup_ok = True
             except (CommitDoesNotExistError,):
                 lookup_ok = False
 
         if lookup_ok is False:
             is_numeric_idx = \
                 (is_bstr and commit_id_or_idx.isdigit() and len(commit_id_or_idx) < 12) \
                 or isinstance(commit_id_or_idx, int)
             if not is_branch and (is_numeric_idx or is_null(commit_id_or_idx)):
                 try:
                     commit_id_or_idx = self.commit_ids[int(commit_id_or_idx)]
                     lookup_ok = True
                 except Exception:
                     raise CommitDoesNotExistError(commit_missing_err)
 
         # we failed regular lookup, and by integer number lookup
         if lookup_ok is False:
             raise CommitDoesNotExistError(commit_missing_err)
 
         # Ensure we return full id
         if not SHA_PATTERN.match(str(commit_id_or_idx)):
             raise CommitDoesNotExistError(
                 "Given commit id %s not recognized" % commit_id_or_idx)
         return commit_id_or_idx
 
     def get_hook_location(self):
         """
         returns absolute path to location where hooks are stored
         """
         loc = os.path.join(self.path, 'hooks')
         if not self.bare:
             loc = os.path.join(self.path, '.git', 'hooks')
         return loc
 
     @LazyProperty
     def last_change(self):
         """
         Returns last change made on this repository as
         `datetime.datetime` object.
         """
         try:
             return self.get_commit().date
         except RepositoryError:
             tzoffset = makedate()[1]
             return utcdate_fromtimestamp(self._get_fs_mtime(), tzoffset)
 
     def _get_fs_mtime(self):
         idx_loc = '' if self.bare else '.git'
         # fallback to filesystem
         in_path = os.path.join(self.path, idx_loc, "index")
         he_path = os.path.join(self.path, idx_loc, "HEAD")
         if os.path.exists(in_path):
             return os.stat(in_path).st_mtime
         else:
             return os.stat(he_path).st_mtime
 
     @LazyProperty
     def description(self):
         description = self._remote.get_description()
         return safe_str(description or self.DEFAULT_DESCRIPTION)
 
     def _get_refs_entries(self, prefix='', reverse=False, strip_prefix=True):
         if self.is_empty():
             return OrderedDict()
 
         result = []
         for ref, sha in self._refs.items():
             if ref.startswith(prefix):
                 ref_name = ref
                 if strip_prefix:
                     ref_name = ref[len(prefix):]
                 result.append((safe_str(ref_name), sha))
 
         def get_name(entry):
             return entry[0]
 
         return OrderedDict(sorted(result, key=get_name, reverse=reverse))
 
     def _get_branches(self):
         return self._get_refs_entries(prefix='refs/heads/', strip_prefix=True)
 
     @CachedProperty
     def branches(self):
         return self._get_branches()
 
     @CachedProperty
     def branches_closed(self):
         return {}
 
     @CachedProperty
     def bookmarks(self):
         return {}
 
     @CachedProperty
     def branches_all(self):
         all_branches = {}
         all_branches.update(self.branches)
         all_branches.update(self.branches_closed)
         return all_branches
 
     @CachedProperty
     def tags(self):
         return self._get_tags()
 
     def _get_tags(self):
         return self._get_refs_entries(prefix='refs/tags/', strip_prefix=True, reverse=True)
 
     def tag(self, name, user, commit_id=None, message=None, date=None,
             **kwargs):
         # TODO: fix this method to apply annotated tags correct with message
         """
         Creates and returns a tag for the given ``commit_id``.
 
         :param name: name for new tag
         :param user: full username, i.e.: "Joe Doe <[e-mail]>"
         :param commit_id: commit id for which new tag would be created
         :param message: message of the tag's commit
         :param date: date of tag's commit
 
         :raises TagAlreadyExistError: if tag with same name already exists
         """
         if name in self.tags:
             raise TagAlreadyExistError("Tag %s already exists" % name)
         commit = self.get_commit(commit_id=commit_id)
-        message = message or "Added tag %s for commit %s" % (name, commit.raw_id)
+        message = message or "Added tag {} for commit {}".format(name, commit.raw_id)
 
         self._remote.set_refs('refs/tags/%s' % name, commit.raw_id)
 
         self._invalidate_prop_cache('tags')
         self._invalidate_prop_cache('_refs')
 
         return commit
 
     def remove_tag(self, name, user, message=None, date=None):
         """
         Removes tag with the given ``name``.
 
         :param name: name of the tag to be removed
         :param user: full username, i.e.: "Joe Doe <[e-mail]>"
         :param message: message of the tag's removal commit
         :param date: date of tag's removal commit
 
         :raises TagDoesNotExistError: if tag with given name does not exists
         """
         if name not in self.tags:
             raise TagDoesNotExistError("Tag %s does not exist" % name)
 
         self._remote.tag_remove(name)
         self._invalidate_prop_cache('tags')
         self._invalidate_prop_cache('_refs')
 
     def _get_refs(self):
         return self._remote.get_refs()
 
     @CachedProperty
     def _refs(self):
         return self._get_refs()
 
     @property
     def _ref_tree(self):
         node = tree = {}
         for ref, sha in self._refs.items():
             path = ref.split('/')
             for bit in path[:-1]:
                 node = node.setdefault(bit, {})
             node[path[-1]] = sha
             node = tree
         return tree
 
     def get_remote_ref(self, ref_name):
-        ref_key = 'refs/remotes/origin/{}'.format(safe_str(ref_name))
+        ref_key = f'refs/remotes/origin/{safe_str(ref_name)}'
         try:
             return self._refs[ref_key]
         except Exception:
             return
 
     def get_commit(self, commit_id=None, commit_idx=None, pre_load=None,
                    translate_tag=True, maybe_unreachable=False, reference_obj=None):
         """
         Returns `GitCommit` object representing commit from git repository
         at the given `commit_id` or head (most recent commit) if None given.
         """
 
         if self.is_empty():
             raise EmptyRepositoryError("There are no commits yet")
 
         if commit_id is not None:
             self._validate_commit_id(commit_id)
             try:
                 # we have cached idx, use it without contacting the remote
                 idx = self._commit_ids[commit_id]
                 return GitCommit(self, commit_id, idx, pre_load=pre_load)
             except KeyError:
                 pass
 
         elif commit_idx is not None:
             self._validate_commit_idx(commit_idx)
             try:
                 _commit_id = self.commit_ids[commit_idx]
                 if commit_idx < 0:
                     commit_idx = self.commit_ids.index(_commit_id)
                 return GitCommit(self, _commit_id, commit_idx, pre_load=pre_load)
             except IndexError:
                 commit_id = commit_idx
         else:
             commit_id = "tip"
 
         if translate_tag:
             commit_id = self._lookup_commit(
                 commit_id, maybe_unreachable=maybe_unreachable,
                 reference_obj=reference_obj)
 
         try:
             idx = self._commit_ids[commit_id]
         except KeyError:
             idx = -1
 
         return GitCommit(self, commit_id, idx, pre_load=pre_load)
 
     def get_commits(
             self, start_id=None, end_id=None, start_date=None, end_date=None,
             branch_name=None, show_hidden=False, pre_load=None, translate_tags=True):
         """
         Returns generator of `GitCommit` objects from start to end (both
         are inclusive), in ascending date order.
 
         :param start_id: None, str(commit_id)
         :param end_id: None, str(commit_id)
         :param start_date: if specified, commits with commit date less than
           ``start_date`` would be filtered out from returned set
         :param end_date: if specified, commits with commit date greater than
           ``end_date`` would be filtered out from returned set
         :param branch_name: if specified, commits not reachable from given
           branch would be filtered out from returned set
         :param show_hidden: Show hidden commits such as obsolete or hidden from
             Mercurial evolve
         :raise BranchDoesNotExistError: If given `branch_name` does not
             exist.
         :raise CommitDoesNotExistError: If commits for given `start` or
           `end` could not be found.
 
         """
         if self.is_empty():
             raise EmptyRepositoryError("There are no commits yet")
 
         self._validate_branch_name(branch_name)
 
         if start_id is not None:
             self._validate_commit_id(start_id)
         if end_id is not None:
             self._validate_commit_id(end_id)
 
         start_raw_id = self._lookup_commit(start_id)
         start_pos = self._commit_ids[start_raw_id] if start_id else None
         end_raw_id = self._lookup_commit(end_id)
         end_pos = max(0, self._commit_ids[end_raw_id]) if end_id else None
 
         if None not in [start_id, end_id] and start_pos > end_pos:
             raise RepositoryError(
                 "Start commit '%s' cannot be after end commit '%s'" %
                 (start_id, end_id))
 
         if end_pos is not None:
             end_pos += 1
 
         filter_ = []
         if branch_name:
             filter_.append({'branch_name': branch_name})
         if start_date and not end_date:
             filter_.append({'since': start_date})
         if end_date and not start_date:
             filter_.append({'until': end_date})
         if start_date and end_date:
             filter_.append({'since': start_date})
             filter_.append({'until': end_date})
 
         # if start_pos or end_pos:
         #     filter_.append({'start': start_pos})
         #     filter_.append({'end': end_pos})
 
         if filter_:
             revfilters = {
                 'branch_name': branch_name,
                 'since': start_date.strftime('%m/%d/%y %H:%M:%S') if start_date else None,
                 'until': end_date.strftime('%m/%d/%y %H:%M:%S') if end_date else None,
                 'start': start_pos,
                 'end': end_pos,
             }
             commit_ids = self._get_commit_ids(filters=revfilters)
 
         else:
             commit_ids = self.commit_ids
 
         if start_pos or end_pos:
             commit_ids = commit_ids[start_pos: end_pos]
 
         return CollectionGenerator(self, commit_ids, pre_load=pre_load,
                                    translate_tag=translate_tags)
 
     def get_diff(
             self, commit1, commit2, path='', ignore_whitespace=False,
             context=3, path1=None):
         """
         Returns (git like) *diff*, as plain text. Shows changes introduced by
         ``commit2`` since ``commit1``.
 
         :param commit1: Entry point from which diff is shown. Can be
           ``self.EMPTY_COMMIT`` - in this case, patch showing all
           the changes since empty state of the repository until ``commit2``
         :param commit2: Until which commits changes should be shown.
         :param path:
         :param ignore_whitespace: If set to ``True``, would not show whitespace
           changes. Defaults to ``False``.
         :param context: How many lines before/after changed lines should be
           shown. Defaults to ``3``.
         :param path1:
         """
         self._validate_diff_commits(commit1, commit2)
         if path1 is not None and path1 != path:
             raise ValueError("Diff of two different paths not supported.")
 
         if path:
             file_filter = path
         else:
             file_filter = None
 
         diff = self._remote.diff(
             commit1.raw_id, commit2.raw_id, file_filter=file_filter,
             opt_ignorews=ignore_whitespace,
             context=context)
 
         return GitDiff(diff)
 
     def strip(self, commit_id, branch_name):
         commit = self.get_commit(commit_id=commit_id)
         if commit.merge:
             raise Exception('Cannot reset to merge commit')
 
         # parent is going to be the new head now
         commit = commit.parents[0]
         self._remote.set_refs('refs/heads/%s' % branch_name, commit.raw_id)
 
         # clear cached properties
         self._invalidate_prop_cache('commit_ids')
         self._invalidate_prop_cache('_refs')
         self._invalidate_prop_cache('branches')
 
         return len(self.commit_ids)
 
     def get_common_ancestor(self, commit_id1, commit_id2, repo2):
         log.debug('Calculating common ancestor between %sc1:%s and %sc2:%s',
                   self, commit_id1, repo2, commit_id2)
 
         if commit_id1 == commit_id2:
             return commit_id1
 
         if self != repo2:
             commits = self._remote.get_missing_revs(
                 commit_id1, commit_id2, repo2.path)
             if commits:
                 commit = repo2.get_commit(commits[-1])
                 if commit.parents:
                     ancestor_id = commit.parents[0].raw_id
                 else:
                     ancestor_id = None
             else:
                 # no commits from other repo, ancestor_id is the commit_id2
                 ancestor_id = commit_id2
         else:
             output, __ = self.run_git_command(
                 ['merge-base', commit_id1, commit_id2])
             ancestor_id = self.COMMIT_ID_PAT.findall(output)[0]
 
         log.debug('Found common ancestor with sha: %s', ancestor_id)
 
         return ancestor_id
 
     def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None):
         repo1 = self
         ancestor_id = None
 
         if commit_id1 == commit_id2:
             commits = []
         elif repo1 != repo2:
             missing_ids = self._remote.get_missing_revs(commit_id1, commit_id2,
                                                         repo2.path)
             commits = [
                 repo2.get_commit(commit_id=commit_id, pre_load=pre_load)
                 for commit_id in reversed(missing_ids)]
         else:
             output, __ = repo1.run_git_command(
                 ['log', '--reverse', '--pretty=format: %H', '-s',
-                 '%s..%s' % (commit_id1, commit_id2)])
+                 '{}..{}'.format(commit_id1, commit_id2)])
             commits = [
                 repo1.get_commit(commit_id=commit_id, pre_load=pre_load)
                 for commit_id in self.COMMIT_ID_PAT.findall(output)]
 
         return commits
 
     @LazyProperty
     def in_memory_commit(self):
         """
         Returns ``GitInMemoryCommit`` object for this repository.
         """
         return GitInMemoryCommit(self)
 
     def pull(self, url, commit_ids=None, update_after=False):
         """
         Pull changes from external location. Pull is different in GIT
         that fetch since it's doing a checkout
 
         :param commit_ids: Optional. Can be set to a list of commit ids
            which shall be pulled from the other repository.
         """
         refs = None
         if commit_ids is not None:
             remote_refs = self._remote.get_remote_refs(url)
             refs = [ref for ref in remote_refs if remote_refs[ref] in commit_ids]
         self._remote.pull(url, refs=refs, update_after=update_after)
         self._remote.invalidate_vcs_cache()
 
     def fetch(self, url, commit_ids=None):
         """
         Fetch all git objects from external location.
         """
         self._remote.sync_fetch(url, refs=commit_ids)
         self._remote.invalidate_vcs_cache()
 
     def push(self, url):
         refs = None
         self._remote.sync_push(url, refs=refs)
 
     def set_refs(self, ref_name, commit_id):
         self._remote.set_refs(ref_name, commit_id)
         self._invalidate_prop_cache('_refs')
 
     def remove_ref(self, ref_name):
         self._remote.remove_ref(ref_name)
         self._invalidate_prop_cache('_refs')
 
     def run_gc(self, prune=True):
         cmd = ['gc', '--aggressive']
         if prune:
             cmd += ['--prune=now']
         _stdout, stderr = self.run_git_command(cmd, fail_on_stderr=False)
         return stderr
 
     def _update_server_info(self):
         """
         runs gits update-server-info command in this repo instance
         """
         self._remote.update_server_info()
 
     def _current_branch(self):
         """
         Return the name of the current branch.
 
         It only works for non bare repositories (i.e. repositories with a
         working copy)
         """
         if self.bare:
             raise RepositoryError('Bare git repos do not have active branches')
 
         if self.is_empty():
             return None
 
         stdout, _ = self.run_git_command(['rev-parse', '--abbrev-ref', 'HEAD'])
         return stdout.strip()
 
     def _checkout(self, branch_name, create=False, force=False):
         """
         Checkout a branch in the working directory.
 
         It tries to create the branch if create is True, failing if the branch
         already exists.
 
         It only works for non bare repositories (i.e. repositories with a
         working copy)
         """
         if self.bare:
             raise RepositoryError('Cannot checkout branches in a bare git repo')
 
         cmd = ['checkout']
         if force:
             cmd.append('-f')
         if create:
             cmd.append('-b')
         cmd.append(branch_name)
         self.run_git_command(cmd, fail_on_stderr=False)
 
     def _create_branch(self, branch_name, commit_id):
         """
         creates a branch in a GIT repo
         """
         self._remote.create_branch(branch_name, commit_id)
 
     def _identify(self):
         """
         Return the current state of the working directory.
         """
         if self.bare:
             raise RepositoryError('Bare git repos do not have active branches')
 
         if self.is_empty():
             return None
 
         stdout, _ = self.run_git_command(['rev-parse', 'HEAD'])
         return stdout.strip()
 
     def _local_clone(self, clone_path, branch_name, source_branch=None):
         """
         Create a local clone of the current repo.
         """
         # N.B.(skreft): the --branch option is required as otherwise the shallow
         # clone will only fetch the active branch.
         cmd = ['clone', '--branch', branch_name,
                self.path, os.path.abspath(clone_path)]
 
         self.run_git_command(cmd, fail_on_stderr=False)
 
         # if we get the different source branch, make sure we also fetch it for
         # merge conditions
         if source_branch and source_branch != branch_name:
             # check if the ref exists.
             shadow_repo = GitRepository(os.path.abspath(clone_path))
             if shadow_repo.get_remote_ref(source_branch):
                 cmd = ['fetch', self.path, source_branch]
                 self.run_git_command(cmd, fail_on_stderr=False)
 
     def _local_fetch(self, repository_path, branch_name, use_origin=False):
         """
         Fetch a branch from a local repository.
         """
         repository_path = os.path.abspath(repository_path)
         if repository_path == self.path:
             raise ValueError('Cannot fetch from the same repository')
 
         if use_origin:
             branch_name = '+{branch}:refs/heads/{branch}'.format(
                 branch=branch_name)
 
         cmd = ['fetch', '--no-tags', '--update-head-ok',
                repository_path, branch_name]
         self.run_git_command(cmd, fail_on_stderr=False)
 
     def _local_reset(self, branch_name):
-        branch_name = '{}'.format(branch_name)
+        branch_name = f'{branch_name}'
         cmd = ['reset', '--hard', branch_name, '--']
         self.run_git_command(cmd, fail_on_stderr=False)
 
     def _last_fetch_heads(self):
         """
         Return the last fetched heads that need merging.
 
         The algorithm is defined at
         https://github.com/git/git/blob/v2.1.3/git-pull.sh#L283
         """
         if not self.bare:
             fetch_heads_path = os.path.join(self.path, '.git', 'FETCH_HEAD')
         else:
             fetch_heads_path = os.path.join(self.path, 'FETCH_HEAD')
 
         heads = []
         with open(fetch_heads_path) as f:
             for line in f:
                 if '    not-for-merge   ' in line:
                     continue
                 line = re.sub('\t.*', '', line, flags=re.DOTALL)
                 heads.append(line)
 
         return heads
 
     def get_shadow_instance(self, shadow_repository_path, enable_hooks=False, cache=False):
         return GitRepository(shadow_repository_path, with_wire={"cache": cache})
 
     def _local_pull(self, repository_path, branch_name, ff_only=True):
         """
         Pull a branch from a local repository.
         """
         if self.bare:
             raise RepositoryError('Cannot pull into a bare git repository')
         # N.B.(skreft): The --ff-only option is to make sure this is a
         # fast-forward (i.e., we are only pulling new changes and there are no
         # conflicts with our current branch)
         # Additionally, that option needs to go before --no-tags, otherwise git
         # pull complains about it being an unknown flag.
         cmd = ['pull']
         if ff_only:
             cmd.append('--ff-only')
         cmd.extend(['--no-tags', repository_path, branch_name])
         self.run_git_command(cmd, fail_on_stderr=False)
 
     def _local_merge(self, merge_message, user_name, user_email, heads):
         """
         Merge the given head into the checked out branch.
 
         It will force a merge commit.
 
         Currently it raises an error if the repo is empty, as it is not possible
         to create a merge commit in an empty repo.
 
         :param merge_message: The message to use for the merge commit.
         :param heads: the heads to merge.
         """
         if self.bare:
             raise RepositoryError('Cannot merge into a bare git repository')
 
         if not heads:
             return
 
         if self.is_empty():
             # TODO(skreft): do something more robust in this case.
             raise RepositoryError('Do not know how to merge into empty repositories yet')
         unresolved = None
 
         # N.B.(skreft): the --no-ff option is used to enforce the creation of a
         # commit message. We also specify the user who is doing the merge.
         cmd = ['-c', f'user.name="{user_name}"',
                '-c', f'user.email={user_email}',
                'merge', '--no-ff', '-m', safe_str(merge_message)]
 
         merge_cmd = cmd + heads
 
         try:
             self.run_git_command(merge_cmd, fail_on_stderr=False)
         except RepositoryError:
             files = self.run_git_command(['diff', '--name-only', '--diff-filter', 'U'],
                                          fail_on_stderr=False)[0].splitlines()
             # NOTE(marcink): we add U notation for consistent with HG backend output
-            unresolved = ['U {}'.format(f) for f in files]
+            unresolved = [f'U {f}' for f in files]
 
             # Cleanup any merge leftovers
             self._remote.invalidate_vcs_cache()
             self.run_git_command(['merge', '--abort'], fail_on_stderr=False)
 
             if unresolved:
                 raise UnresolvedFilesInRepo(unresolved)
             else:
                 raise
 
     def _local_push(
             self, source_branch, repository_path, target_branch,
             enable_hooks=False, rc_scm_data=None):
         """
         Push the source_branch to the given repository and target_branch.
 
         Currently it if the target_branch is not master and the target repo is
         empty, the push will work, but then GitRepository won't be able to find
         the pushed branch or the commits. As the HEAD will be corrupted (i.e.,
         pointing to master, which does not exist).
 
         It does not run the hooks in the target repo.
         """
         # TODO(skreft): deal with the case in which the target repo is empty,
         # and the target_branch is not master.
         target_repo = GitRepository(repository_path)
         if (not target_repo.bare and
                 target_repo._current_branch() == target_branch):
             # Git prevents pushing to the checked out branch, so simulate it by
             # pulling into the target repository.
             target_repo._local_pull(self.path, source_branch)
         else:
             cmd = ['push', os.path.abspath(repository_path),
-                   '%s:%s' % (source_branch, target_branch)]
+                   '{}:{}'.format(source_branch, target_branch)]
             gitenv = {}
             if rc_scm_data:
                 gitenv.update({'RC_SCM_DATA': rc_scm_data})
 
             if not enable_hooks:
                 gitenv['RC_SKIP_HOOKS'] = '1'
             self.run_git_command(cmd, fail_on_stderr=False, extra_env=gitenv)
 
     def _get_new_pr_branch(self, source_branch, target_branch):
-        prefix = 'pr_%s-%s_' % (source_branch, target_branch)
+        prefix = 'pr_{}-{}_'.format(source_branch, target_branch)
         pr_branches = []
         for branch in self.branches:
             if branch.startswith(prefix):
                 pr_branches.append(int(branch[len(prefix):]))
 
         if not pr_branches:
             branch_id = 0
         else:
             branch_id = max(pr_branches) + 1
 
         return '%s%d' % (prefix, branch_id)
 
     def _maybe_prepare_merge_workspace(
             self, repo_id, workspace_id, target_ref, source_ref):
         shadow_repository_path = self._get_shadow_repository_path(
             self.path, repo_id, workspace_id)
         if not os.path.exists(shadow_repository_path):
             self._local_clone(
                 shadow_repository_path, target_ref.name, source_ref.name)
             log.debug('Prepared %s shadow repository in %s',
                       self.alias, shadow_repository_path)
 
         return shadow_repository_path
 
     def _merge_repo(self, repo_id, workspace_id, target_ref,
                     source_repo, source_ref, merge_message,
                     merger_name, merger_email, dry_run=False,
                     use_rebase=False, close_branch=False):
 
         log.debug('Executing merge_repo with %s strategy, dry_run mode:%s',
                   'rebase' if use_rebase else 'merge', dry_run)
         if target_ref.commit_id != self.branches[target_ref.name]:
             log.warning('Target ref %s commit mismatch %s vs %s', target_ref,
                         target_ref.commit_id, self.branches[target_ref.name])
             return MergeResponse(
                 False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD,
                 metadata={'target_ref': target_ref})
 
         shadow_repository_path = self._maybe_prepare_merge_workspace(
             repo_id, workspace_id, target_ref, source_ref)
         shadow_repo = self.get_shadow_instance(shadow_repository_path)
 
         # checkout source, if it's different. Otherwise we could not
         # fetch proper commits for merge testing
         if source_ref.name != target_ref.name:
             if shadow_repo.get_remote_ref(source_ref.name):
                 shadow_repo._checkout(source_ref.name, force=True)
 
         # checkout target, and fetch changes
         shadow_repo._checkout(target_ref.name, force=True)
 
         # fetch/reset pull the target, in case it is changed
         # this handles even force changes
         shadow_repo._local_fetch(self.path, target_ref.name, use_origin=True)
         shadow_repo._local_reset(target_ref.name)
 
         # Need to reload repo to invalidate the cache, or otherwise we cannot
         # retrieve the last target commit.
         shadow_repo = self.get_shadow_instance(shadow_repository_path)
         if target_ref.commit_id != shadow_repo.branches[target_ref.name]:
             log.warning('Shadow Target ref %s commit mismatch %s vs %s',
                         target_ref, target_ref.commit_id,
                         shadow_repo.branches[target_ref.name])
             return MergeResponse(
                 False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD,
                 metadata={'target_ref': target_ref})
 
         # calculate new branch
         pr_branch = shadow_repo._get_new_pr_branch(
             source_ref.name, target_ref.name)
         log.debug('using pull-request merge branch: `%s`', pr_branch)
         # checkout to temp branch, and fetch changes
         shadow_repo._checkout(pr_branch, create=True)
         try:
             shadow_repo._local_fetch(source_repo.path, source_ref.name)
         except RepositoryError:
             log.exception('Failure when doing local fetch on '
                           'shadow repo: %s', shadow_repo)
             return MergeResponse(
                 False, False, None, MergeFailureReason.MISSING_SOURCE_REF,
                 metadata={'source_ref': source_ref})
 
         merge_ref = None
         merge_failure_reason = MergeFailureReason.NONE
         metadata = {}
         try:
             shadow_repo._local_merge(merge_message, merger_name, merger_email,
                                      [source_ref.commit_id])
             merge_possible = True
 
             # Need to invalidate the cache, or otherwise we
             # cannot retrieve the merge commit.
             shadow_repo = shadow_repo.get_shadow_instance(shadow_repository_path)
             merge_commit_id = shadow_repo.branches[pr_branch]
 
             # Set a reference pointing to the merge commit. This reference may
             # be used to easily identify the last successful merge commit in
             # the shadow repository.
             shadow_repo.set_refs('refs/heads/pr-merge', merge_commit_id)
             merge_ref = Reference('branch', 'pr-merge', merge_commit_id)
         except RepositoryError as e:
             log.exception('Failure when doing local merge on git shadow repo')
             if isinstance(e, UnresolvedFilesInRepo):
                 metadata['unresolved_files'] = '\n* conflict: ' + ('\n * conflict: '.join(e.args[0]))
 
             merge_possible = False
             merge_failure_reason = MergeFailureReason.MERGE_FAILED
 
         if merge_possible and not dry_run:
             try:
                 shadow_repo._local_push(
                     pr_branch, self.path, target_ref.name, enable_hooks=True,
                     rc_scm_data=self.config.get('rhodecode', 'RC_SCM_DATA'))
                 merge_succeeded = True
             except RepositoryError:
                 log.exception(
                     'Failure when doing local push from the shadow '
                     'repository to the target repository at %s.', self.path)
                 merge_succeeded = False
                 merge_failure_reason = MergeFailureReason.PUSH_FAILED
                 metadata['target'] = 'git shadow repo'
                 metadata['merge_commit'] = pr_branch
         else:
             merge_succeeded = False
 
         return MergeResponse(
             merge_possible, merge_succeeded, merge_ref, merge_failure_reason,
             metadata=metadata)

rhodecode/lib/vcs/backends/hg/__init__.py

@@ -1,56 +1,54 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 HG module
 """
 import os
 import logging
 
 from rhodecode.lib.vcs import connection
 from rhodecode.lib.vcs.backends.hg.commit import MercurialCommit
 from rhodecode.lib.vcs.backends.hg.inmemory import MercurialInMemoryCommit
 from rhodecode.lib.vcs.backends.hg.repository import MercurialRepository
 
 
 log = logging.getLogger(__name__)
 
 
 def discover_hg_version(raise_on_exc=False):
     """
     Returns the string as it was returned by running 'git --version'
 
     It will return an empty string in case the connection is not initialized
     or no vcsserver is available.
     """
     try:
         return connection.Hg.discover_hg_version()
     except Exception:
         log.warning("Failed to discover the HG version", exc_info=True)
         if raise_on_exc:
             raise
         return ''
 
 
 def largefiles_store(base_location):
     """
     Return a largefile store relative to base_location
     """
     return os.path.join(base_location, '.cache', 'largefiles')

rhodecode/lib/vcs/backends/hg/commit.py

@@ -1,405 +1,403 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 HG commit module
 """
 
 import os
 
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from rhodecode.lib.datelib import utcdate_fromtimestamp
 from rhodecode.lib.str_utils import safe_bytes, safe_str
 from rhodecode.lib.vcs import path as vcspath
 from rhodecode.lib.vcs.backends import base
 from rhodecode.lib.vcs.exceptions import CommitError
 from rhodecode.lib.vcs.nodes import (
     AddedFileNodesGenerator, ChangedFileNodesGenerator, DirNode, FileNode,
     NodeKind, RemovedFileNodesGenerator, RootNode, SubModuleNode,
     LargeFileNode)
 from rhodecode.lib.vcs.utils.paths import get_dirs_for_path
 
 
 class MercurialCommit(base.BaseCommit):
     """
     Represents state of the repository at the single commit.
     """
 
     _filter_pre_load = [
         # git specific property not supported here
         "_commit",
     ]
 
     def __init__(self, repository, raw_id, idx, pre_load=None):
         raw_id = safe_str(raw_id)
 
         self.repository = repository
         self._remote = repository._remote
 
         self.raw_id = raw_id
         self.idx = idx
 
         self._set_bulk_properties(pre_load)
 
         # caches
         self.nodes = {}
         self._stat_modes = {}  # stat info for paths
 
     def _set_bulk_properties(self, pre_load):
         if not pre_load:
             return
         pre_load = [entry for entry in pre_load
                     if entry not in self._filter_pre_load]
         if not pre_load:
             return
 
         result = self._remote.bulk_request(self.raw_id, pre_load)
 
         for attr, value in result.items():
             if attr in ["author", "branch", "message"]:
                 value = safe_str(value)
             elif attr == "affected_files":
                 value = list(map(safe_str, value))
             elif attr == "date":
                 value = utcdate_fromtimestamp(*value)
             elif attr in ["children", "parents"]:
                 value = self._make_commits(value)
             elif attr in ["phase"]:
                 value = self._get_phase_text(value)
             self.__dict__[attr] = value
 
     @LazyProperty
     def tags(self):
         tags = [name for name, commit_id in self.repository.tags.items()
                 if commit_id == self.raw_id]
         return tags
 
     @LazyProperty
     def branch(self):
         return safe_str(self._remote.ctx_branch(self.raw_id))
 
     @LazyProperty
     def bookmarks(self):
         bookmarks = [
             name for name, commit_id in self.repository.bookmarks.items()
             if commit_id == self.raw_id]
         return bookmarks
 
     @LazyProperty
     def message(self):
         return safe_str(self._remote.ctx_description(self.raw_id))
 
     @LazyProperty
     def committer(self):
         return safe_str(self.author)
 
     @LazyProperty
     def author(self):
         return safe_str(self._remote.ctx_user(self.raw_id))
 
     @LazyProperty
     def date(self):
         return utcdate_fromtimestamp(*self._remote.ctx_date(self.raw_id))
 
     @LazyProperty
     def status(self):
         """
         Returns modified, added, removed, deleted files for current commit
         """
         return self._remote.ctx_status(self.raw_id)
 
     @LazyProperty
     def _file_paths(self):
         return self._remote.ctx_list(self.raw_id)
 
     @LazyProperty
     def _dir_paths(self):
         dir_paths = ['']
         dir_paths.extend(list(set(get_dirs_for_path(*self._file_paths))))
 
         return dir_paths
 
     @LazyProperty
     def _paths(self):
         return self._dir_paths + self._file_paths
 
     @LazyProperty
     def id(self):
         if self.last:
             return 'tip'
         return self.short_id
 
     @LazyProperty
     def short_id(self):
         return self.raw_id[:12]
 
     def _make_commits(self, commit_ids, pre_load=None):
         return [self.repository.get_commit(commit_id=commit_id, pre_load=pre_load)
                 for commit_id in commit_ids]
 
     @LazyProperty
     def parents(self):
         """
         Returns list of parent commits.
         """
         parents = self._remote.ctx_parents(self.raw_id)
         return self._make_commits(parents)
 
     def _get_phase_text(self, phase_id):
         return {
                    0: 'public',
                    1: 'draft',
                    2: 'secret',
                }.get(phase_id) or ''
 
     @LazyProperty
     def phase(self):
         phase_id = self._remote.ctx_phase(self.raw_id)
         phase_text = self._get_phase_text(phase_id)
 
         return safe_str(phase_text)
 
     @LazyProperty
     def obsolete(self):
         obsolete = self._remote.ctx_obsolete(self.raw_id)
         return obsolete
 
     @LazyProperty
     def hidden(self):
         hidden = self._remote.ctx_hidden(self.raw_id)
         return hidden
 
     @LazyProperty
     def children(self):
         """
         Returns list of child commits.
         """
         children = self._remote.ctx_children(self.raw_id)
         return self._make_commits(children)
 
     def _get_kind(self, path):
         path = self._fix_path(path)
         if path in self._file_paths:
             return NodeKind.FILE
         elif path in self._dir_paths:
             return NodeKind.DIR
         else:
             raise CommitError(f"Node does not exist at the given path '{path}'")
 
     def _assert_is_path(self, path) -> str:
         path = self._fix_path(path)
         if self._get_kind(path) != NodeKind.FILE:
             raise CommitError(f"File does not exist for commit {self.raw_id} at '{path}'")
 
         return path
 
     def get_file_mode(self, path: bytes):
         """
         Returns stat mode of the file at the given ``path``.
         """
         path = self._assert_is_path(path)
 
         if path not in self._stat_modes:
             self._stat_modes[path] = self._remote.fctx_flags(self.raw_id, path)
 
         if 'x' in self._stat_modes[path]:
             return base.FILEMODE_EXECUTABLE
         return base.FILEMODE_DEFAULT
 
     def is_link(self, path):
         path = self._assert_is_path(path)
         if path not in self._stat_modes:
             self._stat_modes[path] = self._remote.fctx_flags(self.raw_id, path)
 
         return 'l' in self._stat_modes[path]
 
     def is_node_binary(self, path):
         path = self._assert_is_path(path)
         return self._remote.is_binary(self.raw_id, path)
 
     def node_md5_hash(self, path):
         path = self._assert_is_path(path)
         return self._remote.md5_hash(self.raw_id, path)
 
     def get_file_content(self, path):
         """
         Returns content of the file at given ``path``.
         """
         path = self._assert_is_path(path)
         return self._remote.fctx_node_data(self.raw_id, path)
 
     def get_file_content_streamed(self, path):
         path = self._assert_is_path(path)
         stream_method = getattr(self._remote, 'stream:fctx_node_data')
         return stream_method(self.raw_id, path)
 
     def get_file_size(self, path):
         """
         Returns size of the file at given ``path``.
         """
         path = self._assert_is_path(path)
         return self._remote.fctx_size(self.raw_id, path)
 
     def get_path_history(self, path, limit=None, pre_load=None):
         """
         Returns history of file as reversed list of `MercurialCommit` objects
         for which file at given ``path`` has been modified.
         """
         path = self._assert_is_path(path)
         hist = self._remote.node_history(self.raw_id, path, limit)
         return [
             self.repository.get_commit(commit_id=commit_id, pre_load=pre_load)
             for commit_id in hist]
 
     def get_file_annotate(self, path, pre_load=None):
         """
         Returns a generator of four element tuples with
             lineno, commit_id, commit lazy loader and line
         """
         result = self._remote.fctx_annotate(self.raw_id, path)
 
         for ln_no, commit_id, content in result:
             yield (
                 ln_no, commit_id,
                 lambda: self.repository.get_commit(commit_id=commit_id, pre_load=pre_load),
                 content)
 
     def get_nodes(self, path, pre_load=None):
         """
         Returns combined ``DirNode`` and ``FileNode`` objects list representing
         state of commit at the given ``path``. If node at the given ``path``
         is not instance of ``DirNode``, CommitError would be raised.
         """
 
         if self._get_kind(path) != NodeKind.DIR:
             raise CommitError(
-                "Directory does not exist for idx %s at '%s'" % (self.raw_id, path))
+                "Directory does not exist for idx {} at '{}'".format(self.raw_id, path))
         path = self._fix_path(path)
 
         filenodes = [
             FileNode(safe_bytes(f), commit=self, pre_load=pre_load) for f in self._file_paths
             if os.path.dirname(f) == path]
         # TODO: johbo: Check if this can be done in a more obvious way
         dirs = path == '' and '' or [
             d for d in self._dir_paths
             if d and vcspath.dirname(d) == path]
         dirnodes = [
             DirNode(safe_bytes(d), commit=self) for d in dirs
             if os.path.dirname(d) == path]
 
         alias = self.repository.alias
         for k, vals in self._submodules.items():
             if vcspath.dirname(k) == path:
                 loc = vals[0]
                 commit = vals[1]
                 dirnodes.append(SubModuleNode(k, url=loc, commit=commit, alias=alias))
 
         nodes = dirnodes + filenodes
         for node in nodes:
             if node.path not in self.nodes:
                 self.nodes[node.path] = node
         nodes.sort()
 
         return nodes
 
     def get_node(self, path, pre_load=None):
         """
         Returns `Node` object from the given `path`. If there is no node at
         the given `path`, `NodeDoesNotExistError` would be raised.
         """
         path = self._fix_path(path)
 
         if path not in self.nodes:
             if path in self._file_paths:
                 node = FileNode(safe_bytes(path), commit=self, pre_load=pre_load)
             elif path in self._dir_paths:
                 if path == '':
                     node = RootNode(commit=self)
                 else:
                     node = DirNode(safe_bytes(path), commit=self)
             else:
                 raise self.no_node_at_path(path)
 
             # cache node
             self.nodes[path] = node
         return self.nodes[path]
 
     def get_largefile_node(self, path):
         pointer_spec = self._remote.is_large_file(self.raw_id, path)
         if pointer_spec:
             # content of that file regular FileNode is the hash of largefile
             file_id = self.get_file_content(path).strip()
 
             if self._remote.in_largefiles_store(file_id):
                 lf_path = self._remote.store_path(file_id)
                 return LargeFileNode(safe_bytes(lf_path), commit=self, org_path=path)
             elif self._remote.in_user_cache(file_id):
                 lf_path = self._remote.store_path(file_id)
                 self._remote.link(file_id, path)
                 return LargeFileNode(safe_bytes(lf_path), commit=self, org_path=path)
 
     @LazyProperty
     def _submodules(self):
         """
         Returns a dictionary with submodule information from substate file
         of hg repository.
         """
         return self._remote.ctx_substate(self.raw_id)
 
     @LazyProperty
     def affected_files(self):
         """
         Gets a fast accessible file changes for given commit
         """
         return self._remote.ctx_files(self.raw_id)
 
     @property
     def added(self):
         """
         Returns list of added ``FileNode`` objects.
         """
         return AddedFileNodesGenerator(self.added_paths, self)
 
     @LazyProperty
     def added_paths(self):
         return [n for n in self.status[1]]
 
     @property
     def changed(self):
         """
         Returns list of modified ``FileNode`` objects.
         """
         return ChangedFileNodesGenerator(self.changed_paths, self)
 
     @LazyProperty
     def changed_paths(self):
         return [n for n in self.status[0]]
 
     @property
     def removed(self):
         """
         Returns list of removed ``FileNode`` objects.
         """
         return RemovedFileNodesGenerator(self.removed_paths, self)
 
     @LazyProperty
     def removed_paths(self):
         return [n for n in self.status[2]]

rhodecode/lib/vcs/backends/hg/diff.py

@@ -1,49 +1,47 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 HG diff module
 """
 
 import re
 
 from rhodecode.lib.vcs.backends import base
 
 
 class MercurialDiff(base.Diff):
 
     _header_re = re.compile(br"""
         #^diff[ ]--git
             [ ]"?a/(?P<a_path>.+?)"?[ ]"?b/(?P<b_path>.+?)"?\n
         (?:^old[ ]mode[ ](?P<old_mode>\d+)\n
            ^new[ ]mode[ ](?P<new_mode>\d+)(?:\n|$))?
         (?:^similarity[ ]index[ ](?P<similarity_index>\d+)%(?:\n|$))?
         (?:^rename[ ]from[ ](?P<rename_from>[^\r\n]+)\n
            ^rename[ ]to[ ](?P<rename_to>[^\r\n]+)(?:\n|$))?
         (?:^copy[ ]from[ ](?P<copy_from>[^\r\n]+)\n
            ^copy[ ]to[ ](?P<copy_to>[^\r\n]+)(?:\n|$))?
         (?:^new[ ]file[ ]mode[ ](?P<new_file_mode>.+)(?:\n|$))?
         (?:^deleted[ ]file[ ]mode[ ](?P<deleted_file_mode>.+)(?:\n|$))?
         (?:^index[ ](?P<a_blob_id>[0-9A-Fa-f]+)
             \.\.(?P<b_blob_id>[0-9A-Fa-f]+)[ ]?(?P<b_mode>.+)?(?:\n|$))?
         (?:^(?P<bin_patch>GIT[ ]binary[ ]patch)(?:\n|$))?
         (?:^---[ ]("?a/(?P<a_file>.+)|/dev/null)(?:\n|$))?
         (?:^\+\+\+[ ]("?b/(?P<b_file>.+)|/dev/null)(?:\n|$))?
     """, re.VERBOSE | re.MULTILINE)

rhodecode/lib/vcs/backends/hg/inmemory.py

@@ -1,96 +1,94 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 HG inmemory module
 """
 
 from rhodecode.lib.datelib import date_to_timestamp_plus_offset
 from rhodecode.lib.str_utils import safe_str
 from rhodecode.lib.vcs.backends.base import BaseInMemoryCommit
 from rhodecode.lib.vcs.exceptions import RepositoryError
 
 
 class MercurialInMemoryCommit(BaseInMemoryCommit):
 
     def commit(self, message, author, parents=None, branch=None, date=None, **kwargs):
         """
         Performs in-memory commit (doesn't check workdir in any way) and
         returns newly created `MercurialCommit`. Updates repository's
         `commit_ids`.
 
         :param message: message of the commit
         :param author: full username, i.e. "Joe Doe <[e-mail]>"
         :param parents: single parent or sequence of parents from which commit
           would be derived
         :param date: `datetime.datetime` instance. Defaults to
           ``datetime.datetime.now()``.
         :param branch: Optional. Branch name as unicode. Will use the backend's
           default if not given.
 
         :raises `RepositoryError`: if any error occurs while committing
         """
         self.check_integrity(parents)
 
         if not isinstance(message, str) or not isinstance(author, str):
             # TODO: johbo: Should be a TypeError
             raise RepositoryError(
                 f'Given message and author needs to be '
                 f'an <str> instance got {type(message)} & {type(author)} instead'
             )
 
         if branch is None:
             branch = self.repository.DEFAULT_BRANCH_NAME
         kwargs['branch'] = safe_str(branch)
 
         message = safe_str(message)
         author = safe_str(author)
 
         parent_ids = [p.raw_id if p else None for p in self.parents]
 
         updated = []
         for node in self.added + self.changed:
             content = node.content
             # TODO: left for reference pre py3 migration, probably need to be removed
             # if node.is_binary:
             #     content = node.content
             # else:
             #     content = node.content.encode(ENCODING)
             updated.append({
                 'path': node.path,
                 'content': content,
                 'mode': node.mode,
             })
 
         removed = [node.path for node in self.removed]
 
         date, tz = date_to_timestamp_plus_offset(date)
 
         commit_id = self.repository._remote.commitctx(
             message=message, parents=parent_ids,
             commit_time=date, commit_timezone=tz, user=author,
             files=self.get_paths(), extra=kwargs, removed=removed,
             updated=updated)
         self.repository.append_commit_id(commit_id)
 
         self.repository.branches = self.repository._get_branches()
         tip = self.repository.get_commit(commit_id)
         self.reset()
         return tip

rhodecode/lib/vcs/backends/hg/repository.py

@@ -1,1015 +1,1013 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 HG repository module
 """
 import os
 import logging
 import binascii
 import configparser
 import urllib.request
 import urllib.parse
 import urllib.error
 
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from collections import OrderedDict
 from rhodecode.lib.datelib import (
     date_to_timestamp_plus_offset, utcdate_fromtimestamp, makedate)
 from rhodecode.lib.str_utils import safe_str
 from rhodecode.lib.utils2 import CachedProperty
 from rhodecode.lib.vcs import connection, exceptions
 from rhodecode.lib.vcs.backends.base import (
     BaseRepository, CollectionGenerator, Config, MergeResponse,
     MergeFailureReason, Reference, BasePathPermissionChecker)
 from rhodecode.lib.vcs.backends.hg.commit import MercurialCommit
 from rhodecode.lib.vcs.backends.hg.diff import MercurialDiff
 from rhodecode.lib.vcs.backends.hg.inmemory import MercurialInMemoryCommit
 from rhodecode.lib.vcs.exceptions import (
     EmptyRepositoryError, RepositoryError, TagAlreadyExistError,
     TagDoesNotExistError, CommitDoesNotExistError, SubrepoMergeError, UnresolvedFilesInRepo)
 
 hexlify = binascii.hexlify
 nullid = "\0" * 20
 
 log = logging.getLogger(__name__)
 
 
 class MercurialRepository(BaseRepository):
     """
     Mercurial repository backend
     """
     DEFAULT_BRANCH_NAME = 'default'
 
     def __init__(self, repo_path, config=None, create=False, src_url=None,
                  do_workspace_checkout=False, with_wire=None, bare=False):
         """
         Raises RepositoryError if repository could not be find at the given
         ``repo_path``.
 
         :param repo_path: local path of the repository
         :param config: config object containing the repo configuration
         :param create=False: if set to True, would try to create repository if
            it does not exist rather than raising exception
         :param src_url=None: would try to clone repository from given location
         :param do_workspace_checkout=False: sets update of working copy after
            making a clone
         :param bare: not used, compatible with other VCS
         """
 
         self.path = safe_str(os.path.abspath(repo_path))
         # mercurial since 4.4.X requires certain configuration to be present
         # because sometimes we init the repos with config we need to meet
         # special requirements
         self.config = config if config else self.get_default_config(
             default=[('extensions', 'largefiles', '1')])
         self.with_wire = with_wire or {"cache": False}  # default should not use cache
 
         self._init_repo(create, src_url, do_workspace_checkout)
 
         # caches
         self._commit_ids = {}
 
     @LazyProperty
     def _remote(self):
         repo_id = self.path
         return connection.Hg(self.path, repo_id, self.config, with_wire=self.with_wire)
 
     @CachedProperty
     def commit_ids(self):
         """
         Returns list of commit ids, in ascending order.  Being lazy
         attribute allows external tools to inject shas from cache.
         """
         commit_ids = self._get_all_commit_ids()
         self._rebuild_cache(commit_ids)
         return commit_ids
 
     def _rebuild_cache(self, commit_ids):
-        self._commit_ids = dict((commit_id, index)
-                                for index, commit_id in enumerate(commit_ids))
+        self._commit_ids = {commit_id: index
+                                for index, commit_id in enumerate(commit_ids)}
 
     @CachedProperty
     def branches(self):
         return self._get_branches()
 
     @CachedProperty
     def branches_closed(self):
         return self._get_branches(active=False, closed=True)
 
     @CachedProperty
     def branches_all(self):
         all_branches = {}
         all_branches.update(self.branches)
         all_branches.update(self.branches_closed)
         return all_branches
 
     def _get_branches(self, active=True, closed=False):
         """
         Gets branches for this repository
         Returns only not closed active branches by default
 
         :param active: return also active branches
         :param closed: return also closed branches
 
         """
         if self.is_empty():
             return {}
 
         def get_name(ctx):
             return ctx[0]
 
         _branches = [(n, h,) for n, h in
                      self._remote.branches(active, closed).items()]
 
         return OrderedDict(sorted(_branches, key=get_name, reverse=False))
 
     @CachedProperty
     def tags(self):
         """
         Gets tags for this repository
         """
         return self._get_tags()
 
     def _get_tags(self):
         if self.is_empty():
             return {}
 
         def get_name(ctx):
             return ctx[0]
 
         _tags = [(n, h,) for n, h in
                  self._remote.tags().items()]
 
         return OrderedDict(sorted(_tags, key=get_name, reverse=True))
 
     def tag(self, name, user, commit_id=None, message=None, date=None, **kwargs):
         """
         Creates and returns a tag for the given ``commit_id``.
 
         :param name: name for new tag
         :param user: full username, i.e.: "Joe Doe <[e-mail]>"
         :param commit_id: commit id for which new tag would be created
         :param message: message of the tag's commit
         :param date: date of tag's commit
 
         :raises TagAlreadyExistError: if tag with same name already exists
         """
         if name in self.tags:
             raise TagAlreadyExistError("Tag %s already exists" % name)
 
         commit = self.get_commit(commit_id=commit_id)
         local = kwargs.setdefault('local', False)
 
         if message is None:
-            message = "Added tag %s for commit %s" % (name, commit.short_id)
+            message = "Added tag {} for commit {}".format(name, commit.short_id)
 
         date, tz = date_to_timestamp_plus_offset(date)
 
         self._remote.tag(name, commit.raw_id, message, local, user, date, tz)
         self._remote.invalidate_vcs_cache()
 
         # Reinitialize tags
         self._invalidate_prop_cache('tags')
         tag_id = self.tags[name]
 
         return self.get_commit(commit_id=tag_id)
 
     def remove_tag(self, name, user, message=None, date=None):
         """
         Removes tag with the given `name`.
 
         :param name: name of the tag to be removed
         :param user: full username, i.e.: "Joe Doe <[e-mail]>"
         :param message: message of the tag's removal commit
         :param date: date of tag's removal commit
 
         :raises TagDoesNotExistError: if tag with given name does not exists
         """
         if name not in self.tags:
             raise TagDoesNotExistError("Tag %s does not exist" % name)
 
         if message is None:
             message = "Removed tag %s" % name
         local = False
 
         date, tz = date_to_timestamp_plus_offset(date)
 
         self._remote.tag(name, nullid, message, local, user, date, tz)
         self._remote.invalidate_vcs_cache()
         self._invalidate_prop_cache('tags')
 
     @LazyProperty
     def bookmarks(self):
         """
         Gets bookmarks for this repository
         """
         return self._get_bookmarks()
 
     def _get_bookmarks(self):
         if self.is_empty():
             return {}
 
         def get_name(ctx):
             return ctx[0]
 
         _bookmarks = [
             (n, h) for n, h in
             self._remote.bookmarks().items()]
 
         return OrderedDict(sorted(_bookmarks, key=get_name))
 
     def _get_all_commit_ids(self):
         return self._remote.get_all_commit_ids('visible')
 
     def get_diff(
             self, commit1, commit2, path='', ignore_whitespace=False,
             context=3, path1=None):
         """
         Returns (git like) *diff*, as plain text. Shows changes introduced by
         `commit2` since `commit1`.
 
         :param commit1: Entry point from which diff is shown. Can be
           ``self.EMPTY_COMMIT`` - in this case, patch showing all
           the changes since empty state of the repository until `commit2`
         :param commit2: Until which commit changes should be shown.
         :param ignore_whitespace: If set to ``True``, would not show whitespace
           changes. Defaults to ``False``.
         :param context: How many lines before/after changed lines should be
           shown. Defaults to ``3``.
         """
         self._validate_diff_commits(commit1, commit2)
         if path1 is not None and path1 != path:
             raise ValueError("Diff of two different paths not supported.")
 
         if path:
             file_filter = [self.path, path]
         else:
             file_filter = None
 
         diff = self._remote.diff(
             commit1.raw_id, commit2.raw_id, file_filter=file_filter,
             opt_git=True, opt_ignorews=ignore_whitespace,
             context=context)
         return MercurialDiff(diff)
 
     def strip(self, commit_id, branch=None):
         self._remote.strip(commit_id, update=False, backup="none")
 
         self._remote.invalidate_vcs_cache()
         # clear cache
         self._invalidate_prop_cache('commit_ids')
 
         return len(self.commit_ids)
 
     def verify(self):
         verify = self._remote.verify()
 
         self._remote.invalidate_vcs_cache()
         return verify
 
     def hg_update_cache(self):
         update_cache = self._remote.hg_update_cache()
 
         self._remote.invalidate_vcs_cache()
         return update_cache
 
     def hg_rebuild_fn_cache(self):
         update_cache = self._remote.hg_rebuild_fn_cache()
 
         self._remote.invalidate_vcs_cache()
         return update_cache
 
     def get_common_ancestor(self, commit_id1, commit_id2, repo2):
         log.debug('Calculating common ancestor between %sc1:%s and %sc2:%s',
                   self, commit_id1, repo2, commit_id2)
 
         if commit_id1 == commit_id2:
             return commit_id1
 
         ancestors = self._remote.revs_from_revspec(
             "ancestor(id(%s), id(%s))", commit_id1, commit_id2,
             other_path=repo2.path)
 
         ancestor_id = repo2[ancestors[0]].raw_id if ancestors else None
 
         log.debug('Found common ancestor with sha: %s', ancestor_id)
         return ancestor_id
 
     def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None):
         if commit_id1 == commit_id2:
             commits = []
         else:
             if merge:
                 indexes = self._remote.revs_from_revspec(
                     "ancestors(id(%s)) - ancestors(id(%s)) - id(%s)",
                     commit_id2, commit_id1, commit_id1, other_path=repo2.path)
             else:
                 indexes = self._remote.revs_from_revspec(
                     "id(%s)..id(%s) - id(%s)", commit_id1, commit_id2,
                     commit_id1, other_path=repo2.path)
 
             commits = [repo2.get_commit(commit_idx=idx, pre_load=pre_load)
                        for idx in indexes]
 
         return commits
 
     @staticmethod
     def check_url(url, config):
         """
         Function will check given url and try to verify if it's a valid
         link. Sometimes it may happened that mercurial will issue basic
         auth request that can cause whole API to hang when used from python
         or other external calls.
 
         On failures it'll raise urllib2.HTTPError, exception is also thrown
         when the return code is non 200
         """
         # check first if it's not an local url
         if os.path.isdir(url) or url.startswith('file:'):
             return True
 
         # Request the _remote to verify the url
         return connection.Hg.check_url(url, config.serialize())
 
     @staticmethod
     def is_valid_repository(path):
         return os.path.isdir(os.path.join(path, '.hg'))
 
     def _init_repo(self, create, src_url=None, do_workspace_checkout=False):
         """
         Function will check for mercurial repository in given path. If there
         is no repository in that path it will raise an exception unless
         `create` parameter is set to True - in that case repository would
         be created.
 
         If `src_url` is given, would try to clone repository from the
         location at given clone_point. Additionally it'll make update to
         working copy accordingly to `do_workspace_checkout` flag.
         """
         if create and os.path.exists(self.path):
             raise RepositoryError(
                 f"Cannot create repository at {self.path}, location already exist")
 
         if src_url:
             url = str(self._get_url(src_url))
             MercurialRepository.check_url(url, self.config)
 
             self._remote.clone(url, self.path, do_workspace_checkout)
 
             # Don't try to create if we've already cloned repo
             create = False
 
         if create:
             os.makedirs(self.path, mode=0o755)
 
         self._remote.localrepository(create)
 
     @LazyProperty
     def in_memory_commit(self):
         return MercurialInMemoryCommit(self)
 
     @LazyProperty
     def description(self):
         description = self._remote.get_config_value(
             'web', 'description', untrusted=True)
         return safe_str(description or self.DEFAULT_DESCRIPTION)
 
     @LazyProperty
     def contact(self):
         contact = (
             self._remote.get_config_value("web", "contact") or
             self._remote.get_config_value("ui", "username"))
         return safe_str(contact or self.DEFAULT_CONTACT)
 
     @LazyProperty
     def last_change(self):
         """
         Returns last change made on this repository as
         `datetime.datetime` object.
         """
         try:
             return self.get_commit().date
         except RepositoryError:
             tzoffset = makedate()[1]
             return utcdate_fromtimestamp(self._get_fs_mtime(), tzoffset)
 
     def _get_fs_mtime(self):
         # fallback to filesystem
         cl_path = os.path.join(self.path, '.hg', "00changelog.i")
         st_path = os.path.join(self.path, '.hg', "store")
         if os.path.exists(cl_path):
             return os.stat(cl_path).st_mtime
         else:
             return os.stat(st_path).st_mtime
 
     def _get_url(self, url):
         """
         Returns normalized url. If schema is not given, would fall
         to filesystem
         (``file:///``) schema.
         """
         if url != 'default' and '://' not in url:
             url = "file:" + urllib.request.pathname2url(url)
         return url
 
     def get_hook_location(self):
         """
         returns absolute path to location where hooks are stored
         """
         return os.path.join(self.path, '.hg', '.hgrc')
 
     def get_commit(self, commit_id=None, commit_idx=None, pre_load=None,
                    translate_tag=None, maybe_unreachable=False, reference_obj=None):
         """
         Returns ``MercurialCommit`` object representing repository's
         commit at the given `commit_id` or `commit_idx`.
         """
         if self.is_empty():
             raise EmptyRepositoryError("There are no commits yet")
 
         if commit_id is not None:
             self._validate_commit_id(commit_id)
             try:
                 # we have cached idx, use it without contacting the remote
                 idx = self._commit_ids[commit_id]
                 return MercurialCommit(self, commit_id, idx, pre_load=pre_load)
             except KeyError:
                 pass
 
         elif commit_idx is not None:
             self._validate_commit_idx(commit_idx)
             try:
                 _commit_id = self.commit_ids[commit_idx]
                 if commit_idx < 0:
                     commit_idx = self.commit_ids.index(_commit_id)
 
                 return MercurialCommit(self, _commit_id, commit_idx, pre_load=pre_load)
             except IndexError:
                 commit_id = commit_idx
         else:
             commit_id = "tip"
 
         # case here is no cached version, do an actual lookup instead
         try:
             raw_id, idx = self._remote.lookup(commit_id, both=True)
         except CommitDoesNotExistError:
             msg = "Commit {} does not exist for `{}`".format(
                 *map(safe_str, [commit_id, self.name]))
             raise CommitDoesNotExistError(msg)
 
         return MercurialCommit(self, raw_id, idx, pre_load=pre_load)
 
     def get_commits(
             self, start_id=None, end_id=None, start_date=None, end_date=None,
             branch_name=None, show_hidden=False, pre_load=None, translate_tags=None):
         """
         Returns generator of ``MercurialCommit`` objects from start to end
         (both are inclusive)
 
         :param start_id: None, str(commit_id)
         :param end_id: None, str(commit_id)
         :param start_date: if specified, commits with commit date less than
           ``start_date`` would be filtered out from returned set
         :param end_date: if specified, commits with commit date greater than
           ``end_date`` would be filtered out from returned set
         :param branch_name: if specified, commits not reachable from given
           branch would be filtered out from returned set
         :param show_hidden: Show hidden commits such as obsolete or hidden from
             Mercurial evolve
         :raise BranchDoesNotExistError: If given ``branch_name`` does not
             exist.
         :raise CommitDoesNotExistError: If commit for given ``start`` or
           ``end`` could not be found.
         """
         # actually we should check now if it's not an empty repo
         if self.is_empty():
             raise EmptyRepositoryError("There are no commits yet")
         self._validate_branch_name(branch_name)
 
         branch_ancestors = False
         if start_id is not None:
             self._validate_commit_id(start_id)
             c_start = self.get_commit(commit_id=start_id)
             start_pos = self._commit_ids[c_start.raw_id]
         else:
             start_pos = None
 
         if end_id is not None:
             self._validate_commit_id(end_id)
             c_end = self.get_commit(commit_id=end_id)
             end_pos = max(0, self._commit_ids[c_end.raw_id])
         else:
             end_pos = None
 
         if None not in [start_id, end_id] and start_pos > end_pos:
             raise RepositoryError(
                 "Start commit '%s' cannot be after end commit '%s'" %
                 (start_id, end_id))
 
         if end_pos is not None:
             end_pos += 1
 
         commit_filter = []
 
         if branch_name and not branch_ancestors:
-            commit_filter.append('branch("%s")' % (branch_name,))
+            commit_filter.append('branch("{}")'.format(branch_name))
         elif branch_name and branch_ancestors:
-            commit_filter.append('ancestors(branch("%s"))' % (branch_name,))
+            commit_filter.append('ancestors(branch("{}"))'.format(branch_name))
 
         if start_date and not end_date:
-            commit_filter.append('date(">%s")' % (start_date,))
+            commit_filter.append('date(">{}")'.format(start_date))
         if end_date and not start_date:
-            commit_filter.append('date("<%s")' % (end_date,))
+            commit_filter.append('date("<{}")'.format(end_date))
         if start_date and end_date:
             commit_filter.append(
-                'date(">%s") and date("<%s")' % (start_date, end_date))
+                'date(">{}") and date("<{}")'.format(start_date, end_date))
 
         if not show_hidden:
             commit_filter.append('not obsolete()')
             commit_filter.append('not hidden()')
 
         # TODO: johbo: Figure out a simpler way for this solution
         collection_generator = CollectionGenerator
         if commit_filter:
             commit_filter = ' and '.join(map(safe_str, commit_filter))
             revisions = self._remote.rev_range([commit_filter])
             collection_generator = MercurialIndexBasedCollectionGenerator
         else:
             revisions = self.commit_ids
 
         if start_pos or end_pos:
             revisions = revisions[start_pos:end_pos]
 
         return collection_generator(self, revisions, pre_load=pre_load)
 
     def pull(self, url, commit_ids=None):
         """
         Pull changes from external location.
 
         :param commit_ids: Optional. Can be set to a list of commit ids
            which shall be pulled from the other repository.
         """
         url = self._get_url(url)
         self._remote.pull(url, commit_ids=commit_ids)
         self._remote.invalidate_vcs_cache()
 
     def fetch(self, url, commit_ids=None):
         """
         Backward compatibility with GIT fetch==pull
         """
         return self.pull(url, commit_ids=commit_ids)
 
     def push(self, url):
         url = self._get_url(url)
         self._remote.sync_push(url)
 
     def _local_clone(self, clone_path):
         """
         Create a local clone of the current repo.
         """
         self._remote.clone(self.path, clone_path, update_after_clone=True,
                            hooks=False)
 
     def _update(self, revision, clean=False):
         """
         Update the working copy to the specified revision.
         """
         log.debug('Doing checkout to commit: `%s` for %s', revision, self)
         self._remote.update(revision, clean=clean)
 
     def _identify(self):
         """
         Return the current state of the working directory.
         """
         return self._remote.identify().strip().rstrip('+')
 
     def _heads(self, branch=None):
         """
         Return the commit ids of the repository heads.
         """
         return self._remote.heads(branch=branch).strip().split(' ')
 
     def _ancestor(self, revision1, revision2):
         """
         Return the common ancestor of the two revisions.
         """
         return self._remote.ancestor(revision1, revision2)
 
     def _local_push(
             self, revision, repository_path, push_branches=False,
             enable_hooks=False):
         """
         Push the given revision to the specified repository.
 
         :param push_branches: allow to create branches in the target repo.
         """
         self._remote.push(
             [revision], repository_path, hooks=enable_hooks,
             push_branches=push_branches)
 
     def _local_merge(self, target_ref, merge_message, user_name, user_email,
                      source_ref, use_rebase=False, close_commit_id=None, dry_run=False):
         """
         Merge the given source_revision into the checked out revision.
 
         Returns the commit id of the merge and a boolean indicating if the
         commit needs to be pushed.
         """
         source_ref_commit_id = source_ref.commit_id
         target_ref_commit_id = target_ref.commit_id
 
         # update our workdir to target ref, for proper merge
         self._update(target_ref_commit_id, clean=True)
 
         ancestor = self._ancestor(target_ref_commit_id, source_ref_commit_id)
         is_the_same_branch = self._is_the_same_branch(target_ref, source_ref)
 
         if close_commit_id:
             # NOTE(marcink): if we get the close commit, this is our new source
             # which will include the close commit itself.
             source_ref_commit_id = close_commit_id
 
         if ancestor == source_ref_commit_id:
             # Nothing to do, the changes were already integrated
             return target_ref_commit_id, False
 
         elif ancestor == target_ref_commit_id and is_the_same_branch:
             # In this case we should force a commit message
             return source_ref_commit_id, True
 
         unresolved = None
         if use_rebase:
             try:
-                bookmark_name = 'rcbook%s%s' % (source_ref_commit_id, target_ref_commit_id)
+                bookmark_name = 'rcbook{}{}'.format(source_ref_commit_id, target_ref_commit_id)
                 self.bookmark(bookmark_name, revision=source_ref.commit_id)
                 self._remote.rebase(
                     source=source_ref_commit_id, dest=target_ref_commit_id)
                 self._remote.invalidate_vcs_cache()
                 self._update(bookmark_name, clean=True)
                 return self._identify(), True
             except RepositoryError as e:
                 # The rebase-abort may raise another exception which 'hides'
                 # the original one, therefore we log it here.
                 log.exception('Error while rebasing shadow repo during merge.')
                 if 'unresolved conflicts' in safe_str(e):
                     unresolved = self._remote.get_unresolved_files()
                     log.debug('unresolved files: %s', unresolved)
 
                 # Cleanup any rebase leftovers
                 self._remote.invalidate_vcs_cache()
                 self._remote.rebase(abort=True)
                 self._remote.invalidate_vcs_cache()
                 self._remote.update(clean=True)
                 if unresolved:
                     raise UnresolvedFilesInRepo(unresolved)
                 else:
                     raise
         else:
             try:
                 self._remote.merge(source_ref_commit_id)
                 self._remote.invalidate_vcs_cache()
                 self._remote.commit(
                     message=safe_str(merge_message),
-                    username=safe_str('%s <%s>' % (user_name, user_email)))
+                    username=safe_str('{} <{}>'.format(user_name, user_email)))
                 self._remote.invalidate_vcs_cache()
                 return self._identify(), True
             except RepositoryError as e:
                 # The merge-abort may raise another exception which 'hides'
                 # the original one, therefore we log it here.
                 log.exception('Error while merging shadow repo during merge.')
                 if 'unresolved merge conflicts' in safe_str(e):
                     unresolved = self._remote.get_unresolved_files()
                     log.debug('unresolved files: %s', unresolved)
 
                 # Cleanup any merge leftovers
                 self._remote.update(clean=True)
                 if unresolved:
                     raise UnresolvedFilesInRepo(unresolved)
                 else:
                     raise
 
     def _local_close(self, target_ref, user_name, user_email,
                      source_ref, close_message=''):
         """
         Close the branch of the given source_revision
 
         Returns the commit id of the close and a boolean indicating if the
         commit needs to be pushed.
         """
         self._update(source_ref.commit_id)
-        message = close_message or "Closing branch: `{}`".format(source_ref.name)
+        message = close_message or f"Closing branch: `{source_ref.name}`"
         try:
             self._remote.commit(
                 message=safe_str(message),
-                username=safe_str('%s <%s>' % (user_name, user_email)),
+                username=safe_str('{} <{}>'.format(user_name, user_email)),
                 close_branch=True)
             self._remote.invalidate_vcs_cache()
             return self._identify(), True
         except RepositoryError:
             # Cleanup any commit leftovers
             self._remote.update(clean=True)
             raise
 
     def _is_the_same_branch(self, target_ref, source_ref):
         return (
             self._get_branch_name(target_ref) ==
             self._get_branch_name(source_ref))
 
     def _get_branch_name(self, ref):
         if ref.type == 'branch':
             return ref.name
         return self._remote.ctx_branch(ref.commit_id)
 
     def _maybe_prepare_merge_workspace(
             self, repo_id, workspace_id, unused_target_ref, unused_source_ref):
         shadow_repository_path = self._get_shadow_repository_path(
             self.path, repo_id, workspace_id)
         if not os.path.exists(shadow_repository_path):
             self._local_clone(shadow_repository_path)
             log.debug(
                 'Prepared shadow repository in %s', shadow_repository_path)
 
         return shadow_repository_path
 
     def _merge_repo(self, repo_id, workspace_id, target_ref,
                     source_repo, source_ref, merge_message,
                     merger_name, merger_email, dry_run=False,
                     use_rebase=False, close_branch=False):
 
         log.debug('Executing merge_repo with %s strategy, dry_run mode:%s',
                   'rebase' if use_rebase else 'merge', dry_run)
         if target_ref.commit_id not in self._heads():
             return MergeResponse(
                 False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD,
                 metadata={'target_ref': target_ref})
 
         try:
             if target_ref.type == 'branch' and len(self._heads(target_ref.name)) != 1:
                 heads_all = self._heads(target_ref.name)
                 max_heads = 10
                 if len(heads_all) > max_heads:
                     heads = '\n,'.join(
                         heads_all[:max_heads] +
                         ['and {} more.'.format(len(heads_all)-max_heads)])
                 else:
                     heads = '\n,'.join(heads_all)
                 metadata = {
                     'target_ref': target_ref,
                     'source_ref': source_ref,
                     'heads': heads
                 }
                 return MergeResponse(
                     False, False, None,
                     MergeFailureReason.HG_TARGET_HAS_MULTIPLE_HEADS,
                     metadata=metadata)
         except CommitDoesNotExistError:
             log.exception('Failure when looking up branch heads on hg target')
             return MergeResponse(
                 False, False, None, MergeFailureReason.MISSING_TARGET_REF,
                 metadata={'target_ref': target_ref})
 
         shadow_repository_path = self._maybe_prepare_merge_workspace(
             repo_id, workspace_id, target_ref, source_ref)
         shadow_repo = self.get_shadow_instance(shadow_repository_path)
 
         log.debug('Pulling in target reference %s', target_ref)
         self._validate_pull_reference(target_ref)
         shadow_repo._local_pull(self.path, target_ref)
 
         try:
             log.debug('Pulling in source reference %s', source_ref)
             source_repo._validate_pull_reference(source_ref)
             shadow_repo._local_pull(source_repo.path, source_ref)
         except CommitDoesNotExistError:
             log.exception('Failure when doing local pull on hg shadow repo')
             return MergeResponse(
                 False, False, None, MergeFailureReason.MISSING_SOURCE_REF,
                 metadata={'source_ref': source_ref})
 
         merge_ref = None
         merge_commit_id = None
         close_commit_id = None
         merge_failure_reason = MergeFailureReason.NONE
         metadata = {}
 
         # enforce that close branch should be used only in case we source from
         # an actual Branch
         close_branch = close_branch and source_ref.type == 'branch'
 
         # don't allow to close branch if source and target are the same
         close_branch = close_branch and source_ref.name != target_ref.name
 
         needs_push_on_close = False
         if close_branch and not use_rebase and not dry_run:
             try:
                 close_commit_id, needs_push_on_close = shadow_repo._local_close(
                     target_ref, merger_name, merger_email, source_ref)
                 merge_possible = True
             except RepositoryError:
                 log.exception('Failure when doing close branch on '
                               'shadow repo: %s', shadow_repo)
                 merge_possible = False
                 merge_failure_reason = MergeFailureReason.MERGE_FAILED
         else:
             merge_possible = True
 
         needs_push = False
         if merge_possible:
 
             try:
                 merge_commit_id, needs_push = shadow_repo._local_merge(
                     target_ref, merge_message, merger_name, merger_email,
                     source_ref, use_rebase=use_rebase,
                     close_commit_id=close_commit_id, dry_run=dry_run)
                 merge_possible = True
 
                 # read the state of the close action, if it
                 # maybe required a push
                 needs_push = needs_push or needs_push_on_close
 
                 # Set a bookmark pointing to the merge commit. This bookmark
                 # may be used to easily identify the last successful merge
                 # commit in the shadow repository.
                 shadow_repo.bookmark('pr-merge', revision=merge_commit_id)
                 merge_ref = Reference('book', 'pr-merge', merge_commit_id)
             except SubrepoMergeError:
                 log.exception(
                     'Subrepo merge error during local merge on hg shadow repo.')
                 merge_possible = False
                 merge_failure_reason = MergeFailureReason.SUBREPO_MERGE_FAILED
                 needs_push = False
             except RepositoryError as e:
                 log.exception('Failure when doing local merge on hg shadow repo')
                 if isinstance(e, UnresolvedFilesInRepo):
                     all_conflicts = list(e.args[0])
                     max_conflicts = 20
                     if len(all_conflicts) > max_conflicts:
                         conflicts = all_conflicts[:max_conflicts] \
                                     + ['and {} more.'.format(len(all_conflicts)-max_conflicts)]
                     else:
                         conflicts = all_conflicts
                     metadata['unresolved_files'] = \
                         '\n* conflict: ' + \
                         ('\n * conflict: '.join(conflicts))
 
                 merge_possible = False
                 merge_failure_reason = MergeFailureReason.MERGE_FAILED
                 needs_push = False
 
         if merge_possible and not dry_run:
             if needs_push:
                 # In case the target is a bookmark, update it, so after pushing
                 # the bookmarks is also updated in the target.
                 if target_ref.type == 'book':
                     shadow_repo.bookmark(
                         target_ref.name, revision=merge_commit_id)
                 try:
                     shadow_repo_with_hooks = self.get_shadow_instance(
                         shadow_repository_path,
                         enable_hooks=True)
                     # This is the actual merge action, we push from shadow
                     # into origin.
                     # Note: the push_branches option will push any new branch
                     # defined in the source repository to the target. This may
                     # be dangerous as branches are permanent in Mercurial.
                     # This feature was requested in issue #441.
                     shadow_repo_with_hooks._local_push(
                         merge_commit_id, self.path, push_branches=True,
                         enable_hooks=True)
 
                     # maybe we also need to push the close_commit_id
                     if close_commit_id:
                         shadow_repo_with_hooks._local_push(
                             close_commit_id, self.path, push_branches=True,
                             enable_hooks=True)
                     merge_succeeded = True
                 except RepositoryError:
                     log.exception(
                         'Failure when doing local push from the shadow '
                         'repository to the target repository at %s.', self.path)
                     merge_succeeded = False
                     merge_failure_reason = MergeFailureReason.PUSH_FAILED
                     metadata['target'] = 'hg shadow repo'
                     metadata['merge_commit'] = merge_commit_id
             else:
                 merge_succeeded = True
         else:
             merge_succeeded = False
 
         return MergeResponse(
             merge_possible, merge_succeeded, merge_ref, merge_failure_reason,
             metadata=metadata)
 
     def get_shadow_instance(self, shadow_repository_path, enable_hooks=False, cache=False):
         config = self.config.copy()
         if not enable_hooks:
             config.clear_section('hooks')
         return MercurialRepository(shadow_repository_path, config, with_wire={"cache": cache})
 
     def _validate_pull_reference(self, reference):
         if not (reference.name in self.bookmarks or
                 reference.name in self.branches or
                 self.get_commit(reference.commit_id)):
             raise CommitDoesNotExistError(
                 'Unknown branch, bookmark or commit id')
 
     def _local_pull(self, repository_path, reference):
         """
         Fetch a branch, bookmark or commit from a local repository.
         """
         repository_path = os.path.abspath(repository_path)
         if repository_path == self.path:
             raise ValueError('Cannot pull from the same repository')
 
         reference_type_to_option_name = {
             'book': 'bookmark',
             'branch': 'branch',
         }
         option_name = reference_type_to_option_name.get(
             reference.type, 'revision')
 
         if option_name == 'revision':
             ref = reference.commit_id
         else:
             ref = reference.name
 
         options = {option_name: [ref]}
         self._remote.pull_cmd(repository_path, hooks=False, **options)
         self._remote.invalidate_vcs_cache()
 
     def bookmark(self, bookmark, revision=None):
         if isinstance(bookmark, str):
             bookmark = safe_str(bookmark)
         self._remote.bookmark(bookmark, revision=revision)
         self._remote.invalidate_vcs_cache()
 
     def get_path_permissions(self, username):
         hgacl_file = os.path.join(self.path, '.hg/hgacl')
 
         def read_patterns(suffix):
             svalue = None
             for section, option in [
                 ('narrowacl', username + suffix),
                 ('narrowacl', 'default' + suffix),
                 ('narrowhgacl', username + suffix),
                 ('narrowhgacl', 'default' + suffix)
             ]:
                 try:
                     svalue = hgacl.get(section, option)
                     break  # stop at the first value we find
                 except configparser.NoOptionError:
                     pass
             if not svalue:
                 return None
             result = ['/']
             for pattern in svalue.split():
                 result.append(pattern)
                 if '*' not in pattern and '?' not in pattern:
                     result.append(pattern + '/*')
             return result
 
         if os.path.exists(hgacl_file):
             try:
                 hgacl = configparser.RawConfigParser()
                 hgacl.read(hgacl_file)
 
                 includes = read_patterns('.includes')
                 excludes = read_patterns('.excludes')
                 return BasePathPermissionChecker.create_from_patterns(
                     includes, excludes)
             except BaseException as e:
                 msg = 'Cannot read ACL settings from {} on {}: {}'.format(
                     hgacl_file, self.name, e)
                 raise exceptions.RepositoryRequirementError(msg)
         else:
             return None
 
 
 class MercurialIndexBasedCollectionGenerator(CollectionGenerator):
 
     def _commit_factory(self, commit_id):
         if isinstance(commit_id, int):
             return self.repo.get_commit(
                 commit_idx=commit_id, pre_load=self.pre_load)
         else:
             return self.repo.get_commit(
                 commit_id=commit_id, pre_load=self.pre_load)

rhodecode/lib/vcs/backends/svn/__init__.py

@@ -1,47 +1,45 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 SVN module
 """
 import logging
 
 from rhodecode.lib.vcs import connection
 from rhodecode.lib.vcs.backends.svn.commit import SubversionCommit
 from rhodecode.lib.vcs.backends.svn.repository import SubversionRepository
 
 
 log = logging.getLogger(__name__)
 
 
 def discover_svn_version(raise_on_exc=False):
     """
     Returns the string as it was returned by running 'git --version'
 
     It will return an empty string in case the connection is not initialized
     or no vcsserver is available.
     """
     try:
         return connection.Svn.discover_svn_version()
     except Exception:
         log.warning("Failed to discover the SVN version", exc_info=True)
         if raise_on_exc:
             raise
         return ''

rhodecode/lib/vcs/backends/svn/commit.py

@@ -1,256 +1,254 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 SVN commit module
 """
 
 
 import dateutil.parser
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from rhodecode.lib.str_utils import safe_bytes, safe_str
 from rhodecode.lib.vcs import nodes, path as vcspath
 from rhodecode.lib.vcs.backends import base
 from rhodecode.lib.vcs.exceptions import CommitError
 
 
 _SVN_PROP_TRUE = '*'
 
 
 class SubversionCommit(base.BaseCommit):
     """
     Subversion specific implementation of commits
 
     .. attribute:: branch
 
        The Subversion backend does not support to assign branches to
        specific commits. This attribute has always the value `None`.
 
     """
 
     def __init__(self, repository, commit_id):
         self.repository = repository
         self.idx = self.repository._get_commit_idx(commit_id)
         self._svn_rev = self.idx + 1
         self._remote = repository._remote
         # TODO: handling of raw_id should be a method on repository itself,
         # which knows how to translate commit index and commit id
         self.raw_id = commit_id
         self.short_id = commit_id
-        self.id = 'r%s' % (commit_id, )
+        self.id = 'r{}'.format(commit_id)
 
         # TODO: Implement the following placeholder attributes
         self.nodes = {}
         self.tags = []
 
     @property
     def author(self):
         return safe_str(self._properties.get('svn:author'))
 
     @property
     def date(self):
         return _date_from_svn_properties(self._properties)
 
     @property
     def message(self):
         return safe_str(self._properties.get('svn:log'))
 
     @LazyProperty
     def _properties(self):
         return self._remote.revision_properties(self._svn_rev)
 
     @LazyProperty
     def parents(self):
         parent_idx = self.idx - 1
         if parent_idx >= 0:
             parent = self.repository.get_commit(commit_idx=parent_idx)
             return [parent]
         return []
 
     @LazyProperty
     def children(self):
         child_idx = self.idx + 1
         if child_idx < len(self.repository.commit_ids):
             child = self.repository.get_commit(commit_idx=child_idx)
             return [child]
         return []
 
     def get_file_mode(self, path: bytes):
         # Note: Subversion flags files which are executable with a special
         # property `svn:executable` which is set to the value ``"*"``.
         if self._get_file_property(path, 'svn:executable') == _SVN_PROP_TRUE:
             return base.FILEMODE_EXECUTABLE
         else:
             return base.FILEMODE_DEFAULT
 
     def is_link(self, path):
         # Note: Subversion has a flag for special files, the content of the
         # file contains the type of that file.
         if self._get_file_property(path, 'svn:special') == _SVN_PROP_TRUE:
             return self.get_file_content(path).startswith(b'link')
         return False
 
     def is_node_binary(self, path):
         path = self._fix_path(path)
         return self._remote.is_binary(self._svn_rev, safe_str(path))
 
     def node_md5_hash(self, path):
         path = self._fix_path(path)
         return self._remote.md5_hash(self._svn_rev, safe_str(path))
 
     def _get_file_property(self, path, name):
         file_properties = self._remote.node_properties(
             safe_str(path), self._svn_rev)
         return file_properties.get(name)
 
     def get_file_content(self, path):
         path = self._fix_path(path)
         return self._remote.get_file_content(self._svn_rev, safe_str(path))
 
     def get_file_content_streamed(self, path):
         path = self._fix_path(path)
 
         stream_method = getattr(self._remote, 'stream:get_file_content')
         return stream_method(self._svn_rev, safe_str(path))
 
     def get_file_size(self, path):
         path = self._fix_path(path)
         return self._remote.get_file_size(self._svn_rev, safe_str(path))
 
     def get_path_history(self, path, limit=None, pre_load=None):
         path = safe_str(self._fix_path(path))
         history = self._remote.node_history(path, self._svn_rev, limit)
         return [
             self.repository.get_commit(commit_id=str(svn_rev))
             for svn_rev in history]
 
     def get_file_annotate(self, path, pre_load=None):
         result = self._remote.file_annotate(safe_str(path), self._svn_rev)
 
         for zero_based_line_no, svn_rev, content in result:
             commit_id = str(svn_rev)
             line_no = zero_based_line_no + 1
             yield (
                 line_no,
                 commit_id,
                 lambda: self.repository.get_commit(commit_id=commit_id),
                 content)
 
     def get_node(self, path, pre_load=None):
         path = self._fix_path(path)
         if path not in self.nodes:
 
             if path == '':
                 node = nodes.RootNode(commit=self)
             else:
                 node_type = self._remote.get_node_type(self._svn_rev, safe_str(path))
                 if node_type == 'dir':
                     node = nodes.DirNode(safe_bytes(path), commit=self)
                 elif node_type == 'file':
                     node = nodes.FileNode(safe_bytes(path), commit=self, pre_load=pre_load)
                 else:
                     raise self.no_node_at_path(path)
 
             self.nodes[path] = node
         return self.nodes[path]
 
     def get_nodes(self, path, pre_load=None):
         if self._get_kind(path) != nodes.NodeKind.DIR:
             raise CommitError(
                 f"Directory does not exist for commit {self.raw_id} at '{path}'")
         path = safe_str(self._fix_path(path))
 
         path_nodes = []
         for name, kind in self._remote.get_nodes(self._svn_rev, path):
             node_path = vcspath.join(path, name)
             if kind == 'dir':
                 node = nodes.DirNode(safe_bytes(node_path), commit=self)
             elif kind == 'file':
                 node = nodes.FileNode(safe_bytes(node_path), commit=self, pre_load=pre_load)
             else:
                 raise ValueError(f"Node kind {kind} not supported.")
             self.nodes[node_path] = node
             path_nodes.append(node)
 
         return path_nodes
 
     def _get_kind(self, path):
         path = self._fix_path(path)
         kind = self._remote.get_node_type(self._svn_rev, path)
         if kind == 'file':
             return nodes.NodeKind.FILE
         elif kind == 'dir':
             return nodes.NodeKind.DIR
         else:
             raise CommitError(
-                "Node does not exist at the given path '%s'" % (path, ))
+                "Node does not exist at the given path '{}'".format(path))
 
     @LazyProperty
     def _changes_cache(self):
         return self._remote.revision_changes(self._svn_rev)
 
     @LazyProperty
     def affected_files(self):
         changed_files = set()
         for files in self._changes_cache.values():
             changed_files.update(files)
         return list(changed_files)
 
     @LazyProperty
     def id(self):
         return self.raw_id
 
     @property
     def added(self):
         return nodes.AddedFileNodesGenerator(self.added_paths, self)
 
     @LazyProperty
     def added_paths(self):
         return [n for n in self._changes_cache['added']]
 
     @property
     def changed(self):
         return nodes.ChangedFileNodesGenerator(self.changed_paths, self)
 
     @LazyProperty
     def changed_paths(self):
         return [n for n in self._changes_cache['changed']]
 
     @property
     def removed(self):
         return nodes.RemovedFileNodesGenerator(self.removed_paths, self)
 
     @LazyProperty
     def removed_paths(self):
         return [n for n in self._changes_cache['removed']]
 
 
 def _date_from_svn_properties(properties):
     """
     Parses the date out of given svn properties.
 
     :return: :class:`datetime.datetime` instance. The object is naive.
     """
 
     aware_date = dateutil.parser.parse(properties.get('svn:date'))
     # final_date = aware_date.astimezone(dateutil.tz.tzlocal())
     final_date = aware_date
     return final_date.replace(tzinfo=None)

rhodecode/lib/vcs/backends/svn/diff.py

@@ -1,51 +1,49 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 SVN diff module
 """
 
 import re
 
 from rhodecode.lib.vcs.backends import base
 
 
 class SubversionDiff(base.Diff):
 
     _meta_re = re.compile(br"""
         (?:^(?P<svn_bin_patch>Cannot[ ]display:[ ]file[ ]marked[ ]as[ ]a[ ]binary[ ]type.)(?:\n|$))?
     """, re.VERBOSE | re.MULTILINE)
 
     _header_re = re.compile(br"""
         #^diff[ ]--git
             [ ]"?a/(?P<a_path>.+?)"?[ ]"?b/(?P<b_path>.+?)"?\n
         (?:^similarity[ ]index[ ](?P<similarity_index>\d+)%\n
            ^rename[ ]from[ ](?P<rename_from>[^\r\n]+)\n
            ^rename[ ]to[ ](?P<rename_to>[^\r\n]+)(?:\n|$))?
         (?:^old[ ]mode[ ](?P<old_mode>\d+)\n
            ^new[ ]mode[ ](?P<new_mode>\d+)(?:\n|$))?
         (?:^new[ ]file[ ]mode[ ](?P<new_file_mode>.+)(?:\n|$))?
         (?:^deleted[ ]file[ ]mode[ ](?P<deleted_file_mode>.+)(?:\n|$))?
         (?:^index[ ](?P<a_blob_id>[0-9A-Fa-f]+)
             \.\.(?P<b_blob_id>[0-9A-Fa-f]+)[ ]?(?P<b_mode>.+)?(?:\n|$))?
         (?:^(?P<bin_patch>GIT[ ]binary[ ]patch)(?:\n|$))?
         (?:^---[ ]("?a/(?P<a_file>.+)|/dev/null)\t\(revision[ ]\d+\)(?:\n|$))?
         (?:^\+\+\+[ ]("?b/(?P<b_file>.+)|/dev/null)\t\(revision[ ]\d+\)(?:\n|$))?
     """, re.VERBOSE | re.MULTILINE)

rhodecode/lib/vcs/backends/svn/inmemory.py

@@ -1,79 +1,77 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 """
 SVN inmemory module
 """
 
 from rhodecode.lib.datelib import date_astimestamp
 from rhodecode.lib.str_utils import safe_str, safe_bytes
 from rhodecode.lib.vcs.backends import base
 
 
 class SubversionInMemoryCommit(base.BaseInMemoryCommit):
 
     def commit(self, message, author, parents=None, branch=None, date=None, **kwargs):
         if branch not in (None, self.repository.DEFAULT_BRANCH_NAME):
             raise NotImplementedError("Branches are not yet supported")
 
         self.check_integrity(parents)
 
         message = safe_str(message)
         author = safe_str(author)
 
         updated = []
         for node in self.added:
             node_data = {
                 'path': safe_bytes(node.path),
                 'content': node.content,
                 'mode': node.mode,
             }
             if node.is_binary:
                 node_data['properties'] = {
                     'svn:mime-type': 'application/octet-stream'
                 }
             updated.append(node_data)
         for node in self.changed:
             updated.append({
                 'path': safe_bytes(node.path),
                 'content': node.content,
                 'mode': node.mode,
             })
 
         removed = []
         for node in self.removed:
             removed.append({
                 'path': safe_bytes(node.path),
             })
 
         timestamp = date_astimestamp(date) if date else None
         svn_rev = self.repository._remote.commit(
             message=message, author=author, timestamp=timestamp,
             updated=updated, removed=removed)
 
         # TODO: Find a nicer way. If commit_ids is not yet evaluated, then
         # we should not add the commit_id, if it is already evaluated, it
         # will not be evaluated again.
         commit_id = str(svn_rev)
         self.repository.append_commit_id(commit_id)
         tip = self.repository.get_commit()
         self.reset()
         return tip

rhodecode/lib/vcs/backends/svn/repository.py

@@ -1,369 +1,367 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 SVN repository module
 """
 
 import logging
 import os
 import urllib.request
 import urllib.parse
 import urllib.error
 
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from collections import OrderedDict
 from rhodecode.lib.datelib import date_astimestamp
 from rhodecode.lib.str_utils import safe_str
 from rhodecode.lib.utils2 import CachedProperty
 from rhodecode.lib.vcs import connection, path as vcspath
 from rhodecode.lib.vcs.backends import base
 from rhodecode.lib.vcs.backends.svn.commit import (
     SubversionCommit, _date_from_svn_properties)
 from rhodecode.lib.vcs.backends.svn.diff import SubversionDiff
 from rhodecode.lib.vcs.backends.svn.inmemory import SubversionInMemoryCommit
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.lib.vcs.exceptions import (
     CommitDoesNotExistError, EmptyRepositoryError, RepositoryError,
     VCSError, NodeDoesNotExistError)
 
 
 log = logging.getLogger(__name__)
 
 
 class SubversionRepository(base.BaseRepository):
     """
     Subversion backend implementation
 
     .. important::
 
        It is very important to distinguish the commit index and the commit id
        which is assigned by Subversion. The first one is always handled as an
        `int` by this implementation. The commit id assigned by Subversion on
        the other side will always be a `str`.
 
        There is a specific trap since the first commit will have the index
        ``0`` but the svn id will be ``"1"``.
 
     """
 
     # Note: Subversion does not really have a default branch name.
     DEFAULT_BRANCH_NAME = None
 
     contact = base.BaseRepository.DEFAULT_CONTACT
     description = base.BaseRepository.DEFAULT_DESCRIPTION
 
     def __init__(self, repo_path, config=None, create=False, src_url=None, with_wire=None,
                  bare=False, **kwargs):
         self.path = safe_str(os.path.abspath(repo_path))
         self.config = config if config else self.get_default_config()
         self.with_wire = with_wire or {"cache": False}  # default should not use cache
 
         self._init_repo(create, src_url)
 
         # caches
         self._commit_ids = {}
 
     @LazyProperty
     def _remote(self):
         repo_id = self.path
         return connection.Svn(self.path, repo_id, self.config, with_wire=self.with_wire)
 
     def _init_repo(self, create, src_url):
         if create and os.path.exists(self.path):
             raise RepositoryError(
                 f"Cannot create repository at {self.path}, location already exist"
             )
 
         if create:
             self._remote.create_repository(settings.SVN_COMPATIBLE_VERSION)
             if src_url:
                 src_url = _sanitize_url(src_url)
                 self._remote.import_remote_repository(src_url)
         else:
             self._check_path()
 
     @CachedProperty
     def commit_ids(self):
         head = self._remote.lookup(None)
         return [str(r) for r in range(1, head + 1)]
 
     def _rebuild_cache(self, commit_ids):
         pass
 
     def run_svn_command(self, cmd, **opts):
         """
         Runs given ``cmd`` as svn command and returns tuple
         (stdout, stderr).
 
         :param cmd: full svn command to be executed
         :param opts: env options to pass into Subprocess command
         """
         if not isinstance(cmd, list):
             raise ValueError(f'cmd must be a list, got {type(cmd)} instead')
 
         skip_stderr_log = opts.pop('skip_stderr_log', False)
         out, err = self._remote.run_svn_command(cmd, **opts)
         if err and not skip_stderr_log:
             log.debug('Stderr output of svn command "%s":\n%s', cmd, err)
         return out, err
 
     @LazyProperty
     def branches(self):
         return self._tags_or_branches('vcs_svn_branch')
 
     @LazyProperty
     def branches_closed(self):
         return {}
 
     @LazyProperty
     def bookmarks(self):
         return {}
 
     @LazyProperty
     def branches_all(self):
         # TODO: johbo: Implement proper branch support
         all_branches = {}
         all_branches.update(self.branches)
         all_branches.update(self.branches_closed)
         return all_branches
 
     @LazyProperty
     def tags(self):
         return self._tags_or_branches('vcs_svn_tag')
 
     def _tags_or_branches(self, config_section):
         found_items = {}
 
         if self.is_empty():
             return {}
 
         for pattern in self._patterns_from_section(config_section):
             pattern = vcspath.sanitize(pattern)
             tip = self.get_commit()
             try:
                 if pattern.endswith('*'):
                     basedir = tip.get_node(vcspath.dirname(pattern))
                     directories = basedir.dirs
                 else:
                     directories = (tip.get_node(pattern), )
             except NodeDoesNotExistError:
                 continue
             found_items.update((safe_str(n.path), self.commit_ids[-1]) for n in directories)
 
         def get_name(item):
             return item[0]
 
         return OrderedDict(sorted(found_items.items(), key=get_name))
 
     def _patterns_from_section(self, section):
         return (pattern for key, pattern in self.config.items(section))
 
     def get_common_ancestor(self, commit_id1, commit_id2, repo2):
         if self != repo2:
             raise ValueError(
                 "Subversion does not support getting common ancestor of"
                 " different repositories.")
 
         if int(commit_id1) < int(commit_id2):
             return commit_id1
         return commit_id2
 
     def verify(self):
         verify = self._remote.verify()
 
         self._remote.invalidate_vcs_cache()
         return verify
 
     def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None):
         # TODO: johbo: Implement better comparison, this is a very naive
         # version which does not allow to compare branches, tags or folders
         # at all.
         if repo2 != self:
             raise ValueError(
                 "Subversion does not support comparison of of different "
                 "repositories.")
 
         if commit_id1 == commit_id2:
             return []
 
         commit_idx1 = self._get_commit_idx(commit_id1)
         commit_idx2 = self._get_commit_idx(commit_id2)
 
         commits = [
             self.get_commit(commit_idx=idx)
             for idx in range(commit_idx1 + 1, commit_idx2 + 1)]
 
         return commits
 
     def _get_commit_idx(self, commit_id):
         try:
             svn_rev = int(commit_id)
         except:
             # TODO: johbo: this might be only one case, HEAD, check this
             svn_rev = self._remote.lookup(commit_id)
         commit_idx = svn_rev - 1
         if commit_idx >= len(self.commit_ids):
             raise CommitDoesNotExistError(
-                "Commit at index %s does not exist." % (commit_idx, ))
+                "Commit at index {} does not exist.".format(commit_idx))
         return commit_idx
 
     @staticmethod
     def check_url(url, config):
         """
         Check if `url` is a valid source to import a Subversion repository.
         """
         # convert to URL if it's a local directory
         if os.path.isdir(url):
             url = 'file://' + urllib.request.pathname2url(url)
         return connection.Svn.check_url(url, config.serialize())
 
     @staticmethod
     def is_valid_repository(path):
         try:
             SubversionRepository(path)
             return True
         except VCSError:
             pass
         return False
 
     def _check_path(self):
         if not os.path.exists(self.path):
-            raise VCSError('Path "%s" does not exist!' % (self.path, ))
+            raise VCSError('Path "{}" does not exist!'.format(self.path))
         if not self._remote.is_path_valid_repository(self.path):
             raise VCSError(
                 'Path "%s" does not contain a Subversion repository' %
                 (self.path, ))
 
     @LazyProperty
     def last_change(self):
         """
         Returns last change made on this repository as
         `datetime.datetime` object.
         """
         # Subversion always has a first commit which has id "0" and contains
         # what we are looking for.
         last_id = len(self.commit_ids)
         properties = self._remote.revision_properties(last_id)
         return _date_from_svn_properties(properties)
 
     @LazyProperty
     def in_memory_commit(self):
         return SubversionInMemoryCommit(self)
 
     def get_hook_location(self):
         """
         returns absolute path to location where hooks are stored
         """
         return os.path.join(self.path, 'hooks')
 
     def get_commit(self, commit_id=None, commit_idx=None, pre_load=None,
                    translate_tag=None, maybe_unreachable=False, reference_obj=None):
         if self.is_empty():
             raise EmptyRepositoryError("There are no commits yet")
         if commit_id is not None:
             self._validate_commit_id(commit_id)
         elif commit_idx is not None:
             self._validate_commit_idx(commit_idx)
             try:
                 commit_id = self.commit_ids[commit_idx]
             except IndexError:
-                raise CommitDoesNotExistError('No commit with idx: {}'.format(commit_idx))
+                raise CommitDoesNotExistError(f'No commit with idx: {commit_idx}')
 
         commit_id = self._sanitize_commit_id(commit_id)
         commit = SubversionCommit(repository=self, commit_id=commit_id)
         return commit
 
     def get_commits(
             self, start_id=None, end_id=None, start_date=None, end_date=None,
             branch_name=None, show_hidden=False, pre_load=None, translate_tags=None):
         if self.is_empty():
             raise EmptyRepositoryError("There are no commit_ids yet")
         self._validate_branch_name(branch_name)
 
         if start_id is not None:
             self._validate_commit_id(start_id)
         if end_id is not None:
             self._validate_commit_id(end_id)
 
         start_raw_id = self._sanitize_commit_id(start_id)
         start_pos = self.commit_ids.index(start_raw_id) if start_id else None
         end_raw_id = self._sanitize_commit_id(end_id)
         end_pos = max(0, self.commit_ids.index(end_raw_id)) if end_id else None
 
         if None not in [start_id, end_id] and start_pos > end_pos:
             raise RepositoryError(
                 "Start commit '%s' cannot be after end commit '%s'" %
                 (start_id, end_id))
         if end_pos is not None:
             end_pos += 1
 
         # Date based filtering
         if start_date or end_date:
             start_raw_id, end_raw_id = self._remote.lookup_interval(
                 date_astimestamp(start_date) if start_date else None,
                 date_astimestamp(end_date) if end_date else None)
             start_pos = start_raw_id - 1
             end_pos = end_raw_id
 
         commit_ids = self.commit_ids
 
         # TODO: johbo: Reconsider impact of DEFAULT_BRANCH_NAME here
         if branch_name not in [None, self.DEFAULT_BRANCH_NAME]:
             svn_rev = int(self.commit_ids[-1])
             commit_ids = self._remote.node_history(
                 path=branch_name, revision=svn_rev, limit=None)
             commit_ids = [str(i) for i in reversed(commit_ids)]
 
         if start_pos or end_pos:
             commit_ids = commit_ids[start_pos:end_pos]
         return base.CollectionGenerator(self, commit_ids, pre_load=pre_load)
 
     def _sanitize_commit_id(self, commit_id):
         if commit_id and commit_id.isdigit():
             if int(commit_id) <= len(self.commit_ids):
                 return commit_id
             else:
                 raise CommitDoesNotExistError(
-                    "Commit %s does not exist." % (commit_id, ))
+                    "Commit {} does not exist.".format(commit_id))
         if commit_id not in [
                 None, 'HEAD', 'tip', self.DEFAULT_BRANCH_NAME]:
             raise CommitDoesNotExistError(
-                "Commit id %s not understood." % (commit_id, ))
+                "Commit id {} not understood.".format(commit_id))
         svn_rev = self._remote.lookup('HEAD')
         return str(svn_rev)
 
     def get_diff(
             self, commit1, commit2, path=None, ignore_whitespace=False,
             context=3, path1=None):
         self._validate_diff_commits(commit1, commit2)
         svn_rev1 = int(commit1.raw_id)
         svn_rev2 = int(commit2.raw_id)
         diff = self._remote.diff(
             svn_rev1, svn_rev2, path1=path1, path2=path,
             ignore_whitespace=ignore_whitespace, context=context)
         return SubversionDiff(diff)
 
 
 def _sanitize_url(url):
     if '://' not in url:
         url = 'file://' + urllib.request.pathname2url(url)
     return url

rhodecode/lib/vcs/client_http.py

@@ -1,432 +1,429 b''
-
-
 # Copyright (C) 2016-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Client for the VCSServer implemented based on HTTP.
 """
 
 import copy
 import logging
 import threading
 import time
 import urllib.request
 import urllib.error
 import urllib.parse
 import urllib.parse
 import uuid
 import traceback
 
 import pycurl
 import msgpack
 import requests
 from requests.packages.urllib3.util.retry import Retry
 
 import rhodecode
 from rhodecode.lib import rc_cache
 from rhodecode.lib.rc_cache.utils import compute_key_from_params
 from rhodecode.lib.system_info import get_cert_path
 from rhodecode.lib.vcs import exceptions, CurlSession
 from rhodecode.lib.utils2 import str2bool
 
 log = logging.getLogger(__name__)
 
 
 # TODO: mikhail: Keep it in sync with vcsserver's
 # HTTPApplication.ALLOWED_EXCEPTIONS
 EXCEPTIONS_MAP = {
     'KeyError': KeyError,
     'URLError': urllib.error.URLError,
 }
 
 
 def _remote_call(url, payload, exceptions_map, session, retries=3):
 
     for attempt in range(retries):
         try:
             response = session.post(url, data=msgpack.packb(payload))
             break
         except pycurl.error as e:
             error_code, error_message = e.args
             if error_code == pycurl.E_RECV_ERROR:
                 log.warning(f'Received a "Connection reset by peer" error. '
                             f'Retrying... ({attempt + 1}/{retries})')
                 continue  # Retry if connection reset error.
-            msg = '{}. \npycurl traceback: {}'.format(e, traceback.format_exc())
+            msg = f'{e}. \npycurl traceback: {traceback.format_exc()}'
             raise exceptions.HttpVCSCommunicationError(msg)
         except Exception as e:
             message = getattr(e, 'message', '')
             if 'Failed to connect' in message:
                 # gevent doesn't return proper pycurl errors
                 raise exceptions.HttpVCSCommunicationError(e)
             else:
                 raise
 
     if response.status_code >= 400:
         content_type = response.content_type
         log.error('Call to %s returned non 200 HTTP code: %s [%s]',
                   url, response.status_code, content_type)
         raise exceptions.HttpVCSCommunicationError(repr(response.content))
 
     try:
         response = msgpack.unpackb(response.content)
     except Exception:
         log.exception('Failed to decode response from msgpack')
         raise
 
     error = response.get('error')
     if error:
         type_ = error.get('type', 'Exception')
         exc = exceptions_map.get(type_, Exception)
         exc = exc(error.get('message'))
         try:
             exc._vcs_kind = error['_vcs_kind']
         except KeyError:
             pass
 
         try:
             exc._vcs_server_traceback = error['traceback']
             exc._vcs_server_org_exc_name = error['org_exc']
             exc._vcs_server_org_exc_tb = error['org_exc_tb']
         except KeyError:
             pass
 
         exc.add_note(attach_exc_details(error))
         raise exc  # raising the org exception from vcsserver
     return response.get('result')
 
 
 def attach_exc_details(error):
     note = '-- EXC NOTE -- :\n'
     note += f'vcs_kind: {error.get("_vcs_kind")}\n'
     note += f'org_exc: {error.get("_vcs_kind")}\n'
     note += f'tb: {error.get("traceback")}\n'
     note += '-- END EXC NOTE --'
     return note
 
 
 def _streaming_remote_call(url, payload, exceptions_map, session, chunk_size):
     try:
         headers = {
             'X-RC-Method': payload.get('method'),
             'X-RC-Repo-Name': payload.get('_repo_name')
         }
         response = session.post(url, data=msgpack.packb(payload), headers=headers)
     except pycurl.error as e:
         error_code, error_message = e.args
-        msg = '{}. \npycurl traceback: {}'.format(e, traceback.format_exc())
+        msg = f'{e}. \npycurl traceback: {traceback.format_exc()}'
         raise exceptions.HttpVCSCommunicationError(msg)
     except Exception as e:
         message = getattr(e, 'message', '')
         if 'Failed to connect' in message:
             # gevent doesn't return proper pycurl errors
             raise exceptions.HttpVCSCommunicationError(e)
         else:
             raise
 
     if response.status_code >= 400:
         log.error('Call to %s returned non 200 HTTP code: %s',
                   url, response.status_code)
         raise exceptions.HttpVCSCommunicationError(repr(response.content))
 
     return response.iter_content(chunk_size=chunk_size)
 
 
 class ServiceConnection(object):
     def __init__(self, server_and_port, backend_endpoint, session_factory):
         self.url = urllib.parse.urljoin('http://%s' % server_and_port, backend_endpoint)
         self._session_factory = session_factory
 
     def __getattr__(self, name):
         def f(*args, **kwargs):
             return self._call(name, *args, **kwargs)
         return f
 
     @exceptions.map_vcs_exceptions
     def _call(self, name, *args, **kwargs):
         payload = {
             'id': str(uuid.uuid4()),
             'method': name,
             'params': {'args': args, 'kwargs': kwargs}
         }
         return _remote_call(
             self.url, payload, EXCEPTIONS_MAP, self._session_factory())
 
 
 class RemoteVCSMaker(object):
 
     def __init__(self, server_and_port, backend_endpoint, backend_type, session_factory):
         self.url = urllib.parse.urljoin('http://%s' % server_and_port, backend_endpoint)
         self.stream_url = urllib.parse.urljoin('http://%s' % server_and_port, backend_endpoint+'/stream')
 
         self._session_factory = session_factory
         self.backend_type = backend_type
 
     @classmethod
     def init_cache_region(cls, repo_id):
-        cache_namespace_uid = 'repo.{}'.format(repo_id)
+        cache_namespace_uid = f'repo.{repo_id}'
         region = rc_cache.get_or_create_region('cache_repo', cache_namespace_uid)
         return region, cache_namespace_uid
 
     def __call__(self, path, repo_id, config, with_wire=None):
         log.debug('%s RepoMaker call on %s', self.backend_type.upper(), path)
         return RemoteRepo(path, repo_id, config, self, with_wire=with_wire)
 
     def __getattr__(self, name):
         def remote_attr(*args, **kwargs):
             return self._call(name, *args, **kwargs)
         return remote_attr
 
     @exceptions.map_vcs_exceptions
     def _call(self, func_name, *args, **kwargs):
         payload = {
             'id': str(uuid.uuid4()),
             'method': func_name,
             'backend': self.backend_type,
             'params': {'args': args, 'kwargs': kwargs}
         }
         url = self.url
         return _remote_call(url, payload, EXCEPTIONS_MAP, self._session_factory())
 
 
 class RemoteRepo(object):
     CHUNK_SIZE = 16384
 
     def __init__(self, path, repo_id, config, remote_maker, with_wire=None):
         self.url = remote_maker.url
         self.stream_url = remote_maker.stream_url
         self._session = remote_maker._session_factory()
 
         cache_repo_id = self._repo_id_sanitizer(repo_id)
         _repo_name = self._get_repo_name(config, path)
         self._cache_region, self._cache_namespace = \
             remote_maker.init_cache_region(cache_repo_id)
 
         with_wire = with_wire or {}
 
         repo_state_uid = with_wire.get('repo_state_uid') or 'state'
 
         self._wire = {
             "_repo_name": _repo_name,
             "path": path,  # repo path
             "repo_id": repo_id,
             "cache_repo_id": cache_repo_id,
             "config": config,
             "repo_state_uid": repo_state_uid,
             "context": self._create_vcs_cache_context(path, repo_state_uid)
         }
 
         if with_wire:
             self._wire.update(with_wire)
 
         # NOTE(johbo): Trading complexity for performance. Avoiding the call to
         # log.debug brings a few percent gain even if is is not active.
         if log.isEnabledFor(logging.DEBUG):
             self._call_with_logging = True
 
         self.cert_dir = get_cert_path(rhodecode.CONFIG.get('__file__'))
 
     def _get_repo_name(self, config, path):
         repo_store = config.get('paths', '/')
         return path.split(repo_store)[-1].lstrip('/')
 
     def _repo_id_sanitizer(self, repo_id):
         pathless = repo_id.replace('/', '__').replace('-', '_')
         return ''.join(char if ord(char) < 128 else '_{}_'.format(ord(char)) for char in pathless)
 
     def __getattr__(self, name):
 
         if name.startswith('stream:'):
             def repo_remote_attr(*args, **kwargs):
                 return self._call_stream(name, *args, **kwargs)
         else:
             def repo_remote_attr(*args, **kwargs):
                 return self._call(name, *args, **kwargs)
 
         return repo_remote_attr
 
     def _base_call(self, name, *args, **kwargs):
         # TODO: oliver: This is currently necessary pre-call since the
         # config object is being changed for hooking scenarios
         wire = copy.deepcopy(self._wire)
         wire["config"] = wire["config"].serialize()
         wire["config"].append(('vcs', 'ssl_dir', self.cert_dir))
 
         payload = {
             'id': str(uuid.uuid4()),
             'method': name,
             "_repo_name":  wire['_repo_name'],
             'params': {'wire': wire, 'args': args, 'kwargs': kwargs}
         }
 
         context_uid = wire.get('context')
         return context_uid, payload
 
     def get_local_cache(self, name, args):
         cache_on = False
         cache_key = ''
         local_cache_on = rhodecode.ConfigGet().get_bool('vcs.methods.cache')
 
         cache_methods = [
             'branches', 'tags', 'bookmarks',
             'is_large_file', 'is_binary',
             'fctx_size', 'stream:fctx_node_data', 'blob_raw_length',
             'node_history',
             'revision', 'tree_items',
             'ctx_list', 'ctx_branch', 'ctx_description',
             'bulk_request',
             'assert_correct_path'
         ]
 
         if local_cache_on and name in cache_methods:
             cache_on = True
             repo_state_uid = self._wire['repo_state_uid']
             call_args = [a for a in args]
             cache_key = compute_key_from_params(repo_state_uid, name, *call_args)
 
         return cache_on, cache_key
 
     @exceptions.map_vcs_exceptions
     def _call(self, name, *args, **kwargs):
         context_uid, payload = self._base_call(name, *args, **kwargs)
         url = self.url
 
         start = time.time()
         cache_on, cache_key = self.get_local_cache(name, args)
 
         @self._cache_region.conditional_cache_on_arguments(
             namespace=self._cache_namespace, condition=cache_on and cache_key)
         def remote_call(_cache_key):
             if self._call_with_logging:
                 args_repr = f'ARG: {str(args):.512}|KW: {str(kwargs):.512}'
                 log.debug('Calling %s@%s with args:%r. wire_context: %s cache_on: %s',
                           url, name, args_repr, context_uid, cache_on)
             return _remote_call(url, payload, EXCEPTIONS_MAP, self._session)
 
         result = remote_call(cache_key)
         if self._call_with_logging:
             log.debug('Call %s@%s took: %.4fs. wire_context: %s',
                       url, name, time.time()-start, context_uid)
         return result
 
     @exceptions.map_vcs_exceptions
     def _call_stream(self, name, *args, **kwargs):
         context_uid, payload = self._base_call(name, *args, **kwargs)
         payload['chunk_size'] = self.CHUNK_SIZE
         url = self.stream_url
 
         start = time.time()
         cache_on, cache_key = self.get_local_cache(name, args)
 
         # Cache is a problem because this is a stream
         def streaming_remote_call(_cache_key):
             if self._call_with_logging:
                 args_repr = f'ARG: {str(args):.512}|KW: {str(kwargs):.512}'
                 log.debug('Calling %s@%s with args:%r. wire_context: %s cache_on: %s',
                           url, name, args_repr, context_uid, cache_on)
             return _streaming_remote_call(url, payload, EXCEPTIONS_MAP, self._session, self.CHUNK_SIZE)
 
         result = streaming_remote_call(cache_key)
         if self._call_with_logging:
             log.debug('Call %s@%s took: %.4fs. wire_context: %s',
                       url, name, time.time()-start, context_uid)
         return result
 
     def __getitem__(self, key):
         return self.revision(key)
 
     def _create_vcs_cache_context(self, *args):
         """
         Creates a unique string which is passed to the VCSServer on every
         remote call. It is used as cache key in the VCSServer.
         """
         hash_key = '-'.join(map(str, args))
         return str(uuid.uuid5(uuid.NAMESPACE_URL, hash_key))
 
     def invalidate_vcs_cache(self):
         """
         This invalidates the context which is sent to the VCSServer on every
         call to a remote method. It forces the VCSServer to create a fresh
         repository instance on the next call to a remote method.
         """
         self._wire['context'] = str(uuid.uuid4())
 
 
 class VcsHttpProxy(object):
 
     CHUNK_SIZE = 16384
 
     def __init__(self, server_and_port, backend_endpoint):
         retries = Retry(total=5, connect=None, read=None, redirect=None)
 
         adapter = requests.adapters.HTTPAdapter(max_retries=retries)
         self.base_url = urllib.parse.urljoin('http://%s' % server_and_port, backend_endpoint)
         self.session = requests.Session()
         self.session.mount('http://', adapter)
 
     def handle(self, environment, input_data, *args, **kwargs):
         data = {
             'environment': environment,
             'input_data': input_data,
             'args': args,
             'kwargs': kwargs
         }
         result = self.session.post(
             self.base_url, msgpack.packb(data), stream=True)
         return self._get_result(result)
 
     def _deserialize_and_raise(self, error):
         exception = Exception(error['message'])
         try:
             exception._vcs_kind = error['_vcs_kind']
         except KeyError:
             pass
         raise exception
 
     def _iterate(self, result):
         unpacker = msgpack.Unpacker()
         for line in result.iter_content(chunk_size=self.CHUNK_SIZE):
             unpacker.feed(line)
-            for chunk in unpacker:
-                yield chunk
+            yield from unpacker
 
     def _get_result(self, result):
         iterator = self._iterate(result)
         error = next(iterator)
         if error:
             self._deserialize_and_raise(error)
 
         status = next(iterator)
         headers = next(iterator)
 
         return iterator, status, headers
 
 
 class ThreadlocalSessionFactory(object):
     """
     Creates one CurlSession per thread on demand.
     """
 
     def __init__(self):
         self._thread_local = threading.local()
 
     def __call__(self):
         if not hasattr(self._thread_local, 'curl_session'):
             self._thread_local.curl_session = CurlSession()
         return self._thread_local.curl_session

rhodecode/lib/vcs/conf/__init__.py

@@ -1,18 +1,17 b''
-
 # Copyright (C) 2010-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/

rhodecode/lib/vcs/conf/mtypes.py

@@ -1,1221 +1,1219 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 DEFAULTS = {
  'encodings_map': {'.gz': 'gzip',
                    '.Z': 'compress',
                    '.bz2': 'bzip2',
                    '.xz': 'xz'},
  'suffix_map': {'.svgz': '.svg.gz',
                 '.tgz': '.tar.gz',
                 '.taz': '.tar.gz',
                 '.tz': '.tar.gz',
                 '.tbz2': '.tar.bz2',
                 '.txz': '.tar.xz'},
 }
 
 TYPES_MAP = [
  {'.jpg': 'image/jpg',
   '.mid': 'audio/midi',
   '.midi': 'audio/midi',
   '.pct': 'image/pict',
   '.pic': 'image/pict',
   '.pict': 'image/pict',
   '.rtf': 'application/rtf',
   '.xul': 'text/xul'},
  {'.123': 'application/vnd.lotus-1-2-3',
   '.3dml': 'text/vnd.in3d.3dml',
   '.3g2': 'video/3gpp2',
   '.3gp': 'video/3gpp',
   '.7z': 'application/x-7z-compressed',
   '.ASM': 'text/x-nasm',
   '.C': 'text/x-c++hdr',
   '.COB': 'text/x-cobol',
   '.CPP': 'text/x-c++hdr',
   '.CPY': 'text/x-cobol',
   '.F': 'text/x-fortran',
   '.F90': 'text/x-fortran',
   '.H': 'text/x-c++hdr',
   '.R': 'text/S-plus',
   '.Rd': 'text/x-r-doc',
   '.S': 'text/S-plus',
   '.[1234567]': 'application/x-troff',
   '.a': 'application/octet-stream',
   '.aab': 'application/x-authorware-bin',
   '.aac': 'audio/x-aac',
   '.aam': 'application/x-authorware-map',
   '.aas': 'application/x-authorware-seg',
   '.abap': 'text/x-abap',
   '.abw': 'application/x-abiword',
   '.ac': 'application/pkix-attr-cert',
   '.acc': 'application/vnd.americandynamics.acc',
   '.ace': 'application/x-ace-compressed',
   '.acu': 'application/vnd.acucobol',
   '.acutc': 'application/vnd.acucorp',
   '.ada': 'text/x-ada',
   '.adb': 'text/x-ada',
   '.adp': 'audio/adpcm',
   '.ads': 'text/x-ada',
   '.aep': 'application/vnd.audiograph',
   '.afm': 'application/x-font-type1',
   '.afp': 'application/vnd.ibm.modcap',
   '.ahead': 'application/vnd.ahead.space',
   '.ahk': 'text/x-autohotkey',
   '.ahkl': 'text/x-autohotkey',
   '.ai': 'application/postscript',
   '.aif': 'audio/x-aiff',
   '.aifc': 'audio/x-aiff',
   '.aiff': 'audio/x-aiff',
   '.air': 'application/vnd.adobe.air-application-installer-package+zip',
   '.ait': 'application/vnd.dvb.ait',
   '.aj': 'text/x-aspectj',
   '.ami': 'application/vnd.amiga.ami',
   '.apk': 'application/vnd.android.package-archive',
   '.application': 'application/x-ms-application',
   '.apr': 'application/vnd.lotus-approach',
   '.as': 'application/x-actionscript3',
   '.asc': 'application/pgp-signature',
   '.asf': 'video/x-ms-asf',
   '.asm': 'text/x-asm',
   '.aso': 'application/vnd.accpac.simply.aso',
   '.aspx': 'application/x-aspx',
   '.asx': 'video/x-ms-asf',
   '.asy': 'text/x-asymptote',
   '.atc': 'application/vnd.acucorp',
   '.atom': 'application/atom+xml',
   '.atomcat': 'application/atomcat+xml',
   '.atomsvc': 'application/atomsvc+xml',
   '.atx': 'application/vnd.antix.game-component',
   '.au': 'audio/basic',
   '.au3': 'text/x-autoit',
   '.aux': 'text/x-tex',
   '.avi': 'video/x-msvideo',
   '.aw': 'application/applixware',
   '.awk': 'application/x-awk',
   '.azf': 'application/vnd.airzip.filesecure.azf',
   '.azs': 'application/vnd.airzip.filesecure.azs',
   '.azw': 'application/vnd.amazon.ebook',
   '.b': 'application/x-brainfuck',
   '.bas': 'text/x-vbnet',
   '.bash': 'text/x-sh',
   '.bat': 'application/x-msdownload',
   '.bcpio': 'application/x-bcpio',
   '.bdf': 'application/x-font-bdf',
   '.bdm': 'application/vnd.syncml.dm+wbxml',
   '.bed': 'application/vnd.realvnc.bed',
   '.befunge': 'application/x-befunge',
   '.bf': 'application/x-brainfuck',
   '.bh2': 'application/vnd.fujitsu.oasysprs',
   '.bin': 'application/octet-stream',
   '.bmi': 'application/vnd.bmi',
   '.bmp': 'image/bmp',
   '.bmx': 'text/x-bmx',
   '.boo': 'text/x-boo',
   '.book': 'application/vnd.framemaker',
   '.box': 'application/vnd.previewsystems.box',
   '.boz': 'application/x-bzip2',
   '.bpk': 'application/octet-stream',
   '.btif': 'image/prs.btif',
   '.bz': 'application/x-bzip',
   '.bz2': 'application/x-bzip2',
   '.c': 'text/x-c',
   '.c++': 'text/x-c++hdr',
   '.c++-objdump': 'text/x-cpp-objdump',
   '.c-objdump': 'text/x-c-objdump',
   '.c11amc': 'application/vnd.cluetrust.cartomobile-config',
   '.c11amz': 'application/vnd.cluetrust.cartomobile-config-pkg',
   '.c4d': 'application/vnd.clonk.c4group',
   '.c4f': 'application/vnd.clonk.c4group',
   '.c4g': 'application/vnd.clonk.c4group',
   '.c4p': 'application/vnd.clonk.c4group',
   '.c4u': 'application/vnd.clonk.c4group',
   '.cab': 'application/vnd.ms-cab-compressed',
   '.car': 'application/vnd.curl.car',
   '.cat': 'application/vnd.ms-pki.seccat',
   '.cc': 'text/x-c',
   '.cct': 'application/x-director',
   '.ccxml': 'application/ccxml+xml',
   '.cdbcmsg': 'application/vnd.contact.cmsg',
   '.cdf': 'application/x-netcdf',
   '.cdkey': 'application/vnd.mediastation.cdkey',
   '.cdmia': 'application/cdmi-capability',
   '.cdmic': 'application/cdmi-container',
   '.cdmid': 'application/cdmi-domain',
   '.cdmio': 'application/cdmi-object',
   '.cdmiq': 'application/cdmi-queue',
   '.cdx': 'chemical/x-cdx',
   '.cdxml': 'application/vnd.chemdraw+xml',
   '.cdy': 'application/vnd.cinderella',
   '.cer': 'application/pkix-cert',
   '.ceylon': 'text/x-ceylon',
   '.cfc': 'application/x-coldfusion',
   '.cfg': 'text/x-ini',
   '.cfm': 'application/x-coldfusion',
   '.cfml': 'application/x-coldfusion',
   '.cgm': 'image/cgm',
   '.chat': 'application/x-chat',
   '.chm': 'application/vnd.ms-htmlhelp',
   '.chrt': 'application/vnd.kde.kchart',
   '.cif': 'chemical/x-cif',
   '.cii': 'application/vnd.anser-web-certificate-issue-initiation',
   '.cil': 'application/vnd.ms-artgalry',
   '.cl': 'text/x-common-lisp',
   '.cla': 'application/vnd.claymore',
   '.class': 'application/java-vm',
   '.clj': 'text/x-clojure',
   '.clkk': 'application/vnd.crick.clicker.keyboard',
   '.clkp': 'application/vnd.crick.clicker.palette',
   '.clkt': 'application/vnd.crick.clicker.template',
   '.clkw': 'application/vnd.crick.clicker.wordbank',
   '.clkx': 'application/vnd.crick.clicker',
   '.clp': 'application/x-msclip',
   '.cls': 'text/x-openedge',
   '.cmake': 'text/x-cmake',
   '.cmc': 'application/vnd.cosmocaller',
   '.cmd': 'application/x-dos-batch',
   '.cmdf': 'chemical/x-cmdf',
   '.cml': 'chemical/x-cml',
   '.cmp': 'application/vnd.yellowriver-custom-menu',
   '.cmx': 'image/x-cmx',
   '.cob': 'text/x-cobol',
   '.cod': 'application/vnd.rim.cod',
   '.coffee': 'text/coffeescript',
   '.com': 'application/x-msdownload',
   '.conf': 'text/plain',
   '.cp': 'text/x-c++hdr',
   '.cpio': 'application/x-cpio',
   '.cpp': 'text/x-c',
   '.cpp-objdump': 'text/x-cpp-objdump',
   '.cpt': 'application/mac-compactpro',
   '.cpy': 'text/x-cobol',
   '.crd': 'application/x-mscardfile',
   '.crl': 'application/pkix-crl',
   '.croc': 'text/x-crocsrc',
   '.crt': 'application/x-x509-ca-cert',
   '.cryptonote': 'application/vnd.rig.cryptonote',
   '.cs': 'text/x-csharp',
   '.csh': 'application/x-csh',
   '.csml': 'chemical/x-csml',
   '.csp': 'application/vnd.commonspace',
   '.css': 'text/css',
   '.cst': 'application/x-director',
   '.csv': 'text/csv',
   '.cu': 'application/cu-seeme',
   '.cuh': 'text/x-cuda',
   '.curl': 'text/vnd.curl',
   '.cww': 'application/prs.cww',
   '.cxt': 'application/x-director',
   '.cxx': 'text/x-c',
   '.cxx-objdump': 'text/x-cpp-objdump',
   '.d': 'text/x-dsrc',
   '.d-objdump': 'text/x-d-objdump',
   '.dae': 'model/vnd.collada+xml',
   '.daf': 'application/vnd.mobius.daf',
   '.dart': 'text/x-dart',
   '.dataless': 'application/vnd.fdsn.seed',
   '.davmount': 'application/davmount+xml',
   '.dcr': 'application/x-director',
   '.dcurl': 'text/vnd.curl.dcurl',
   '.dd2': 'application/vnd.oma.dd2+xml',
   '.ddd': 'application/vnd.fujixerox.ddd',
   '.deb': 'application/x-debian-package',
   '.def': 'text/plain',
   '.deploy': 'application/octet-stream',
   '.der': 'application/x-x509-ca-cert',
   '.dfac': 'application/vnd.dreamfactory',
   '.dg': 'text/x-dg',
   '.di': 'text/x-dsrc',
   '.dic': 'text/x-c',
   '.dif': 'video/x-dv',
   '.diff': 'text/x-diff',
   '.dir': 'application/x-director',
   '.dis': 'application/vnd.mobius.dis',
   '.dist': 'application/octet-stream',
   '.distz': 'application/octet-stream',
   '.djv': 'image/vnd.djvu',
   '.djvu': 'image/vnd.djvu',
   '.dll': 'application/x-msdownload',
   '.dmg': 'application/octet-stream',
   '.dms': 'application/octet-stream',
   '.dna': 'application/vnd.dna',
   '.doc': 'application/msword',
   '.docm': 'application/vnd.ms-word.document.macroenabled.12',
   '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
   '.dot': 'application/msword',
   '.dotm': 'application/vnd.ms-word.template.macroenabled.12',
   '.dotx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
   '.dp': 'application/vnd.osgi.dp',
   '.dpg': 'application/vnd.dpgraph',
   '.dra': 'audio/vnd.dra',
   '.dsc': 'text/prs.lines.tag',
   '.dssc': 'application/dssc+der',
   '.dtb': 'application/x-dtbook+xml',
   '.dtd': 'application/xml-dtd',
   '.dts': 'audio/vnd.dts',
   '.dtshd': 'audio/vnd.dts.hd',
   '.duby': 'text/x-ruby',
   '.duel': 'text/x-duel',
   '.dump': 'application/octet-stream',
   '.dv': 'video/x-dv',
   '.dvi': 'application/x-dvi',
   '.dwf': 'model/vnd.dwf',
   '.dwg': 'image/vnd.dwg',
   '.dxf': 'image/vnd.dxf',
   '.dxp': 'application/vnd.spotfire.dxp',
   '.dxr': 'application/x-director',
   '.dyl': 'text/x-dylan',
   '.dylan': 'text/x-dylan',
   '.dylan-console': 'text/x-dylan-console',
   '.ebuild': 'text/x-sh',
   '.ec': 'text/x-echdr',
   '.ecelp4800': 'audio/vnd.nuera.ecelp4800',
   '.ecelp7470': 'audio/vnd.nuera.ecelp7470',
   '.ecelp9600': 'audio/vnd.nuera.ecelp9600',
   '.ecl': 'text/x-ecl',
   '.eclass': 'text/x-sh',
   '.ecma': 'application/ecmascript',
   '.edm': 'application/vnd.novadigm.edm',
   '.edx': 'application/vnd.novadigm.edx',
   '.efif': 'application/vnd.picsel',
   '.eh': 'text/x-echdr',
   '.ei6': 'application/vnd.pg.osasli',
   '.el': 'text/x-common-lisp',
   '.elc': 'application/octet-stream',
   '.eml': 'message/rfc822',
   '.emma': 'application/emma+xml',
   '.eol': 'audio/vnd.digital-winds',
   '.eot': 'application/vnd.ms-fontobject',
   '.eps': 'application/postscript',
   '.epub': 'application/epub+zip',
   '.erl': 'text/x-erlang',
   '.erl-sh': 'text/x-erl-shellsession',
   '.es': 'text/x-erlang',
   '.es3': 'application/vnd.eszigno3+xml',
   '.escript': 'text/x-erlang',
   '.esf': 'application/vnd.epson.esf',
   '.et3': 'application/vnd.eszigno3+xml',
   '.etx': 'text/x-setext',
   '.evoque': 'application/x-evoque',
   '.ex': 'text/x-elixir',
   '.exe': 'application/x-msdownload',
   '.exi': 'application/exi',
   '.exs': 'text/x-elixir',
   '.ext': 'application/vnd.novadigm.ext',
   '.ez': 'application/andrew-inset',
   '.ez2': 'application/vnd.ezpix-album',
   '.ez3': 'application/vnd.ezpix-package',
   '.f': 'text/x-fortran',
   '.f4v': 'video/x-f4v',
   '.f77': 'text/x-fortran',
   '.f90': 'text/x-fortran',
   '.factor': 'text/x-factor',
   '.fan': 'application/x-fantom',
   '.fancypack': 'text/x-fancysrc',
   '.fbs': 'image/vnd.fastbidsheet',
   '.fcs': 'application/vnd.isac.fcs',
   '.fdf': 'application/vnd.fdf',
   '.fe_launch': 'application/vnd.denovo.fcselayout-link',
   '.feature': 'text/x-gherkin',
   '.fg5': 'application/vnd.fujitsu.oasysgp',
   '.fgd': 'application/x-director',
   '.fh': 'image/x-freehand',
   '.fh4': 'image/x-freehand',
   '.fh5': 'image/x-freehand',
   '.fh7': 'image/x-freehand',
   '.fhc': 'image/x-freehand',
   '.fig': 'application/x-xfig',
   '.fli': 'video/x-fli',
   '.flo': 'application/vnd.micrografx.flo',
   '.flv': 'video/x-flv',
   '.flw': 'application/vnd.kde.kivio',
   '.flx': 'text/vnd.fmi.flexstor',
   '.flxh': 'text/x-felix',
   '.fly': 'text/vnd.fly',
   '.fm': 'application/vnd.framemaker',
   '.fnc': 'application/vnd.frogans.fnc',
   '.for': 'text/x-fortran',
   '.fpx': 'image/vnd.fpx',
   '.frag': 'text/x-glslsrc',
   '.frame': 'application/vnd.framemaker',
   '.fs': 'text/x-fsharp',
   '.fsc': 'application/vnd.fsc.weblaunch',
   '.fsi': 'text/x-fsharp',
   '.fst': 'image/vnd.fst',
   '.ftc': 'application/vnd.fluxtime.clip',
   '.fti': 'application/vnd.anser-web-funds-transfer-initiation',
   '.fun': 'text/x-standardml',
   '.fvt': 'video/vnd.fvt',
   '.fxp': 'application/vnd.adobe.fxp',
   '.fxpl': 'application/vnd.adobe.fxp',
   '.fy': 'text/x-fancysrc',
   '.fzs': 'application/vnd.fuzzysheet',
   '.g2w': 'application/vnd.geoplan',
   '.g3': 'image/g3fax',
   '.g3w': 'application/vnd.geospace',
   '.gac': 'application/vnd.groove-account',
   '.gdc': 'text/x-gooddata-cl',
   '.gdl': 'model/vnd.gdl',
   '.gemspec': 'text/x-ruby',
   '.geo': 'application/vnd.dynageo',
   '.gex': 'application/vnd.geometry-explorer',
   '.ggb': 'application/vnd.geogebra.file',
   '.ggt': 'application/vnd.geogebra.tool',
   '.ghf': 'application/vnd.groove-help',
   '.gif': 'image/gif',
   '.gim': 'application/vnd.groove-identity-message',
   '.gmx': 'application/vnd.gmx',
   '.gnumeric': 'application/x-gnumeric',
   '.go': 'text/x-gosrc',
   '.gph': 'application/vnd.flographit',
   '.gqf': 'application/vnd.grafeq',
   '.gqs': 'application/vnd.grafeq',
   '.gram': 'application/srgs',
   '.gre': 'application/vnd.geometry-explorer',
   '.groovy': 'text/x-groovy',
   '.grv': 'application/vnd.groove-injector',
   '.grxml': 'application/srgs+xml',
   '.gs': 'text/x-gosu',
   '.gsf': 'application/x-font-ghostscript',
   '.gsp': 'text/x-gosu',
   '.gst': 'text/x-gosu-template',
   '.gsx': 'text/x-gosu',
   '.gtar': 'application/x-gtar',
   '.gtm': 'application/vnd.groove-tool-message',
   '.gtw': 'model/vnd.gtw',
   '.gv': 'text/vnd.graphviz',
   '.gxt': 'application/vnd.geonext',
   '.h': 'text/x-c',
   '.h++': 'text/x-c++hdr',
   '.h261': 'video/h261',
   '.h263': 'video/h263',
   '.h264': 'video/h264',
   '.hal': 'application/vnd.hal+xml',
   '.haml': 'text/x-haml',
   '.hbci': 'application/vnd.hbci',
   '.hdf': 'application/x-hdf',
   '.hdp': 'text/x-dylan-lid',
   '.hh': 'text/x-c',
   '.hlp': 'application/winhlp',
   '.hpgl': 'application/vnd.hp-hpgl',
   '.hpid': 'application/vnd.hp-hpid',
   '.hpp': 'text/x-c++hdr',
   '.hps': 'application/vnd.hp-hps',
   '.hqx': 'application/mac-binhex40',
   '.hrl': 'text/x-erlang',
   '.hs': 'text/x-haskell',
   '.htke': 'application/vnd.kenameaapp',
   '.htm': 'text/html',
   '.html': 'text/html',
   '.hvd': 'application/vnd.yamaha.hv-dic',
   '.hvp': 'application/vnd.yamaha.hv-voice',
   '.hvs': 'application/vnd.yamaha.hv-script',
   '.hx': 'text/haxe',
   '.hxx': 'text/x-c++hdr',
   '.hy': 'text/x-hybris',
   '.hyb': 'text/x-hybris',
   '.i2g': 'application/vnd.intergeo',
   '.icc': 'application/vnd.iccprofile',
   '.ice': 'x-conference/x-cooltalk',
   '.icm': 'application/vnd.iccprofile',
   '.ico': 'image/x-icon',
   '.ics': 'text/calendar',
   '.idc': 'text/x-chdr',
   '.ief': 'image/ief',
   '.ifb': 'text/calendar',
   '.ifm': 'application/vnd.shana.informed.formdata',
   '.iges': 'model/iges',
   '.igl': 'application/vnd.igloader',
   '.igm': 'application/vnd.insors.igm',
   '.igs': 'model/iges',
   '.igx': 'application/vnd.micrografx.igx',
   '.iif': 'application/vnd.shana.informed.interchange',
   '.ik': 'text/x-iokesrc',
   '.imp': 'application/vnd.accpac.simply.imp',
   '.ims': 'application/vnd.ms-ims',
   '.in': 'text/plain',
   '.inc': 'text/x-povray',
   '.ini': 'text/x-ini',
   '.intr': 'text/x-dylan',
   '.io': 'text/x-iosrc',
   '.ipfix': 'application/ipfix',
   '.ipk': 'application/vnd.shana.informed.package',
   '.irm': 'application/vnd.ibm.rights-management',
   '.irp': 'application/vnd.irepository.package+xml',
   '.iso': 'application/octet-stream',
   '.itp': 'application/vnd.shana.informed.formtemplate',
   '.ivp': 'application/vnd.immervision-ivp',
   '.ivu': 'application/vnd.immervision-ivu',
   '.j': 'text/x-objective-j',
   '.jad': 'text/vnd.sun.j2me.app-descriptor',
   '.jade': 'text/x-jade',
   '.jam': 'application/vnd.jam',
   '.jar': 'application/java-archive',
   '.java': 'text/x-java-source',
   '.jbst': 'text/x-duel',
   '.jisp': 'application/vnd.jisp',
   '.jl': 'text/x-julia',
   '.jlt': 'application/vnd.hp-jlyt',
   '.jnlp': 'application/x-java-jnlp-file',
   '.joda': 'application/vnd.joost.joda-archive',
   '.jp2': 'image/jp2',
   '.jpe': 'image/jpeg',
   '.jpeg': 'image/jpeg',
   '.jpg': 'image/jpeg',
   '.jpgm': 'video/jpm',
   '.jpgv': 'video/jpeg',
   '.jpm': 'video/jpm',
   '.js': 'application/javascript',
   '.json': 'application/json',
   '.jsp': 'application/x-jsp',
   '.kar': 'audio/midi',
   '.karbon': 'application/vnd.kde.karbon',
   '.kfo': 'application/vnd.kde.kformula',
   '.kia': 'application/vnd.kidspiration',
   '.kid': 'application/x-genshi',
   '.kk': 'text/x-koka',
   '.kki': 'text/x-koka',
   '.kml': 'application/vnd.google-earth.kml+xml',
   '.kmz': 'application/vnd.google-earth.kmz',
   '.kne': 'application/vnd.kinar',
   '.knp': 'application/vnd.kinar',
   '.kon': 'application/vnd.kde.kontour',
   '.kpr': 'application/vnd.kde.kpresenter',
   '.kpt': 'application/vnd.kde.kpresenter',
   '.ksh': 'text/plain',
   '.ksp': 'application/vnd.kde.kspread',
   '.kt': 'text/x-kotlin',
   '.ktr': 'application/vnd.kahootz',
   '.ktx': 'image/ktx',
   '.ktz': 'application/vnd.kahootz',
   '.kwd': 'application/vnd.kde.kword',
   '.kwt': 'application/vnd.kde.kword',
   '.lasso': 'text/x-lasso',
   '.lasso[89]': 'text/x-lasso',
   '.lasxml': 'application/vnd.las.las+xml',
   '.latex': 'application/x-latex',
   '.lbd': 'application/vnd.llamagraphics.life-balance.desktop',
   '.lbe': 'application/vnd.llamagraphics.life-balance.exchange+xml',
   '.les': 'application/vnd.hhe.lesson-player',
   '.less': 'text/x-less',
   '.lgt': 'text/x-logtalk',
   '.lha': 'application/octet-stream',
   '.lhs': 'text/x-literate-haskell',
   '.lid': 'text/x-dylan-lid',
   '.link66': 'application/vnd.route66.link66+xml',
   '.lisp': 'text/x-common-lisp',
   '.list': 'text/plain',
   '.list3820': 'application/vnd.ibm.modcap',
   '.listafp': 'application/vnd.ibm.modcap',
   '.ll': 'text/x-llvm',
   '.log': 'text/plain',
   '.lostxml': 'application/lost+xml',
   '.lrf': 'application/octet-stream',
   '.lrm': 'application/vnd.ms-lrm',
   '.ls': 'text/x-livescript',
   '.lsp': 'text/x-newlisp',
   '.ltf': 'application/vnd.frogans.ltf',
   '.ltx': 'text/x-latex',
   '.lua': 'text/x-lua',
   '.lvp': 'audio/vnd.lucent.voice',
   '.lwp': 'application/vnd.lotus-wordpro',
   '.lzh': 'application/octet-stream',
   '.m': 'text/octave',
   '.m13': 'application/x-msmediaview',
   '.m14': 'application/x-msmediaview',
   '.m1v': 'video/mpeg',
   '.m21': 'application/mp21',
   '.m2a': 'audio/mpeg',
   '.m2v': 'video/mpeg',
   '.m3a': 'audio/mpeg',
   '.m3u': 'audio/x-mpegurl',
   '.m3u8': 'application/x-mpegurl',
   '.m4a': 'audio/mp4a-latm',
   '.m4p': 'audio/mp4a-latm',
   '.m4u': 'video/vnd.mpegurl',
   '.m4v': 'video/x-m4v',
   '.ma': 'application/mathematica',
   '.mac': 'image/x-macpaint',
   '.mads': 'application/mads+xml',
   '.mag': 'application/vnd.ecowin.chart',
   '.mak': 'text/x-makefile',
   '.maker': 'application/vnd.framemaker',
   '.mako': 'application/x-mako',
   '.man': 'text/troff',
   '.manifest': 'text/cache-manifest',
   '.maql': 'text/x-gooddata-maql',
   '.markdown': 'text/x-markdown',
   '.mathml': 'application/mathml+xml',
   '.mb': 'application/mathematica',
   '.mbk': 'application/vnd.mobius.mbk',
   '.mbox': 'application/mbox',
   '.mc': 'application/x-mason',
   '.mc1': 'application/vnd.medcalcdata',
   '.mcd': 'application/vnd.mcd',
   '.mcurl': 'text/vnd.curl.mcurl',
   '.md': 'text/x-minidsrc',
   '.mdb': 'application/x-msaccess',
   '.mdi': 'image/vnd.ms-modi',
   '.mdown': 'text/x-markdown',
   '.me': 'text/troff',
   '.mesh': 'model/mesh',
   '.meta4': 'application/metalink4+xml',
   '.mets': 'application/mets+xml',
   '.mfm': 'application/vnd.mfmp',
   '.mgp': 'application/vnd.osgeo.mapguide.package',
   '.mgz': 'application/vnd.proteus.magazine',
   '.mht': 'message/rfc822',
   '.mhtml': 'message/rfc822',
   '.mi': 'application/x-mason',
   '.mid': 'audio/midi',
   '.midi': 'audio/midi',
   '.mif': 'application/vnd.mif',
   '.mime': 'message/rfc822',
   '.mj2': 'video/mj2',
   '.mjp2': 'video/mj2',
   '.ml': 'text/x-ocaml',
   '.mli': 'text/x-ocaml',
   '.mll': 'text/x-ocaml',
   '.mlp': 'application/vnd.dolby.mlp',
   '.mly': 'text/x-ocaml',
   '.mm': 'text/x-objective-c++',
   '.mmd': 'application/vnd.chipnuts.karaoke-mmd',
   '.mmf': 'application/vnd.smaf',
   '.mmr': 'image/vnd.fujixerox.edmics-mmr',
   '.mny': 'application/x-msmoney',
   '.mo': 'text/x-modelica',
   '.mobi': 'application/x-mobipocket-ebook',
   '.mobipocket-ebook': 'application/octet-stream',
   '.mod': 'text/x-modula2',
   '.mods': 'application/mods+xml',
   '.monkey': 'text/x-monkey',
   '.moo': 'text/x-moocode',
   '.moon': 'text/x-moonscript',
   '.mov': 'video/quicktime',
   '.movie': 'video/x-sgi-movie',
   '.mp2': 'audio/mpeg',
   '.mp21': 'application/mp21',
   '.mp2a': 'audio/mpeg',
   '.mp3': 'audio/mpeg',
   '.mp4': 'video/mp4',
   '.mp4a': 'audio/mp4',
   '.mp4s': 'application/mp4',
   '.mp4v': 'video/mp4',
   '.mpa': 'video/mpeg',
   '.mpc': 'application/vnd.mophun.certificate',
   '.mpe': 'video/mpeg',
   '.mpeg': 'video/mpeg',
   '.mpg': 'video/mpeg',
   '.mpg4': 'video/mp4',
   '.mpga': 'audio/mpeg',
   '.mpkg': 'application/vnd.apple.installer+xml',
   '.mpm': 'application/vnd.blueice.multipass',
   '.mpn': 'application/vnd.mophun.application',
   '.mpp': 'application/vnd.ms-project',
   '.mpt': 'application/vnd.ms-project',
   '.mpy': 'application/vnd.ibm.minipay',
   '.mqy': 'application/vnd.mobius.mqy',
   '.mrc': 'application/marc',
   '.mrcx': 'application/marcxml+xml',
   '.ms': 'text/troff',
   '.mscml': 'application/mediaservercontrol+xml',
   '.mseed': 'application/vnd.fdsn.mseed',
   '.mseq': 'application/vnd.mseq',
   '.msf': 'application/vnd.epson.msf',
   '.msh': 'model/mesh',
   '.msi': 'application/x-msdownload',
   '.msl': 'application/vnd.mobius.msl',
   '.msty': 'application/vnd.muvee.style',
   '.mts': 'model/vnd.mts',
   '.mus': 'application/vnd.musician',
   '.musicxml': 'application/vnd.recordare.musicxml+xml',
   '.mvb': 'application/x-msmediaview',
   '.mwf': 'application/vnd.mfer',
   '.mxf': 'application/mxf',
   '.mxl': 'application/vnd.recordare.musicxml',
   '.mxml': 'application/xv+xml',
   '.mxs': 'application/vnd.triscape.mxs',
   '.mxu': 'video/vnd.mpegurl',
   '.myt': 'application/x-myghty',
   '.n': 'text/x-nemerle',
   '.n-gage': 'application/vnd.nokia.n-gage.symbian.install',
   '.n3': 'text/n3',
   '.nb': 'application/mathematica',
   '.nbp': 'application/vnd.wolfram.player',
   '.nc': 'application/x-netcdf',
   '.ncx': 'application/x-dtbncx+xml',
   '.ngdat': 'application/vnd.nokia.n-gage.data',
   '.nim': 'text/x-nimrod',
   '.nimrod': 'text/x-nimrod',
   '.nl': 'text/x-newlisp',
   '.nlu': 'application/vnd.neurolanguage.nlu',
   '.nml': 'application/vnd.enliven',
   '.nnd': 'application/vnd.noblenet-directory',
   '.nns': 'application/vnd.noblenet-sealer',
   '.nnw': 'application/vnd.noblenet-web',
   '.npx': 'image/vnd.net-fpx',
   '.ns2': 'text/x-newspeak',
   '.nsf': 'application/vnd.lotus-notes',
   '.nsh': 'text/x-nsis',
   '.nsi': 'text/x-nsis',
   '.nws': 'message/rfc822',
   '.o': 'application/octet-stream',
   '.oa2': 'application/vnd.fujitsu.oasys2',
   '.oa3': 'application/vnd.fujitsu.oasys3',
   '.oas': 'application/vnd.fujitsu.oasys',
   '.obd': 'application/x-msbinder',
   '.obj': 'application/octet-stream',
   '.objdump': 'text/x-objdump',
   '.oda': 'application/oda',
   '.odb': 'application/vnd.oasis.opendocument.database',
   '.odc': 'application/vnd.oasis.opendocument.chart',
   '.odf': 'application/vnd.oasis.opendocument.formula',
   '.odft': 'application/vnd.oasis.opendocument.formula-template',
   '.odg': 'application/vnd.oasis.opendocument.graphics',
   '.odi': 'application/vnd.oasis.opendocument.image',
   '.odm': 'application/vnd.oasis.opendocument.text-master',
   '.odp': 'application/vnd.oasis.opendocument.presentation',
   '.ods': 'application/vnd.oasis.opendocument.spreadsheet',
   '.odt': 'application/vnd.oasis.opendocument.text',
   '.oga': 'audio/ogg',
   '.ogg': 'audio/ogg',
   '.ogv': 'video/ogg',
   '.ogx': 'application/ogg',
   '.onepkg': 'application/onenote',
   '.onetmp': 'application/onenote',
   '.onetoc': 'application/onenote',
   '.onetoc2': 'application/onenote',
   '.ooc': 'text/x-ooc',
   '.opa': 'text/x-opa',
   '.opf': 'application/oebps-package+xml',
   '.oprc': 'application/vnd.palm',
   '.org': 'application/vnd.lotus-organizer',
   '.osf': 'application/vnd.yamaha.openscoreformat',
   '.osfpvg': 'application/vnd.yamaha.openscoreformat.osfpvg+xml',
   '.otc': 'application/vnd.oasis.opendocument.chart-template',
   '.otf': 'application/x-font-otf',
   '.otg': 'application/vnd.oasis.opendocument.graphics-template',
   '.oth': 'application/vnd.oasis.opendocument.text-web',
   '.oti': 'application/vnd.oasis.opendocument.image-template',
   '.otp': 'application/vnd.oasis.opendocument.presentation-template',
   '.ots': 'application/vnd.oasis.opendocument.spreadsheet-template',
   '.ott': 'application/vnd.oasis.opendocument.text-template',
   '.oxt': 'application/vnd.openofficeorg.extension',
   '.p': 'text/x-pascal',
   '.p10': 'application/pkcs10',
   '.p12': 'application/x-pkcs12',
   '.p7b': 'application/x-pkcs7-certificates',
   '.p7c': 'application/pkcs7-mime',
   '.p7m': 'application/pkcs7-mime',
   '.p7r': 'application/x-pkcs7-certreqresp',
   '.p7s': 'application/pkcs7-signature',
   '.p8': 'application/pkcs8',
   '.pas': 'text/x-pascal',
   '.patch': 'text/x-diff',
   '.paw': 'application/vnd.pawaafile',
   '.pbd': 'application/vnd.powerbuilder6',
   '.pbm': 'image/x-portable-bitmap',
   '.pcf': 'application/x-font-pcf',
   '.pcl': 'application/vnd.hp-pcl',
   '.pclxl': 'application/vnd.hp-pclxl',
   '.pct': 'image/x-pict',
   '.pcurl': 'application/vnd.curl.pcurl',
   '.pcx': 'image/x-pcx',
   '.pdb': 'application/vnd.palm',
   '.pdf': 'application/pdf',
   '.pfa': 'application/x-font-type1',
   '.pfb': 'application/x-font-type1',
   '.pfm': 'application/x-font-type1',
   '.pfr': 'application/font-tdpfr',
   '.pfx': 'application/x-pkcs12',
   '.pgm': 'image/x-portable-graymap',
   '.pgn': 'application/x-chess-pgn',
   '.pgp': 'application/pgp-encrypted',
   '.php': 'text/x-php',
   '.php[345]': 'text/x-php',
   '.phtml': 'application/x-php',
   '.pic': 'image/x-pict',
   '.pict': 'image/pict',
   '.pkg': 'application/octet-stream',
   '.pki': 'application/pkixcmp',
   '.pkipath': 'application/pkix-pkipath',
   '.pl': 'text/plain',
   '.plb': 'application/vnd.3gpp.pic-bw-large',
   '.plc': 'application/vnd.mobius.plc',
   '.plf': 'application/vnd.pocketlearn',
   '.plot': 'text/x-gnuplot',
   '.pls': 'application/pls+xml',
   '.plt': 'text/x-gnuplot',
   '.pm': 'text/x-perl',
   '.pml': 'application/vnd.ctc-posml',
   '.png': 'image/png',
   '.pnm': 'image/x-portable-anymap',
   '.pnt': 'image/x-macpaint',
   '.pntg': 'image/x-macpaint',
   '.po': 'application/x-gettext',
   '.portpkg': 'application/vnd.macports.portpkg',
   '.pot': 'application/vnd.ms-powerpoint',
   '.potm': 'application/vnd.ms-powerpoint.template.macroenabled.12',
   '.potx': 'application/vnd.openxmlformats-officedocument.presentationml.template',
   '.pov': 'text/x-povray',
   '.ppa': 'application/vnd.ms-powerpoint',
   '.ppam': 'application/vnd.ms-powerpoint.addin.macroenabled.12',
   '.ppd': 'application/vnd.cups-ppd',
   '.ppm': 'image/x-portable-pixmap',
   '.pps': 'application/vnd.ms-powerpoint',
   '.ppsm': 'application/vnd.ms-powerpoint.slideshow.macroenabled.12',
   '.ppsx': 'application/vnd.openxmlformats-officedocument.presentationml.slideshow',
   '.ppt': 'application/vnd.ms-powerpoint',
   '.pptm': 'application/vnd.ms-powerpoint.presentation.macroenabled.12',
   '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
   '.pqa': 'application/vnd.palm',
   '.prc': 'application/x-mobipocket-ebook',
   '.pre': 'application/vnd.lotus-freelance',
   '.prf': 'application/pics-rules',
   '.pro': 'text/idl',
   '.prolog': 'text/x-prolog',
   '.properties': 'text/x-properties',
   '.ps': 'application/postscript',
   '.ps1': 'text/x-powershell',
   '.psb': 'application/vnd.3gpp.pic-bw-small',
   '.psd': 'image/vnd.adobe.photoshop',
   '.psf': 'application/x-font-linux-psf',
   '.pskcxml': 'application/pskc+xml',
   '.ptid': 'application/vnd.pvi.ptid1',
   '.pub': 'application/x-mspublisher',
   '.pvb': 'application/vnd.3gpp.pic-bw-var',
   '.pwn': 'application/vnd.3m.post-it-notes',
   '.pwz': 'application/vnd.ms-powerpoint',
   '.pxd': 'text/x-cython',
   '.pxi': 'text/x-cython',
   '.py': 'text/x-python',
   '.py3tb': 'text/x-python3-traceback',
   '.pya': 'audio/vnd.ms-playready.media.pya',
   '.pyc': 'application/x-python-code',
   '.pyo': 'application/x-python-code',
   '.pypylog': 'application/x-pypylog',
   '.pytb': 'text/x-python-traceback',
   '.pyv': 'video/vnd.ms-playready.media.pyv',
   '.pyw': 'text/x-python',
   '.pyx': 'text/x-cython',
   '.qam': 'application/vnd.epson.quickanime',
   '.qbo': 'application/vnd.intu.qbo',
   '.qfx': 'application/vnd.intu.qfx',
   '.qml': 'application/x-qml',
   '.qps': 'application/vnd.publishare-delta-tree',
   '.qt': 'video/quicktime',
   '.qti': 'image/x-quicktime',
   '.qtif': 'image/x-quicktime',
   '.qwd': 'application/vnd.quark.quarkxpress',
   '.qwt': 'application/vnd.quark.quarkxpress',
   '.qxb': 'application/vnd.quark.quarkxpress',
   '.qxd': 'application/vnd.quark.quarkxpress',
   '.qxl': 'application/vnd.quark.quarkxpress',
   '.qxt': 'application/vnd.quark.quarkxpress',
   '.r': 'text/x-rebol',
   '.r3': 'text/x-rebol',
   '.ra': 'audio/x-pn-realaudio',
   '.rake': 'text/x-ruby',
   '.ram': 'audio/x-pn-realaudio',
   '.rar': 'application/x-rar-compressed',
   '.ras': 'image/x-cmu-raster',
   '.rb': 'text/x-ruby',
   '.rbw': 'text/x-ruby',
   '.rbx': 'text/x-ruby',
   '.rc': 'text/x-stsrc',
   '.rcprofile': 'application/vnd.ipunplugged.rcprofile',
   '.rdf': 'application/rdf+xml',
   '.rdz': 'application/vnd.data-vision.rdz',
   '.reg': 'text/x-windows-registry',
   '.rep': 'application/vnd.businessobjects',
   '.res': 'application/x-dtbresource+xml',
   '.rest': 'text/x-rst',
   '.rgb': 'image/x-rgb',
   '.rhtml': 'text/html+ruby',
   '.rif': 'application/reginfo+xml',
   '.rip': 'audio/vnd.rip',
   '.rkt': 'text/x-racket',
   '.rktl': 'text/x-racket',
   '.rl': 'application/resource-lists+xml',
   '.rlc': 'image/vnd.fujixerox.edmics-rlc',
   '.rld': 'application/resource-lists-diff+xml',
   '.rm': 'application/vnd.rn-realmedia',
   '.rmi': 'audio/midi',
   '.rmp': 'audio/x-pn-realaudio-plugin',
   '.rms': 'application/vnd.jcp.javame.midlet-rms',
   '.rnc': 'application/relax-ng-compact-syntax',
   '.robot': 'text/x-robotframework',
   '.roff': 'text/troff',
   '.rp9': 'application/vnd.cloanto.rp9',
   '.rpss': 'application/vnd.nokia.radio-presets',
   '.rpst': 'application/vnd.nokia.radio-preset',
   '.rq': 'application/sparql-query',
   '.rs': 'application/rls-services+xml',
   '.rsd': 'application/rsd+xml',
   '.rss': 'application/rss+xml',
   '.rst': 'text/x-rst',
   '.rtf': 'application/rtf',
   '.rtx': 'text/richtext',
   '.s': 'text/x-asm',
   '.saf': 'application/vnd.yamaha.smaf-audio',
   '.sage': 'text/x-python',
   '.sass': 'text/x-sass',
   '.sbml': 'application/sbml+xml',
   '.sc': 'application/vnd.ibm.secure-container',
   '.scala': 'text/x-scala',
   '.scaml': 'text/x-scaml',
   '.scd': 'application/x-msschedule',
   '.sce': 'text/scilab',
   '.sci': 'text/scilab',
   '.scm': 'application/vnd.lotus-screencam',
   '.scq': 'application/scvp-cv-request',
   '.scs': 'application/scvp-cv-response',
   '.scss': 'text/x-scss',
   '.scurl': 'text/vnd.curl.scurl',
   '.sda': 'application/vnd.stardivision.draw',
   '.sdc': 'application/vnd.stardivision.calc',
   '.sdd': 'application/vnd.stardivision.impress',
   '.sdkd': 'application/vnd.solent.sdkm+xml',
   '.sdkm': 'application/vnd.solent.sdkm+xml',
   '.sdp': 'application/sdp',
   '.sdw': 'application/vnd.stardivision.writer',
   '.see': 'application/vnd.seemail',
   '.seed': 'application/vnd.fdsn.seed',
   '.sema': 'application/vnd.sema',
   '.semd': 'application/vnd.semd',
   '.semf': 'application/vnd.semf',
   '.ser': 'application/java-serialized-object',
   '.setpay': 'application/set-payment-initiation',
   '.setreg': 'application/set-registration-initiation',
   '.sfd-hdstx': 'application/vnd.hydrostatix.sof-data',
   '.sfs': 'application/vnd.spotfire.sfs',
   '.sgl': 'application/vnd.stardivision.writer-global',
   '.sgm': 'text/sgml',
   '.sgml': 'text/sgml',
   '.sh': 'application/x-sh',
   '.sh-session': 'application/x-shell-session',
   '.shar': 'application/x-shar',
   '.shell-session': 'application/x-sh-session',
   '.shf': 'application/shf+xml',
   '.sig': 'application/pgp-signature',
   '.silo': 'model/mesh',
   '.sis': 'application/vnd.symbian.install',
   '.sisx': 'application/vnd.symbian.install',
   '.sit': 'application/x-stuffit',
   '.sitx': 'application/x-stuffitx',
   '.skd': 'application/vnd.koan',
   '.skm': 'application/vnd.koan',
   '.skp': 'application/vnd.koan',
   '.skt': 'application/vnd.koan',
   '.sldm': 'application/vnd.ms-powerpoint.slide.macroenabled.12',
   '.sldx': 'application/vnd.openxmlformats-officedocument.presentationml.slide',
   '.slt': 'application/vnd.epson.salt',
   '.sm': 'application/vnd.stepmania.stepchart',
   '.smali': 'text/smali',
   '.smf': 'application/vnd.stardivision.math',
   '.smi': 'application/smil+xml',
   '.smil': 'application/smil+xml',
   '.sml': 'text/x-standardml',
   '.snd': 'audio/basic',
   '.snf': 'application/x-font-snf',
   '.snobol': 'text/x-snobol',
   '.so': 'application/octet-stream',
   '.sp': 'text/x-sourcepawn',
   '.spc': 'application/x-pkcs7-certificates',
   '.spec': 'text/x-rpm-spec',
   '.spf': 'application/vnd.yamaha.smaf-phrase',
   '.spl': 'application/x-futuresplash',
   '.spot': 'text/vnd.in3d.spot',
   '.spp': 'application/scvp-vp-response',
   '.spq': 'application/scvp-vp-request',
   '.spt': 'application/x-cheetah',
   '.spx': 'audio/ogg',
   '.sql': 'text/x-sql',
   '.sqlite3-console': 'text/x-sqlite3-console',
   '.src': 'application/x-wais-source',
   '.sru': 'application/sru+xml',
   '.srx': 'application/sparql-results+xml',
   '.ss': 'text/x-scheme',
   '.sse': 'application/vnd.kodak-descriptor',
   '.ssf': 'application/vnd.epson.ssf',
   '.ssml': 'application/ssml+xml',
   '.ssp': 'application/x-ssp',
   '.st': 'application/vnd.sailingtracker.track',
   '.stc': 'application/vnd.sun.xml.calc.template',
   '.std': 'application/vnd.sun.xml.draw.template',
   '.stf': 'application/vnd.wt.stf',
   '.sti': 'application/vnd.sun.xml.impress.template',
   '.stk': 'application/hyperstudio',
   '.stl': 'application/vnd.ms-pki.stl',
   '.str': 'application/vnd.pg.format',
   '.stw': 'application/vnd.sun.xml.writer.template',
   '.sub': 'image/vnd.dvb.subtitle',
   '.sus': 'application/vnd.sus-calendar',
   '.susp': 'application/vnd.sus-calendar',
   '.sv': 'text/x-systemverilog',
   '.sv4cpio': 'application/x-sv4cpio',
   '.sv4crc': 'application/x-sv4crc',
   '.svc': 'application/vnd.dvb.service',
   '.svd': 'application/vnd.svd',
   '.svg': 'image/svg+xml',
   '.svgz': 'image/svg+xml',
   '.svh': 'text/x-systemverilog',
   '.swa': 'application/x-director',
   '.swf': 'application/x-shockwave-flash',
   '.swi': 'application/vnd.aristanetworks.swi',
   '.sxc': 'application/vnd.sun.xml.calc',
   '.sxd': 'application/vnd.sun.xml.draw',
   '.sxg': 'application/vnd.sun.xml.writer.global',
   '.sxi': 'application/vnd.sun.xml.impress',
   '.sxm': 'application/vnd.sun.xml.math',
   '.sxw': 'application/vnd.sun.xml.writer',
   '.t': 'text/troff',
   '.tac': 'text/x-python',
   '.tao': 'application/vnd.tao.intent-module-archive',
   '.tar': 'application/x-tar',
   '.tcap': 'application/vnd.3gpp2.tcap',
   '.tcl': 'application/x-tcl',
   '.tcsh': 'application/x-csh',
   '.tea': 'text/x-tea',
   '.teacher': 'application/vnd.smart.teacher',
   '.tei': 'application/tei+xml',
   '.teicorpus': 'application/tei+xml',
   '.tex': 'application/x-tex',
   '.texi': 'application/x-texinfo',
   '.texinfo': 'application/x-texinfo',
   '.text': 'text/plain',
   '.tfi': 'application/thraud+xml',
   '.tfm': 'application/x-tex-tfm',
   '.thmx': 'application/vnd.ms-officetheme',
   '.tif': 'image/tiff',
   '.tiff': 'image/tiff',
   '.tmo': 'application/vnd.tmobile-livetv',
   '.tmpl': 'application/x-cheetah',
   '.toc': 'text/x-tex',
   '.torrent': 'application/x-bittorrent',
   '.tpl': 'application/vnd.groove-tool-template',
   '.tpt': 'application/vnd.trid.tpt',
   '.tr': 'text/troff',
   '.tra': 'application/vnd.trueapp',
   '.trm': 'application/x-msterminal',
   '.ts': 'video/mp2t',
   '.tsd': 'application/timestamped-data',
   '.tst': 'text/scilab',
   '.tsv': 'text/tab-separated-values',
   '.ttc': 'application/x-font-ttf',
   '.ttf': 'application/x-font-ttf',
   '.ttl': 'text/turtle',
   '.twd': 'application/vnd.simtech-mindmapper',
   '.twds': 'application/vnd.simtech-mindmapper',
   '.txd': 'application/vnd.genomatix.tuxedo',
   '.txf': 'application/vnd.mobius.txf',
   '.txt': 'text/plain',
   '.u': 'application/x-urbiscript',
   '.u32': 'application/x-authorware-bin',
   '.udeb': 'application/x-debian-package',
   '.ufd': 'application/vnd.ufdl',
   '.ufdl': 'application/vnd.ufdl',
   '.umj': 'application/vnd.umajin',
   '.unityweb': 'application/vnd.unity',
   '.uoml': 'application/vnd.uoml+xml',
   '.uri': 'text/uri-list',
   '.uris': 'text/uri-list',
   '.urls': 'text/uri-list',
   '.ustar': 'application/x-ustar',
   '.utz': 'application/vnd.uiq.theme',
   '.uu': 'text/x-uuencode',
   '.uva': 'audio/vnd.dece.audio',
   '.uvd': 'application/vnd.dece.data',
   '.uvf': 'application/vnd.dece.data',
   '.uvg': 'image/vnd.dece.graphic',
   '.uvh': 'video/vnd.dece.hd',
   '.uvi': 'image/vnd.dece.graphic',
   '.uvm': 'video/vnd.dece.mobile',
   '.uvp': 'video/vnd.dece.pd',
   '.uvs': 'video/vnd.dece.sd',
   '.uvt': 'application/vnd.dece.ttml+xml',
   '.uvu': 'video/vnd.uvvu.mp4',
   '.uvv': 'video/vnd.dece.video',
   '.uvva': 'audio/vnd.dece.audio',
   '.uvvd': 'application/vnd.dece.data',
   '.uvvf': 'application/vnd.dece.data',
   '.uvvg': 'image/vnd.dece.graphic',
   '.uvvh': 'video/vnd.dece.hd',
   '.uvvi': 'image/vnd.dece.graphic',
   '.uvvm': 'video/vnd.dece.mobile',
   '.uvvp': 'video/vnd.dece.pd',
   '.uvvs': 'video/vnd.dece.sd',
   '.uvvt': 'application/vnd.dece.ttml+xml',
   '.uvvu': 'video/vnd.uvvu.mp4',
   '.uvvv': 'video/vnd.dece.video',
   '.uvvx': 'application/vnd.dece.unspecified',
   '.uvx': 'application/vnd.dece.unspecified',
   '.v': 'text/x-verilog',
   '.vala': 'text/x-vala',
   '.vapi': 'text/x-vala',
   '.vark': 'text/x-gosu',
   '.vb': 'text/vbscript',
   '.vcd': 'application/x-cdlink',
   '.vcf': 'text/x-vcard',
   '.vcg': 'application/vnd.groove-vcard',
   '.vcs': 'text/x-vcalendar',
   '.vcx': 'application/vnd.vcx',
   '.vert': 'text/x-glslsrc',
   '.vhd': 'text/x-vhdl',
   '.vhdl': 'text/x-vhdl',
   '.vim': 'text/x-vim',
   '.vis': 'application/vnd.visionary',
   '.viv': 'video/vnd.vivo',
   '.vor': 'application/vnd.stardivision.writer',
   '.vox': 'application/x-authorware-bin',
   '.vrml': 'model/vrml',
   '.vsd': 'application/vnd.visio',
   '.vsf': 'application/vnd.vsf',
   '.vss': 'application/vnd.visio',
   '.vst': 'application/vnd.visio',
   '.vsw': 'application/vnd.visio',
   '.vtu': 'model/vnd.vtu',
   '.vxml': 'application/voicexml+xml',
   '.w3d': 'application/x-director',
   '.wad': 'application/x-doom',
   '.wav': 'audio/x-wav',
   '.wax': 'audio/x-ms-wax',
   '.wbmp': 'image/vnd.wap.wbmp',
   '.wbs': 'application/vnd.criticaltools.wbs+xml',
   '.wbxml': 'application/vnd.wap.wbxml',
   '.wcm': 'application/vnd.ms-works',
   '.wdb': 'application/vnd.ms-works',
   '.weba': 'audio/webm',
   '.webm': 'video/webm',
   '.webp': 'image/webp',
   '.weechatlog': 'text/x-irclog',
   '.wg': 'application/vnd.pmi.widget',
   '.wgt': 'application/widget',
   '.wiz': 'application/msword',
   '.wks': 'application/vnd.ms-works',
   '.wlua': 'text/x-lua',
   '.wm': 'video/x-ms-wm',
   '.wma': 'audio/x-ms-wma',
   '.wmd': 'application/x-ms-wmd',
   '.wmf': 'application/x-msmetafile',
   '.wml': 'text/vnd.wap.wml',
   '.wmlc': 'application/vnd.wap.wmlc',
   '.wmls': 'text/vnd.wap.wmlscript',
   '.wmlsc': 'application/vnd.wap.wmlscriptc',
   '.wmv': 'video/x-ms-wmv',
   '.wmx': 'video/x-ms-wmx',
   '.wmz': 'application/x-ms-wmz',
   '.woff': 'application/x-font-woff',
   '.wpd': 'application/vnd.wordperfect',
   '.wpl': 'application/vnd.ms-wpl',
   '.wps': 'application/vnd.ms-works',
   '.wqd': 'application/vnd.wqd',
   '.wri': 'application/x-mswrite',
   '.wrl': 'model/vrml',
   '.wsdl': 'application/wsdl+xml',
   '.wspolicy': 'application/wspolicy+xml',
   '.wtb': 'application/vnd.webturbo',
   '.wvx': 'video/x-ms-wvx',
   '.x': 'text/x-logos',
   '.x32': 'application/x-authorware-bin',
   '.x3d': 'application/vnd.hzn-3d-crossword',
   '.xap': 'application/x-silverlight-app',
   '.xar': 'application/vnd.xara',
   '.xbap': 'application/x-ms-xbap',
   '.xbd': 'application/vnd.fujixerox.docuworks.binder',
   '.xbm': 'image/x-xbitmap',
   '.xdf': 'application/xcap-diff+xml',
   '.xdm': 'application/vnd.syncml.dm+xml',
   '.xdp': 'application/vnd.adobe.xdp+xml',
   '.xdssc': 'application/dssc+xml',
   '.xdw': 'application/vnd.fujixerox.docuworks',
   '.xenc': 'application/xenc+xml',
   '.xer': 'application/patch-ops-error+xml',
   '.xfdf': 'application/vnd.adobe.xfdf',
   '.xfdl': 'application/vnd.xfdl',
   '.xht': 'application/xhtml+xml',
   '.xhtml': 'application/xhtml+xml',
   '.xhvml': 'application/xv+xml',
   '.xi': 'text/x-logos',
   '.xif': 'image/vnd.xiff',
   '.xla': 'application/vnd.ms-excel',
   '.xlam': 'application/vnd.ms-excel.addin.macroenabled.12',
   '.xlb': 'application/vnd.ms-excel',
   '.xlc': 'application/vnd.ms-excel',
   '.xlm': 'application/vnd.ms-excel',
   '.xls': 'application/vnd.ms-excel',
   '.xlsb': 'application/vnd.ms-excel.sheet.binary.macroenabled.12',
   '.xlsm': 'application/vnd.ms-excel.sheet.macroenabled.12',
   '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
   '.xlt': 'application/vnd.ms-excel',
   '.xltm': 'application/vnd.ms-excel.template.macroenabled.12',
   '.xltx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.template',
   '.xlw': 'application/vnd.ms-excel',
   '.xm': 'text/x-logos',
   '.xmi': 'text/x-logos',
   '.xml': 'application/xml',
   '.xo': 'application/vnd.olpc-sugar',
   '.xop': 'application/xop+xml',
   '.xpdl': 'application/xml',
   '.xpi': 'application/x-xpinstall',
   '.xpl': 'application/xsl+xml',
   '.xpm': 'image/x-xpixmap',
   '.xpr': 'application/vnd.is-xpr',
   '.xps': 'application/vnd.ms-xpsdocument',
   '.xpw': 'application/vnd.intercon.formnet',
   '.xpx': 'application/vnd.intercon.formnet',
   '.xq': 'application/xquery',
   '.xql': 'application/xquery',
   '.xqm': 'application/xquery',
   '.xquery': 'application/xquery',
   '.xqy': 'application/xquery',
   '.xsd': 'application/xml',
   '.xsl': 'application/xml',
   '.xslt': 'application/xslt+xml',
   '.xsm': 'application/vnd.syncml+xml',
   '.xspf': 'application/xspf+xml',
   '.xtend': 'text/x-xtend',
   '.xul': 'application/vnd.mozilla.xul+xml',
   '.xvm': 'application/xv+xml',
   '.xvml': 'application/xv+xml',
   '.xwd': 'image/x-xwindowdump',
   '.xyz': 'chemical/x-xyz',
   '.yaml': 'text/x-yaml',
   '.yang': 'application/yang',
   '.yin': 'application/yin+xml',
   '.yml': 'text/x-yaml',
   '.zaz': 'application/vnd.zzazz.deck+xml',
   '.zip': 'application/zip',
   '.zir': 'application/vnd.zul',
   '.zirz': 'application/vnd.zul',
   '.zmm': 'application/vnd.handheld-entertainment+xml'}
 ]
 
 
 def get_mimetypes_db(extra_types=None):
     import mimetypes
     types_map = TYPES_MAP
     if extra_types:
         types_map = TYPES_MAP[::]  # copy the initial version for extending
         types_map[1].update(extra_types)
     db = mimetypes.MimeTypes()
     db.types_map = types_map
     db.encodings_map.update(DEFAULTS['encodings_map'])
     db.suffix_map.update(DEFAULTS['suffix_map'])
     return db

rhodecode/lib/vcs/conf/settings.py

@@ -1,76 +1,74 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Internal settings for vcs-lib
 """
 
 # list of default encoding used in safe_str methods
 DEFAULT_ENCODINGS = ['utf8']
 
 
 # Compatibility version when creating SVN repositories. None means newest.
 # Other available options are: pre-1.4-compatible, pre-1.5-compatible,
 # pre-1.6-compatible, pre-1.8-compatible
 SVN_COMPATIBLE_VERSION = None
 
 ALIASES = ['hg', 'git', 'svn']
 
 BACKENDS = {
     'hg': 'rhodecode.lib.vcs.backends.hg.MercurialRepository',
     'git': 'rhodecode.lib.vcs.backends.git.GitRepository',
     'svn': 'rhodecode.lib.vcs.backends.svn.SubversionRepository',
 }
 
 
 ARCHIVE_SPECS = [
     ('tbz2', 'application/x-bzip2', '.tbz2'),
     ('tbz2', 'application/x-bzip2', '.tar.bz2'),
 
     ('tgz', 'application/x-gzip', '.tgz'),
     ('tgz', 'application/x-gzip', '.tar.gz'),
 
     ('zip', 'application/zip', '.zip'),
 ]
 
 HOOKS_PROTOCOL = None
 HOOKS_DIRECT_CALLS = False
 HOOKS_HOST = '127.0.0.1'
 
 
 MERGE_MESSAGE_TMPL = (
-    u'Merge pull request !{pr_id} from {source_repo} {source_ref_name}\n\n '
-    u'{pr_title}')
+    'Merge pull request !{pr_id} from {source_repo} {source_ref_name}\n\n '
+    '{pr_title}')
 MERGE_DRY_RUN_MESSAGE = 'dry_run_merge_message_from_rhodecode'
 MERGE_DRY_RUN_USER = 'Dry-Run User'
 MERGE_DRY_RUN_EMAIL = '[e-mail]'
 
 
 def available_aliases():
     """
     Mercurial is required for the system to work, so in case vcs.backends does
     not include it, we make sure it will be available internally
     TODO: anderson: refactor vcs.backends so it won't be necessary, VCS server
     should be responsible to dictate available backends.
     """
     aliases = ALIASES[:]
     if 'hg' not in aliases:
         aliases += ['hg']
     return aliases

rhodecode/lib/vcs/connection.py

@@ -1,45 +1,43 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Holds connection for remote server.
 """
 
 
 class NotInitializedConnection(object):
     """Placeholder for objects which have to be initialized first."""
 
     def _raise_exc(self):
         raise Exception(
             "rhodecode.lib.vcs is not yet initialized. "
             "Make sure `vcs.server` is enabled in your configuration.")
 
     def __getattr__(self, item):
         self._raise_exc()
 
     def __call__(self, *args, **kwargs):
         self._raise_exc()
 
 # TODO: figure out a nice default value for these things
 Service = NotInitializedConnection()
 
 Git = NotInitializedConnection()
 Hg = NotInitializedConnection()
 Svn = NotInitializedConnection()

rhodecode/lib/vcs/exceptions.py

@@ -1,234 +1,232 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Custom vcs exceptions module.
 """
 import logging
 import functools
 import urllib.error
 import urllib.parse
 import rhodecode
 
 log = logging.getLogger(__name__)
 
 
 class VCSCommunicationError(Exception):
     pass
 
 
 class HttpVCSCommunicationError(VCSCommunicationError):
     pass
 
 
 class VCSError(Exception):
     pass
 
 
 class RepositoryError(VCSError):
     pass
 
 
 class RepositoryRequirementError(RepositoryError):
     pass
 
 
 class UnresolvedFilesInRepo(RepositoryError):
     pass
 
 
 class VCSBackendNotSupportedError(VCSError):
     """
     Exception raised when VCSServer does not support requested backend
     """
 
 
 class EmptyRepositoryError(RepositoryError):
     pass
 
 
 class TagAlreadyExistError(RepositoryError):
     pass
 
 
 class TagDoesNotExistError(RepositoryError):
     pass
 
 
 class BranchAlreadyExistError(RepositoryError):
     pass
 
 
 class BranchDoesNotExistError(RepositoryError):
     pass
 
 
 class CommitError(RepositoryError):
     """
     Exceptions related to an existing commit
     """
 
 
 class CommitDoesNotExistError(CommitError):
     pass
 
 
 class CommittingError(RepositoryError):
     """
     Exceptions happening while creating a new commit
     """
 
 
 class NothingChangedError(CommittingError):
     pass
 
 
 class NodeError(VCSError):
     pass
 
 
 class RemovedFileNodeError(NodeError):
     pass
 
 
 class NodeAlreadyExistsError(CommittingError):
     pass
 
 
 class NodeAlreadyChangedError(CommittingError):
     pass
 
 
 class NodeDoesNotExistError(CommittingError):
     pass
 
 
 class NodeNotChangedError(CommittingError):
     pass
 
 
 class NodeAlreadyAddedError(CommittingError):
     pass
 
 
 class NodeAlreadyRemovedError(CommittingError):
     pass
 
 
 class SubrepoMergeError(RepositoryError):
     """
     This happens if we try to merge a repository which contains subrepos and
     the subrepos cannot be merged. The subrepos are not merged itself but
     their references in the root repo are merged.
     """
 
 
 class ImproperArchiveTypeError(VCSError):
     pass
 
 
 class CommandError(VCSError):
     pass
 
 
 class UnhandledException(VCSError):
     """
     Signals that something unexpected went wrong.
 
     This usually means we have a programming error on the side of the VCSServer
     and should inspect the logfile of the VCSServer to find more details.
     """
 
 
 _EXCEPTION_MAP = {
     'abort': RepositoryError,
     'archive': ImproperArchiveTypeError,
     'error': RepositoryError,
     'lookup': CommitDoesNotExistError,
     'repo_locked': RepositoryError,
     'requirement': RepositoryRequirementError,
     'unhandled': UnhandledException,
     # TODO: johbo: Define our own exception for this and stop abusing
     # urllib's exception class.
     'url_error': urllib.error.URLError,
     'subrepo_merge_error': SubrepoMergeError,
 }
 
 
 def map_vcs_exceptions(func):
     """
     Utility to decorate functions so that plain exceptions are translated.
 
     The translation is based on `exc_map` which maps a `str` indicating
     the error type into an exception class representing this error inside
     of the vcs layer.
     """
 
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
         try:
             return func(*args, **kwargs)
         except Exception as e:
             debug = rhodecode.ConfigGet().get_bool('debug')
 
             # The error middleware adds information if it finds
             # __traceback_info__ in a frame object. This way the remote
             # traceback information is made available in error reports.
 
             remote_tb = getattr(e, '_vcs_server_traceback', None)
             org_remote_tb = getattr(e, '_vcs_server_org_exc_tb', '')
             __traceback_info__ = None
             if remote_tb:
                 if isinstance(remote_tb, str):
                     remote_tb = [remote_tb]
                 __traceback_info__ = (
                     'Found VCSServer remote traceback information:\n'
                     '{}\n'
                     '+++ BEG SOURCE EXCEPTION +++\n\n'
                     '{}\n'
                     '+++ END SOURCE EXCEPTION +++\n'
                     ''.format('\n'.join(remote_tb), org_remote_tb)
                 )
 
                 # Avoid that remote_tb also appears in the frame
                 del remote_tb
 
             # Special vcs errors had an attribute "_vcs_kind" which is used
             # to translate them to the proper exception class in the vcs
             # client layer.
             kind = getattr(e, '_vcs_kind', None)
             exc_name = getattr(e, '_vcs_server_org_exc_name', None)
 
             if kind:
                 if any(e.args):
                     _args = [a for a in e.args]
                     # replace the first argument with a prefix exc name
                     args = ['{}:{}'.format(exc_name, _args[0] if _args else '?')] + _args[1:]
                 else:
-                    args = [__traceback_info__ or '{}: UnhandledException'.format(exc_name)]
+                    args = [__traceback_info__ or f'{exc_name}: UnhandledException']
                 if debug or __traceback_info__ and kind not in ['unhandled', 'lookup']:
                     # for other than unhandled errors also log the traceback
                     # can be useful for debugging
                     log.error(__traceback_info__)
 
                 raise _EXCEPTION_MAP[kind](*args)
             else:
                 raise
     return wrapper

rhodecode/lib/vcs/geventcurl.py

@@ -1,253 +1,251 b''
-
-
 # Copyright (C) 2016-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 This serves as a drop in replacement for pycurl. It implements the pycurl Curl
 class in a way that is compatible with gevent.
 """
 
 
 import logging
 import gevent
 import pycurl
 import greenlet
 
 # Import everything from pycurl.
 # This allows us to use this module as a drop in replacement of pycurl.
 from pycurl import *  # pragma: no cover
 
 from gevent import core
 from gevent.hub import Waiter
 
 
 log = logging.getLogger(__name__)
 
 
 class GeventCurlMulti(object):
     """
     Wrapper around pycurl.CurlMulti that integrates it into gevent's event
     loop.
 
     Parts of this class are a modified version of code copied from the Tornado
     Web Server project which is licensed under the Apache License, Version 2.0
     (the "License"). To be more specific the code originates from this file:
     https://github.com/tornadoweb/tornado/blob/stable/tornado/curl_httpclient.py
 
     This is the original license header of the origin:
 
         Copyright 2009 Facebook
 
         Licensed under the Apache License, Version 2.0 (the "License"); you may
         not use this file except in compliance with the License. You may obtain
         a copy of the License at
 
             http://www.apache.org/licenses/LICENSE-2.0
 
         Unless required by applicable law or agreed to in writing, software
         distributed under the License is distributed on an "AS IS" BASIS,
         WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
         implied. See the License for the specific language governing
         permissions and limitations under the License.
     """
 
     def __init__(self, loop=None):
         self._watchers = {}
         self._timeout = None
         self.loop = loop or gevent.get_hub().loop
 
         # Setup curl's multi instance.
         self._curl_multi = pycurl.CurlMulti()
         self.setopt(pycurl.M_TIMERFUNCTION, self._set_timeout)
         self.setopt(pycurl.M_SOCKETFUNCTION, self._handle_socket)
 
     def __getattr__(self, item):
         """
         The pycurl.CurlMulti class is final and we cannot subclass it.
         Therefore we are wrapping it and forward everything to it here.
         """
         return getattr(self._curl_multi, item)
 
     def add_handle(self, curl):
         """
         Add handle variant that also takes care about the initial invocation of
         socket action method. This is done by setting an immediate timeout.
         """
         result = self._curl_multi.add_handle(curl)
         self._set_timeout(0)
         return result
 
     def _handle_socket(self, event, fd, multi, data):
         """
         Called by libcurl when it wants to change the file descriptors it cares
         about.
         """
         event_map = {
             pycurl.POLL_NONE: core.NONE,
             pycurl.POLL_IN: core.READ,
             pycurl.POLL_OUT: core.WRITE,
             pycurl.POLL_INOUT: core.READ | core.WRITE
         }
 
         if event == pycurl.POLL_REMOVE:
             watcher = self._watchers.pop(fd, None)
             if watcher is not None:
                 watcher.stop()
         else:
             gloop_event = event_map[event]
             watcher = self._watchers.get(fd)
             if watcher is None:
                 watcher = self.loop.io(fd, gloop_event)
                 watcher.start(self._handle_events, fd, pass_events=True)
                 self._watchers[fd] = watcher
             else:
                 if watcher.events != gloop_event:
                     watcher.stop()
                     watcher.events = gloop_event
                     watcher.start(self._handle_events, fd, pass_events=True)
 
     def _set_timeout(self, msecs):
         """
         Called by libcurl to schedule a timeout.
         """
         if self._timeout is not None:
             self._timeout.stop()
         self._timeout = self.loop.timer(msecs/1000.0)
         self._timeout.start(self._handle_timeout)
 
     def _handle_events(self, events, fd):
         action = 0
         if events & core.READ:
             action |= pycurl.CSELECT_IN
         if events & core.WRITE:
             action |= pycurl.CSELECT_OUT
         while True:
             try:
                 ret, num_handles = self._curl_multi.socket_action(fd, action)
             except pycurl.error as e:
                 ret = e.args[0]
             if ret != pycurl.E_CALL_MULTI_PERFORM:
                 break
         self._finish_pending_requests()
 
     def _handle_timeout(self):
         """
         Called by IOLoop when the requested timeout has passed.
         """
         if self._timeout is not None:
             self._timeout.stop()
             self._timeout = None
         while True:
             try:
                 ret, num_handles = self._curl_multi.socket_action(
                     pycurl.SOCKET_TIMEOUT, 0)
             except pycurl.error as e:
                 ret = e.args[0]
             if ret != pycurl.E_CALL_MULTI_PERFORM:
                 break
         self._finish_pending_requests()
 
         # In theory, we shouldn't have to do this because curl will call
         # _set_timeout whenever the timeout changes. However, sometimes after
         # _handle_timeout we will need to reschedule immediately even though
         # nothing has changed from curl's perspective. This is because when
         # socket_action is called with SOCKET_TIMEOUT, libcurl decides
         # internally which timeouts need to be processed by using a monotonic
         # clock (where available) while tornado uses python's time.time() to
         # decide when timeouts have occurred. When those clocks disagree on
         # elapsed time (as they will whenever there is an NTP adjustment),
         # tornado might call _handle_timeout before libcurl is ready. After
         # each timeout, resync the scheduled timeout with libcurl's current
         # state.
         new_timeout = self._curl_multi.timeout()
         if new_timeout >= 0:
             self._set_timeout(new_timeout)
 
     def _finish_pending_requests(self):
         """
         Process any requests that were completed by the last call to
         multi.socket_action.
         """
         while True:
             num_q, ok_list, err_list = self._curl_multi.info_read()
             for curl in ok_list:
                 curl.waiter.switch(None)
             for curl, errnum, errmsg in err_list:
                 curl.waiter.throw(Exception('%s %s' % (errnum, errmsg)))
             if num_q == 0:
                 break
 
 
 class GeventCurl(object):
     """
     Gevent compatible implementation of the pycurl.Curl class. Essentially a
     wrapper around pycurl.Curl with a customized perform method. It uses the
     GeventCurlMulti class to implement a blocking API to libcurl's "easy"
     interface.
     """
 
     # Reference to the GeventCurlMulti instance.
     _multi_instance = None
 
     def __init__(self):
         self._curl = pycurl.Curl()
 
     def __getattr__(self, item):
         """
         The pycurl.Curl class is final and we cannot subclass it. Therefore we
         are wrapping it and forward everything to it here.
         """
         return getattr(self._curl, item)
 
     @property
     def _multi(self):
         """
         Lazy property that returns the GeventCurlMulti instance. The value is
         cached as a class attribute. Therefore only one instance per process
         exists.
         """
         if GeventCurl._multi_instance is None:
             GeventCurl._multi_instance = GeventCurlMulti()
         return GeventCurl._multi_instance
 
     def perform(self):
         """
         This perform method is compatible with gevent because it uses gevent
         synchronization mechanisms to wait for the request to finish.
         """
         if getattr(self._curl, 'waiter', None) is not None:
             current = greenlet.getcurrent()
             msg = 'This curl object is already used by another greenlet, {}, \n' \
                   'this is {}'.format(self._curl.waiter, current)
             raise Exception(msg)
 
         waiter = self._curl.waiter = Waiter()
         try:
             self._multi.add_handle(self._curl)
             try:
                 return waiter.get()
             finally:
                 self._multi.remove_handle(self._curl)
         finally:
             del self._curl.waiter
 
 
 # Curl is originally imported from pycurl. At this point we override it with
 # our custom implementation.
 Curl = GeventCurl

rhodecode/lib/vcs/nodes.py

@@ -1,963 +1,962 b''
 
 
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Module holding everything related to vcs nodes, with vcs2 architecture.
 """
 import functools
 import os
 import stat
 
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from rhodecode.config.conf import LANGUAGES_EXTENSIONS_MAP
 from rhodecode.lib.str_utils import safe_str, safe_bytes
 from rhodecode.lib.hash_utils import md5
 from rhodecode.lib.vcs import path as vcspath
 from rhodecode.lib.vcs.backends.base import EmptyCommit, FILEMODE_DEFAULT
 from rhodecode.lib.vcs.conf.mtypes import get_mimetypes_db
 from rhodecode.lib.vcs.exceptions import NodeError, RemovedFileNodeError
 
 LARGEFILE_PREFIX = '.hglf'
 
 
 class NodeKind:
     SUBMODULE = -1
     DIR = 1
     FILE = 2
     LARGEFILE = 3
 
 
 class NodeState:
     ADDED = 'added'
     CHANGED = 'changed'
     NOT_CHANGED = 'not changed'
     REMOVED = 'removed'
 
 #TODO: not sure if that should be bytes or str ?
 # most probably bytes because content should be bytes and we check it
 BIN_BYTE_MARKER = b'\0'
 
 
 class NodeGeneratorBase(object):
     """
     Base class for removed added and changed filenodes, it's a lazy generator
     class that will create filenodes only on iteration or call
 
     The len method doesn't need to create filenodes at all
     """
 
     def __init__(self, current_paths, cs):
         self.cs = cs
         self.current_paths = current_paths
 
     def __call__(self):
         return [n for n in self]
 
     def __getitem__(self, key):
         if isinstance(key, slice):
             for p in self.current_paths[key.start:key.stop]:
                 yield self.cs.get_node(p)
 
     def __len__(self):
         return len(self.current_paths)
 
     def __iter__(self):
         for p in self.current_paths:
             yield self.cs.get_node(p)
 
 
 class AddedFileNodesGenerator(NodeGeneratorBase):
     """
     Class holding added files for current commit
     """
 
 
 class ChangedFileNodesGenerator(NodeGeneratorBase):
     """
     Class holding changed files for current commit
     """
 
 
 class RemovedFileNodesGenerator(NodeGeneratorBase):
     """
     Class holding removed files for current commit
     """
     def __iter__(self):
         for p in self.current_paths:
             yield RemovedFileNode(path=safe_bytes(p))
 
     def __getitem__(self, key):
         if isinstance(key, slice):
             for p in self.current_paths[key.start:key.stop]:
                 yield RemovedFileNode(path=safe_bytes(p))
 
 
 @functools.total_ordering
 class Node(object):
     """
     Simplest class representing file or directory on repository.  SCM backends
     should use ``FileNode`` and ``DirNode`` subclasses rather than ``Node``
     directly.
 
     Node's ``path`` cannot start with slash as we operate on *relative* paths
     only. Moreover, every single node is identified by the ``path`` attribute,
     so it cannot end with slash, too. Otherwise, path could lead to mistakes.
     """
     # RTLO marker allows swapping text, and certain
     # security attacks could be used with this
     RTLO_MARKER = "\u202E"
 
     commit = None
 
     def __init__(self, path: bytes, kind):
         self._validate_path(path)  # can throw exception if path is invalid
 
         self.bytes_path = path.rstrip(b'/')  # store for __repr__
         self.path = safe_str(self.bytes_path)  # we store paths as str
 
         if self.bytes_path == b'' and kind != NodeKind.DIR:
             raise NodeError("Only DirNode and its subclasses may be "
                             "initialized with empty path")
         self.kind = kind
 
         if self.is_root() and not self.is_dir():
             raise NodeError("Root node cannot be FILE kind")
 
     def __eq__(self, other):
         if type(self) is not type(other):
             return False
         for attr in ['name', 'path', 'kind']:
             if getattr(self, attr) != getattr(other, attr):
                 return False
         if self.is_file():
             # FileNode compare, we need to fallback to content compare
             return None
         else:
             # For DirNode's check without entering each dir
             self_nodes_paths = list(sorted(n.path for n in self.nodes))
             other_nodes_paths = list(sorted(n.path for n in self.nodes))
             if self_nodes_paths != other_nodes_paths:
                 return False
         return True
 
     def __lt__(self, other):
         if self.kind < other.kind:
             return True
         if self.kind > other.kind:
             return False
         if self.path < other.path:
             return True
         if self.path > other.path:
             return False
 
     # def __cmp__(self, other):
     #     """
     #     Comparator using name of the node, needed for quick list sorting.
     #     """
     #
     #     kind_cmp = cmp(self.kind, other.kind)
     #     if kind_cmp:
     #         if isinstance(self, SubModuleNode):
     #             # we make submodules equal to dirnode for "sorting" purposes
     #             return NodeKind.DIR
     #         return kind_cmp
     #     return cmp(self.name, other.name)
 
     def __repr__(self):
         maybe_path = getattr(self, 'path', 'UNKNOWN_PATH')
         return f'<{self.__class__.__name__} {maybe_path!r}>'
 
     def __str__(self):
         return self.name
 
     def _validate_path(self, path: bytes):
         self._assert_bytes(path)
 
         if path.startswith(b'/'):
             raise NodeError(
                 f"Cannot initialize Node objects with slash at "
                 f"the beginning as only relative paths are supported. "
                 f"Got {path}")
 
     def _assert_bytes(self, value):
         if not isinstance(value, bytes):
             raise TypeError(f"Bytes required as input, got {type(value)} of {value}.")
 
     @LazyProperty
     def parent(self):
         parent_path = self.get_parent_path()
         if parent_path:
             if self.commit:
                 return self.commit.get_node(parent_path)
             return DirNode(parent_path)
         return None
 
     @LazyProperty
     def str_path(self) -> str:
         return safe_str(self.path)
 
     @LazyProperty
     def has_rtlo(self):
         """Detects if a path has right-to-left-override marker"""
         return self.RTLO_MARKER in self.str_path
 
     @LazyProperty
     def dir_path(self):
         """
         Returns name of the directory from full path of this vcs node. Empty
         string is returned if there's no directory in the path
         """
         _parts = self.path.rstrip('/').rsplit('/', 1)
         if len(_parts) == 2:
             return _parts[0]
         return ''
 
     @LazyProperty
     def name(self):
         """
         Returns name of the node so if its path
         then only last part is returned.
         """
         return self.path.rstrip('/').split('/')[-1]
 
     @property
     def kind(self):
         return self._kind
 
     @kind.setter
     def kind(self, kind):
         if hasattr(self, '_kind'):
             raise NodeError("Cannot change node's kind")
         else:
             self._kind = kind
             # Post setter check (path's trailing slash)
             if self.path.endswith('/'):
                 raise NodeError("Node's path cannot end with slash")
 
     def get_parent_path(self) -> bytes:
         """
         Returns node's parent path or empty string if node is root.
         """
         if self.is_root():
             return b''
         str_path = vcspath.dirname(self.path.rstrip('/')) + '/'
 
         return safe_bytes(str_path)
 
     def is_file(self):
         """
         Returns ``True`` if node's kind is ``NodeKind.FILE``, ``False``
         otherwise.
         """
         return self.kind == NodeKind.FILE
 
     def is_dir(self):
         """
         Returns ``True`` if node's kind is ``NodeKind.DIR``, ``False``
         otherwise.
         """
         return self.kind == NodeKind.DIR
 
     def is_root(self):
         """
         Returns ``True`` if node is a root node and ``False`` otherwise.
         """
         return self.kind == NodeKind.DIR and self.path == ''
 
     def is_submodule(self):
         """
         Returns ``True`` if node's kind is ``NodeKind.SUBMODULE``, ``False``
         otherwise.
         """
         return self.kind == NodeKind.SUBMODULE
 
     def is_largefile(self):
         """
         Returns ``True`` if node's kind is ``NodeKind.LARGEFILE``, ``False``
         otherwise
         """
         return self.kind == NodeKind.LARGEFILE
 
     def is_link(self):
         if self.commit:
             return self.commit.is_link(self.path)
         return False
 
     @LazyProperty
     def added(self):
         return self.state is NodeState.ADDED
 
     @LazyProperty
     def changed(self):
         return self.state is NodeState.CHANGED
 
     @LazyProperty
     def not_changed(self):
         return self.state is NodeState.NOT_CHANGED
 
     @LazyProperty
     def removed(self):
         return self.state is NodeState.REMOVED
 
 
 class FileNode(Node):
     """
     Class representing file nodes.
 
     :attribute: path: path to the node, relative to repository's root
     :attribute: content: if given arbitrary sets content of the file
     :attribute: commit: if given, first time content is accessed, callback
     :attribute: mode: stat mode for a node. Default is `FILEMODE_DEFAULT`.
     """
     _filter_pre_load = []
 
     def __init__(self, path: bytes, content: bytes | None = None, commit=None, mode=None, pre_load=None):
         """
         Only one of ``content`` and ``commit`` may be given. Passing both
         would raise ``NodeError`` exception.
 
         :param path: relative path to the node
         :param content: content may be passed to constructor
         :param commit: if given, will use it to lazily fetch content
         :param mode: ST_MODE (i.e. 0100644)
         """
         if content and commit:
             raise NodeError("Cannot use both content and commit")
 
         super().__init__(path, kind=NodeKind.FILE)
 
         self.commit = commit
         if content and not isinstance(content, bytes):
             # File content is one thing that inherently must be bytes
             # we support passing str too, and convert the content
             content = safe_bytes(content)
         self._content = content
         self._mode = mode or FILEMODE_DEFAULT
 
         self._set_bulk_properties(pre_load)
 
     def __eq__(self, other):
-        eq = super(FileNode, self).__eq__(other)
+        eq = super().__eq__(other)
         if eq is not None:
             return eq
         return self.content == other.content
 
     def __hash__(self):
         raw_id = getattr(self.commit, 'raw_id', '')
         return hash((self.path, raw_id))
 
     def __lt__(self, other):
-        lt = super(FileNode, self).__lt__(other)
+        lt = super().__lt__(other)
         if lt is not None:
             return lt
         return self.content < other.content
 
     def __repr__(self):
         short_id = getattr(self.commit, 'short_id', '')
         return f'<{self.__class__.__name__} path={self.path!r}, short_id={short_id}>'
 
     def _set_bulk_properties(self, pre_load):
         if not pre_load:
             return
         pre_load = [entry for entry in pre_load
                     if entry not in self._filter_pre_load]
         if not pre_load:
             return
 
         remote = self.commit.get_remote()
         result = remote.bulk_file_request(self.commit.raw_id, self.path, pre_load)
 
         for attr, value in result.items():
             if attr == "flags":
                 self.__dict__['mode'] = safe_str(value)
             elif attr == "size":
                 self.__dict__['size'] = value
             elif attr == "data":
                 self.__dict__['_content'] = value
             elif attr == "is_binary":
                 self.__dict__['is_binary'] = value
             elif attr == "md5":
                 self.__dict__['md5'] = value
             else:
                 raise ValueError(f'Unsupported attr in bulk_property: {attr}')
 
     @LazyProperty
     def mode(self):
         """
         Returns lazily mode of the FileNode. If `commit` is not set, would
         use value given at initialization or `FILEMODE_DEFAULT` (default).
         """
         if self.commit:
             mode = self.commit.get_file_mode(self.path)
         else:
             mode = self._mode
         return mode
 
     @LazyProperty
     def raw_bytes(self) -> bytes:
         """
         Returns lazily the raw bytes of the FileNode.
         """
         if self.commit:
             if self._content is None:
                 self._content = self.commit.get_file_content(self.path)
             content = self._content
         else:
             content = self._content
         return content
 
     def content_uncached(self):
         """
         Returns lazily content of the FileNode.
         """
         if self.commit:
             content = self.commit.get_file_content(self.path)
         else:
             content = self._content
         return content
 
     def stream_bytes(self):
         """
         Returns an iterator that will stream the content of the file directly from
         vcsserver without loading it to memory.
         """
         if self.commit:
             return self.commit.get_file_content_streamed(self.path)
         raise NodeError("Cannot retrieve stream_bytes without related commit attribute")
 
     def metadata_uncached(self):
         """
         Returns md5, binary flag of the file node, without any cache usage.
         """
 
         content = self.content_uncached()
 
         is_binary = bool(content and BIN_BYTE_MARKER in content)
         size = 0
         if content:
             size = len(content)
 
         return is_binary, md5(content), size, content
 
     @LazyProperty
     def content(self) -> bytes:
         """
         Returns lazily content of the FileNode.
         """
         content = self.raw_bytes
         if content and not isinstance(content, bytes):
             raise ValueError(f'Content is of type {type(content)} instead of bytes')
         return content
 
     @LazyProperty
     def str_content(self) -> str:
         return safe_str(self.raw_bytes)
 
     @LazyProperty
     def size(self):
         if self.commit:
             return self.commit.get_file_size(self.path)
         raise NodeError(
             "Cannot retrieve size of the file without related "
             "commit attribute")
 
     @LazyProperty
     def message(self):
         if self.commit:
             return self.last_commit.message
         raise NodeError(
             "Cannot retrieve message of the file without related "
             "commit attribute")
 
     @LazyProperty
     def last_commit(self):
         if self.commit:
             pre_load = ["author", "date", "message", "parents"]
             return self.commit.get_path_commit(self.path, pre_load=pre_load)
         raise NodeError(
             "Cannot retrieve last commit of the file without "
             "related commit attribute")
 
     def get_mimetype(self):
         """
         Mimetype is calculated based on the file's content. If ``_mimetype``
         attribute is available, it will be returned (backends which store
         mimetypes or can easily recognize them, should set this private
         attribute to indicate that type should *NOT* be calculated).
         """
 
         if hasattr(self, '_mimetype'):
             if (isinstance(self._mimetype, (tuple, list)) and
                     len(self._mimetype) == 2):
                 return self._mimetype
             else:
                 raise NodeError('given _mimetype attribute must be an 2 '
                                 'element list or tuple')
 
         db = get_mimetypes_db()
         mtype, encoding = db.guess_type(self.name)
 
         if mtype is None:
             if not self.is_largefile() and self.is_binary:
                 mtype = 'application/octet-stream'
                 encoding = None
             else:
                 mtype = 'text/plain'
                 encoding = None
 
                 # try with pygments
                 try:
                     from pygments.lexers import get_lexer_for_filename
                     mt = get_lexer_for_filename(self.name).mimetypes
                 except Exception:
                     mt = None
 
                 if mt:
                     mtype = mt[0]
 
         return mtype, encoding
 
     @LazyProperty
     def mimetype(self):
         """
         Wrapper around full mimetype info. It returns only type of fetched
         mimetype without the encoding part. use get_mimetype function to fetch
         full set of (type,encoding)
         """
         return self.get_mimetype()[0]
 
     @LazyProperty
     def mimetype_main(self):
         return self.mimetype.split('/')[0]
 
     @classmethod
     def get_lexer(cls, filename, content=None):
         from pygments import lexers
 
         extension = filename.split('.')[-1]
         lexer = None
 
         try:
             lexer = lexers.guess_lexer_for_filename(
                 filename, content, stripnl=False)
         except lexers.ClassNotFound:
             pass
 
         # try our EXTENSION_MAP
         if not lexer:
             try:
                 lexer_class = LANGUAGES_EXTENSIONS_MAP.get(extension)
                 if lexer_class:
                     lexer = lexers.get_lexer_by_name(lexer_class[0])
             except lexers.ClassNotFound:
                 pass
 
         if not lexer:
             lexer = lexers.TextLexer(stripnl=False)
 
         return lexer
 
     @LazyProperty
     def lexer(self):
         """
         Returns pygment's lexer class. Would try to guess lexer taking file's
         content, name and mimetype.
         """
         # TODO: this is more proper, but super heavy on investigating the type based on the content
         #self.get_lexer(self.name, self.content)
 
         return self.get_lexer(self.name)
 
     @LazyProperty
     def lexer_alias(self):
         """
         Returns first alias of the lexer guessed for this file.
         """
         return self.lexer.aliases[0]
 
     @LazyProperty
     def history(self):
         """
         Returns a list of commit for this file in which the file was changed
         """
         if self.commit is None:
             raise NodeError('Unable to get commit for this FileNode')
         return self.commit.get_path_history(self.path)
 
     @LazyProperty
     def annotate(self):
         """
         Returns a list of three element tuples with lineno, commit and line
         """
         if self.commit is None:
             raise NodeError('Unable to get commit for this FileNode')
         pre_load = ["author", "date", "message", "parents"]
         return self.commit.get_file_annotate(self.path, pre_load=pre_load)
 
     @LazyProperty
     def state(self):
         if not self.commit:
             raise NodeError(
                 "Cannot check state of the node if it's not "
                 "linked with commit")
         elif self.path in (node.path for node in self.commit.added):
             return NodeState.ADDED
         elif self.path in (node.path for node in self.commit.changed):
             return NodeState.CHANGED
         else:
             return NodeState.NOT_CHANGED
 
     @LazyProperty
     def is_binary(self):
         """
         Returns True if file has binary content.
         """
         if self.commit:
             return self.commit.is_node_binary(self.path)
         else:
             raw_bytes = self._content
             return bool(raw_bytes and BIN_BYTE_MARKER in raw_bytes)
 
     @LazyProperty
     def md5(self):
         """
         Returns md5 of the file node.
         """
 
         if self.commit:
             return self.commit.node_md5_hash(self.path)
         else:
             raw_bytes = self._content
             # TODO: this sucks, we're computing md5 on potentially super big stream data...
             return md5(raw_bytes)
 
     @LazyProperty
     def extension(self):
         """Returns filenode extension"""
         return self.name.split('.')[-1]
 
     @property
     def is_executable(self):
         """
         Returns ``True`` if file has executable flag turned on.
         """
         return bool(self.mode & stat.S_IXUSR)
 
     def get_largefile_node(self):
         """
         Try to return a Mercurial FileNode from this node. It does internal
         checks inside largefile store, if that file exist there it will
         create special instance of LargeFileNode which can get content from
         LF store.
         """
         if self.commit:
             return self.commit.get_largefile_node(self.path)
 
     def count_lines(self, content: str | bytes, count_empty=False):
         if isinstance(content, str):
             newline_marker = '\n'
         elif isinstance(content, bytes):
             newline_marker = b'\n'
         else:
             raise ValueError('content must be bytes or str got {type(content)} instead')
 
         if count_empty:
             all_lines = 0
             empty_lines = 0
             for line in content.splitlines(True):
                 if line == newline_marker:
                     empty_lines += 1
                 all_lines += 1
 
             return all_lines, all_lines - empty_lines
         else:
             # fast method
             empty_lines = all_lines = content.count(newline_marker)
             if all_lines == 0 and content:
                 # one-line without a newline
                 empty_lines = all_lines = 1
 
         return all_lines, empty_lines
 
     def lines(self, count_empty=False):
         all_lines, empty_lines = 0, 0
 
         if not self.is_binary:
             content = self.content
             all_lines, empty_lines = self.count_lines(content, count_empty=count_empty)
         return all_lines, empty_lines
 
 
 class RemovedFileNode(FileNode):
     """
     Dummy FileNode class - trying to access any public attribute except path,
     name, kind or state (or methods/attributes checking those two) would raise
     RemovedFileNodeError.
     """
     ALLOWED_ATTRIBUTES = [
         'name', 'path', 'state', 'is_root', 'is_file', 'is_dir', 'kind',
         'added', 'changed', 'not_changed', 'removed', 'bytes_path'
     ]
 
     def __init__(self, path):
         """
         :param path: relative path to the node
         """
         super().__init__(path=path)
 
     def __getattribute__(self, attr):
         if attr.startswith('_') or attr in RemovedFileNode.ALLOWED_ATTRIBUTES:
             return super().__getattribute__(attr)
         raise RemovedFileNodeError(f"Cannot access attribute {attr} on RemovedFileNode. Not in allowed attributes")
 
     @LazyProperty
     def state(self):
         return NodeState.REMOVED
 
 
 class DirNode(Node):
     """
     DirNode stores list of files and directories within this node.
     Nodes may be used standalone but within repository context they
     lazily fetch data within same repository's commit.
     """
 
     def __init__(self, path, nodes=(), commit=None, default_pre_load=None):
         """
         Only one of ``nodes`` and ``commit`` may be given. Passing both
         would raise ``NodeError`` exception.
 
         :param path: relative path to the node
         :param nodes: content may be passed to constructor
         :param commit: if given, will use it to lazily fetch content
         """
         if nodes and commit:
             raise NodeError("Cannot use both nodes and commit")
-        super(DirNode, self).__init__(path, NodeKind.DIR)
+        super().__init__(path, NodeKind.DIR)
         self.commit = commit
         self._nodes = nodes
         self.default_pre_load = default_pre_load or ['is_binary', 'size']
 
     def __iter__(self):
-        for node in self.nodes:
-            yield node
+        yield from self.nodes
 
     def __eq__(self, other):
-        eq = super(DirNode, self).__eq__(other)
+        eq = super().__eq__(other)
         if eq is not None:
             return eq
         # check without entering each dir
         self_nodes_paths = list(sorted(n.path for n in self.nodes))
         other_nodes_paths = list(sorted(n.path for n in self.nodes))
         return self_nodes_paths == other_nodes_paths
 
     def __lt__(self, other):
-        lt = super(DirNode, self).__lt__(other)
+        lt = super().__lt__(other)
         if lt is not None:
             return lt
         # check without entering each dir
         self_nodes_paths = list(sorted(n.path for n in self.nodes))
         other_nodes_paths = list(sorted(n.path for n in self.nodes))
         return self_nodes_paths < other_nodes_paths
 
     @LazyProperty
     def content(self):
         raise NodeError(f"{self} represents a dir and has no `content` attribute")
 
     @LazyProperty
     def nodes(self):
         if self.commit:
             nodes = self.commit.get_nodes(self.path, pre_load=self.default_pre_load)
         else:
             nodes = self._nodes
-        self._nodes_dict = dict((node.path, node) for node in nodes)
+        self._nodes_dict = {node.path: node for node in nodes}
         return sorted(nodes)
 
     @LazyProperty
     def files(self):
-        return sorted((node for node in self.nodes if node.is_file()))
+        return sorted(node for node in self.nodes if node.is_file())
 
     @LazyProperty
     def dirs(self):
-        return sorted((node for node in self.nodes if node.is_dir()))
+        return sorted(node for node in self.nodes if node.is_dir())
 
     def get_node(self, path):
         """
         Returns node from within this particular ``DirNode``, so it is now
         allowed to fetch, i.e. node located at 'docs/api/index.rst' from node
         'docs'. In order to access deeper nodes one must fetch nodes between
         them first - this would work::
 
            docs = root.get_node('docs')
            docs.get_node('api').get_node('index.rst')
 
         :param: path - relative to the current node
 
         .. note::
            To access lazily (as in example above) node have to be initialized
            with related commit object - without it node is out of
            context and may know nothing about anything else than nearest
            (located at same level) nodes.
         """
         try:
             path = path.rstrip('/')
             if path == '':
                 raise NodeError("Cannot retrieve node without path")
             self.nodes  # access nodes first in order to set _nodes_dict
             paths = path.split('/')
             if len(paths) == 1:
                 if not self.is_root():
                     path = '/'.join((self.path, paths[0]))
                 else:
                     path = paths[0]
                 return self._nodes_dict[path]
             elif len(paths) > 1:
                 if self.commit is None:
                     raise NodeError("Cannot access deeper nodes without commit")
                 else:
                     path1, path2 = paths[0], '/'.join(paths[1:])
                     return self.get_node(path1).get_node(path2)
             else:
                 raise KeyError
         except KeyError:
             raise NodeError(f"Node does not exist at {path}")
 
     @LazyProperty
     def state(self):
         raise NodeError("Cannot access state of DirNode")
 
     @LazyProperty
     def size(self):
         size = 0
         for root, dirs, files in self.commit.walk(self.path):
             for f in files:
                 size += f.size
 
         return size
 
     @LazyProperty
     def last_commit(self):
         if self.commit:
             pre_load = ["author", "date", "message", "parents"]
             return self.commit.get_path_commit(self.path, pre_load=pre_load)
         raise NodeError(
             "Cannot retrieve last commit of the file without "
             "related commit attribute")
 
     def __repr__(self):
         short_id = getattr(self.commit, 'short_id', '')
         return f'<{self.__class__.__name__} {self.path!r} @ {short_id}>'
 
 
 class RootNode(DirNode):
     """
     DirNode being the root node of the repository.
     """
 
     def __init__(self, nodes=(), commit=None):
-        super(RootNode, self).__init__(path=b'', nodes=nodes, commit=commit)
+        super().__init__(path=b'', nodes=nodes, commit=commit)
 
     def __repr__(self):
         return f'<{self.__class__.__name__}>'
 
 
 class SubModuleNode(Node):
     """
     represents a SubModule of Git or SubRepo of Mercurial
     """
     is_binary = False
     size = 0
 
     def __init__(self, name, url=None, commit=None, alias=None):
         self.path = name
         self.kind = NodeKind.SUBMODULE
         self.alias = alias
 
         # we have to use EmptyCommit here since this can point to svn/git/hg
         # submodules we cannot get from repository
         self.commit = EmptyCommit(str(commit), alias=alias)
         self.url = url or self._extract_submodule_url()
 
     def __repr__(self):
         short_id = getattr(self.commit, 'short_id', '')
         return f'<{self.__class__.__name__} {self.path!r} @ {short_id}>'
 
     def _extract_submodule_url(self):
         # TODO: find a way to parse gits submodule file and extract the
         # linking URL
         return self.path
 
     @LazyProperty
     def name(self):
         """
         Returns name of the node so if its path
         then only last part is returned.
         """
         org = safe_str(self.path.rstrip('/').split('/')[-1])
         return f'{org} @ {self.commit.short_id}'
 
 
 class LargeFileNode(FileNode):
 
     def __init__(self, path, url=None, commit=None, alias=None, org_path=None):
         self._validate_path(path)  # can throw exception if path is invalid
         self.org_path = org_path  # as stored in VCS as LF pointer
 
         self.bytes_path = path.rstrip(b'/')  # store for __repr__
         self.path = safe_str(self.bytes_path)  # we store paths as str
 
         self.kind = NodeKind.LARGEFILE
         self.alias = alias
         self._content = b''
 
     def _validate_path(self, path: bytes):
         """
         we override check since the LargeFileNode path is system absolute, but we check for bytes only
         """
         self._assert_bytes(path)
 
     def __repr__(self):
         return f'<{self.__class__.__name__} {self.org_path} -> {self.path!r}>'
 
     @LazyProperty
     def size(self):
         return os.stat(self.path).st_size
 
     @LazyProperty
     def raw_bytes(self):
         with open(self.path, 'rb') as f:
             content = f.read()
         return content
 
     @LazyProperty
     def name(self):
         """
         Overwrites name to be the org lf path
         """
         return self.org_path
 
     def stream_bytes(self):
         with open(self.path, 'rb') as stream:
             while True:
                 data = stream.read(16 * 1024)
                 if not data:
                     break
                 yield data

rhodecode/lib/vcs/path.py

@@ -1,34 +1,32 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Utility functions to handle vcs paths.
 """
 
 # Note: Instead of re-implementing things which are provided by posixpath
 # we forward import them here.
 from posixpath import join, dirname, relpath, split
 
 
 def sanitize(path):
     """
     Sanitizes path into a canonical vcs path
     """
     return path.lstrip('/')

rhodecode/lib/vcs/utils/__init__.py

@@ -1,64 +1,63 b''
-
 # Copyright (C) 2010-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 This module provides some useful tools for ``vcs`` like annotate/diff html
 output. It also includes some internal helpers.
 """
 
 
 def author_email(author):
     """
     returns email address of given author.
     If any of <,> sign are found, it fallbacks to regex findall()
     and returns first found result or empty string
 
     Regex taken from http://www.regular-expressions.info/email.html
     """
     import re
     if not author:
         return ''
 
     r = author.find('>')
     l = author.find('<')
 
     if l == -1 or r == -1:
         # fallback to regex match of email out of a string
         email_re = re.compile(r"""[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!"""
                               r"""#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z"""
                               r"""0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]"""
                               r"""*[a-z0-9])?""", re.IGNORECASE)
         m = re.findall(email_re, author)
         return m[0] if m else ''
 
     return author[l + 1:r].strip()
 
 
 def author_name(author):
     """
     get name of author, or else username.
     It'll try to find an email in the author string and just cut it off
     to get the username
     """
 
     if not author or '@' not in author:
         return author
     else:
         return author.replace(author_email(author), '').replace('<', '')\
             .replace('>', '').strip()

rhodecode/lib/vcs/utils/helpers.py

@@ -1,161 +1,159 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Utilities aimed to help achieve mostly basic tasks.
 """
 
 
 
 
 import re
 import os
 import time
 import datetime
 import logging
 
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.lib.vcs.exceptions import VCSError, VCSBackendNotSupportedError
 
 
 log = logging.getLogger(__name__)
 
 
 def get_scm(path):
     """
     Returns one of alias from ``ALIASES`` (in order of precedence same as
     shortcuts given in ``ALIASES``) and working dir path for the given
     argument. If no scm-specific directory is found or more than one scm is
     found at that directory, ``VCSError`` is raised.
     """
     if not os.path.isdir(path):
         raise VCSError("Given path %s is not a directory" % path)
 
     found_scms = [(scm, path) for scm in get_scms_for_path(path)]
 
     if len(found_scms) > 1:
-        found = ', '.join((x[0] for x in found_scms))
+        found = ', '.join(x[0] for x in found_scms)
         raise VCSError(
-            'More than one [%s] scm found at given path %s' % (found, path))
+            'More than one [{}] scm found at given path {}'.format(found, path))
 
     if len(found_scms) == 0:
         raise VCSError('No scm found at given path %s' % path)
 
     return found_scms[0]
 
 
 def get_scm_backend(backend_type):
     from rhodecode.lib.vcs.backends import get_backend
     return get_backend(backend_type)
 
 
 def get_scms_for_path(path):
     """
     Returns all scm's found at the given path. If no scm is recognized
     - empty list is returned.
 
     :param path: path to directory which should be checked. May be callable.
 
     :raises VCSError: if given ``path`` is not a directory
     """
     from rhodecode.lib.vcs.backends import get_backend
     if hasattr(path, '__call__'):
         path = path()
     if not os.path.isdir(path):
         raise VCSError("Given path %r is not a directory" % path)
 
     result = []
     for key in settings.available_aliases():
         try:
             backend = get_backend(key)
         except VCSBackendNotSupportedError:
             log.warning('VCSBackendNotSupportedError: %s not supported', key)
             continue
         if backend.is_valid_repository(path):
             result.append(key)
     return result
 
 
 def parse_datetime(text):
     """
     Parses given text and returns ``datetime.datetime`` instance or raises
     ``ValueError``.
 
     :param text: string of desired date/datetime or something more verbose,
       like *yesterday*, *2weeks 3days*, etc.
     """
     if not text:
         raise ValueError('Wrong date: "%s"' % text)
 
     if isinstance(text, datetime.datetime):
         return text
 
     # we limit a format to no include microseconds e.g 2017-10-17t17:48:23.XXXX
     text = text.strip().lower()[:19]
 
     input_formats = (
         '%Y-%m-%d %H:%M:%S',
         '%Y-%m-%dt%H:%M:%S',
         '%Y-%m-%d %H:%M',
         '%Y-%m-%dt%H:%M',
         '%Y-%m-%d',
         '%m/%d/%Y %H:%M:%S',
         '%m/%d/%Yt%H:%M:%S',
         '%m/%d/%Y %H:%M',
         '%m/%d/%Yt%H:%M',
         '%m/%d/%Y',
         '%m/%d/%y %H:%M:%S',
         '%m/%d/%yt%H:%M:%S',
         '%m/%d/%y %H:%M',
         '%m/%d/%yt%H:%M',
         '%m/%d/%y',
     )
     for format_def in input_formats:
         try:
             return datetime.datetime(*time.strptime(text, format_def)[:6])
         except ValueError:
             pass
 
     # Try descriptive texts
     if text == 'tomorrow':
         future = datetime.datetime.now() + datetime.timedelta(days=1)
         args = future.timetuple()[:3] + (23, 59, 59)
         return datetime.datetime(*args)
     elif text == 'today':
         return datetime.datetime(*datetime.datetime.today().timetuple()[:3])
     elif text == 'now':
         return datetime.datetime.now()
     elif text == 'yesterday':
         past = datetime.datetime.now() - datetime.timedelta(days=1)
         return datetime.datetime(*past.timetuple()[:3])
     else:
         days = 0
         matched = re.match(
             r'^((?P<weeks>\d+) ?w(eeks?)?)? ?((?P<days>\d+) ?d(ays?)?)?$', text)
         if matched:
             groupdict = matched.groupdict()
             if groupdict['days']:
                 days += int(matched.groupdict()['days'])
             if groupdict['weeks']:
                 days += int(matched.groupdict()['weeks']) * 7
             past = datetime.datetime.now() - datetime.timedelta(days=days)
             return datetime.datetime(*past.timetuple()[:3])
 
     raise ValueError('Wrong date: "%s"' % text)

rhodecode/lib/vcs/utils/imports.py

@@ -1,46 +1,45 b''
-
 # Copyright (C) 2010-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 from rhodecode.lib.vcs.exceptions import VCSError
 
 
 def import_class(class_path):
     """
     Returns class from the given path.
 
     For example, in order to get class located at
     ``vcs.backends.hg.MercurialRepository``:
 
         try:
             hgrepo = import_class('vcs.backends.hg.MercurialRepository')
         except VCSError:
             # hadle error
     """
     splitted = class_path.split('.')
     mod_path = '.'.join(splitted[:-1])
     class_name = splitted[-1]
     try:
         class_mod = __import__(mod_path, {}, {}, [class_name])
     except ImportError as err:
         msg = "There was problem while trying to import backend class. "\
             "Original error was:\n%s" % err
         raise VCSError(msg)
     cls = getattr(class_mod, class_name)
 
     return cls

rhodecode/lib/vcs/utils/paths.py

@@ -1,33 +1,32 b''
-
 # Copyright (C) 2010-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import os.path
 
 
 def get_dirs_for_path(*paths):
     """Return list of directories, including intermediate."""
     for path in paths:
         head = path
         while head:
             head, tail = os.path.split(head)
             if head:
                 yield head
             else:
                 # We don't need to yield empty path
                 break