fix(file-caching): fixed cases when old cache was used before changes to operate on bytestrings

rhodecode/apps/_base/__init__.py

@@ -395,7 +395,7 class RepoAppView(BaseAppView):
         settings = settings_model.get_repo_settings_inherited()
         return settings.get(settings_key, default)
 
-    def _get_readme_data(self, db_repo, renderer_type, commit_id=None, path="/"):
+    def _get_readme_data(self, db_repo, renderer_type, commit_id=None, path="/", nodes=None):
         log.debug("Looking for README file at path %s", path)
         if commit_id:
             landing_commit_id = commit_id
@@ -413,16 +413,14 class RepoAppView(BaseAppView):
 
         @region.conditional_cache_on_arguments(namespace=cache_namespace_uid)
         def generate_repo_readme(
-            repo_id, _commit_id, _repo_name, _readme_search_path, _renderer_type
+            _repo_id, _commit_id, _repo_name, _readme_search_path, _renderer_type
         ):
-            readme_data = None
-            readme_filename = None
+            _readme_data = None
+            _readme_filename = None
 
             commit = db_repo.get_commit(_commit_id)
             log.debug("Searching for a README file at commit %s.", _commit_id)
-            readme_node = ReadmeFinder(_renderer_type).search(
-                commit, path=_readme_search_path
-            )
+            readme_node = ReadmeFinder(_renderer_type).search(commit, path=_readme_search_path, nodes=nodes)
 
             if readme_node:
                 log.debug("Found README node: %s", readme_node)
@@ -442,19 +440,19 class RepoAppView(BaseAppView):
                     ),
                 }
 
-                readme_data = self._render_readme_or_none(
+                _readme_data = self._render_readme_or_none(
                     commit, readme_node, relative_urls
                 )
-                readme_filename = readme_node.str_path
+                _readme_filename = readme_node.str_path
 
-            return readme_data, readme_filename
+            return _readme_data, _readme_filename
 
         readme_data, readme_filename = generate_repo_readme(
             db_repo.repo_id,
             landing_commit_id,
             db_repo.repo_name,
             path,
-            renderer_type,
+            renderer_type
         )
 
         compute_time = time.time() - start

rhodecode/apps/repository/views/repo_files.py

@@ -40,25 +40,34 from rhodecode.lib import diffs, helpers
 from rhodecode.lib import audit_logger
 from rhodecode.lib.hash_utils import sha1_safe
 from rhodecode.lib.archive_cache import (
-    get_archival_cache_store, get_archival_config, ArchiveCacheGenerationLock, archive_iterator)
+    get_archival_cache_store,
+    get_archival_config,
+    ArchiveCacheGenerationLock,
+    archive_iterator,
+)
 from rhodecode.lib.str_utils import safe_bytes, convert_special_chars
 from rhodecode.lib.view_utils import parse_path_ref
 from rhodecode.lib.exceptions import NonRelativePathError
-from rhodecode.lib.codeblocks import (
-    filenode_as_lines_tokens, filenode_as_annotated_lines_tokens)
+from rhodecode.lib.codeblocks import filenode_as_lines_tokens, filenode_as_annotated_lines_tokens
 from rhodecode.lib.utils2 import convert_line_endings, detect_mode
 from rhodecode.lib.type_utils import str2bool
 from rhodecode.lib.str_utils import safe_str, safe_int, header_safe_str
-from rhodecode.lib.auth import (
-    LoginRequired, HasRepoPermissionAnyDecorator, CSRFRequired)
+from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator, CSRFRequired
 from rhodecode.lib.vcs import path as vcspath
 from rhodecode.lib.vcs.backends.base import EmptyCommit
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.lib.vcs.exceptions import (
-    RepositoryError, CommitDoesNotExistError, EmptyRepositoryError,
-    ImproperArchiveTypeError, VCSError, NodeAlreadyExistsError,
-    NodeDoesNotExistError, CommitError, NodeError)
+    RepositoryError,
+    CommitDoesNotExistError,
+    EmptyRepositoryError,
+    ImproperArchiveTypeError,
+    VCSError,
+    NodeAlreadyExistsError,
+    NodeDoesNotExistError,
+    CommitError,
+    NodeError,
+)
 
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.db import Repository
@@ -66,17 +75,17 from rhodecode.model.db import Repositor
 log = logging.getLogger(__name__)
 
 
-def get_archive_name(db_repo_id, db_repo_name, commit_sha, ext, subrepos=False, path_sha='', with_hash=True):
+def get_archive_name(db_repo_id, db_repo_name, commit_sha, ext, subrepos=False, path_sha="", with_hash=True):
     # original backward compat name of archive
-    clean_name = safe_str(convert_special_chars(db_repo_name).replace('/', '_'))
+    clean_name = safe_str(convert_special_chars(db_repo_name).replace("/", "_"))
 
     # e.g vcsserver-id-abcd-sub-1-abcfdef-archive-all.zip
     # vcsserver-id-abcd-sub-0-abcfdef-COMMIT_SHA-PATH_SHA.zip
     id_sha = sha1_safe(str(db_repo_id))[:4]
-    sub_repo = 'sub-1' if subrepos else 'sub-0'
-    commit = commit_sha if with_hash else 'archive'
-    path_marker = (path_sha if with_hash else '') or 'all'
-    archive_name = f'{clean_name}-id-{id_sha}-{sub_repo}-{commit}-{path_marker}{ext}'
+    sub_repo = "sub-1" if subrepos else "sub-0"
+    commit = commit_sha if with_hash else "archive"
+    path_marker = (path_sha if with_hash else "") or "all"
+    archive_name = f"{clean_name}-id-{id_sha}-{sub_repo}-{commit}-{path_marker}{ext}"
 
     return archive_name
 
@@ -86,16 +95,15 def get_path_sha(at_path):
 
 
 def _get_archive_spec(fname):
-    log.debug('Detecting archive spec for: `%s`', fname)
+    log.debug("Detecting archive spec for: `%s`", fname)
 
     fileformat = None
     ext = None
     content_type = None
     for a_type, content_type, extension in settings.ARCHIVE_SPECS:
-
         if fname.endswith(extension):
             fileformat = a_type
-            log.debug('archive is of type: %s', fileformat)
+            log.debug("archive is of type: %s", fileformat)
             ext = extension
             break
 
@@ -103,13 +111,12 def _get_archive_spec(fname):
         raise ValueError()
 
     # left over part of whole fname is the commit
-    commit_id = fname[:-len(ext)]
+    commit_id = fname[: -len(ext)]
 
     return commit_id, ext, fileformat, content_type
 
 
 class RepoFilesView(RepoAppView):
-
     @staticmethod
     def adjust_file_path_for_svn(f_path, repo):
         """
@@ -118,13 +125,11 class RepoFilesView(RepoAppView):
         This is mainly based on prefix matching of the recognized tags and
         branches in the underlying repository.
         """
-        tags_and_branches = itertools.chain(
-            repo.branches.keys(),
-            repo.tags.keys())
+        tags_and_branches = itertools.chain(repo.branches.keys(), repo.tags.keys())
         tags_and_branches = sorted(tags_and_branches, key=len, reverse=True)
 
         for name in tags_and_branches:
-            if f_path.startswith(f'{name}/'):
+            if f_path.startswith(f"{name}/"):
                 f_path = vcspath.relpath(f_path, name)
                 break
         return f_path
@@ -135,59 +140,52 class RepoFilesView(RepoAppView):
         c.enable_downloads = self.db_repo.enable_downloads
         return c
 
-    def _ensure_not_locked(self, commit_id='tip'):
+    def _ensure_not_locked(self, commit_id="tip"):
         _ = self.request.translate
 
         repo = self.db_repo
         if repo.enable_locking and repo.locked[0]:
-            h.flash(_('This repository has been locked by %s on %s')
-                    % (h.person_by_id(repo.locked[0]),
-                    h.format_date(h.time_to_datetime(repo.locked[1]))),
-                    'warning')
-            files_url = h.route_path(
-                'repo_files:default_path',
-                repo_name=self.db_repo_name, commit_id=commit_id)
+            h.flash(
+                _("This repository has been locked by %s on %s")
+                % (h.person_by_id(repo.locked[0]), h.format_date(h.time_to_datetime(repo.locked[1]))),
+                "warning",
+            )
+            files_url = h.route_path("repo_files:default_path", repo_name=self.db_repo_name, commit_id=commit_id)
             raise HTTPFound(files_url)
 
-    def forbid_non_head(self, is_head, f_path, commit_id='tip', json_mode=False):
+    def forbid_non_head(self, is_head, f_path, commit_id="tip", json_mode=False):
         _ = self.request.translate
 
         if not is_head:
-            message = _('Cannot modify file. '
-                        'Given commit `{}` is not head of a branch.').format(commit_id)
-            h.flash(message, category='warning')
+            message = _("Cannot modify file. " "Given commit `{}` is not head of a branch.").format(commit_id)
+            h.flash(message, category="warning")
 
             if json_mode:
                 return message
 
-            files_url = h.route_path(
-                'repo_files', repo_name=self.db_repo_name, commit_id=commit_id,
-                f_path=f_path)
+            files_url = h.route_path("repo_files", repo_name=self.db_repo_name, commit_id=commit_id, f_path=f_path)
             raise HTTPFound(files_url)
 
-    def check_branch_permission(self, branch_name, commit_id='tip', json_mode=False):
+    def check_branch_permission(self, branch_name, commit_id="tip", json_mode=False):
         _ = self.request.translate
 
-        rule, branch_perm = self._rhodecode_user.get_rule_and_branch_permission(
-            self.db_repo_name, branch_name)
-        if branch_perm and branch_perm not in ['branch.push', 'branch.push_force']:
-            message = _('Branch `{}` changes forbidden by rule {}.').format(
-                h.escape(branch_name), h.escape(rule))
-            h.flash(message, 'warning')
+        rule, branch_perm = self._rhodecode_user.get_rule_and_branch_permission(self.db_repo_name, branch_name)
+        if branch_perm and branch_perm not in ["branch.push", "branch.push_force"]:
+            message = _("Branch `{}` changes forbidden by rule {}.").format(h.escape(branch_name), h.escape(rule))
+            h.flash(message, "warning")
 
             if json_mode:
                 return message
 
-            files_url = h.route_path(
-                'repo_files:default_path', repo_name=self.db_repo_name, commit_id=commit_id)
+            files_url = h.route_path("repo_files:default_path", repo_name=self.db_repo_name, commit_id=commit_id)
 
             raise HTTPFound(files_url)
 
     def _get_commit_and_path(self):
         default_commit_id = self.db_repo.landing_ref_name
-        default_f_path = '/'
+        default_f_path = "/"
 
-        commit_id = self.request.matchdict.get('commit_id', default_commit_id)
+        commit_id = self.request.matchdict.get("commit_id", default_commit_id)
         f_path = self._get_f_path(self.request.matchdict, default_f_path)
 
         bytes_path = safe_bytes(f_path)
@@ -195,8 +193,8 class RepoFilesView(RepoAppView):
 
     @classmethod
     def _get_default_encoding(cls, c):
