Parse the man page and return the parsed lines.
558254
def parse_man_page(command, platform):
    """"""
    page_path = find_page_location(command, platform)
    output_lines = parse_page(page_path)
    return output_lines
777899
def parse_line(self, line):
        """"""

        prefix = ""
        # ignore comma at start of lines
        if line.startswith(","):
            line, prefix = line[1:], ","

        j = json.loads(line)
        yield j
        self.io.write_line(prefix + json.dumps(j))
854303
def parse(self, sentence):
        
        self.asa.stdin.write(sentence.encode(self.encoding) + b'\n')
        self.asa.stdin.flush()
        result = []
        while not result:
            with open(self.tempfile, 'r', encoding=self.encoding) as out:
                asa_return = out.read()
            if asa_return and asa_return.splitlines()[-1].startswith('input'):
                result = self._parse_asa_return(asa_return)
            time.sleep(0.1)
        open(self.tempfile, 'w').close()  # Initialize temp file
        return result
244214
def parse_columns(lines):
    
    data = []
    index = []
    for line in lines:
        line = line.rstrip()
        if line.startswith("#"):
            tmp = __parse_entry(line)
            data.append(tmp[1])
            index.append(tmp[0])

    return DataFrame(data, index=index, columns=['description'])
174611
def parse(self):
        
        try:
            # Continues until `next_line()` raises StopIteration
            # This can trigger here or in parse functions in the subclass
            while True:
                # Only advance the parser if the previous line was consumed.
                # Parse functions reading multiple lines can end up reading one line too far,
                # so they return without consuming the line and we pick it up here
                if not self.line:
                    self.next_line()

                if self.line[0] == '#' or len(self.values) < 2:
                    self.consume_line()
                    continue

                self.dispatcher.get(self.values[0], self.parse_fallback)()
        except StopIteration:
            pass

        if self.auto_post_parse:
            self.post_parse()
784642
def parse_input(self):
        '''
        '''

        if self._text:
            lines = iter(self._text.splitlines())
        elif self._file:
            lines = self._file
        else:
            lines = ()

        sample_lines = []

        for line in lines:
            if len(sample_lines) > 100:
                break

            sample_lines.append(line)

        lines = itertools.chain(sample_lines, lines)

        self.guess_type(sample_lines)

        datetime_format = wpull.protocol.ftp.ls.date.guess_datetime_format(
            sample_lines)

        self.set_datetime_format(datetime_format)

        return self.parse(lines)
433808
def _parse_next(self):
        ''''''

        this_line = self.line
        while self.line < len(self.lines):
            s = self.lines[self.line].rstrip()
            elements = s.split(", ")
            this_line = self.line
            # move to next line
            self.line += 1
            if len(elements) >= 2:
                # this_line is good
                break

        if this_line >= len(self.lines):
            return None

        # cope with empty structures
        if len(elements) == 5 and elements[-1] == ',':
            elements[-1] = ''
            elements.append('')

        self.percent = 100.0 * (this_line / float(len(self.lines)))

        msg_type = elements[0]

        if not msg_type in self.formats:
            return self._parse_next()
        
        fmt = self.formats[msg_type]

        if len(elements) < len(fmt.format)+1:
            # not enough columns
            return self._parse_next()

        elements = elements[1:]
        
        name = fmt.name.rstrip('\0')
        if name == 'FMT':
            # add to formats
            # name, len, format, headings
            self.formats[elements[2]] = DFFormat(int(elements[0]), elements[2], int(elements[1]), elements[3], elements[4])

        try:
            m = DFMessage(fmt, elements, False)
        except ValueError:
            return self._parse_next()

        self._add_msg(m)

        return m
137194
def _read_parsed(self, lines):
        
        self.log(u"Parsing fragments from parsed text format")
        pairs = []
        for line in lines:
            pieces = line.split(gc.PARSED_TEXT_SEPARATOR)
            if len(pieces) == 2:
                identifier = pieces[0].strip()
                text = pieces[1].strip()
                if len(identifier) > 0:
                    pairs.append((identifier, [text]))
        self._create_text_fragments(pairs)
698394
def parse_blocks(lines):  # type: (List[str]) -> List[List[str]]
    
    blocks = []

    while lines:
        if lines[0] == '':
            lines.pop(0)
        else:
            blocks.append(parse_block(lines))

    return blocks
983267
def _parse(self):
        
        cur_ver = None
        cur_line = None
        for line in self.content:
            m = re.match('[^ ]+ \(([0-9]+\.[0-9]+\.[0-9]+)-[0-9]+\) [^ ]+; urgency=[^ ]+', line)
            if m:
                cur_ver = m.group(1)
                self.versions.append(cur_ver)
                self.entries[cur_ver] = []
                cur_entry = self.entries[cur_ver]
                if self.latest_version is None or StrictVersion(cur_ver) > StrictVersion(self.latest_version):
                    self.latest_version = m.group(1)
            elif cur_ver:
                m = re.match('  \* (.*)', line)
                if m:
                    cur_entry.append(m.group(1).strip())
                elif not re.match('$', line) and re.match(' *[^$]+', line):
                    cur_entry[-1] += " " + line.strip()
687631
def readlines(self, *args, **kwargs):
        """"""
        return list(iter(partial(self.readline, *args, **kwargs), u''))
31224
def parse(self, line):
        
        tree = list(self.parser.raw_parse(line))[0]
        tree = tree[0]
        return tree
941730
def _get_results(self, page):
		""""""

		soup = _get_soup(page)
		details = soup.find_all("tr", class_="odd")
		even = soup.find_all("tr", class_="even")
		# Join the results
		for i in range(len(even)):
			details.insert((i * 2)+1, even[i])

		return self._parse_details(details)
1253905
def parse_lines(self, lines: Iterable[str]) -> List[ParseResults]:
        """"""
        return [
            self.parseString(line, line_number)
            for line_number, line in enumerate(lines)
        ]
1063158
function parsePages(options) {
  return readFileTree(options.src.pages, options.keys.pages, options);
}
793302
def parse(cls, requester, entries):
        """"""
        result_entries = SearchableList()
        for entry in entries:
            result_entries.append(cls.instance.parse(requester, entry))
        return result_entries
594960
def parse_line(self, line):
        """"""
        # The parser may only need to run until it has seen a specific line.
        # Once that's occurred, it can mark itself as complete, to save
        # being run against later log lines.
        if self.parser.complete:
            return

        # Perf data is stored in a json structure contained in a single line,
        # if the MAX_LINE_LENGTH is applied the data structure could be
        # truncated, preventing it from being ingested.
        if 'PERFHERDER_DATA' not in line:
            line = line[:self.MAX_LINE_LENGTH]

        self.parser.parse_line(line, self.lineno)
        self.lineno += 1