Return the meta data.
484043
def get_meta(self, subtype=None):
        
        if subtype:
            return DotDict(self._meta.get(subtype, {}))
        return  self._meta
1277206
def get_ladders_metadata(session, parsed):
    """"""
    ladders = {}
    for ladder in parsed.find_all('a', href=re.compile(LADDER_URL_REGEX)):
        ladders[ladder.text] = get_ladder_metadata(session, ladder['href'])
    return ladders
1299871
def data(self):
        """"""

        # the environment variable CONTENT_LENGTH may be empty or missing
        try:
            request_body_size = int(self.environ.get('CONTENT_LENGTH', 0))
        except (ValueError):
            request_body_size = 0

        data = self.environ['wsgi.input'].read(request_body_size)

        return data
98287
def get_meta_attributes(self, **kwargs):
        """"""
        superuser = kwargs.get('superuser', False)
        if (self.untl_object.qualifier == 'recordStatus'
                or self.untl_object.qualifier == 'system'):
            if superuser:
                self.editable = True
                self.repeatable = True
            else:
                self.editable = False
            self.view_type = 'qualified-input'
        elif self.untl_object.qualifier == 'hidden':
            self.label = 'Object Hidden'
            self.view_type = 'radio'
        else:
            self.editable = False
            self.view_type = 'qualified-input'
364638
def _parse_metadata(self, meta):
        """"""
        formatted_fields = self.settings['FORMATTED_FIELDS']

        output = collections.OrderedDict()
        for name, value in meta.items():
            name = name.lower()
            if name in formatted_fields:
                rendered = self._render(value).strip()
                output[name] = self.process_metadata(name, rendered)
            else:
                output[name] = self.process_metadata(name, value)
        return output
536442
def metaprop(name: str, doc: str, readonly=False):
        """"""
        def get(self):
            return self.meta[name]
        get.__doc__ = "Get %s%s." % (doc, " (readonly)" if readonly else "")

        if not readonly:
            def set(self, value):
                self.meta[name] = value
            set.__doc__ = "Set %s." % doc

            return property(get, set)
        return property(get)
1321500
def get_meta(request, pid):
    """"""
    d1_gmn.app.event_log.log_read_event(pid, request)
    return django.http.HttpResponse(
        d1_gmn.app.views.util.generate_sysmeta_xml_matching_api_version(request, pid),
        d1_common.const.CONTENT_TYPE_XML,
    )
798050
def get_metadata(headers):
  """"""
  return dict((k, v) for k, v in headers.iteritems()
              if any(k.lower().startswith(valid) for valid in _GCS_METADATA))
1096197
@SuppressWarnings("unchecked")
    public HashMap<String, HashMap<String, String>> getMetaData() {
        HashMap<String, HashMap<String, String>> result = new HashMap<String, HashMap<String, String>>();
        for (MetaRecord mr : meta) {
            result.put((String) mr.get(FieldName.META_FILENAME),
                    (HashMap<String, String>) mr.get(FieldName.META_PROPERTIES));
        }
        return result;
    }
241518
def __meta_metadata(self, field, key):
        """"""
        mf = ''
        try:
            mf = str([f[key] for f in self.metadata
                     if f['field_name'] == field][0])
        except IndexError:
            print("%s not in metadata field:%s" % (key, field))
            return mf
        else:
            return mf
24608
def index():
    """"""
    classes = []
    with app.app_context():
        classes = set(current_app.class_references.values())
    if _get_acceptable_response_type() == JSON:
        meta_data = {}
        for cls in classes:
            meta_data[cls.endpoint()] = {
                'link': '/' + cls.endpoint(),
                'meta': '/' + cls.endpoint() + '/meta'
                }
        return jsonify(meta_data)
    else:
        return render_template('index.html', classes=classes)
1141086
def _process_meta(self, response):
        """"""
        for key in self.META_ENVELOPES:
            self.meta[key] = response.get(key)
766726
def http_meta_data(self):
        """"""

        # For each flow process the contents
        for flow in self.input_stream:

            # Client to Server
            if flow['direction'] == 'CTS':
                try:
                    request = dpkt.http.Request(flow['payload'])
                    request_data = data_utils.make_dict(request)
                    request_data['uri'] = self._clean_uri(request['uri'])
                    flow['http'] = {'type':'HTTP_REQUEST', 'data':request_data}
                except (dpkt.dpkt.NeedData, dpkt.dpkt.UnpackError):
                    flow['http'] = None

            # Server to Client
            else:
                try:
                    response = dpkt.http.Response(flow['payload'])
                    flow['http'] = {'type': 'HTTP_RESPONSE', 'data': data_utils.make_dict(response)}
                except (dpkt.dpkt.NeedData, dpkt.dpkt.UnpackError):
                    flow['http'] = None

            # Mark non-TCP HTTP
            if flow['http'] and flow['protocol'] != 'TCP':
                flow['http'].update({'weird': 'UDP-HTTP'})

            # All done
            yield flow
231260
def get_metadata(self):
        

        if self._metadata is None:
            self._metadata = self._source.get_metadata(self._handle)
        return self._metadata
1280882
def get_meta(self):
        
        rdf = self.get_meta_rdf(fmt='n3')
        return ThingMeta(self, rdf, self._client.default_lang, fmt='n3')
985671
def getMetadata(self, remote, address, key):
        """"""
        if self._server is not None:
            # pylint: disable=E1121
            return self._server.getAllMetadata(remote, address, key)
1004550
def metadata(self):
        """"""
        output = dict(self.defaults)
        output.update(self.extra_metadata)
        return output