-        enc_list = getattr(c, 'default_encodings', [])
-        return enc_list[0] if enc_list else 'UTF-8'
+        enc_list = getattr(c, "default_encodings", [])
+        return enc_list[0] if enc_list else "UTF-8"
 
     def _get_commit_or_redirect(self, commit_id, redirect_after=True):
         """
@@ -215,31 +213,25 class RepoFilesView(RepoAppView):
                 return None
 
             add_new = upload_new = ""
-            if h.HasRepoPermissionAny(
-                    'repository.write', 'repository.admin')(self.db_repo_name):
-                _url = h.route_path(
-                    'repo_files_add_file',
-                    repo_name=self.db_repo_name, commit_id=0, f_path='')
-                add_new = h.link_to(
-                    _('add a new file'), _url, class_="alert-link")
+            if h.HasRepoPermissionAny("repository.write", "repository.admin")(self.db_repo_name):
+                _url = h.route_path("repo_files_add_file", repo_name=self.db_repo_name, commit_id=0, f_path="")
+                add_new = h.link_to(_("add a new file"), _url, class_="alert-link")
 
-                _url_upld = h.route_path(
-                    'repo_files_upload_file',
-                    repo_name=self.db_repo_name, commit_id=0, f_path='')
-                upload_new = h.link_to(
-                    _('upload a new file'), _url_upld, class_="alert-link")
+                _url_upld = h.route_path("repo_files_upload_file", repo_name=self.db_repo_name, commit_id=0, f_path="")
+                upload_new = h.link_to(_("upload a new file"), _url_upld, class_="alert-link")
 
-            h.flash(h.literal(
-                _('There are no files yet. Click here to %s or %s.') % (add_new, upload_new)), category='warning')
-            raise HTTPFound(
-                h.route_path('repo_summary', repo_name=self.db_repo_name))
+            h.flash(
+                h.literal(_("There are no files yet. Click here to %s or %s.") % (add_new, upload_new)),
+                category="warning",
+            )
+            raise HTTPFound(h.route_path("repo_summary", repo_name=self.db_repo_name))
 
         except (CommitDoesNotExistError, LookupError) as e:
-            msg = _('No such commit exists for this repository. Commit: {}').format(commit_id)
-            h.flash(msg, category='error')
+            msg = _("No such commit exists for this repository. Commit: {}").format(commit_id)
+            h.flash(msg, category="error")
             raise HTTPNotFound()
         except RepositoryError as e:
-            h.flash(h.escape(safe_str(e)), category='error')
+            h.flash(h.escape(safe_str(e)), category="error")
             raise HTTPNotFound()
 
     def _get_filenode_or_redirect(self, commit_obj, path, pre_load=None):
@@ -252,22 +244,22 class RepoFilesView(RepoAppView):
         try:
             file_node = commit_obj.get_node(path, pre_load=pre_load)
             if file_node.is_dir():
-                raise RepositoryError('The given path is a directory')
+                raise RepositoryError("The given path is a directory")
         except CommitDoesNotExistError:
-            log.exception('No such commit exists for this repository')
-            h.flash(_('No such commit exists for this repository'), category='error')
+            log.exception("No such commit exists for this repository")
+            h.flash(_("No such commit exists for this repository"), category="error")
             raise HTTPNotFound()
         except RepositoryError as e:
-            log.warning('Repository error while fetching filenode `%s`. Err:%s', path, e)
-            h.flash(h.escape(safe_str(e)), category='error')
+            log.warning("Repository error while fetching filenode `%s`. Err:%s", path, e)
+            h.flash(h.escape(safe_str(e)), category="error")
             raise HTTPNotFound()
 
         return file_node
 
     def _is_valid_head(self, commit_id, repo, landing_ref):
-        branch_name = sha_commit_id = ''
+        branch_name = sha_commit_id = ""
         is_head = False
-        log.debug('Checking if commit_id `%s` is a head for %s.', commit_id, repo)
+        log.debug("Checking if commit_id `%s` is a head for %s.", commit_id, repo)
 
         for _branch_name, branch_commit_id in repo.branches.items():
             # simple case we pass in branch name, it's a HEAD
@@ -303,39 +295,39 class RepoFilesView(RepoAppView):
         return branch_name, sha_commit_id, is_head
 
     def _get_tree_at_commit(self, c, commit_id, f_path, full_load=False, at_rev=None):
-
         repo_id = self.db_repo.repo_id
         force_recache = self.get_recache_flag()
 
-        cache_seconds = safe_int(
-            rhodecode.CONFIG.get('rc_cache.cache_repo.expiration_time'))
+        cache_seconds = rhodecode.ConfigGet().get_int("rc_cache.cache_repo.expiration_time")
         cache_on = not force_recache and cache_seconds > 0
+
         log.debug(
-            'Computing FILE TREE for repo_id %s commit_id `%s` and path `%s`'
-            'with caching: %s[TTL: %ss]' % (
-                repo_id, commit_id, f_path, cache_on, cache_seconds or 0))
+            "Computing FILE TREE for repo_id %s commit_id `%s` and path `%s`"
+            "with caching: %s[TTL: %ss]" % (repo_id, commit_id, f_path, cache_on, cache_seconds or 0)
+        )
 
-        cache_namespace_uid = f'repo.{rc_cache.FILE_TREE_CACHE_VER}.{repo_id}'
-        region = rc_cache.get_or_create_region('cache_repo', cache_namespace_uid)
+        cache_namespace_uid = f"repo.{rc_cache.FILE_TREE_CACHE_VER}.{repo_id}"
+        region = rc_cache.get_or_create_region("cache_repo", cache_namespace_uid)
 
         @region.conditional_cache_on_arguments(namespace=cache_namespace_uid, condition=cache_on)
         def compute_file_tree(_name_hash, _repo_id, _commit_id, _f_path, _full_load, _at_rev):
-            log.debug('Generating cached file tree at for repo_id: %s, %s, %s',
-                      _repo_id, _commit_id, _f_path)
+            log.debug("Generating cached file tree at for repo_id: %s, %s, %s", _repo_id, _commit_id, _f_path)
 
             c.full_load = _full_load
             return render(
-                'rhodecode:templates/files/files_browser_tree.mako',
-                self._get_template_context(c), self.request, _at_rev)
+                "rhodecode:templates/files/files_browser_tree.mako",
+                self._get_template_context(c),
+                self.request,
+                _at_rev,
+            )
 
         return compute_file_tree(
-            self.db_repo.repo_name_hash, self.db_repo.repo_id, commit_id, f_path, full_load, at_rev)
+            self.db_repo.repo_name_hash, self.db_repo.repo_id, commit_id, f_path, full_load, at_rev
+        )
 
     def create_pure_path(self, *parts):
         # Split paths and sanitize them, removing any ../ etc
-        sanitized_path = [
-            x for x in pathlib.PurePath(*parts).parts
-            if x not in ['.', '..']]
+        sanitized_path = [x for x in pathlib.PurePath(*parts).parts if x not in [".", ".."]]
 
         pure_path = pathlib.PurePath(*sanitized_path)
         return pure_path
@@ -343,10 +335,7 class RepoFilesView(RepoAppView):
     def _is_lf_enabled(self, target_repo):
         lf_enabled = False
 
-        lf_key_for_vcs_map = {
-            'hg': 'extensions_largefiles',
-            'git': 'vcs_git_lfs_enabled'
-        }
+        lf_key_for_vcs_map = {"hg": "extensions_largefiles", "git": "vcs_git_lfs_enabled"}
 
         lf_key_for_vcs = lf_key_for_vcs_map.get(target_repo.repo_type)
 
@@ -356,66 +345,77 class RepoFilesView(RepoAppView):
         return lf_enabled
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator(
-        'repository.read', 'repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.read", "repository.write", "repository.admin")
     def repo_archivefile(self):
         # archive cache config
         from rhodecode import CONFIG
+
         _ = self.request.translate
         self.load_default_context()
 
-        subrepos = self.request.GET.get('subrepos') == 'true'
-        with_hash = str2bool(self.request.GET.get('with_hash', '1'))
+        subrepos = self.request.GET.get("subrepos") == "true"
+        with_hash = str2bool(self.request.GET.get("with_hash", "1"))
 
-        default_at_path = '/'
-        fname = self.request.matchdict['fname']
-        at_path = self.request.GET.get('at_path') or default_at_path
+        default_at_path = "/"
+        fname = self.request.matchdict["fname"]
+        at_path = self.request.GET.get("at_path") or default_at_path
 
         if not self.db_repo.enable_downloads:
-            return Response(_('Downloads disabled'))
+            return Response(_("Downloads disabled"))
 
         try:
             commit_id, ext, file_format, content_type = _get_archive_spec(fname)
         except ValueError:
-            return Response(_('Unknown archive type for: `{}`').format(h.escape(fname)))
+            return Response(_("Unknown archive type for: `{}`").format(h.escape(fname)))
 
         try:
             commit = self.rhodecode_vcs_repo.get_commit(commit_id)
         except CommitDoesNotExistError:
-            return Response(_('Unknown commit_id {}').format(
-                h.escape(commit_id)))
+            return Response(_("Unknown commit_id {}").format(h.escape(commit_id)))
         except EmptyRepositoryError:
-            return Response(_('Empty repository'))
+            return Response(_("Empty repository"))
 
         # we used a ref, or a shorter version, lets redirect client ot use explicit hash
         if commit_id != commit.raw_id:
-            fname=f'{commit.raw_id}{ext}'
+            fname = f"{commit.raw_id}{ext}"
             raise HTTPFound(self.request.current_route_path(fname=fname))
 
         try:
             at_path = commit.get_node(safe_bytes(at_path)).path or default_at_path
         except Exception:
-            return Response(_('No node at path {} for this repository').format(h.escape(at_path)))
+            return Response(_("No node at path {} for this repository").format(h.escape(at_path)))
 
         path_sha = get_path_sha(at_path)
 
         # used for cache etc, consistent unique archive name
         archive_name_key = get_archive_name(
-            self.db_repo.repo_id, self.db_repo_name, commit_sha=commit.short_id, ext=ext, subrepos=subrepos,
-            path_sha=path_sha, with_hash=True)
+            self.db_repo.repo_id,
+            self.db_repo_name,
+            commit_sha=commit.short_id,
+            ext=ext,
+            subrepos=subrepos,
+            path_sha=path_sha,
+            with_hash=True,
+        )
 
         if not with_hash:
-            path_sha = ''
+            path_sha = ""
 
         # what end client gets served
         response_archive_name = get_archive_name(
-            self.db_repo.repo_id, self.db_repo_name, commit_sha=commit.short_id, ext=ext, subrepos=subrepos,
-            path_sha=path_sha, with_hash=with_hash)
+            self.db_repo.repo_id,
+            self.db_repo_name,
+            commit_sha=commit.short_id,
+            ext=ext,
+            subrepos=subrepos,
+            path_sha=path_sha,
+            with_hash=with_hash,
+        )
 
         # remove extension from our archive directory name
-        archive_dir_name = response_archive_name[:-len(ext)]
+        archive_dir_name = response_archive_name[: -len(ext)]
 
-        archive_cache_disable = self.request.GET.get('no_cache')
+        archive_cache_disable = self.request.GET.get("no_cache")
 
         d_cache = get_archival_cache_store(config=CONFIG)
 
@@ -423,29 +423,38 class RepoFilesView(RepoAppView):
         d_cache_conf = get_archival_config(config=CONFIG)
 
         # This is also a cache key, and lock key
-        reentrant_lock_key = archive_name_key + '.lock'
+        reentrant_lock_key = archive_name_key + ".lock"
 
         use_cached_archive = False
         if not archive_cache_disable and archive_name_key in d_cache:
             reader, metadata = d_cache.fetch(archive_name_key)
 
             use_cached_archive = True
-            log.debug('Found cached archive as key=%s tag=%s, serving archive from cache reader=%s',
-                      archive_name_key, metadata, reader.name)
+            log.debug(
+                "Found cached archive as key=%s tag=%s, serving archive from cache reader=%s",
+                archive_name_key,
+                metadata,
+                reader.name,
+            )
         else:
             reader = None
-            log.debug('Archive with key=%s is not yet cached, creating one now...', archive_name_key)
+            log.debug("Archive with key=%s is not yet cached, creating one now...", archive_name_key)
 
         if not reader:
             # generate new archive, as previous was not found in the cache
             try:
                 with d_cache.get_lock(reentrant_lock_key):
                     try:
-                        commit.archive_repo(archive_name_key, archive_dir_name=archive_dir_name,
-                                            kind=file_format, subrepos=subrepos,
-                                            archive_at_path=at_path, cache_config=d_cache_conf)
+                        commit.archive_repo(
+                            archive_name_key,
+                            archive_dir_name=archive_dir_name,
+                            kind=file_format,
+                            subrepos=subrepos,
+                            archive_at_path=at_path,
+                            cache_config=d_cache_conf,
+                        )
                     except ImproperArchiveTypeError:
-                        return _('Unknown archive type')
+                        return _("Unknown archive type")
 
             except ArchiveCacheGenerationLock:
                 retry_after = round(random.uniform(0.3, 3.0), 1)
@@ -464,7 +473,7 class RepoFilesView(RepoAppView):
             reader, metadata = d_cache.fetch(archive_name_key, retry=True, retry_attempts=30)
 
         response = Response(app_iter=archive_iterator(reader))
-        response.content_disposition = f'attachment; filename={response_archive_name}'
+        response.content_disposition = f"attachment; filename={response_archive_name}"
         response.content_type = str(content_type)
 
         try:
@@ -472,23 +481,25 class RepoFilesView(RepoAppView):
         finally:
             # store download action
             audit_logger.store_web(
-                'repo.archive.download', action_data={
-                    'user_agent': self.request.user_agent,
-                    'archive_name': archive_name_key,
-                    'archive_spec': fname,
-                    'archive_cached': use_cached_archive},
+                "repo.archive.download",
+                action_data={
+                    "user_agent": self.request.user_agent,
+                    "archive_name": archive_name_key,
+                    "archive_spec": fname,
+                    "archive_cached": use_cached_archive,
+                },
                 user=self._rhodecode_user,
                 repo=self.db_repo,
-                commit=True
+                commit=True,
             )
 
     def _get_file_node(self, commit_id, f_path):
-        if commit_id not in ['', None, 'None', '0' * 12, '0' * 40]:
+        if commit_id not in ["", None, "None", "0" * 12, "0" * 40]:
             commit = self.rhodecode_vcs_repo.get_commit(commit_id=commit_id)
             try:
                 node = commit.get_node(safe_bytes(f_path))
                 if node.is_dir():
-                    raise NodeError(f'{node} path is a {type(node)} not a file')
+                    raise NodeError(f"{node} path is a {type(node)} not a file")
             except NodeDoesNotExistError:
                 commit = EmptyCommit(
                     commit_id=commit_id,
@@ -497,46 +508,43 class RepoFilesView(RepoAppView):
                     alias=commit.repository.alias,
                     message=commit.message,
                     author=commit.author,
-                    date=commit.date)
-                node = FileNode(safe_bytes(f_path), b'', commit=commit)
+                    date=commit.date,
+                )
+                node = FileNode(safe_bytes(f_path), b"", commit=commit)
         else:
-            commit = EmptyCommit(
-                repo=self.rhodecode_vcs_repo,
-                alias=self.rhodecode_vcs_repo.alias)
-            node = FileNode(safe_bytes(f_path), b'', commit=commit)
+            commit = EmptyCommit(repo=self.rhodecode_vcs_repo, alias=self.rhodecode_vcs_repo.alias)
+            node = FileNode(safe_bytes(f_path), b"", commit=commit)
         return node
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator(
-        'repository.read', 'repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.read", "repository.write", "repository.admin")
     def repo_files_diff(self):
         c = self.load_default_context()
         f_path = self._get_f_path(self.request.matchdict)
-        diff1 = self.request.GET.get('diff1', '')
-        diff2 = self.request.GET.get('diff2', '')
+        diff1 = self.request.GET.get("diff1", "")
+        diff2 = self.request.GET.get("diff2", "")
 
         path1, diff1 = parse_path_ref(diff1, default_path=f_path)
 
-        ignore_whitespace = str2bool(self.request.GET.get('ignorews'))
-        line_context = self.request.GET.get('context', 3)
+        ignore_whitespace = str2bool(self.request.GET.get("ignorews"))
+        line_context = self.request.GET.get("context", 3)
 
         if not any((diff1, diff2)):
-            h.flash(
-                'Need query parameter "diff1" or "diff2" to generate a diff.',
-                category='error')
+            h.flash('Need query parameter "diff1" or "diff2" to generate a diff.', category="error")
             raise HTTPBadRequest()
 
-        c.action = self.request.GET.get('diff')
-        if c.action not in ['download', 'raw']:
+        c.action = self.request.GET.get("diff")
+        if c.action not in ["download", "raw"]:
             compare_url = h.route_path(
-                'repo_compare',
+                "repo_compare",
                 repo_name=self.db_repo_name,
-                source_ref_type='rev',
+                source_ref_type="rev",
                 source_ref=diff1,
                 target_repo=self.db_repo_name,
-                target_ref_type='rev',
+                target_ref_type="rev",
                 target_ref=diff2,
-                _query=dict(f_path=f_path))
+                _query=dict(f_path=f_path),
+            )
             # redirect to new view if we render diff
             raise HTTPFound(compare_url)
 
@@ -545,43 +553,34 class RepoFilesView(RepoAppView):
             node2 = self._get_file_node(diff2, f_path)
         except (RepositoryError, NodeError):
             log.exception("Exception while trying to get node from repository")
-            raise HTTPFound(
-                h.route_path('repo_files', repo_name=self.db_repo_name,
-                             commit_id='tip', f_path=f_path))
+            raise HTTPFound(h.route_path("repo_files", repo_name=self.db_repo_name, commit_id="tip", f_path=f_path))
 
-        if all(isinstance(node.commit, EmptyCommit)
-               for node in (node1, node2)):
+        if all(isinstance(node.commit, EmptyCommit) for node in (node1, node2)):
             raise HTTPNotFound()
 
         c.commit_1 = node1.commit
         c.commit_2 = node2.commit
 
-        if c.action == 'download':
-            _diff = diffs.get_gitdiff(node1, node2,
-                                      ignore_whitespace=ignore_whitespace,
-                                      context=line_context)
+        if c.action == "download":
+            _diff = diffs.get_gitdiff(node1, node2, ignore_whitespace=ignore_whitespace, context=line_context)
             # NOTE: this was using diff_format='gitdiff'
-            diff = diffs.DiffProcessor(_diff, diff_format='newdiff')
+            diff = diffs.DiffProcessor(_diff, diff_format="newdiff")
 
             response = Response(self.path_filter.get_raw_patch(diff))
-            response.content_type = 'text/plain'
-            response.content_disposition = (
-                f'attachment; filename={f_path}_{diff1}_vs_{diff2}.diff'
-            )
+            response.content_type = "text/plain"
+            response.content_disposition = f"attachment; filename={f_path}_{diff1}_vs_{diff2}.diff"
             charset = self._get_default_encoding(c)
             if charset:
                 response.charset = charset
             return response
 
-        elif c.action == 'raw':
-            _diff = diffs.get_gitdiff(node1, node2,
-                                      ignore_whitespace=ignore_whitespace,
-                                      context=line_context)
+        elif c.action == "raw":
+            _diff = diffs.get_gitdiff(node1, node2, ignore_whitespace=ignore_whitespace, context=line_context)
             # NOTE: this was using diff_format='gitdiff'
-            diff = diffs.DiffProcessor(_diff, diff_format='newdiff')
+            diff = diffs.DiffProcessor(_diff, diff_format="newdiff")
 
             response = Response(self.path_filter.get_raw_patch(diff))
-            response.content_type = 'text/plain'
+            response.content_type = "text/plain"
             charset = self._get_default_encoding(c)
             if charset:
                 response.charset = charset
@@ -591,31 +590,32 class RepoFilesView(RepoAppView):
         raise HTTPNotFound()
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator(
-        'repository.read', 'repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.read", "repository.write", "repository.admin")
     def repo_files_diff_2way_redirect(self):
         """
         Kept only to make OLD links work
         """
         f_path = self._get_f_path_unchecked(self.request.matchdict)
-        diff1 = self.request.GET.get('diff1', '')
-        diff2 = self.request.GET.get('diff2', '')
+        diff1 = self.request.GET.get("diff1", "")
+        diff2 = self.request.GET.get("diff2", "")
 
         if not any((diff1, diff2)):
-            h.flash(
-                'Need query parameter "diff1" or "diff2" to generate a diff.',
-                category='error')
+            h.flash('Need query parameter "diff1" or "diff2" to generate a diff.', category="error")
             raise HTTPBadRequest()
 
         compare_url = h.route_path(
-            'repo_compare',
+            "repo_compare",
             repo_name=self.db_repo_name,
-            source_ref_type='rev',
+            source_ref_type="rev",
             source_ref=diff1,
-            target_ref_type='rev',
+            target_ref_type="rev",
             target_ref=diff2,
-            _query=dict(f_path=f_path, diffmode='sideside',
-                        target_repo=self.db_repo_name,))
+            _query=dict(
+                f_path=f_path,
+                diffmode="sideside",
+                target_repo=self.db_repo_name,
+            ),
+        )
         raise HTTPFound(compare_url)
 
     @LoginRequired()
@@ -629,138 +629,131 class RepoFilesView(RepoAppView):
         landing_url = h.repo_files_by_ref_url(
             c.rhodecode_db_repo.repo_name,
             c.rhodecode_db_repo.repo_type,
-            f_path='',
+            f_path="",
             ref_name=ref_name,
-            commit_id='tip',
-            query=dict(at=ref_name)
+            commit_id="tip",
+            query=dict(at=ref_name),
         )
 
         raise HTTPFound(landing_url)
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator(
-        'repository.read', 'repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.read", "repository.write", "repository.admin")
     def repo_files(self):
         c = self.load_default_context()
 
-        view_name = getattr(self.request.matched_route, 'name', None)
+        view_name = getattr(self.request.matched_route, "name", None)
 
-        c.annotate = view_name == 'repo_files:annotated'
+        c.annotate = view_name == "repo_files:annotated"
         # default is false, but .rst/.md files later are auto rendered, we can
         # overwrite auto rendering by setting this GET flag
-        c.renderer = view_name == 'repo_files:rendered' or not self.request.GET.get('no-render', False)
+        c.renderer = view_name == "repo_files:rendered" or not self.request.GET.get("no-render", False)
 
         commit_id, f_path, bytes_path = self._get_commit_and_path()
 
         c.commit = self._get_commit_or_redirect(commit_id)
-        c.branch = self.request.GET.get('branch', None)
+        c.branch = self.request.GET.get("branch", None)
         c.f_path = f_path
-        at_rev = self.request.GET.get('at')
+        at_rev = self.request.GET.get("at")
 
         # files or dirs
         try:
-
-            c.file = c.commit.get_node(bytes_path, pre_load=['is_binary', 'size', 'data'])
+            c.file = c.commit.get_node(bytes_path, pre_load=["is_binary", "size", "data"])
 
             c.file_author = True
-            c.file_tree = ''
+            c.file_tree = ""
 
             # prev link
             try:
                 prev_commit = c.commit.prev(c.branch)
                 c.prev_commit = prev_commit
-                c.url_prev = h.route_path('repo_files', repo_name=self.db_repo_name, commit_id=prev_commit.raw_id, f_path=f_path)
+                c.url_prev = h.route_path(
+                    "repo_files", repo_name=self.db_repo_name, commit_id=prev_commit.raw_id, f_path=f_path
+                )
                 if c.branch:
-                    c.url_prev += f'?branch={c.branch}'
+                    c.url_prev += f"?branch={c.branch}"
             except (CommitDoesNotExistError, VCSError):
-                c.url_prev = '#'
+                c.url_prev = "#"
                 c.prev_commit = EmptyCommit()
 
             # next link
             try:
                 next_commit = c.commit.next(c.branch)
                 c.next_commit = next_commit
-                c.url_next = h.route_path('repo_files', repo_name=self.db_repo_name, commit_id=next_commit.raw_id, f_path=f_path)
+                c.url_next = h.route_path(
+                    "repo_files", repo_name=self.db_repo_name, commit_id=next_commit.raw_id, f_path=f_path
+                )
                 if c.branch:
-                    c.url_next += f'?branch={c.branch}'
+                    c.url_next += f"?branch={c.branch}"
             except (CommitDoesNotExistError, VCSError):
-                c.url_next = '#'
+                c.url_next = "#"
                 c.next_commit = EmptyCommit()
 
             # load file content
             if c.file.is_file():
-
                 c.lf_node = {}
 
                 has_lf_enabled = self._is_lf_enabled(self.db_repo)
                 if has_lf_enabled:
                     c.lf_node = c.file.get_largefile_node()
 
-                c.file_source_page = 'true'
+                c.file_source_page = "true"
                 c.file_last_commit = c.file.last_commit
 
                 c.file_size_too_big = c.file.size > c.visual.cut_off_limit_file
 
                 if not (c.file_size_too_big or c.file.is_binary):
                     if c.annotate:  # annotation has precedence over renderer
-                        c.annotated_lines = filenode_as_annotated_lines_tokens(
-                            c.file
-                        )
+                        c.annotated_lines = filenode_as_annotated_lines_tokens(c.file)
                     else:
-                        c.renderer = (
-                            c.renderer and h.renderer_from_filename(c.file.path)
-                        )
+                        c.renderer = c.renderer and h.renderer_from_filename(c.file.path)
                         if not c.renderer:
                             c.lines = filenode_as_lines_tokens(c.file)
 
-                _branch_name, _sha_commit_id, is_head = \
-                    self._is_valid_head(commit_id, self.rhodecode_vcs_repo,
-                                        landing_ref=self.db_repo.landing_ref_name)
+                _branch_name, _sha_commit_id, is_head = self._is_valid_head(
+                    commit_id, self.rhodecode_vcs_repo, landing_ref=self.db_repo.landing_ref_name
+                )
                 c.on_branch_head = is_head
 
-                branch = c.commit.branch if (
-                    c.commit.branch and '/' not in c.commit.branch) else None
+                branch = c.commit.branch if (c.commit.branch and "/" not in c.commit.branch) else None
                 c.branch_or_raw_id = branch or c.commit.raw_id
                 c.branch_name = c.commit.branch or h.short_id(c.commit.raw_id)
 
                 author = c.file_last_commit.author
-                c.authors = [[
-                    h.email(author),
-                    h.person(author, 'username_or_name_or_email'),
-                    1
-                ]]
+                c.authors = [[h.email(author), h.person(author, "username_or_name_or_email"), 1]]
 
-            else:  # load tree content at path
-                c.file_source_page = 'false'
+            else:  # load tree content (dir content) at path
+                c.file_source_page = "false"
                 c.authors = []
+
+                dir_node = c.file
+                c.file_nodes = dir_node.commit.get_nodes(dir_node.bytes_path, pre_load=dir_node.default_pre_load)
                 # this loads a simple tree without metadata to speed things up
                 # later via ajax we call repo_nodetree_full and fetch whole
                 c.file_tree = self._get_tree_at_commit(c, c.commit.raw_id, f_path, at_rev=at_rev)
 
-                c.readme_data, c.readme_file = \
-                    self._get_readme_data(self.db_repo, c.visual.default_renderer, c.commit.raw_id, bytes_path)
+                c.readme_data, c.readme_file = self._get_readme_data(
+                    self.db_repo, c.visual.default_renderer, c.commit.raw_id, bytes_path, nodes=c.file_nodes
+                )
 
         except RepositoryError as e:
-            h.flash(h.escape(safe_str(e)), category='error')
+            h.flash(h.escape(safe_str(e)), category="error")
             raise HTTPNotFound()
 
-        if self.request.environ.get('HTTP_X_PJAX'):
-            html = render('rhodecode:templates/files/files_pjax.mako',
-                          self._get_template_context(c), self.request)
+        if self.request.environ.get("HTTP_X_PJAX"):
+            html = render("rhodecode:templates/files/files_pjax.mako", self._get_template_context(c), self.request)
         else:
-            html = render('rhodecode:templates/files/files.mako',
-                          self._get_template_context(c), self.request)
+            html = render("rhodecode:templates/files/files.mako", self._get_template_context(c), self.request)
         return Response(html)
 
-    @HasRepoPermissionAnyDecorator(
-        'repository.read', 'repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.read", "repository.write", "repository.admin")
     def repo_files_annotated_previous(self):
         self.load_default_context()
 
         commit_id, bytes_path, bytes_path = self._get_commit_and_path()
         commit = self._get_commit_or_redirect(commit_id)
         prev_commit_id = commit.raw_id
-        line_anchor = self.request.GET.get('line_anchor')
+        line_anchor = self.request.GET.get("line_anchor")
         is_file = False
         try:
             _file = commit.get_node(bytes_path)
@@ -770,18 +763,19 class RepoFilesView(RepoAppView):
 
         if is_file:
             history = commit.get_path_history(bytes_path)
-            prev_commit_id = history[1].raw_id \
-                if len(history) > 1 else prev_commit_id
+            prev_commit_id = history[1].raw_id if len(history) > 1 else prev_commit_id
         prev_url = h.route_path(
-            'repo_files:annotated', repo_name=self.db_repo_name,
-            commit_id=prev_commit_id, f_path=bytes_path,
-            _anchor=f'L{line_anchor}')
+            "repo_files:annotated",
+            repo_name=self.db_repo_name,
+            commit_id=prev_commit_id,
+            f_path=bytes_path,
+            _anchor=f"L{line_anchor}",
+        )
 
         raise HTTPFound(prev_url)
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator(
-        'repository.read', 'repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.read", "repository.write", "repository.admin")
     def repo_nodetree_full(self):
         """
         Returns rendered html of file tree that contains commit date,
