code: def find_common_type(array_types, scalar_types):
      """
      Determine common type following standard coercion rules.
  
      .. deprecated:: NumPy 1.25
  
          This function is deprecated, use `numpy.promote_types` or
          `numpy.result_type` instead.  To achieve semantics for the
          `scalar_types` argument, use `numpy.result_type` and pass the Python
          values `0`, `0.0`, or `0j`.
          This will give the same results in almost all cases.
          More information and rare exception can be found in the
          `NumPy 1.25 release notes <https://numpy.org/devdocs/release/1.25.0-notes.html>`_.
  
      Parameters
      ----------
      array_types : sequence
          A list of dtypes or dtype convertible objects representing arrays.
      scalar_types : sequence
          A list of dtypes or dtype convertible objects representing scalars.
  
      Returns
      -------
      datatype : dtype
          The common data type, which is the maximum of `array_types` ignoring
          `scalar_types`, unless the maximum of `scalar_types` is of a
          different kind (`dtype.kind`). If the kind is not understood, then
          None is returned.
  
      See Also
      --------
      dtype, common_type, can_cast, mintypecode
  
      Examples
      --------
      >>> np.find_common_type([], [np.int64, np.float32, complex])
      dtype('complex128')
      >>> np.find_common_type([np.int64, np.float32], [])
      dtype('float64')
  
      The standard casting rules ensure that a scalar cannot up-cast an
      array unless the scalar is of a fundamentally different kind of data
      (i.e. under a different hierarchy in the data type hierarchy) then
      the array:
  
      >>> np.find_common_type([np.float32], [np.int64, np.float64])
      dtype('float32')
  
      Complex is of a different type, so it up-casts the float in the
      `array_types` argument:
  
      >>> np.find_common_type([np.float32], [complex])
      dtype('complex128')
  
      Type specifier strings are convertible to dtypes and can therefore
      be used instead of dtypes:
  
      >>> np.find_common_type(['f4', 'f4', 'i4'], ['c8'])
      dtype('complex128')
  
      """
      # Deprecated 2022-11-07, NumPy 1.25
      warnings.warn(
          "np.find_common_type is deprecated.  Please use `np.result_type` "
          "or `np.promote_types`.\n"
          "See https://numpy.org/devdocs/release/1.25.0-notes.html and the "
          "docs for more information.  (Deprecated NumPy 1.25)",
          DeprecationWarning,
          stacklevel=2,
      )
  
      array_types = [dtype(x) for x in array_types]
      scalar_types = [dtype(x) for x in scalar_types]
  
      maxa = _can_coerce_all(array_types)
      maxsc = _can_coerce_all(scalar_types)
  
      if maxa is None:
          return maxsc
  
      if maxsc is None:
          return maxa
  
      try:
          index_a = _kind_list.index(maxa.kind)
          index_sc = _kind_list.index(maxsc.kind)
      except ValueError:
          return None
  
      if index_sc > index_a:
          return _find_common_coerce(maxsc, maxa)
      else:
          return maxa
  
imports: import numbers
  import warnings
  from .multiarray import ndarray, array, dtype, datetime_data, datetime_as_string, busday_offset, busday_count, is_busday, busdaycalendar
  from .._utils import set_module
  from ._string_helpers import english_lower, english_upper, english_capitalize, LOWER_TABLE, UPPER_TABLE
  from ._type_aliases import sctypeDict, allTypes, bitname, sctypes, _concrete_types, _concrete_typeinfo, _bits_of
  from ._dtype import _kind_name
  from builtins import bool, int, float, complex, object, str, bytes
  from numpy.compat import long, unicode
label_desc: Use image node_id 13 for calling a global function with example usage: find_common_type(array_types, scalar_types) and returns: maxsc, maxa, _find_common_coerce, maxa, None