code: def blow_out(self,
                   location: Union[types.Location, Well] = None
                   ) -> 'InstrumentContext':
          
          if location is None:
              if not self._ctx.location_cache:
                  raise RuntimeError('No valid current location cache present')
              else:
                  location = self._ctx.location_cache.labware  # type: ignore
                  # type checked below
  
          if isinstance(location, Well):
              if location.parent.is_tiprack:
                  self._log.warning('Blow_out being performed on a tiprack. '
                                    'Please re-check your code')
              target = location.top()
          elif isinstance(location, types.Location) and not \
                  isinstance(location.labware, Well):
              raise TypeError(
                  'location should be a Well or None, but it is {}'
                  .format(location))
          else:
              raise TypeError(
                  'location should be a Well or None, but it is {}'
                  .format(location))
          self.move_to(target)
          self._hw_manager.hardware.blow_out(self._mount)
          return self
docs: Blow liquid out of the tip.
  
          If :py:attr:`dispense` is used to completely empty a pipette,
          usually a small amount of liquid will remain in the tip. This
          method moves the plunger past its usual stops to fully remove
          any remaining liquid from the tip. Regardless of how much liquid
          was in the tip when this function is called, after it is done
          the tip will be empty.
  
          :param location: The location to blow out into. If not specified,
                           defaults to the current location of the pipette
          :type location: :py:class:`.Well` or :py:class:`.Location` or None
  
          :raises RuntimeError: If no location is specified and location cache is
                                None. This should happen if `blow_out` is called
                                without first calling a method that takes a
                                location (eg, :py:meth:`.aspirate`,
                                :py:meth:`dispense`)
          :returns: This instance