@@ -795,17 +789,17 class RepoFilesView(RepoAppView):
         try:
             dir_node = commit.get_node(bytes_path)
         except RepositoryError as e:
-            return Response(f'error: {h.escape(safe_str(e))}')
+            return Response(f"error: {h.escape(safe_str(e))}")
 
         if dir_node.is_file():
-            return Response('')
+            return Response("")
 
         c.file = dir_node
+        c.file_nodes = dir_node.commit.get_nodes(dir_node.bytes_path, pre_load=dir_node.default_pre_load)
         c.commit = commit
-        at_rev = self.request.GET.get('at')
+        at_rev = self.request.GET.get("at")
 
-        html = self._get_tree_at_commit(
-            c, commit.raw_id, dir_node.path, full_load=True, at_rev=at_rev)
+        html = self._get_tree_at_commit(c, commit.raw_id, dir_node.path, full_load=True, at_rev=at_rev)
 
         return Response(html)
 
@@ -814,15 +808,12 class RepoFilesView(RepoAppView):
         safe_path = f_name.replace('"', '\\"')
         encoded_path = urllib.parse.quote(f_name)
 
-        headers = f"attachment; " \
-                  f"filename=\"{safe_path}\"; " \
-                  f"filename*=UTF-8\'\'{encoded_path}"
+        headers = f"attachment; " f'filename="{safe_path}"; ' f"filename*=UTF-8''{encoded_path}"
 
         return header_safe_str(headers)
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator(
-        'repository.read', 'repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.read", "repository.write", "repository.admin")
     def repo_file_raw(self):
         """
         Action for show as raw, some mimetypes are "rendered",
@@ -839,16 +830,15 class RepoFilesView(RepoAppView):
             # you can also provide a content-disposition to override the
             # default "attachment" disposition.
             # orig_type: (new_type, new_dispo)
-
             # show images inline:
             # Do not re-add SVG: it is unsafe and permits XSS attacks. One can
             # for example render an SVG with javascript inside or even render
             # HTML.
-            'image/x-icon': ('image/x-icon', 'inline'),
-            'image/png': ('image/png', 'inline'),
-            'image/gif': ('image/gif', 'inline'),
-            'image/jpeg': ('image/jpeg', 'inline'),
-            'application/pdf': ('application/pdf', 'inline'),
+            "image/x-icon": ("image/x-icon", "inline"),
+            "image/png": ("image/png", "inline"),
+            "image/gif": ("image/gif", "inline"),
+            "image/jpeg": ("image/jpeg", "inline"),
+            "application/pdf": ("application/pdf", "inline"),
         }
 
         mimetype = file_node.mimetype
@@ -858,7 +848,7 class RepoFilesView(RepoAppView):
             # we don't know anything special about this, handle it safely
             if file_node.is_binary:
                 # do same as download raw for binary files
-                mimetype, disposition = 'application/octet-stream', 'attachment'
+                mimetype, disposition = "application/octet-stream", "attachment"
             else:
                 # do not just use the original mimetype, but force text/plain,
                 # otherwise it would serve text/html and that might be unsafe.
@@ -867,9 +857,9 class RepoFilesView(RepoAppView):
                 # binary.This might lead to erroneous text display in some
                 # cases, but helps in other cases, like with text files
                 # without extension.
-                mimetype, disposition = 'text/plain', 'inline'
+                mimetype, disposition = "text/plain", "inline"
 
-        if disposition == 'attachment':
+        if disposition == "attachment":
             disposition = self._get_attachement_headers(f_path)
 
         stream_content = file_node.stream_bytes()
@@ -885,8 +875,7 class RepoFilesView(RepoAppView):
         return response
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator(
-        'repository.read', 'repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.read", "repository.write", "repository.admin")
     def repo_file_download(self):
         c = self.load_default_context()
 
@@ -894,7 +883,7 class RepoFilesView(RepoAppView):
         commit = self._get_commit_or_redirect(commit_id)
         file_node = self._get_filenode_or_redirect(commit, bytes_path)
 
-        if self.request.GET.get('lf'):
+        if self.request.GET.get("lf"):
             # only if lf get flag is passed, we download this file
             # as LFS/Largefile
             lf_node = file_node.get_largefile_node()
@@ -917,44 +906,41 class RepoFilesView(RepoAppView):
         return response
 
     def _get_nodelist_at_commit(self, repo_name, repo_id, commit_id, f_path):
-
-        cache_seconds = rhodecode.ConfigGet().get_int('rc_cache.cache_repo.expiration_time')
+        cache_seconds = rhodecode.ConfigGet().get_int("rc_cache.cache_repo.expiration_time")
         cache_on = cache_seconds > 0
         log.debug(
-            'Computing FILE SEARCH for repo_id %s commit_id `%s` and path `%s`'
-            'with caching: %s[TTL: %ss]' % (
-                repo_id, commit_id, f_path, cache_on, cache_seconds or 0))
+            "Computing FILE SEARCH for repo_id %s commit_id `%s` and path `%s`"
+            "with caching: %s[TTL: %ss]" % (repo_id, commit_id, f_path, cache_on, cache_seconds or 0)
+        )
 
-        cache_namespace_uid = f'repo.{repo_id}'
-        region = rc_cache.get_or_create_region('cache_repo', cache_namespace_uid)
+        cache_namespace_uid = f"repo.{repo_id}"
+        region = rc_cache.get_or_create_region("cache_repo", cache_namespace_uid)
 
         @region.conditional_cache_on_arguments(namespace=cache_namespace_uid, condition=cache_on)
         def compute_file_search(_name_hash, _repo_id, _commit_id, _f_path):
-            log.debug('Generating cached nodelist for repo_id:%s, %s, %s', _repo_id, commit_id, f_path)
+            log.debug("Generating cached nodelist for repo_id:%s, %s, %s", _repo_id, commit_id, f_path)
             try:
                 _d, _f = ScmModel().get_quick_filter_nodes(repo_name, _commit_id, _f_path)
             except (RepositoryError, CommitDoesNotExistError, Exception) as e:
                 log.exception(safe_str(e))
-                h.flash(h.escape(safe_str(e)), category='error')
-                raise HTTPFound(h.route_path('repo_files', repo_name=self.db_repo_name, commit_id='tip', f_path='/'))
+                h.flash(h.escape(safe_str(e)), category="error")
+                raise HTTPFound(h.route_path("repo_files", repo_name=self.db_repo_name, commit_id="tip", f_path="/"))
 
             return _d + _f
 
         result = compute_file_search(self.db_repo.repo_name_hash, self.db_repo.repo_id, commit_id, f_path)
-        return filter(lambda n: self.path_filter.path_access_allowed(n['name']), result)
+        return filter(lambda n: self.path_filter.path_access_allowed(n["name"]), result)
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator(
-        'repository.read', 'repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.read", "repository.write", "repository.admin")
     def repo_nodelist(self):
         self.load_default_context()
 
         commit_id, f_path, bytes_path = self._get_commit_and_path()
         commit = self._get_commit_or_redirect(commit_id)
 
-        metadata = self._get_nodelist_at_commit(
-            self.db_repo_name, self.db_repo.repo_id, commit.raw_id, f_path)
-        return {'nodes': [x for x in metadata]}
+        metadata = self._get_nodelist_at_commit(self.db_repo_name, self.db_repo.repo_id, commit.raw_id, f_path)
+        return {"nodes": [x for x in metadata]}
 
     def _create_references(self, branches_or_tags, symbolic_reference, f_path, ref_type):
         items = []
@@ -971,7 +957,7 class RepoFilesView(RepoAppView):
 
         # NOTE(dan): old code we used in "diff" mode compare
         new_f_path = vcspath.join(name, f_path)
-        return f'{new_f_path}@{commit_id}'
+        return f"{new_f_path}@{commit_id}"
 
     def _get_node_history(self, commit_obj, f_path, commits=None):
         """
@@ -997,29 +983,26 class RepoFilesView(RepoAppView):
         history = []
         commits_group = ([], _("Changesets"))
         for commit in commits:
-            branch = ' (%s)' % commit.branch if commit.branch else ''
-            n_desc = f'r{commit.idx}:{commit.short_id}{branch}'
-            commits_group[0].append((commit.raw_id, n_desc, 'sha'))
+            branch = " (%s)" % commit.branch if commit.branch else ""
+            n_desc = f"r{commit.idx}:{commit.short_id}{branch}"
+            commits_group[0].append((commit.raw_id, n_desc, "sha"))
         history.append(commits_group)
 
         symbolic_reference = self._symbolic_reference
 
-        if self.rhodecode_vcs_repo.alias == 'svn':
-            adjusted_f_path = RepoFilesView.adjust_file_path_for_svn(
-                f_path, self.rhodecode_vcs_repo)
+        if self.rhodecode_vcs_repo.alias == "svn":
+            adjusted_f_path = RepoFilesView.adjust_file_path_for_svn(f_path, self.rhodecode_vcs_repo)
             if adjusted_f_path != f_path:
                 log.debug(
-                    'Recognized svn tag or branch in file "%s", using svn '
-                    'specific symbolic references', f_path)
+                    'Recognized svn tag or branch in file "%s", using svn ' "specific symbolic references", f_path
+                )
                 f_path = adjusted_f_path
                 symbolic_reference = self._symbolic_reference_svn
 
