Get list of free object defined in database with name
        matching the specified filter

        :param argin: The filter
        :type: tango.DevString
        :return: Object name list
        :rtype: tango.DevVarStringArray
17351
def DbGetObjectList(self, argin):
        
        self._log.debug("In DbGetObjectList()")
        argin = replace_wildcard(argin)
        return self.db.get_object_list(argin)
546965
def extract_objects(self, fname, type_filter=None):
    '''
    '''
    objects = []
    if fname in self.object_cache:
      objects = self.object_cache[fname]
    else:
      with io.open(fname, 'rt', encoding='utf-8') as fh:
        text = fh.read()
        objects = parse_verilog(text)
        self.object_cache[fname] = objects

    if type_filter:
      objects = [o for o in objects if isinstance(o, type_filter)]

    return objects
1366583
def get_full_current_object(arn, current_model):
    
    LOG.debug(f'[-->] Item with ARN: {arn} was too big for SNS -- fetching it from the Current table...')
    item = list(current_model.query(arn))

    # If for whatever reason, the item *cannot* be found, then this record should be skipped over.
    # This will happen if this event came in and got processed right after the item was deleted
    # from the Current table. If so, then do nothing -- the deletion event will be processed later.
    if not item:
        return None

    # We need to place the real configuration data into the record so it can be deserialized into
    # the current model correctly:
    return item[0]
569802
def QueryDatabases(self, query, options=None):
        
        if options is None:
            options = {}

        def fetch_fn(options):
            return self.__QueryFeed('/dbs',
                                    'dbs',
                                    '',
                                    lambda r: r['Databases'],
                                    lambda _, b: b,
                                    query,
                                    options), self.last_response_headers
        return query_iterable.QueryIterable(self, query, options, fetch_fn)
525777
def fetch_column_names(cls,
                           db: DATABASE_SUPPORTER_FWD_REF,
                           table: str) -> List[str]:
        """"""
        raise RuntimeError(_MSG_NO_FLAVOUR)
321146
def registered_filters_list(self):
        
        return [filter_name for filter_name in self.__jinja2_environment.filters.keys() if filter_name not in self.__jinja2_predefined_filters ]
1197017
def filters(self):
        
        objects = javabridge.get_env().get_object_array_elements(
            javabridge.call(self.jobject, "getFilters", "()[Lweka/filters/Filter;"))
        result = []
        for obj in objects:
            result.append(Filter(jobject=obj))
        return result
274191
public static snmptrap[] get_filtered(nitro_service service, String filter) throws Exception{
		snmptrap obj = new snmptrap();
		options option = new options();
		option.set_filter(filter);
		snmptrap[] response = (snmptrap[]) obj.getfiltered(service, option);
		return response;
	}
829142
def _filter_names(names):
    
    names = [n for n in names
             if n not in EXCLUDE_NAMES]
    # This is needed when building a distro from a working
    # copy (likely a checkout) rather than a pristine export:
    for pattern in EXCLUDE_PATTERNS:
        names = [n for n in names
                 if (not fnmatch.fnmatch(n, pattern))
                 and (not n.endswith('.py'))]
    return names
707251
def get_list_by_name(self, display_name):
        

        if not display_name:
            raise ValueError('Must provide a valid list display name')

        url = self.build_url(self._endpoints.get('get_list_by_name').format(display_name=display_name))

        response = self.con.get(url)
        if not response:
            return []

        data = response.json()

        return self.list_constructor(parent=self, **{self._cloud_data_key: data})
204208
def get(self, arg):
        
        try:
            reservations = self.get_all_instances(filters={'tag:Name': [arg]})
            instance = reservations[0].instances[0]
        except IndexError:
            try:
                instance = self.get_all_instances([arg])[0].instances[0]
            except (_ResponseError, IndexError):
                # TODO: encapsulate actual exception for debugging
                err = "Can't find any instance with name or ID '%s'" % arg
                raise ValueError(err)
        return instance
309572
async def get_object_or_none(cls, db, **kwargs):
        
        async for obj in cls.filter_by(db, limit=1, **kwargs):
            return obj
        return None
36295
def DbDeleteProperty(self, argin):
        
        self._log.debug("In DbDeleteProperty()")
        obj_name = argin[0]
        for prop_name in argin[1:]:
            self.db.delete_property(obj_name, prop_name)
962883
public static nshostname[] get_filtered(nitro_service service, String filter) throws Exception{
		nshostname obj = new nshostname();
		options option = new options();
		option.set_filter(filter);
		nshostname[] response = (nshostname[]) obj.getfiltered(service, option);
		return response;
	}
11164
def get_table(self, tablename):
        
        temp = filter(lambda x: x.name == tablename, self.tables)
        if temp == list():
            raise Exception("No such table")
        return temp[0]
311768
def fetch_by_relname(self, name):
        

        ormclass = self._mapped[name]
        query = self.session.query(ormclass)

        if name != carr_ormclass:

            query = query.filter(
                ormclass.scn_name == self.scn_name)

        if self.version:
            query = query.filter(ormclass.version == self.version)

        # TODO: Naming is not consistent. Change in database required.
        if name == 'Transformer':
            name = 'Trafo'

        df = pd.read_sql(query.statement,
                         self.session.bind,
                         index_col=name.lower() + '_id')
        if name == 'Link':
            df['bus0'] = df.bus0.astype(int)
            df['bus1'] = df.bus1.astype(int)

        if 'source' in df:
            df.source = df.source.map(self.id_to_source())

        return df
737442
def DbDeleteServer(self, argin):
        
        self._log.debug("In DbDeleteServer()")

        if '*' in argin or '%' in argin or not '/' in argin:
            self.warn_stream("DataBase::db_delete_server(): server name " + argin + " incorrect ")
            th_exc(DB_IncorrectServerName,
                   "failed to delete server, server name incorrect",
                   "DataBase::DeleteServer()")

        self.db.delete_server(argin)