code: def eval_sum_hyper(f, i_a_b):
      i, a, b = i_a_b
  
      if f.is_hypergeometric(i) is False:
          return
  
      if (b - a).is_Integer:
          # We are never going to do better than doing the sum in the obvious way
          return None
  
      old_sum = Sum(f, (i, a, b))
  
      if b != S.Infinity:
          if a is S.NegativeInfinity:
              res = _eval_sum_hyper(f.subs(i, -i), i, -b)
              if res is not None:
                  return Piecewise(res, (old_sum, True))
          else:
              n_illegal = lambda x: sum(x.count(_) for _ in _illegal)
              had = n_illegal(f)
              # check that no extra illegals are introduced
              res1 = _eval_sum_hyper(f, i, a)
              if res1 is None or n_illegal(res1) > had:
                  return
              res2 = _eval_sum_hyper(f, i, b + 1)
              if res2 is None or n_illegal(res2) > had:
                  return
              (res1, cond1), (res2, cond2) = res1, res2
              cond = And(cond1, cond2)
              if cond == False:
                  return None
              return Piecewise((res1 - res2, cond), (old_sum, True))
  
      if a is S.NegativeInfinity:
          res1 = _eval_sum_hyper(f.subs(i, -i), i, 1)
          res2 = _eval_sum_hyper(f, i, 0)
          if res1 is None or res2 is None:
              return None
          res1, cond1 = res1
          res2, cond2 = res2
          cond = And(cond1, cond2)
          if cond == False or cond.as_set() == S.EmptySet:
              return None
          return Piecewise((res1 + res2, cond), (old_sum, True))
  
      # Now b == oo, a != -oo
      res = _eval_sum_hyper(f, i, a)
      if res is not None:
          r, c = res
          if c == False:
              if r.is_number:
                  f = f.subs(
                      i, Dummy("i", integer=True, positive=True) + a
                  )
                  if f.is_positive or f.is_zero:
                      return S.Infinity
                  elif f.is_negative:
                      return S.NegativeInfinity
              return None
          return Piecewise(res, (old_sum, True))
  
imports: from typing import Tuple
  from sympy.calculus.singularities import is_decreasing
  from sympy.calculus.accumulationbounds import AccumulationBounds
  from .expr_with_intlimits import ExprWithIntLimits
  from .expr_with_limits import AddWithLimits
  from .gosper import gosper_sum
  from sympy.core.expr import Expr
  from sympy.core.add import Add
  from sympy.core.containers import Tuple
  from sympy.core.function import Derivative, expand
  from sympy.core.mul import Mul
  from sympy.core.numbers import Float, _illegal
  from sympy.core.relational import Eq
  from sympy.core.singleton import S
  from sympy.core.sorting import ordered
  from sympy.core.symbol import Dummy, Wild, Symbol, symbols
  from sympy.functions.combinatorial.factorials import factorial
  from sympy.functions.combinatorial.numbers import bernoulli, harmonic
  from sympy.functions.elementary.exponential import exp, log
  from sympy.functions.elementary.piecewise import Piecewise
  from sympy.functions.elementary.trigonometric import cot, csc
  from sympy.functions.special.hyper import hyper
  from sympy.functions.special.tensor_functions import KroneckerDelta
  from sympy.functions.special.zeta_functions import zeta
  from sympy.integrals.integrals import Integral
  from sympy.logic.boolalg import And
  from sympy.polys.partfrac import apart
  from sympy.polys.polyerrors import PolynomialError, PolificationFailed
  from sympy.polys.polytools import parallel_poly_from_expr, Poly, factor
  from sympy.polys.rationaltools import together
  from sympy.series.limitseq import limit_seq
  from sympy.series.order import O
  from sympy.series.residues import residue
  from sympy.sets.sets import FiniteSet, Interval
  from sympy.utilities.iterables import sift
  import itertools
label_desc: Use image node_id 8 for calling a global function with example usage: eval_sum_hyper(f, i_a_b) and returns: None, Piecewise, Piecewise, Piecewise, None, None, None, Piecewise, None, S, S