-        branches = self._create_references(
-            self.rhodecode_vcs_repo.branches, symbolic_reference, f_path, 'branch')
+        branches = self._create_references(self.rhodecode_vcs_repo.branches, symbolic_reference, f_path, "branch")
         branches_group = (branches, _("Branches"))
 
-        tags = self._create_references(
-            self.rhodecode_vcs_repo.tags, symbolic_reference, f_path, 'tag')
+        tags = self._create_references(self.rhodecode_vcs_repo.tags, symbolic_reference, f_path, "tag")
         tags_group = (tags, _("Tags"))
 
         history.append(branches_group)
@@ -1028,8 +1011,7 class RepoFilesView(RepoAppView):
         return history, commits
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator(
-        'repository.read', 'repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.read", "repository.write", "repository.admin")
     def repo_file_history(self):
         self.load_default_context()
 
@@ -1044,35 +1026,23 class RepoFilesView(RepoAppView):
             for section_items, section in file_history:
                 items = []
                 for obj_id, obj_text, obj_type in section_items:
-                    at_rev = ''
-                    if obj_type in ['branch', 'bookmark', 'tag']:
+                    at_rev = ""
+                    if obj_type in ["branch", "bookmark", "tag"]:
                         at_rev = obj_text
-                    entry = {
-                        'id': obj_id,
-                        'text': obj_text,
-                        'type': obj_type,
-                        'at_rev': at_rev
-                    }
+                    entry = {"id": obj_id, "text": obj_text, "type": obj_type, "at_rev": at_rev}
 
                     items.append(entry)
 
-                res.append({
-                    'text': section,
-                    'children': items
-                })
+                res.append({"text": section, "children": items})
 
-            data = {
-                'more': False,
-                'results': res
-            }
+            data = {"more": False, "results": res}
             return data
 
-        log.warning('Cannot fetch history for directory')
+        log.warning("Cannot fetch history for directory")
         raise HTTPBadRequest()
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator(
-        'repository.read', 'repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.read", "repository.write", "repository.admin")
     def repo_file_authors(self):
         c = self.load_default_context()
 
@@ -1084,12 +1054,10 class RepoFilesView(RepoAppView):
             raise HTTPBadRequest()
 
         c.file_last_commit = file_node.last_commit
-        if self.request.GET.get('annotate') == '1':
+        if self.request.GET.get("annotate") == "1":
             # use _hist from annotation if annotation mode is on
             commit_ids = {x[1] for x in file_node.annotate}
-            _hist = (
-                self.rhodecode_vcs_repo.get_commit(commit_id)
-                for commit_id in commit_ids)
+            _hist = (self.rhodecode_vcs_repo.get_commit(commit_id) for commit_id in commit_ids)
         else:
             _f_history, _hist = self._get_node_history(commit, f_path)
         c.file_author = False
@@ -1100,8 +1068,8 class RepoFilesView(RepoAppView):
             if author not in unique:
                 unique[commit.author] = [
                     h.email(author),
-                    h.person(author, 'username_or_name_or_email'),
-                    1  # counter
+                    h.person(author, "username_or_name_or_email"),
+                    1,  # counter
                 ]
 
             else:
@@ -1113,20 +1081,21 class RepoFilesView(RepoAppView):
         return self._get_template_context(c)
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.write", "repository.admin")
     def repo_files_check_head(self):
         self.load_default_context()
 
         commit_id, f_path, bytes_path = self._get_commit_and_path()
-        _branch_name, _sha_commit_id, is_head = \
-            self._is_valid_head(commit_id, self.rhodecode_vcs_repo, landing_ref=self.db_repo.landing_ref_name)
+        _branch_name, _sha_commit_id, is_head = self._is_valid_head(
+            commit_id, self.rhodecode_vcs_repo, landing_ref=self.db_repo.landing_ref_name
+        )
 
-        new_path = self.request.POST.get('path')
-        operation = self.request.POST.get('operation')
-        path_exist = ''
+        new_path = self.request.POST.get("path")
+        operation = self.request.POST.get("operation")
+        path_exist = ""
 
-        if new_path and operation in ['create', 'upload']:
-            new_f_path = os.path.join(f_path.lstrip('/'), new_path)
+        if new_path and operation in ["create", "upload"]:
+            new_f_path = os.path.join(f_path.lstrip("/"), new_path)
             try:
                 commit_obj = self.rhodecode_vcs_repo.get_commit(commit_id)
                 # NOTE(dan): construct whole path without leading /
@@ -1136,24 +1105,19 class RepoFilesView(RepoAppView):
             except (EmptyRepositoryError, NodeDoesNotExistError):
                 pass
 
-        return {
-            'branch': _branch_name,
-            'sha': _sha_commit_id,
-            'is_head': is_head,
-            'path_exists': path_exist
-        }
+        return {"branch": _branch_name, "sha": _sha_commit_id, "is_head": is_head, "path_exists": path_exist}
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.write", "repository.admin")
     def repo_files_remove_file(self):
         _ = self.request.translate
         c = self.load_default_context()
         commit_id, f_path, bytes_path = self._get_commit_and_path()
 
         self._ensure_not_locked()
-        _branch_name, _sha_commit_id, is_head = \
-            self._is_valid_head(commit_id, self.rhodecode_vcs_repo,
-                                landing_ref=self.db_repo.landing_ref_name)
+        _branch_name, _sha_commit_id, is_head = self._is_valid_head(
+            commit_id, self.rhodecode_vcs_repo, landing_ref=self.db_repo.landing_ref_name
+        )
 
         self.forbid_non_head(is_head, f_path)
         self.check_branch_permission(_branch_name)
@@ -1161,14 +1125,13 class RepoFilesView(RepoAppView):
         c.commit = self._get_commit_or_redirect(commit_id)
         c.file = self._get_filenode_or_redirect(c.commit, bytes_path)
 
-        c.default_message = _(
-            'Deleted file {} via RhodeCode Enterprise').format(f_path)
+        c.default_message = _("Deleted file {} via RhodeCode Enterprise").format(f_path)
         c.f_path = f_path
 
         return self._get_template_context(c)
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.write", "repository.admin")
     @CSRFRequired()
     def repo_files_delete_file(self):
         _ = self.request.translate
@@ -1177,9 +1140,9 class RepoFilesView(RepoAppView):
         commit_id, f_path, bytes_path = self._get_commit_and_path()
 
         self._ensure_not_locked()
-        _branch_name, _sha_commit_id, is_head = \
-            self._is_valid_head(commit_id, self.rhodecode_vcs_repo,
-                                landing_ref=self.db_repo.landing_ref_name)
+        _branch_name, _sha_commit_id, is_head = self._is_valid_head(
+            commit_id, self.rhodecode_vcs_repo, landing_ref=self.db_repo.landing_ref_name
+        )
 
         self.forbid_non_head(is_head, f_path)
         self.check_branch_permission(_branch_name)
@@ -1187,46 +1150,39 class RepoFilesView(RepoAppView):
         c.commit = self._get_commit_or_redirect(commit_id)
         c.file = self._get_filenode_or_redirect(c.commit, bytes_path)
 
-        c.default_message = _('Deleted file {} via RhodeCode Enterprise').format(f_path)
+        c.default_message = _("Deleted file {} via RhodeCode Enterprise").format(f_path)
         c.f_path = f_path
         node_path = f_path
         author = self._rhodecode_db_user.full_contact
-        message = self.request.POST.get('message') or c.default_message
+        message = self.request.POST.get("message") or c.default_message
         try:
-            nodes = {
-                safe_bytes(node_path): {
-                    'content': b''
-                }
-            }
+            nodes = {safe_bytes(node_path): {"content": b""}}
             ScmModel().delete_nodes(
-                user=self._rhodecode_db_user.user_id, repo=self.db_repo,
+                user=self._rhodecode_db_user.user_id,
+                repo=self.db_repo,
                 message=message,
                 nodes=nodes,
                 parent_commit=c.commit,
                 author=author,
             )
 
-            h.flash(
-                _('Successfully deleted file `{}`').format(
-                    h.escape(f_path)), category='success')
+            h.flash(_("Successfully deleted file `{}`").format(h.escape(f_path)), category="success")
         except Exception:
-            log.exception('Error during commit operation')
-            h.flash(_('Error occurred during commit'), category='error')
-        raise HTTPFound(
-            h.route_path('repo_commit', repo_name=self.db_repo_name,
-                         commit_id='tip'))
+            log.exception("Error during commit operation")
+            h.flash(_("Error occurred during commit"), category="error")
+        raise HTTPFound(h.route_path("repo_commit", repo_name=self.db_repo_name, commit_id="tip"))
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.write", "repository.admin")
     def repo_files_edit_file(self):
         _ = self.request.translate
         c = self.load_default_context()
         commit_id, f_path, bytes_path = self._get_commit_and_path()
 
         self._ensure_not_locked()
-        _branch_name, _sha_commit_id, is_head = \
-            self._is_valid_head(commit_id, self.rhodecode_vcs_repo,
-                                landing_ref=self.db_repo.landing_ref_name)
+        _branch_name, _sha_commit_id, is_head = self._is_valid_head(
+            commit_id, self.rhodecode_vcs_repo, landing_ref=self.db_repo.landing_ref_name
+        )
 
         self.forbid_non_head(is_head, f_path, commit_id=commit_id)
         self.check_branch_permission(_branch_name, commit_id=commit_id)
@@ -1236,18 +1192,17 class RepoFilesView(RepoAppView):
 
         if c.file.is_binary:
             files_url = h.route_path(
-                'repo_files',
-                repo_name=self.db_repo_name,
-                commit_id=c.commit.raw_id, f_path=f_path)
+                "repo_files", repo_name=self.db_repo_name, commit_id=c.commit.raw_id, f_path=f_path
+            )
             raise HTTPFound(files_url)
 
-        c.default_message = _('Edited file {} via RhodeCode Enterprise').format(f_path)
+        c.default_message = _("Edited file {} via RhodeCode Enterprise").format(f_path)
         c.f_path = f_path
 
         return self._get_template_context(c)
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.write", "repository.admin")
     @CSRFRequired()
     def repo_files_update_file(self):
         _ = self.request.translate
@@ -1260,53 +1215,52 class RepoFilesView(RepoAppView):
         c.file = self._get_filenode_or_redirect(c.commit, bytes_path)
 
         if c.file.is_binary:
-            raise HTTPFound(h.route_path('repo_files', repo_name=self.db_repo_name,
-                                         commit_id=c.commit.raw_id, f_path=f_path))
+            raise HTTPFound(
+                h.route_path("repo_files", repo_name=self.db_repo_name, commit_id=c.commit.raw_id, f_path=f_path)
+            )
 
-        _branch_name, _sha_commit_id, is_head = \
-            self._is_valid_head(commit_id, self.rhodecode_vcs_repo,
-                                landing_ref=self.db_repo.landing_ref_name)
+        _branch_name, _sha_commit_id, is_head = self._is_valid_head(
+            commit_id, self.rhodecode_vcs_repo, landing_ref=self.db_repo.landing_ref_name
+        )
 
         self.forbid_non_head(is_head, f_path, commit_id=commit_id)
         self.check_branch_permission(_branch_name, commit_id=commit_id)
 
-        c.default_message = _('Edited file {} via RhodeCode Enterprise').format(f_path)
+        c.default_message = _("Edited file {} via RhodeCode Enterprise").format(f_path)
         c.f_path = f_path
 
         old_content = c.file.str_content
         sl = old_content.splitlines(1)
-        first_line = sl[0] if sl else ''
+        first_line = sl[0] if sl else ""
 
         r_post = self.request.POST
         # line endings:  0 - Unix, 1 - Mac, 2 - DOS
         line_ending_mode = detect_mode(first_line, 0)
-        content = convert_line_endings(r_post.get('content', ''), line_ending_mode)
+        content = convert_line_endings(r_post.get("content", ""), line_ending_mode)
 
-        message = r_post.get('message') or c.default_message
+        message = r_post.get("message") or c.default_message
 
         org_node_path = c.file.str_path
-        filename = r_post['filename']
+        filename = r_post["filename"]
 
         root_path = c.file.dir_path
         pure_path = self.create_pure_path(root_path, filename)
         node_path = pure_path.as_posix()
 
-        default_redirect_url = h.route_path('repo_commit', repo_name=self.db_repo_name,
-                                            commit_id=commit_id)
+        default_redirect_url = h.route_path("repo_commit", repo_name=self.db_repo_name, commit_id=commit_id)
         if content == old_content and node_path == org_node_path:
-            h.flash(_('No changes detected on {}').format(h.escape(org_node_path)),
-                    category='warning')
+            h.flash(_("No changes detected on {}").format(h.escape(org_node_path)), category="warning")
             raise HTTPFound(default_redirect_url)
 
         try:
             mapping = {
                 c.file.bytes_path: {
-                    'org_filename': org_node_path,
-                    'filename': safe_bytes(node_path),
-                    'content': safe_bytes(content),
-                    'lexer': '',
-                    'op': 'mod',
-                    'mode': c.file.mode
+                    "org_filename": org_node_path,
+                    "filename": safe_bytes(node_path),
+                    "content": safe_bytes(content),
+                    "lexer": "",
+                    "op": "mod",
+                    "mode": c.file.mode,
                 }
             }
 
@@ -1318,19 +1272,17 class RepoFilesView(RepoAppView):
                 parent_commit=c.commit,
             )
 
