docs: def list_instances(self, hourly=True, monthly=True, tags=None, cpus=None,
                         memory=None, hostname=None, domain=None,
                         local_disk=None, datacenter=None, nic_speed=None,
                         public_ip=None, private_ip=None, **kwargs):
          """Retrieve a list of all virtual servers on the account.
  
          Example::
  
              # Print out a list of hourly instances in the DAL05 data center.
  
              for vsi in mgr.list_instances(hourly=True, datacenter='dal05'):
                 print vsi['fullyQualifiedDomainName'], vsi['primaryIpAddress']
  
              # Using a custom object-mask. Will get ONLY what is specified
              object_mask = "mask[hostname,monitoringRobot[robotStatus]]"
              for vsi in mgr.list_instances(mask=object_mask,hourly=True):
                  print vsi
  
          :param boolean hourly: include hourly instances
          :param boolean monthly: include monthly instances
          :param list tags: filter based on list of tags
          :param integer cpus: filter based on number of CPUS
          :param integer memory: filter based on amount of memory
          :param string hostname: filter based on hostname
          :param string domain: filter based on domain
          :param string local_disk: filter based on local_disk
          :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
                    virtual servers
          """
          if 'mask' not in kwargs:
              items = [
                  'id',
                  'globalIdentifier',
                  'hostname',
                  'domain',
                  'fullyQualifiedDomainName',
                  'primaryBackendIpAddress',
                  'primaryIpAddress',
                  'lastKnownPowerState.name',
                  'powerState',
                  'maxCpu',
                  'maxMemory',
                  'datacenter',
                  'activeTransaction.transactionStatus[friendlyName,name]',
                  'status',
              ]
              kwargs['mask'] = "mask[%s]" % ','.join(items)
  
          call = 'getVirtualGuests'
          if not all([hourly, monthly]):
              if hourly:
                  call = 'getHourlyVirtualGuests'
              elif monthly:
                  call = 'getMonthlyVirtualGuests'
  
          _filter = utils.NestedDict(kwargs.get('filter') or {})
          if tags:
              _filter['virtualGuests']['tagReferences']['tag']['name'] = {
                  'operation': 'in',
                  'options': [{'name': 'data', 'value': tags}],
              }
  
          if cpus:
              _filter['virtualGuests']['maxCpu'] = utils.query_filter(cpus)
  
          if memory:
              _filter['virtualGuests']['maxMemory'] = utils.query_filter(memory)
  
          if hostname:
              _filter['virtualGuests']['hostname'] = utils.query_filter(hostname)
  
          if domain:
              _filter['virtualGuests']['domain'] = utils.query_filter(domain)
  
          if local_disk is not None:
              _filter['virtualGuests']['localDiskFlag'] = (
                  utils.query_filter(bool(local_disk)))
  
          if datacenter:
              _filter['virtualGuests']['datacenter']['name'] = (
                  utils.query_filter(datacenter))
  
          if nic_speed:
              _filter['virtualGuests']['networkComponents']['maxSpeed'] = (
                  utils.query_filter(nic_speed))
  
          if public_ip:
              _filter['virtualGuests']['primaryIpAddress'] = (
                  utils.query_filter(public_ip))
  
          if private_ip:
              _filter['virtualGuests']['primaryBackendIpAddress'] = (
                  utils.query_filter(private_ip))
  
          kwargs['filter'] = _filter.to_dict()
          kwargs['iter'] = True
          return self.client.call('Account', call, **kwargs)