docs: def _try_services(self, method_name, *args, **kwargs):
          """
          Try each service until one returns a response. This function only
          catches the bare minimum of exceptions from the service class. We want
          exceptions to be raised so the service classes can be debugged and
          fixed quickly.
          """
          crypto = ((args and args[0]) or kwargs['crypto']).lower()
          address = kwargs.get('address', '').lower()
          fiat = kwargs.get('fiat', '').lower()
  
          if not self.services:
              raise CurrencyNotSupported("No services defined for %s for %s" % (method_name, crypto))
  
          if self.random_wait_seconds > 0:
              # for privacy... To avoid correlating addresses to same origin
              # only gets called before the first service call. Does not pause
              # before each and every call.
              pause_time = random.random() * self.random_wait_seconds
              if self.verbose:
                  print("Pausing for: %.2f seconds" % pause_time)
              time.sleep(pause_time)
  
          for service in self.services:
              if service.supported_cryptos and (crypto not in service.supported_cryptos):
                  if self.verbose:
                      print("SKIP:", "%s not supported for %s" % (crypto, service.__class__.__name__))
                  continue
              try:
                  if self.verbose: print("* Trying:", service, crypto, "%s%s" % (address, fiat))
                  ret =  getattr(service, method_name)(*args, **kwargs)
                  self._successful_service = service
                  return ret
              except (KeyError, IndexError, TypeError, ValueError,
                      requests.exceptions.Timeout, requests.exceptions.ConnectionError) as exc:
                  # API has probably changed, therefore service class broken
                  if self.verbose: print("FAIL:", service, exc.__class__.__name__, exc)
                  self._failed_services.append({
                      'service': service,
                      'error': "%s %s" % (exc.__class__.__name__, exc)
                  })
              except NoService as exc:
                  # service classes can raise this exception if for whatever reason
                  # that service can't return a response, but maybe another one can.
                  if self.verbose: print("SKIP:", exc.__class__.__name__, exc)
                  self._failed_services.append({'service': service, 'error': "Skipped: %s" % str(exc)})
              except NotImplementedError as exc:
                  if self.verbose: print("SKIP:", exc.__class__.__name__, exc)
                  self._failed_services.append({'service': service, 'error': "Not Implemented"})
  
  
          if not self._failed_services:
              raise NotImplementedError(
                  "No Services defined for %s and %s" % (crypto, method_name)
              )
  
          if set(x['error'] for x in self._failed_services) == set(['Not Implemented']) and method_name.endswith("multi"):
              # some currencies may not have any multi functions defined, so retry
              # with private mode (which tries multiple services).
              raise RevertToPrivateMode("All services do not implement %s service" % method_name)
  
          failed_msg = ', '.join(
              ["{service.name} -> {error}".format(**x) for x in self._failed_services]
          )
          raise NoService(self.no_service_msg(*args, **kwargs) + "! Tried: " + failed_msg)