-            h.flash(_('Successfully committed changes to file `{}`').format(
-                    h.escape(f_path)), category='success')
-            default_redirect_url = h.route_path(
-                'repo_commit', repo_name=self.db_repo_name, commit_id=commit.raw_id)
+            h.flash(_("Successfully committed changes to file `{}`").format(h.escape(f_path)), category="success")
+            default_redirect_url = h.route_path("repo_commit", repo_name=self.db_repo_name, commit_id=commit.raw_id)
 
         except Exception:
-            log.exception('Error occurred during commit')
-            h.flash(_('Error occurred during commit'), category='error')
+            log.exception("Error occurred during commit")
+            h.flash(_("Error occurred during commit"), category="error")
 
         raise HTTPFound(default_redirect_url)
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.write", "repository.admin")
     def repo_files_add_file(self):
         _ = self.request.translate
         c = self.load_default_context()
@@ -1339,7 +1291,7 class RepoFilesView(RepoAppView):
         self._ensure_not_locked()
 
         # Check if we need to use this page to upload binary
-        upload_binary = str2bool(self.request.params.get('upload_binary', False))
+        upload_binary = str2bool(self.request.params.get("upload_binary", False))
 
         c.commit = self._get_commit_or_redirect(commit_id, redirect_after=False)
         if c.commit is None:
