Retrieves the selected metadata values of the given set

        :param set: cluster that contains the data
        :param selected_meta: the values of the selected_meta
        :return: the values of the selected meta of the cluster
193342
def get_values(self, set, selected_meta):
        
        warnings.warn("\n\nThis method assumes that the last level of the index is the sample_id.\n"
                      "In case of single index, the index itself should be the sample_id")
        sample_ids = set.index.get_level_values(-1)
        corresponding_meta = self.meta.loc[sample_ids]
        values = corresponding_meta[selected_meta]

        try:
            values = values.astype(float)
        except ValueError:
            print("the values should be numeric")
        return values
1208971
def get_catalog_metadata(catalog, exclude_meta_fields=None):
    """"""
    exclude_meta_fields = exclude_meta_fields or []
    catalog_dict_copy = catalog.copy()
    del catalog_dict_copy["dataset"]

    for excluded_meta_field in exclude_meta_fields:
        catalog_dict_copy.pop(excluded_meta_field, None)

    return catalog_dict_copy
63357
def _get_selected_items(self):
        """"""
        selection = self.get_selection()
        if selection.get_mode() != gtk.SELECTION_MULTIPLE:
            raise AttributeError('selected_items only valid for '
                                 'select_multiple')
        model, selected_paths = selection.get_selected_rows()
        result = []
        for path in selected_paths:
            result.append(model[path][0])
        return result
1068423
public MergedSelectionSet collectFields(FieldCollectorParameters parameters, SelectionSet selectionSet) {
        Map<String, MergedField> subFields = new LinkedHashMap<>();
        List<String> visitedFragments = new ArrayList<>();
        this.collectFields(parameters, selectionSet, visitedFragments, subFields);
        return newMergedSelectionSet().subFields(subFields).build();
    }
547338
protected Set<String> getExclusions(AnnotationMetadata metadata,
			AnnotationAttributes attributes) {
		Set<String> excluded = new LinkedHashSet<>();
		excluded.addAll(asList(attributes, "exclude"));
		excluded.addAll(Arrays.asList(attributes.getStringArray("excludeName")));
		excluded.addAll(getExcludeAutoConfigurationsProperty());
		return excluded;
	}
555418
def metadata(self):
        
        from ambry.metadata.schema import Top  # cross-module import
        top = Top()
        top.build_from_db(self.dataset)
        return top
888123
def _is_in_set(self, inpt, metadata):
        """"""
        # makes an assumption there is only one _set in the metadata dict
        get_set_methods = [m for m in dir(metadata) if 'get_' in m and '_set' in m]
        set_results = None
        for m in get_set_methods:
            try:
                set_results = getattr(metadata, m)()
                break
            except errors.IllegalState:
                pass
        if set_results is not None and inpt in set_results:
            return True
        return False
1366216
def get_meta(self, key=None):
        """"""
        if self.is_fake:
            return {}

        if key == "tag":
            return self.tag
        elif key is None:
            ret = {}
            for key in self.journal.info.keys():
                ret[key] = self.meta_mappings.map_get(self.journal.info, key)[1]
            return ret
        else:
            key, value = self.meta_mappings.map_get(self.journal.info, key)
            return value
669130
public Map<String, String> getMetadata() {
    return metadata == null || Data.isNull(metadata) ? null : Collections.unmodifiableMap(metadata);
  }
142630
@SuppressWarnings("unchecked")
    public HashMap<String, String> getFlattenedMetaData() {
        HashMap<String, String> result = new HashMap<String, String>();
        for (MetaRecord mr : meta) {
            result.putAll((Map<String, String>) mr
                    .get(FieldName.META_PROPERTIES));
        }
        return result;
    }
8634
def process_metadata(meta):
    
    mvgds = []

    metadata = meta[0]

    for mvgd in meta:
        if isinstance(mvgd['mv_grid_districts'], list):
            mvgds.extend(mvgd['mv_grid_districts'])
        else:
            mvgds.append(mvgd['mv_grid_districts'])

    metadata['mv_grid_districts'] = mvgds

    return metadata
484199
def _get_metadata(self):
        """"""
        self.metadata = self.fetch_header()
        self.variables = {g.name for g in self.metadata.grids}
1331653
def get_metadata(bind):
    """"""
    if bind == '':
        bind = None
    m = MetaData()
    for t in target_metadata.tables.values():
        if t.info.get('bind_key') == bind:
            t.tometadata(m)
    return m
1194093
private List<Setter> getSetters(ResultSetMetaData meta) throws SQLException {

        int columnCount = meta.getColumnCount();
        List<Setter> setters = new ArrayList<Setter>(columnCount);
        for (int i = 1; i <= columnCount; i++) {
            String column = meta.getColumnName(i);
            Method setMethod = orMapping.getSetter(column);

            if (setMethod != null) {
                Setter setter = new Setter(setMethod, column, setMethod.getParameterTypes()[0]);
                setters.add(setter);
            }
        }
        return setters;
    }
1063453
def get_meta(self, ignore=['uniqueid']):
        
        return OrderedDict([(k, getattr(self, k)) for k in _meta_fields_all if k not in ignore])
911347
def _get_final_set(self, sets, pk, sort_options):
        
        if self._lazy_collection['intersects']:
            # if the intersect method was called, we had new sets to intersect
            # to the global set of sets.
            # And it there is no real filters, we had the set of the whole
            # collection because we cannot be sure that entries in "intersects"
            # are all real primary keys
            sets = sets[::]
            sets.extend(self._lazy_collection['intersects'])
            if not self._lazy_collection['sets'] and not self.stored_key:
                sets.append(self.cls.get_field('pk').collection_key)

        final_set, keys_to_delete_later = super(ExtendedCollectionManager,
                                    self)._get_final_set(sets, pk, sort_options)

        # if we have a slice and we want to sort by the score of a sorted set,
        # as redis sort command doesn't handle this, we have to create keys for
        # each value of the sorted set and sort on them
        # @antirez, y u don't allow this !!??!!
        if final_set and self._sort_by_sortedset_before:
            # TODO: if we have filters, maybe apply _zet_to_keys to only
            #       intersected values
            base_tmp_key, tmp_keys = self._prepare_sort_by_score(None, sort_options)
            # new keys have to be deleted once the final sort is done
            if not keys_to_delete_later:
                keys_to_delete_later = []
            keys_to_delete_later.append(base_tmp_key)
            keys_to_delete_later += tmp_keys

        return final_set, keys_to_delete_later
274015
def mget(meta_docs)
      merge_data = {:_index => name}
      @server.mget(meta_docs.map {|d| d.merge(merge_data) })
    end