code: def load(self, environment, name, globals=None):
          
          code = None
          if globals is None:
              globals = {}
  
          # first we try to get the source for this template together
          # with the filename and the uptodate function.
          source, filename, uptodate = self.get_source(environment, name)
  
          # try to load the code from the bytecode cache if there is a
          # bytecode cache configured.
          bcc = environment.bytecode_cache
          if bcc is not None:
              bucket = bcc.get_bucket(environment, name, filename, source)
              code = bucket.code
  
          # if we don't have code so far (not cached, no longer up to
          # date) etc. we compile the template
          if code is None:
              code = environment.compile(source, name, filename)
  
          # if the bytecode cache is available and the bucket doesn't
          # have a code so far, we give the bucket the new code and put
          # it back to the bytecode cache.
          if bcc is not None and bucket.code is None:
              bucket.code = code
              bcc.set_bucket(bucket)
  
          return environment.template_class.from_code(environment, code,
                                                      globals, uptodate)
docs: Loads a template.  This method looks up the template in the cache
          or loads one by calling :meth:`get_source`.  Subclasses should not
          override this method as loaders working on collections of other
          loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
          will not call this method but `get_source` directly.