Parse the officials

        :returns: ``self`` on success, ``None`` otherwise
429270
def parse_officials(self):
        
        # begin proper body of method
        lx_doc = self.html_doc()
        off_parser = opm(self.game_key.season)
        self.officials = off_parser(lx_doc)

        return self if self.officials else None
1333198
def parse(self, body):
        

        self._parse_top_level(body)
        self._parse_resource(body['data'])

        resource = body['data']

        if 'attributes' in resource:
            self._parse_attributes(resource['attributes'])
        if 'relationships' in resource:
            self._parse_relationships(resource['relationships'])
208183
def parse(line)
      fields = [:name, :value, :unit, :status, :type, :state, :lower_nonrec,
                :lower_crit, :lower_noncrit, :upper_crit, :upper_nonrec, :asserts_enabled, :deasserts_enabled]
      # skip the header
      data = line.split(/\|/)
      # should we ever encounter a field not in the fields list, just use a counter based fieldname
      i = 0
      data.each do |value|
        field ||= fields.shift || "field#{i}"
        self[field] = value.strip
        i = i.next
      end
    end
306703
def parse(self, data):
        
        parsed_data = self.yacc.parse(
            data, lexer=self.lexer.get_yacc_compat_lexer(), debug=self.debug)
        self.errors = self.lexer.errors + self.errors
        return parsed_data, self.errors
223119
def parse(self):
        

        keys = {
            'fn': self._parse_name,
            'kind': self._parse_kind,
            'adr': self._parse_address,
            'tel': self._parse_phone,
            'email': self._parse_email,
            'role': self._parse_role,
            'title': self._parse_title
        }

        for val in self.vcard:

            try:

                parser = keys.get(val[0])
                parser(val)

            except (KeyError, ValueError, TypeError):

                pass
483257
def parse(self, response):
        
        if not self.helper.parse_crawler.content_type(response):
            return

        yield self.helper.parse_crawler.pass_to_pipeline(
            response,
            self.helper.url_extractor.get_allowed_domain(response.url)
        )
931381
def parse(cls, op):
        
        for event in cls:
            if event.value == int(op):
                return event
        return None
12511
def auto_parser(parsers=(x_request_id, x_correlation_id, amazon_elb_trace_id)):
    

    for parser in parsers:
        request_id = parser()
        if request_id is not None:
            return request_id

    return None
83144
def post_parse_response(self, response, **kwargs):
        

        if "scope" not in response:
            try:
                _key = kwargs['state']
            except KeyError:
                pass
            else:
                if _key:
                    item = self.get_item(oauth2.AuthorizationRequest,
                                         'auth_request', _key)
                    try:
                        response["scope"] = item["scope"]
                    except KeyError:
                        pass
        return response
230803
def parse_authority(cls, authority):
        ''''''
        userinfo, sep, host = authority.partition('@')

        if not sep:
            return '', userinfo
        else:
            return userinfo, host
855542
def parse(self):
        

        try:

            self.vars['handle'] = self.json['handle'].strip()

        except (KeyError, ValueError, TypeError):

            raise InvalidEntityObject('Handle is missing for RDAP entity')

        for v in ['roles', 'country']:

            try:

                self.vars[v] = self.json[v]

            except (KeyError, ValueError):

                pass

        try:

            vcard = self.json['vcardArray'][1]
            c = _RDAPContact(vcard)
            c.parse()

            self.vars['contact'] = c.vars

        except (KeyError, ValueError, TypeError):

            pass

        try:

            self.vars['events_actor'] = self.summarize_events(
                self.json['asEventActor'])

        except (KeyError, ValueError, TypeError):

            pass

        self.vars['entities'] = []
        try:

            for ent in self.json['entities']:

                if ent['handle'] not in self.vars['entities']:

                    self.vars['entities'].append(ent['handle'])

        except (KeyError, ValueError, TypeError):

            pass

        if not self.vars['entities']:

            self.vars['entities'] = None

        self._parse()
578517
def parse(self, limit=None, or_limit=1):
        
        dir_path = Path(self.rawdir)
        aeolus_file = dir_path / self.files['aeolus']['file']
        aeolus_fh = aeolus_file.open('r')
        count = 0
        for line in aeolus_fh.readlines():
            if limit is not None and count >= limit:
                break
            line = line.rstrip("\n,")
            if line != '[' and line != ']':
                self._parse_aeolus_data(document=json.loads(line),
                                        or_limit=or_limit)
                count += 1
            if count % 500 == 0:
                LOG.info("Processed %i documents", count)

        aeolus_fh.close()
        return
17254
def _parse(self):
        
        self.response = self.resource
        self.resource = self.resource.xpath("//ti:passage/tei:TEI", namespaces=XPATH_NAMESPACES)[0]

        self._prev_id, self._next_id = _SharedMethod.prevnext(self.response)

        if not self.citation.is_set() and len(self.resource.xpath("//ti:citation", namespaces=XPATH_NAMESPACES)):
            self.citation = CtsCollection.XmlCtsCitation.ingest(
                self.response,
                xpath=".//ti:citation[not(ancestor::ti:citation)]"
            )
489699
def parse(self):
        
        status = Status()
        self.expect_line(Status.client_list.label)

        status.updated_at = self.expect_tuple(Status.updated_at.label)
        status.client_list.update({
            text_type(c.real_address): c
            for c in self._parse_fields(Client, Status.routing_table.label)})
        status.routing_table.update({
            text_type(r.virtual_address): r
            for r in self._parse_fields(Routing, Status.global_stats.label)})
        status.global_stats = GlobalStats()
        status.global_stats.max_bcast_mcast_queue_len = self.expect_tuple(
            GlobalStats.max_bcast_mcast_queue_len.label)

        self.expect_line(self.terminator)
        return status
197470
def parse(name, content, releases, get_head_fn):
    
    try:
        return {e["version"]: e["changelog"] for e in content["entries"]
                if e["changelog"]}
    except KeyError:
        return {}
845026
def parseRest(self, response):
        
        body = json.loads(response)

        try:
            error = body['error']['description']
            code = body['error']['code']
        except Exception:
            return body['data']
        else:
            raise ClickatellError(error, code);
620559
def parse(data):
    

    # convert to string
    data = data.decode("ascii")

    if len(data) == 2 and data == "A5":
        return AckMessage()

    # split into bytes
    raw = [data[i:i+2] for i in range(len(data)) if i % 2 == 0]

    if len(raw) != 7:
        return UnknownMessage(raw)

    if raw[1] == "B8":
        return StateMessage(raw)
    elif raw[3] == "12":
        return CommandMessage(raw)
    elif raw[3] == "14":
        return ScenarioTriggeredMessage(raw)
    elif raw[3] == "15":
        return RequestStatusMessage(raw)
    else:
        return UnknownMessage(raw)