@@ -1348,24 +1300,27 class RepoFilesView(RepoAppView):
         if self.rhodecode_vcs_repo.is_empty():
             # for empty repository we cannot check for current branch, we rely on
             # c.commit.branch instead
-            _branch_name, _sha_commit_id, is_head = c.commit.branch, '', True
+            _branch_name, _sha_commit_id, is_head = c.commit.branch, "", True
         else:
-            _branch_name, _sha_commit_id, is_head = \
-                self._is_valid_head(commit_id, self.rhodecode_vcs_repo,
-                                    landing_ref=self.db_repo.landing_ref_name)
+            _branch_name, _sha_commit_id, is_head = self._is_valid_head(
+                commit_id, self.rhodecode_vcs_repo, landing_ref=self.db_repo.landing_ref_name
+            )
 
         self.forbid_non_head(is_head, f_path, commit_id=commit_id)
         self.check_branch_permission(_branch_name, commit_id=commit_id)
 
-        c.default_message = (_('Added file via RhodeCode Enterprise')) \
-            if not upload_binary else (_('Edited file {} via RhodeCode Enterprise').format(f_path))
-        c.f_path = f_path.lstrip('/')  # ensure not relative path
+        c.default_message = (
+            (_("Added file via RhodeCode Enterprise"))
+            if not upload_binary
+            else (_("Edited file {} via RhodeCode Enterprise").format(f_path))
+        )
+        c.f_path = f_path.lstrip("/")  # ensure not relative path
         c.replace_binary = upload_binary
 
         return self._get_template_context(c)
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.write", "repository.admin")
     @CSRFRequired()
     def repo_files_create_file(self):
         _ = self.request.translate
@@ -1380,56 +1335,48 class RepoFilesView(RepoAppView):
 
         # calculate redirect URL
         if self.rhodecode_vcs_repo.is_empty():
-            default_redirect_url = h.route_path(
-                'repo_summary', repo_name=self.db_repo_name)
+            default_redirect_url = h.route_path("repo_summary", repo_name=self.db_repo_name)
         else:
-            default_redirect_url = h.route_path(
-                'repo_commit', repo_name=self.db_repo_name, commit_id='tip')
+            default_redirect_url = h.route_path("repo_commit", repo_name=self.db_repo_name, commit_id="tip")
 
         if self.rhodecode_vcs_repo.is_empty():
             # for empty repository we cannot check for current branch, we rely on
             # c.commit.branch instead
-            _branch_name, _sha_commit_id, is_head = c.commit.branch, '', True
+            _branch_name, _sha_commit_id, is_head = c.commit.branch, "", True
         else:
-            _branch_name, _sha_commit_id, is_head = \
-                self._is_valid_head(commit_id, self.rhodecode_vcs_repo,
-                                    landing_ref=self.db_repo.landing_ref_name)
+            _branch_name, _sha_commit_id, is_head = self._is_valid_head(
+                commit_id, self.rhodecode_vcs_repo, landing_ref=self.db_repo.landing_ref_name
+            )
 
         self.forbid_non_head(is_head, f_path, commit_id=commit_id)
         self.check_branch_permission(_branch_name, commit_id=commit_id)
 
