code: def eval_atom(context, atom):
      """
      Basically to process ``atom`` nodes. The parser sometimes doesn't
      generate the node (because it has just one child). In that case an atom
      might be a name or a literal as well.
      """
      if atom.type == "name":
          # This is the first global lookup.
          stmt = (
              tree.search_ancestor(atom, "expr_stmt", "lambdef") or atom
          )
          if stmt.type == "lambdef":
              stmt = atom
          return context.py__getattribute__(
              name_or_str=atom,
              position=stmt.start_pos,
              search_global=True,
          )
      elif atom.type == "keyword":
          # For False/True/None
          if atom.value in ("False", "True", "None"):
              return ContextSet(
                  compiled.builtin_from_name(
                      context.evaluator, atom.value
                  )
              )
          elif atom.value == "print":
              # print e.g. could be evaluated like this in Python 2.7
              return NO_CONTEXTS
          elif atom.value == "yield":
              # Contrary to yield from, yield can just appear alone to return a
              # value when used with `.send()`.
              return NO_CONTEXTS
          assert False, "Cannot evaluate the keyword %s" % atom
  
      elif isinstance(atom, tree.Literal):
          string = (
              context.evaluator.compiled_subprocess.safe_literal_eval(
                  atom.value
              )
          )
          return ContextSet(
              compiled.create_simple_object(context.evaluator, string)
          )
      elif atom.type == "strings":
          # Will be multiple string.
          context_set = eval_atom(context, atom.children[0])
          for string in atom.children[1:]:
              right = eval_atom(context, string)
              context_set = _eval_comparison(
                  context.evaluator, context, context_set, "+", right
              )
          return context_set
      else:
          c = atom.children
          # Parentheses without commas are not tuples.
          if (
              c[0] == "("
              and not len(c) == 2
              and not (
                  c[1].type == "testlist_comp"
                  and len(c[1].children) > 1
              )
          ):
              return context.eval_node(c[1])
  
          try:
              comp_for = c[1].children[1]
          except (IndexError, AttributeError):
              pass
          else:
              if comp_for == ":":
                  # Dict comprehensions have a colon at the 3rd index.
                  try:
                      comp_for = c[1].children[3]
                  except IndexError:
                      pass
  
              if comp_for.type == "comp_for":
                  return ContextSet(
                      iterable.comprehension_from_atom(
                          context.evaluator, context, atom
                      )
                  )
  
          # It's a dict/list/tuple literal.
          array_node = c[1]
          try:
              array_node_c = array_node.children
          except AttributeError:
              array_node_c = []
          if c[0] == "{" and (
              array_node == "}"
              or ":" in array_node_c
              or "**" in array_node_c
          ):
              context = iterable.DictLiteralContext(
                  context.evaluator, context, atom
              )
          else:
              context = iterable.SequenceLiteralContext(
                  context.evaluator, context, atom
              )
          return ContextSet(context)
  
imports: import copy
  from parso.python import tree
  from jedi._compatibility import force_unicode, unicode
  from jedi import debug
  from jedi import parser_utils
  from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS, ContextualizedNode, ContextualizedName, iterator_to_context_set, iterate_contexts
  from jedi.evaluate import compiled
  from jedi.evaluate import pep0484
  from jedi.evaluate import recursion
  from jedi.evaluate import helpers
  from jedi.evaluate import analysis
  from jedi.evaluate import imports
  from jedi.evaluate import arguments
  from jedi.evaluate.pep0484 import _evaluate_for_annotation
  from jedi.evaluate.context import ClassContext, FunctionContext
  from jedi.evaluate.context import iterable
  from jedi.evaluate.context import TreeInstance, CompiledInstance
  from jedi.evaluate.finder import NameFinder
  from jedi.evaluate.helpers import is_string, is_literal, is_number, is_compiled
  from jedi.evaluate.compiled.access import COMPARISON_OPERATORS
label_desc: Use image node_id 5 for calling a global function with example usage: eval_atom(context, atom) and returns: context, ContextSet, ContextSet, NO_CONTEXTS, context_set, ContextSet, NO_CONTEXTS, context, ContextSet