code: def search_function(encoding):
      # Cache lookup
      entry = _cache.get(encoding, _unknown)
      if entry is not _unknown:
          return entry
  
      # Import the module:
      #
      # First try to find an alias for the normalized encoding
      # name and lookup the module using the aliased name, then try to
      # lookup the module using the standard import scheme, i.e. first
      # try in the encodings package, then at top-level.
      #
      norm_encoding = normalize_encoding(encoding)
      aliased_encoding = _aliases.get(norm_encoding) or _aliases.get(
          norm_encoding.replace(".", "_")
      )
      if aliased_encoding is not None:
          modnames = [aliased_encoding, norm_encoding]
      else:
          modnames = [norm_encoding]
      for modname in modnames:
          if not modname or "." in modname:
              continue
          try:
              # Import is absolute to prevent the possibly malicious import of a
              # module with side-effects that is not in the 'encodings' package.
              mod = __import__(
                  "encodings." + modname, fromlist=_import_tail, level=0
              )
          except ImportError:
              # ImportError may occur because 'encodings.(modname)' does not exist,
              # or because it imports a name that does not exist (see mbcs and oem)
              pass
          else:
              break
      else:
          mod = None
  
      try:
          getregentry = mod.getregentry
      except AttributeError:
          # Not a codec module
          mod = None
  
      if mod is None:
          # Cache misses
          _cache[encoding] = None
          return None
  
      # Now ask the module for the registry entry
      entry = getregentry()
      if not isinstance(entry, codecs.CodecInfo):
          if not 4 <= len(entry) <= 7:
              raise CodecRegistryError(
                  'module "%s" (%s) failed to register'
                  % (mod.__name__, mod.__file__)
              )
          if (
              not callable(entry[0])
              or not callable(entry[1])
              or (entry[2] is not None and not callable(entry[2]))
              or (entry[3] is not None and not callable(entry[3]))
              or (
                  len(entry) > 4
                  and entry[4] is not None
                  and not callable(entry[4])
              )
              or (
                  len(entry) > 5
                  and entry[5] is not None
                  and not callable(entry[5])
              )
          ):
              raise CodecRegistryError(
                  'incompatible codecs in module "%s" (%s)'
                  % (mod.__name__, mod.__file__)
              )
          if len(entry) < 7 or entry[6] is None:
              entry += (None,) * (6 - len(entry)) + (
                  mod.__name__.split(".", 1)[1],
              )
          entry = codecs.CodecInfo(*entry)
  
      # Cache the codec registry entry
      _cache[encoding] = entry
  
      # Register its aliases (without overwriting previously registered
      # aliases)
      try:
          codecaliases = mod.getaliases()
      except AttributeError:
          pass
      else:
          for alias in codecaliases:
              if alias not in _aliases:
                  _aliases[alias] = modname
  
      # Return the registry entry
      return entry
  
file_path: cpython/Lib/encodings/__init__.py
imports: import codecs
  import sys
  from .None import aliases
label_desc: Use image node_id 2 for calling a global function with example usage: search_function(encoding) and returns: entry, entry, None