-        c.default_message = (_('Added file via RhodeCode Enterprise'))
+        c.default_message = _("Added file via RhodeCode Enterprise")
         c.f_path = f_path
 
         r_post = self.request.POST
-        message = r_post.get('message') or c.default_message
-        filename = r_post.get('filename')
+        message = r_post.get("message") or c.default_message
+        filename = r_post.get("filename")
         unix_mode = 0
 
         if not filename:
             # If there's no commit, redirect to repo summary
             if type(c.commit) is EmptyCommit:
-                redirect_url = h.route_path(
-                    'repo_summary', repo_name=self.db_repo_name)
+                redirect_url = h.route_path("repo_summary", repo_name=self.db_repo_name)
             else:
                 redirect_url = default_redirect_url
-            h.flash(_('No filename specified'), category='warning')
+            h.flash(_("No filename specified"), category="warning")
             raise HTTPFound(redirect_url)
 
         root_path = f_path
         pure_path = self.create_pure_path(root_path, filename)
-        node_path = pure_path.as_posix().lstrip('/')
+        node_path = pure_path.as_posix().lstrip("/")
 
         author = self._rhodecode_db_user.full_contact
-        content = convert_line_endings(r_post.get('content', ''), unix_mode)
-        nodes = {
-            safe_bytes(node_path): {
-                'content': safe_bytes(content)
-            }
-        }
+        content = convert_line_endings(r_post.get("content", ""), unix_mode)
+        nodes = {safe_bytes(node_path): {"content": safe_bytes(content)}}
 
         try:
-
             commit = ScmModel().create_nodes(
                 user=self._rhodecode_db_user.user_id,
                 repo=self.db_repo,
@@ -1439,26 +1386,27 class RepoFilesView(RepoAppView):
                 author=author,
             )
 
-            h.flash(_('Successfully committed new file `{}`').format(h.escape(node_path)), category='success')
+            h.flash(_("Successfully committed new file `{}`").format(h.escape(node_path)), category="success")
 
-            default_redirect_url = h.route_path(
-                'repo_commit', repo_name=self.db_repo_name, commit_id=commit.raw_id)
+            default_redirect_url = h.route_path("repo_commit", repo_name=self.db_repo_name, commit_id=commit.raw_id)
 
         except NonRelativePathError:
-            log.exception('Non Relative path found')
-            h.flash(_('The location specified must be a relative path and must not '
-                      'contain .. in the path'), category='warning')
+            log.exception("Non Relative path found")
+            h.flash(
+                _("The location specified must be a relative path and must not " "contain .. in the path"),
+                category="warning",
+            )
             raise HTTPFound(default_redirect_url)
         except (NodeError, NodeAlreadyExistsError) as e:
-            h.flash(h.escape(safe_str(e)), category='error')
+            h.flash(h.escape(safe_str(e)), category="error")
         except Exception:
-            log.exception('Error occurred during commit')
-            h.flash(_('Error occurred during commit'), category='error')
+            log.exception("Error occurred during commit")
+            h.flash(_("Error occurred during commit"), category="error")
 
         raise HTTPFound(default_redirect_url)
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.write", "repository.admin")
     @CSRFRequired()
     def repo_files_upload_file(self):
         _ = self.request.translate
@@ -1473,65 +1421,52 class RepoFilesView(RepoAppView):
 
         # calculate redirect URL
         if self.rhodecode_vcs_repo.is_empty():
-            default_redirect_url = h.route_path(
-                'repo_summary', repo_name=self.db_repo_name)
+            default_redirect_url = h.route_path("repo_summary", repo_name=self.db_repo_name)
         else:
-            default_redirect_url = h.route_path(
-                'repo_commit', repo_name=self.db_repo_name, commit_id='tip')
+            default_redirect_url = h.route_path("repo_commit", repo_name=self.db_repo_name, commit_id="tip")
 
         if self.rhodecode_vcs_repo.is_empty():
             # for empty repository we cannot check for current branch, we rely on
             # c.commit.branch instead
-            _branch_name, _sha_commit_id, is_head = c.commit.branch, '', True
+            _branch_name, _sha_commit_id, is_head = c.commit.branch, "", True
         else:
-            _branch_name, _sha_commit_id, is_head = \
-                self._is_valid_head(commit_id, self.rhodecode_vcs_repo,
-                                    landing_ref=self.db_repo.landing_ref_name)
+            _branch_name, _sha_commit_id, is_head = self._is_valid_head(
+                commit_id, self.rhodecode_vcs_repo, landing_ref=self.db_repo.landing_ref_name
+            )
 
         error = self.forbid_non_head(is_head, f_path, json_mode=True)
         if error:
-            return {
-                'error': error,
-                'redirect_url': default_redirect_url
-            }
+            return {"error": error, "redirect_url": default_redirect_url}
         error = self.check_branch_permission(_branch_name, json_mode=True)
         if error:
-            return {
-                'error': error,
-                'redirect_url': default_redirect_url
-            }
+            return {"error": error, "redirect_url": default_redirect_url}
 
-        c.default_message = (_('Added file via RhodeCode Enterprise'))
+        c.default_message = _("Added file via RhodeCode Enterprise")
         c.f_path = f_path
 
         r_post = self.request.POST
 
         message = c.default_message
-        user_message = r_post.getall('message')
+        user_message = r_post.getall("message")
         if isinstance(user_message, list) and user_message:
             # we take the first from duplicated results if it's not empty
             message = user_message[0] if user_message[0] else message
 
         nodes = {}
 
-        for file_obj in r_post.getall('files_upload') or []:
+        for file_obj in r_post.getall("files_upload") or []:
             content = file_obj.file
             filename = file_obj.filename
 
             root_path = f_path
             pure_path = self.create_pure_path(root_path, filename)
-            node_path = pure_path.as_posix().lstrip('/')
+            node_path = pure_path.as_posix().lstrip("/")
 
-            nodes[safe_bytes(node_path)] = {
-                'content': content
-            }
+            nodes[safe_bytes(node_path)] = {"content": content}
 
         if not nodes:
-            error = 'missing files'
-            return {
-                'error': error,
-                'redirect_url': default_redirect_url
-            }
+            error = "missing files"
+            return {"error": error, "redirect_url": default_redirect_url}
 
         author = self._rhodecode_db_user.full_contact
 
@@ -1545,49 +1480,35 class RepoFilesView(RepoAppView):
                 author=author,
             )
             if len(nodes) == 1:
-                flash_message = _('Successfully committed {} new files').format(len(nodes))
+                flash_message = _("Successfully committed {} new files").format(len(nodes))
             else:
-                flash_message = _('Successfully committed 1 new file')
+                flash_message = _("Successfully committed 1 new file")
 
-            h.flash(flash_message, category='success')
+            h.flash(flash_message, category="success")
 
-            default_redirect_url = h.route_path(
-                'repo_commit', repo_name=self.db_repo_name, commit_id=commit.raw_id)
+            default_redirect_url = h.route_path("repo_commit", repo_name=self.db_repo_name, commit_id=commit.raw_id)
 
         except NonRelativePathError:
-            log.exception('Non Relative path found')
-            error = _('The location specified must be a relative path and must not '
-                      'contain .. in the path')
-            h.flash(error, category='warning')
+            log.exception("Non Relative path found")
+            error = _("The location specified must be a relative path and must not " "contain .. in the path")
+            h.flash(error, category="warning")
 
-            return {
-                'error': error,
-                'redirect_url': default_redirect_url
-            }
+            return {"error": error, "redirect_url": default_redirect_url}
         except (NodeError, NodeAlreadyExistsError) as e:
             error = h.escape(e)
-            h.flash(error, category='error')
+            h.flash(error, category="error")
 
-            return {
-                'error': error,
-                'redirect_url': default_redirect_url
-            }
+            return {"error": error, "redirect_url": default_redirect_url}
         except Exception:
-            log.exception('Error occurred during commit')
-            error = _('Error occurred during commit')
-            h.flash(error, category='error')
-            return {
-                'error': error,
-                'redirect_url': default_redirect_url
-            }
+            log.exception("Error occurred during commit")
+            error = _("Error occurred during commit")
+            h.flash(error, category="error")
+            return {"error": error, "redirect_url": default_redirect_url}
 
-        return {
-            'error': None,
-            'redirect_url': default_redirect_url
-        }
+        return {"error": None, "redirect_url": default_redirect_url}
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
+    @HasRepoPermissionAnyDecorator("repository.write", "repository.admin")
     @CSRFRequired()
     def repo_files_replace_file(self):
         _ = self.request.translate
@@ -1601,64 +1522,50 class RepoFilesView(RepoAppView):
             c.commit = EmptyCommit(alias=self.rhodecode_vcs_repo.alias)
 
         if self.rhodecode_vcs_repo.is_empty():
-            default_redirect_url = h.route_path(
-                'repo_summary', repo_name=self.db_repo_name)
+            default_redirect_url = h.route_path("repo_summary", repo_name=self.db_repo_name)
         else:
-            default_redirect_url = h.route_path(
-                'repo_commit', repo_name=self.db_repo_name, commit_id='tip')
+            default_redirect_url = h.route_path("repo_commit", repo_name=self.db_repo_name, commit_id="tip")
 
         if self.rhodecode_vcs_repo.is_empty():
             # for empty repository we cannot check for current branch, we rely on
             # c.commit.branch instead
-            _branch_name, _sha_commit_id, is_head = c.commit.branch, '', True
+            _branch_name, _sha_commit_id, is_head = c.commit.branch, "", True
         else:
-            _branch_name, _sha_commit_id, is_head = \
-                self._is_valid_head(commit_id, self.rhodecode_vcs_repo,
-                                    landing_ref=self.db_repo.landing_ref_name)
+            _branch_name, _sha_commit_id, is_head = self._is_valid_head(
+                commit_id, self.rhodecode_vcs_repo, landing_ref=self.db_repo.landing_ref_name
+            )
 
         error = self.forbid_non_head(is_head, f_path, json_mode=True)
         if error:
-            return {
-                'error': error,
-                'redirect_url': default_redirect_url
-            }
+            return {"error": error, "redirect_url": default_redirect_url}
         error = self.check_branch_permission(_branch_name, json_mode=True)
         if error:
-            return {
-                'error': error,
-                'redirect_url': default_redirect_url
-            }
+            return {"error": error, "redirect_url": default_redirect_url}
 
-        c.default_message = (_('Edited file {} via RhodeCode Enterprise').format(f_path))
+        c.default_message = _("Edited file {} via RhodeCode Enterprise").format(f_path)
         c.f_path = f_path
 
         r_post = self.request.POST
 
         message = c.default_message
-        user_message = r_post.getall('message')
+        user_message = r_post.getall("message")
         if isinstance(user_message, list) and user_message:
             # we take the first from duplicated results if it's not empty
             message = user_message[0] if user_message[0] else message
 
-        data_for_replacement = r_post.getall('files_upload') or []
+        data_for_replacement = r_post.getall("files_upload") or []
         if (objects_count := len(data_for_replacement)) > 1:
-            return {
-                'error': 'too many files for replacement',
-                'redirect_url': default_redirect_url
-            }
+            return {"error": "too many files for replacement", "redirect_url": default_redirect_url}
         elif not objects_count:
