docs: def list_hardware(self, tags=None, cpus=None, memory=None, hostname=None,
                        domain=None, datacenter=None, nic_speed=None,
                        public_ip=None, private_ip=None, **kwargs):
          """List all hardware (servers and bare metal computing instances).
  
          :param list tags: filter based on tags
          :param integer cpus: filter based on number of CPUS
          :param integer memory: filter based on amount of memory in gigabytes
          :param string hostname: filter based on hostname
          :param string domain: filter based on domain
          :param string datacenter: filter based on datacenter
          :param integer nic_speed: filter based on network speed (in MBPS)
          :param string public_ip: filter based on public ip address
          :param string private_ip: filter based on private ip address
          :param dict \\*\\*kwargs: response-level options (mask, limit, etc.)
          :returns: Returns a list of dictionaries representing the matching
                    hardware. This list will contain both dedicated servers and
                    bare metal computing instances
  
         Example::
  
              # Using a custom object-mask. Will get ONLY what is specified
              # These will stem from the SoftLayer_Hardware_Server datatype
              object_mask = "mask[hostname,monitoringRobot[robotStatus]]"
              result = mgr.list_hardware(mask=object_mask)
          """
          if 'mask' not in kwargs:
              hw_items = [
                  'id',
                  'hostname',
                  'domain',
                  'hardwareStatusId',
                  'globalIdentifier',
                  'fullyQualifiedDomainName',
                  'processorPhysicalCoreAmount',
                  'memoryCapacity',
                  'primaryBackendIpAddress',
                  'primaryIpAddress',
                  'datacenter',
              ]
              server_items = [
                  'activeTransaction[id, transactionStatus[friendlyName,name]]',
              ]
  
              kwargs['mask'] = ('[mask[%s],'
                                ' mask(SoftLayer_Hardware_Server)[%s]]'
                                % (','.join(hw_items), ','.join(server_items)))
  
          _filter = utils.NestedDict(kwargs.get('filter') or {})
          if tags:
              _filter['hardware']['tagReferences']['tag']['name'] = {
                  'operation': 'in',
                  'options': [{'name': 'data', 'value': tags}],
              }
  
          if cpus:
              _filter['hardware']['processorPhysicalCoreAmount'] = (
                  utils.query_filter(cpus))
  
          if memory:
              _filter['hardware']['memoryCapacity'] = utils.query_filter(memory)
  
          if hostname:
              _filter['hardware']['hostname'] = utils.query_filter(hostname)
  
          if domain:
              _filter['hardware']['domain'] = utils.query_filter(domain)
  
          if datacenter:
              _filter['hardware']['datacenter']['name'] = (
                  utils.query_filter(datacenter))
  
          if nic_speed:
              _filter['hardware']['networkComponents']['maxSpeed'] = (
                  utils.query_filter(nic_speed))
  
          if public_ip:
              _filter['hardware']['primaryIpAddress'] = (
                  utils.query_filter(public_ip))
  
          if private_ip:
              _filter['hardware']['primaryBackendIpAddress'] = (
                  utils.query_filter(private_ip))
  
          kwargs['filter'] = _filter.to_dict()
          kwargs['iter'] = True
          return self.client.call('Account', 'getHardware', **kwargs)