docs: def find_template(self, name, context, peeking=False):
          """
          Replacement for Django's ``find_template`` that uses the current
          template context to keep track of which template directories it
          has used when finding a template. This allows multiple templates
          with the same relative name/path to be discovered, so that
          circular template inheritance can occur.
          """
  
          # These imports want settings, which aren't available when this
          # module is imported to ``add_to_builtins``, so do them here.
          import django.template.loaders.app_directories as app_directories
  
          from yacms.conf import settings
  
          # Store a dictionary in the template context mapping template
          # names to the lists of template directories available to
          # search for that template. Each time a template is loaded, its
          # origin directory is removed from its directories list.
          context_name = "OVEREXTENDS_DIRS"
          if context_name not in context:
              context[context_name] = {}
          if name not in context[context_name]:
              all_dirs = (
                  list(chain.from_iterable(
                      [template_engine.get('DIRS', [])
                       for template_engine in settings.TEMPLATES])) +
                  list(app_directories.get_app_template_dirs('templates')))
              # os.path.abspath is needed under uWSGI, and also ensures we
              # have consistent path separators across different OSes.
              context[context_name][name] = list(map(os.path.abspath, all_dirs))
  
          # Build a list of template loaders to use. For loaders that wrap
          # other loaders like the ``cached`` template loader, unwind its
          # internal loaders and add those instead.
          loaders = []
          for loader in context.template.engine.template_loaders:
              loaders.extend(getattr(loader, "loaders", [loader]))
  
          # Go through the loaders and try to find the template. When
          # found, removed its absolute path from the context dict so
          # that it won't be used again when the same relative name/path
          # is requested.
          for loader in loaders:
              dirs = context[context_name][name]
              try:
                  source, path = loader.load_template_source(name, dirs)
              except TemplateDoesNotExist:
                  pass
              else:
                  # Only remove the absolute path for the initial call in
                  # get_parent, and not when we're peeking during the
                  # second call.
                  if not peeking:
                      remove_path = os.path.abspath(path[:-len(name) - 1])
                      context[context_name][name].remove(remove_path)
                  return Template(source)
          raise TemplateDoesNotExist(name)