code: def _eval_comparison_part(evaluator, context, left, operator, right):
      l_is_num = is_number(left)
      r_is_num = is_number(right)
      if isinstance(operator, unicode):
          str_operator = operator
      else:
          str_operator = force_unicode(str(operator.value))
  
      if str_operator == "*":
          # for iterables, ignore * operations
          if isinstance(left, iterable.Sequence) or is_string(left):
              return ContextSet(left)
          elif isinstance(right, iterable.Sequence) or is_string(right):
              return ContextSet(right)
      elif str_operator == "+":
          if (
              l_is_num
              and r_is_num
              or is_string(left)
              and is_string(right)
          ):
              return ContextSet(
                  left.execute_operation(right, str_operator)
              )
          elif (
              _is_tuple(left)
              and _is_tuple(right)
              or _is_list(left)
              and _is_list(right)
          ):
              return ContextSet(
                  iterable.MergedArray(evaluator, (left, right))
              )
      elif str_operator == "-":
          if l_is_num and r_is_num:
              return ContextSet(
                  left.execute_operation(right, str_operator)
              )
      elif str_operator == "%":
          # With strings and numbers the left type typically remains. Except for
          # `int() % float()`.
          return ContextSet(left)
      elif str_operator in COMPARISON_OPERATORS:
          if is_compiled(left) and is_compiled(right):
              # Possible, because the return is not an option. Just compare.
              try:
                  return ContextSet(
                      left.execute_operation(right, str_operator)
                  )
              except TypeError:
                  # Could be True or False.
                  pass
          else:
              if str_operator in ("is", "!=", "==", "is not"):
                  operation = COMPARISON_OPERATORS[str_operator]
                  bool_ = operation(left, right)
                  return ContextSet(_bool_to_context(evaluator, bool_))
  
          return ContextSet(
              _bool_to_context(evaluator, True),
              _bool_to_context(evaluator, False),
          )
      elif str_operator == "in":
          return NO_CONTEXTS
  
      def check(obj):
          """Checks if a Jedi object is either a float or an int."""
          return isinstance(
              obj, CompiledInstance
          ) and obj.name.string_name in ("int", "float")
  
      # Static analysis, one is a number, the other one is not.
      if (
          str_operator in ("+", "-")
          and l_is_num != r_is_num
          and not (check(left) or check(right))
      ):
          message = (
              "TypeError: unsupported operand type(s) for +: %s and %s"
          )
          analysis.add(
              context,
              "type-error-operation",
              operator,
              message % (left, right),
          )
  
      return ContextSet(left, right)
  
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 15 for calling a global function with example usage: _eval_comparison_part(evaluator, context, left, operator, right) and returns: ContextSet, unknown, ContextSet, ContextSet, ContextSet, ContextSet, ContextSet, ContextSet, ContextSet, NO_CONTEXTS, ContextSet, ContextSet