code: def _process(wires):
      """Converts the input to a tuple of wire labels.
  
      If `wires` can be iterated over, its elements are interpreted as wire labels
      and turned into a tuple. Otherwise, `wires` is interpreted as a single wire label.
  
      The only exception to this are strings, which are always interpreted as a single
      wire label, so users can address wires with labels such as `"ancilla"`.
  
      Any type can be a wire label, as long as it is hashable. We need this to establish
      the uniqueness of two labels. For example, `0` and `0.` are interpreted as
      the same wire label because `hash(0.) == hash(0)` evaluates to true.
  
      Note that opposed to numpy arrays, `pennylane.numpy` 0-dim array are hashable.
      """
  
      if isinstance(wires, str):
          # Interpret string as a non-iterable object.
          # This is the only exception to the logic
          # of considering the elements of iterables as wire labels.
          wires = [wires]
  
      try:
          # Use tuple conversion as a check for whether `wires` can be iterated over.
          # Note, this is not the same as `isinstance(wires, Iterable)` which would
          # pass for 0-dim numpy arrays that cannot be iterated over.
          tuple_of_wires = tuple(wires)
      except TypeError:
          # if not iterable, interpret as single wire label
          try:
              hash(wires)
          except TypeError as e:
              # if object is not hashable, cannot identify unique wires
              if str(e).startswith("unhashable"):
                  raise WireError(
                      f"Wires must be hashable; got object of type {type(wires)}."
                  ) from e
          return (wires,)
  
      try:
          # We need the set for the uniqueness check,
          # so we can use it for hashability check of iterables.
          set_of_wires = set(wires)
      except TypeError as e:
          if str(e).startswith("unhashable"):
              raise WireError(
                  f"Wires must be hashable; got {wires}."
              ) from e
  
      if len(set_of_wires) != len(tuple_of_wires):
          raise WireError(f"Wires must be unique; got {wires}.")
  
      return tuple_of_wires
  
imports: import functools
  import itertools
  from collections.abc import Iterable, Sequence
  import numpy
  from pennylane.pytrees import register_pytree
label_desc: Use image node_id 1 for calling a global function with example usage: _process(wires) and returns: tuple_of_wires, wires