code: def _eval_expr_stmt(context, stmt, seek_name=None):
      """
      The starting point of the completion. A statement always owns a call
      list, which are the calls, that a statement does. In case multiple
      names are defined in the statement, `seek_name` returns the result for
      this name.
  
      :param stmt: A `tree.ExprStmt`.
      """
      debug.dbg("eval_expr_stmt %s (%s)", stmt, seek_name)
      rhs = stmt.get_rhs()
      context_set = context.eval_node(rhs)
  
      if seek_name:
          c_node = ContextualizedName(context, seek_name)
          context_set = check_tuple_assignments(
              context.evaluator, c_node, context_set
          )
  
      first_operator = next(stmt.yield_operators(), None)
      if (
          first_operator not in ("=", None)
          and first_operator.type == "operator"
      ):
          # `=` is always the last character in aug assignments -> -1
          operator = copy.copy(first_operator)
          operator.value = operator.value[:-1]
          name = stmt.get_defined_names()[0].value
          left = context.py__getattribute__(
              name, position=stmt.start_pos, search_global=True
          )
  
          for_stmt = tree.search_ancestor(stmt, "for_stmt")
          if (
              for_stmt is not None
              and for_stmt.type == "for_stmt"
              and context_set
              and parser_utils.for_stmt_defines_one_name(for_stmt)
          ):
              # Iterate through result and add the values, that's possible
              # only in for loops without clutter, because they are
              # predictable. Also only do it, if the variable is not a tuple.
              node = for_stmt.get_testlist()
              cn = ContextualizedNode(context, node)
              ordered = list(cn.infer().iterate(cn))
  
              for lazy_context in ordered:
                  dct = {
                      for_stmt.children[1].value: lazy_context.infer()
                  }
                  with helpers.predefine_names(context, for_stmt, dct):
                      t = context.eval_node(rhs)
                      left = _eval_comparison(
                          context.evaluator, context, left, operator, t
                      )
              context_set = left
          else:
              context_set = _eval_comparison(
                  context.evaluator,
                  context,
                  left,
                  operator,
                  context_set,
              )
      debug.dbg("eval_expr_stmt result %s", context_set)
      return context_set
  
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 7 for calling a global function with example usage: _eval_expr_stmt(context, stmt, seek_name) and returns: context_set