force : bool
        machine_names : typing.Sequence[str]
        Returns -> None
438426
async def DestroyMachines(self, force, machine_names):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='Client',
                   request='DestroyMachines',
                   version=1,
                   params=_params)
        _params['force'] = force
        _params['machine-names'] = machine_names
        reply = await self.rpc(msg)
        return reply
525351
def family_name(self):
        
        def find_first(dict_, keys, default=None):
            for key in keys:
                value = dict_.get(key)
                if value is not None:
                    return value
            return default
        # keys for Unicode, Mac, and Windows family name, respectively
        return find_first(self._names, ((0, 1), (1, 1), (3, 1)))
828188
def _detect_issue351():
    
    class Tuple(typing.Generic[typing.T]):
        pass

    res = Tuple[str] == typing.Tuple[str]
    del Tuple
    return res
1364577
def create_database(name, number=1, force_clear=False):
    
    print 'Got:'
    print 'name', name, type(name)
    print 'number', number, type(number)
    print 'force_clear', force_clear, type(force_clear)
1076062
def get_processor_name():
    
    if platform.system() == "Linux":
        with open("/proc/cpuinfo", "rb") as cpuinfo:
            all_info = cpuinfo.readlines()
            for line in all_info:
                if b'model name' in line:
                    return re.sub(b'.*model name.*:', b'', line, 1)

    return platform.processor()
265589
def machines(self, id=None, name=None, search=None):
        
        if self._machines is None:
            self._machines = {}
            self._list_machines()

        if id:
            return [self._machines[machine_id] for machine_id in self._machines.keys()
                    if str(id) == str(self._machines[machine_id].id)]
        elif name:
            return [self._machines[machine_id] for machine_id in self._machines.keys()
                    if name == self._machines[machine_id].name]
        elif search:
            return [self._machines[machine_id] for machine_id in self._machines.keys()
                    if str(search) == str(self._machines[machine_id].name)
                    or str(search) == str(self._machines[machine_id].id)]
        else:
            return [self._machines[machine_id] for machine_id in self._machines.keys()]
594710
async def read(cls, *, hostnames: typing.Sequence[str] = None):
        
        params = {}
        if hostnames:
            params["hostname"] = [
                normalize_hostname(hostname)
                for hostname in hostnames
            ]
        data = await cls._handler.read(**params)
        return cls(map(cls._object, data))
956130
def auto_detect_serial(preferred_list=['*']):
    ''''''
    # see if 
    if os.name == 'nt':
        return auto_detect_serial_win32(preferred_list=preferred_list)
    return auto_detect_serial_unix(preferred_list=preferred_list)
987127
def _get_registry_names(self, registry):
        
        return ', '.join(
            f.__name__ if not isinstance(f, tuple) else f[0].__name__
            for f in getattr(self, registry, []))
265871
def _notnull(expr):
    

    if isinstance(expr, SequenceExpr):
        return NotNull(_input=expr, _data_type=types.boolean)
    elif isinstance(expr, Scalar):
        return NotNull(_input=expr, _value_type=types.boolean)
1211802
def vb_list_machines(**kwargs):
    '''
    
    '''
    manager = vb_get_manager()
    machines = manager.getArray(vb_get_box(), 'machines')
    return [
        vb_xpcom_to_attribute_dict(machine, 'IMachine', **kwargs)
        for machine in machines
        ]
284554
def _validate_machines(machines, add_error):
    
    if not machines:
        return
    for machine_id, machine in machines.items():
        if machine_id < 0:
            add_error(
                'machine {} has an invalid id, must be positive digit'
                ''.format(machine_id))
        if machine is None:
            continue
        elif not isdict(machine):
            add_error(
                'machine {} does not appear to be well-formed'
                ''.format(machine_id))
            continue
        label = 'machine {}'.format(machine_id)
        _validate_constraints(machine.get('constraints'), label, add_error)
        _validate_series(machine.get('series'), label, add_error)
        _validate_annotations(machine.get('annotations'), label, add_error)
891327
def InputDNAQuantity(seq_length, n_features=1, name=None, **kwargs):
    
    return Input((seq_length, n_features), name=name, **kwargs)
736438
async def SetInstanceInfo(self, machines):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='Provisioner',
                   request='SetInstanceInfo',
                   version=7,
                   params=_params)
        _params['machines'] = machines
        reply = await self.rpc(msg)
        return reply
90740
def get_records(self, sequence_id, gt=None, gte=None, lt=None, lte=None, limit=None,
                    query_ascending=True, results_ascending=True):
        
710152
def _is_sequence(typ):
    
    # PEP_560 deprecates issubclass for
    # List types, for the time being
    # we'll support a specific escape hatch.
    if PEP_560:  # pragma: no cover
        return isinstance(typ, _GenericAlias) and typ.__origin__ is list
    else:  # pragma: no cover
        return issubclass(typ, Sequence)
344671
def machines(self):
        """"""
        if self._resources is None:
            self.__init()
        if "machines" in self._resources:
            url = self._url + "/machines"
            return _machines.Machines(url,
                                      securityHandler=self._securityHandler,
                                      initialize=False,
                                      proxy_url=self._proxy_url,
                                      proxy_port=self._proxy_port)
        else:
            return None