-            return {
-                'error': 'missing files',
-                'redirect_url': default_redirect_url
-            }
+            return {"error": "missing files", "redirect_url": default_redirect_url}
 
         content = data_for_replacement[0].file
         retrieved_filename = data_for_replacement[0].filename
 
-        if retrieved_filename.split('.')[-1] != f_path.split('.')[-1]:
+        if retrieved_filename.split(".")[-1] != f_path.split(".")[-1]:
             return {
-                'error': 'file extension of uploaded file doesn\'t match an original file\'s extension',
-                'redirect_url': default_redirect_url
+                "error": "file extension of uploaded file doesn't match an original file's extension",
+                "redirect_url": default_redirect_url,
             }
 
         author = self._rhodecode_db_user.full_contact
@@ -1669,36 +1576,26 class RepoFilesView(RepoAppView):
                 repo=self.db_repo,
                 message=message,
                 node={
-                    'content': content,
-                    'file_path': f_path.encode(),
+                    "content": content,
+                    "file_path": f_path.encode(),
                 },
                 parent_commit=c.commit,
                 author=author,
             )
 
-            h.flash(_('Successfully committed 1 new file'), category='success')
+            h.flash(_("Successfully committed 1 new file"), category="success")
 
-            default_redirect_url = h.route_path(
-                'repo_commit', repo_name=self.db_repo_name, commit_id=commit.raw_id)
+            default_redirect_url = h.route_path("repo_commit", repo_name=self.db_repo_name, commit_id=commit.raw_id)
 
         except (NodeError, NodeAlreadyExistsError) as e:
             error = h.escape(e)
-            h.flash(error, category='error')
+            h.flash(error, category="error")
 
-            return {
-                'error': error,
-                'redirect_url': default_redirect_url
-            }
+            return {"error": error, "redirect_url": default_redirect_url}
         except Exception:
-            log.exception('Error occurred during commit')
-            error = _('Error occurred during commit')
-            h.flash(error, category='error')
-            return {
-                'error': error,
-                'redirect_url': default_redirect_url
-            }
+            log.exception("Error occurred during commit")
+            error = _("Error occurred during commit")
+            h.flash(error, category="error")
+            return {"error": error, "redirect_url": default_redirect_url}
 
-        return {
-            'error': None,
-            'redirect_url': default_redirect_url
-        }
+        return {"error": None, "redirect_url": default_redirect_url}

rhodecode/lib/rc_cache/__init__.py

@@ -55,7 +55,7 register_backend(
 log = logging.getLogger(__name__)
 
 
-FILE_TREE_CACHE_VER = 'v5'
+FILE_TREE_CACHE_VER = 'v6'
 LICENSE_CACHE_VER = 'v3'
 PERMISSIONS_CACHE_VER = 'v2'
 

rhodecode/lib/utils2.py

@@ -153,6 +153,7 def remove_prefix(s, prefix):
 
 def find_calling_context(ignore_modules=None, depth=4, output_writer=None, indent=True):
     """
+    How to find calling context:
     Look through the calling stack and return the frame which called
     this function and is part of core module ( ie. rhodecode.* )
 

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

@@ -295,19 +295,16 class GitCommit(base.BaseCommit):
             raise CommitError(f"Directory does not exist for commit {self.raw_id} at '{path}'")
         path = self._fix_path(path)
 
-        # call and check tree_id for this path
-        tree_id, _ = self._get_path_tree_id_and_type(path)
-
         path_nodes = []
 
-        for bytes_name, stat_, tree_item_id, node_kind in self._remote.tree_items(tree_id):
+        for obj_name, stat_, tree_item_id, node_kind, pre_load_data in self._remote.get_nodes(self.raw_id, path, pre_load):
             if node_kind is None:
                 raise CommitError(f"Requested object type={node_kind} cannot be determined")
 
-            if path != b"":
-                obj_path = b"/".join((path, bytes_name))
+            if path == b"":
+                obj_path = obj_name
             else:
-                obj_path = bytes_name
+                obj_path = b"/".join((path, obj_name))
 
             # cache file mode for git, since we have it already
             if obj_path not in self._path_mode_cache:
@@ -322,12 +319,12 class GitCommit(base.BaseCommit):
                 entry = self.nodes[obj_path]
             else:
                 if node_kind == NodeKind.SUBMODULE:
-                    url = self._get_submodule_url(b"/".join((path, bytes_name)))
-                    entry= SubModuleNode(bytes_name, url=url, commit=tree_item_id, alias=self.repository.alias)
+                    url = self._get_submodule_url(obj_path)
+                    entry= SubModuleNode(obj_name, url=url, commit=tree_item_id, alias=self.repository.alias)
                 elif node_kind == NodeKind.DIR:
                     entry = DirNode(safe_bytes(obj_path), commit=self)
                 elif node_kind == NodeKind.FILE:
-                    entry = FileNode(safe_bytes(obj_path), commit=self, mode=stat_, pre_load=pre_load)
+                    entry = FileNode(safe_bytes(obj_path), commit=self, mode=stat_, pre_load_data=pre_load_data)
 
             if entry:
                 self.nodes[obj_path] = entry

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

@@ -274,7 +274,7 class MercurialCommit(base.BaseCommit):
 
         path_nodes = []
 
-        for obj_path, (node_kind, flags) in self._remote.dir_items(self.raw_id, path):
+        for obj_path, node_kind, flags, pre_load_data in self._remote.get_nodes(self.raw_id, path, pre_load):
 
             if node_kind is None:
                 raise CommitError(f"Requested object type={node_kind} cannot be mapped to a proper type")
@@ -295,7 +295,7 class MercurialCommit(base.BaseCommit):
                 if node_kind == NodeKind.DIR:
                     entry = DirNode(safe_bytes(obj_path), commit=self)
                 elif node_kind == NodeKind.FILE:
-                    entry = FileNode(safe_bytes(obj_path), commit=self, mode=stat_, pre_load=pre_load)
+                    entry = FileNode(safe_bytes(obj_path), commit=self, mode=stat_, pre_load=pre_load, pre_load_data=pre_load_data)
             if entry:
                 self.nodes[obj_path] = entry
                 path_nodes.append(entry)

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

@@ -201,8 +201,8 class SubversionCommit(base.BaseCommit):
         path = self._fix_path(path)
 
         path_nodes = []
-        for name, node_kind in self._remote.get_nodes(self._svn_rev, path):
-            obj_path = vcspath.join(path, name)
+
+        for obj_path, node_kind, pre_load_data in self._remote.get_nodes(self._svn_rev, path, pre_load):
 
             if node_kind is None:
                 raise CommitError(f"Requested object type={node_kind} cannot be determined")
@@ -224,7 +224,7 class SubversionCommit(base.BaseCommit):
                 if node_kind == NodeKind.DIR:
                     entry = nodes.DirNode(safe_bytes(obj_path), commit=self)
                 elif node_kind == NodeKind.FILE:
-                    entry = nodes.FileNode(safe_bytes(obj_path), commit=self, mode=stat_, pre_load=pre_load)
+                    entry = nodes.FileNode(safe_bytes(obj_path), commit=self, mode=stat_, pre_load=pre_load, pre_load_data=pre_load_data)
             if entry:
                 self.nodes[obj_path] = entry
                 path_nodes.append(entry)

rhodecode/lib/vcs/nodes.py

@@ -241,7 +241,7 class FileNode(Node):
 
     _filter_pre_load = []
 
-    def __init__(self, path: bytes, content: bytes | None = None, commit=None, mode=None, pre_load=None):
+    def __init__(self, path: bytes, content: bytes | None = None, commit=None, mode=None, pre_load=None, pre_load_data=None):
         """
         Only one of ``content`` and ``commit`` may be given. Passing both
         would raise ``NodeError`` exception.
@@ -263,8 +263,10 class FileNode(Node):
             content = safe_bytes(content)
         self._content = content
         self._mode = mode or FILEMODE_DEFAULT
-
-        self._set_bulk_properties(pre_load)
+        if pre_load_data:
+            self._store_pre_load(pre_load_data)
+        else:
+            self._set_bulk_properties(pre_load)
 
     def __eq__(self, other):
         eq = super().__eq__(other)
@@ -296,7 +298,10 class FileNode(Node):
         remote = self.commit.get_remote()
         result = remote.bulk_file_request(self.commit.raw_id, self.bytes_path, pre_load)
 
-        for attr, value in result.items():
+        self._store_pre_load(result.items())
+
+    def _store_pre_load(self, pre_load_data):
+        for attr, value in pre_load_data:
             if attr == "flags":
                 self.__dict__["mode"] = safe_str(value)
             elif attr == "size":

rhodecode/model/repo.py

@@ -1141,7 +1141,7 class ReadmeFinder:
         self._default_renderer = default_renderer
         self._renderer_extensions = self.RENDERER_TO_EXTENSION.get(default_renderer, [])
 
-    def search(self, commit, path=b'/'):
+    def search(self, commit, path=b'/', nodes=None):
         """
         Find a readme in the given `commit`.
         """
@@ -1150,7 +1150,9 class ReadmeFinder:
         if commit.get_node(bytes_path).kind != NodeKind.DIR:
             return None
 
-        nodes = commit.get_nodes(bytes_path)
+        if not nodes:
+            nodes = commit.get_nodes(bytes_path)
+
         matches = self._match_readmes(nodes)
         matches = self._sort_according_to_priority(matches)
         if matches:

rhodecode/templates/files/files_browser_tree.mako

@@ -38,7 +38,7 http://docker-dev:10020/ipython/files/ma
 
         <% has_files = False %>
         % if not c.file.is_submodule():
-            % for cnt, node in enumerate(c.file):
+            % for cnt, node in enumerate(c.file_nodes):
             <% has_files = True %>
             <tr class="parity${(cnt % 2)}">
                 <td class="td-componentname">
@@ -105,6 +105,8 http://docker-dev:10020/ipython/files/ma
                         ${h.escape(c.file.name)}
                         <pre>${c.file.url}</pre>
                     </span>
+                % else:
+                    <div>${_('Empty directory')}</div>
                 %endif
             </td>
         </tr>

rhodecode/tests/vcs/test_git.py

@@ -1218,19 +1218,21 class TestGetSubmoduleUrl(object):
     def test_get_nodes_returns_links(self):
         repository = mock.MagicMock()
         repository.alias = "git"
-        repository._remote.tree_items.return_value = [(b"subrepo", "stat", 1, NodeKind.SUBMODULE)]
+        # obj_name, stat_, tree_item_id, node_kind, pre_load_data
+        repository._remote.get_nodes.return_value = [(b"subrepo", "stat", 1, NodeKind.SUBMODULE, [])]
         commit = GitCommit(repository=repository, raw_id="abcdef12", idx=1)
         submodule_url = "https://code.rhodecode.com/dulwich"
+
         get_id_patch = mock.patch.object(commit, "_get_path_tree_id_and_type", return_value=(1, NodeKind.DIR))
         get_submodule_patch = mock.patch.object(commit, "_get_submodule_url", return_value=submodule_url)
 
         with get_id_patch, get_submodule_patch as submodule_mock:
             nodes = commit.get_nodes(b"/abcde")
 
-        submodule_mock.assert_called_once_with(b"/abcde/subrepo")
         assert len(nodes) == 1
         assert type(nodes[0]) == SubModuleNode
         assert nodes[0].url == submodule_url
+        submodule_mock.assert_called_once_with(b"/abcde/subrepo")
 
 
 class TestGetShadowInstance(object):