Get all names in existence
        If `all=true` is set, then include expired names.
        Returns the list on success
        Returns 400 on invalid arguments
        Returns 502 on failure to get names
359443
def GET_names( self, path_info ):
        

        include_expired = False

        qs_values = path_info['qs_values']
        page = qs_values.get('page', None)
        if page is None:
            log.error("Page required")
            return self._reply_json({'error': 'page= argument required'}, status_code=400)

        try:
            page = int(page)
            if page < 0:
                raise ValueError("Page is negative")

        except ValueError:
            log.error("Invalid page")
            return self._reply_json({'error': 'Invalid page= value'}, status_code=400)

        if qs_values.get('all', '').lower() in ['1', 'true']:
            include_expired = True

        offset = page * 100
        count = 100

        blockstackd_url = get_blockstackd_url()
        res = blockstackd_client.get_all_names(offset, count, include_expired=include_expired, hostport=blockstackd_url)
        if json_is_error(res):
            log.error("Failed to list all names (offset={}, count={}): {}".format(offset, count, res['error']))
            return self._reply_json({'error': 'Failed to list all names'}, status_code=res.get('http_status', 502))

        return self._reply_json(res)
557372
def all(cls, otp=False, ccid=False, u2f=False):
        """"""
        modes = set([
            cls.OTP,
            cls.CCID,
            cls.OTP_CCID,
            cls.U2F,
            cls.OTP_U2F,
            cls.U2F_CCID,
            cls.OTP_U2F_CCID
        ])

        if otp:
            modes.difference_update(set([
                cls.CCID,
                cls.U2F,
                cls.U2F_CCID
            ]))

        if ccid:
            modes.difference_update(set([
                cls.OTP,
                cls.U2F,
                cls.OTP_U2F
            ]))

        if u2f:
            modes.difference_update(set([
                cls.OTP,
                cls.CCID,
                cls.OTP_CCID
            ]))

        return modes
995778
def find_all(name, version = nil)
      matched = []
      find(name, version) {|p| matched << p }
      matched
    end
541163
public static String[] getAvailableStatusNames() {
    List<String> nameList = new ArrayList<>();
    for (Status status : INSTANCES.values()) {
      nameList.add(status.getName());
    }
    return nameList.toArray(new String[nameList.size()]);
  }
1052122
def allFileExists(fileList):
    
    allExists = True
    for fileName in fileList:
        allExists = allExists and os.path.isfile(fileName)
    return allExists
334415
def get_all_term_lists(custom_headers:nil)
      response = get_all_term_lists_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
1113809
async def all(self, include_inactive: bool = False) -> list:
        """"""
        data = await self._request('get', 'program')
        return [p for p in data['programs'] if include_inactive or p['active']]
789458
def namedb_get_names_in_namespace( cur, namespace_id, current_block, offset=None, count=None ):
    

    unexpired_query, unexpired_args = namedb_select_where_unexpired_names( current_block )

    query = "SELECT name FROM name_records JOIN namespaces ON name_records.namespace_id = namespaces.namespace_id WHERE name_records.namespace_id = ? AND " + unexpired_query + " ORDER BY name "
    args = (namespace_id,) + unexpired_args

    offset_count_query, offset_count_args = namedb_offset_count_predicate( offset=offset, count=count )
    query += offset_count_query + ";"
    args += offset_count_args

    name_rows = namedb_query_execute( cur, query, tuple(args) )
    ret = []
    for name_row in name_rows:
        rec = {}
        rec.update( name_row )
        ret.append( rec['name'] )

    return ret
474776
def get_name_record(self, name, include_expired=False, include_history=False):
        
        if not check_name(name):
            return {'error': 'invalid name', 'http_status': 400}
        
        name = str(name)

        db = get_db_state(self.working_dir)
        name_record = db.get_name(str(name), include_expired=include_expired, include_history=include_history)

        if name_record is None:
            db.close()
            return {"error": "Not found.", 'http_status': 404}

        else:
            assert 'opcode' in name_record, 'BUG: missing opcode in {}'.format(json.dumps(name_record, sort_keys=True))
            name_record = self.load_name_info(db, name_record)
            db.close()

            # also get the subdomain resolver 
            resolver = get_subdomain_resolver(name)
            name_record['resolver'] = resolver
            return {'status': True, 'record': name_record}
1243781
def get_all_if_set(self):
        

        with self._lock:
            results = {}
            for add, fut in self._state.items():
                if self._contains_and_set(add):
                    results[add] = fut.result()
            return results
400397
def all(self):
        
        return self._client.get(
            url=self._client.get_full_url(
                self.get_path('collection', realm=self._realm_name)
            )
        )
907094
def all(self, paths, access=None):
        """"""
        self.failures = [path for path in paths if not
                         isvalid(path, access, filetype='all')]

        return not self.failures
123644
def files_exist(self, filenames):
        
        return all([os.path.exists(os.path.abspath(filename)) and os.path.isfile(os.path.abspath(filename))
                    for filename in filenames])
651865
def get_names(self):
        
        names = [id for id in self.ecrm_P1_is_identified_by if id.uri == surf.ns.EFRBROO['F12_Name']]
        self.names = []
        for name in names:
            for variant in name.rdfs_label:
                self.names.append((variant.language,variant.title()))
        return self.names
945887
def get_names(infos):
    
    names = []
    for x in infos:
        for y in x:
            names.append(y["name"][0])
    return names
1309736
def get_all(self, name, default=None):
        """"""
        if default is None:
            default = []
        return self._headers.get_list(name) or default
193075
def get_all():
    
    result = {}
    for k,v in nago.extensions.info.node_data.items():
        result[k] = v.get('facts', {})
    return result