Process the table to extract Statements.
12655
def extract_statements(self):
        """"""
        for _, (tf, target, effect, refs) in self.df.iterrows():
            tf_agent = get_grounded_agent(tf)
            target_agent = get_grounded_agent(target)
            if effect == 'Activation':
                stmt_cls = IncreaseAmount
            elif effect == 'Repression':
                stmt_cls = DecreaseAmount
            else:
                continue
            pmids = refs.split(';')
            for pmid in pmids:
                stmt = make_stmt(stmt_cls, tf_agent, target_agent, pmid)
                self.statements.append(stmt)
1055322
def process_data(self, text, colsep=u"\t", rowsep=u"\n",
                     transpose=False, skiprows=0, comments='#'):
        """"""
        data = self._shape_text(text, colsep, rowsep, transpose, skiprows,
                                comments)
        self._model = PreviewTableModel(data)
        self.setModel(self._model)
909250
private function process(Statement $results)
    {
        return $this->manager
            ->getResultProcessor()
            ->processRecords(
                $this->entity,
                $this->with,
                $this->fetchResults(
                    $results,
                    $this->entity->getPrimaryKey()
                ),
                $this->readOnly
            );
    }
461541
def extract_queries(self, args, kwargs):
        '''
            
        '''
        return super(POSTGRESExtPillar, self).extract_queries(args, kwargs)
608433
def process_data(lines)  
      data = {}
      lines.each do |line|
        line = line.split
        key = line.first.split('.value').first
        data[key] = line.last
      end
      data
    end
19872
def process(self, stream):
        """"""
        EOS_TTYPE = T.Whitespace, T.Comment.Single

        # Run over all stream tokens
        for ttype, value in stream:
            # Yield token if we finished a statement and there's no whitespaces
            # It will count newline token as a non whitespace. In this context
            # whitespace ignores newlines.
            # why don't multi line comments also count?
            if self.consume_ws and ttype not in EOS_TTYPE:
                yield sql.Statement(self.tokens)

                # Reset filter and prepare to process next statement
                self._reset()

            # Change current split level (increase, decrease or remain equal)
            self.level += self._change_splitlevel(ttype, value)

            # Append the token to the current statement
            self.tokens.append(sql.Token(ttype, value))

            # Check if we get the end of a statement
            if self.level <= 0 and ttype is T.Punctuation and value == ';':
                self.consume_ws = True

        # Yield pending statement (if any)
        if self.tokens:
            yield sql.Statement(self.tokens)
1068304
def process_document(self, doc):
        
        d = doc.select_segments("$.raw_content")[0]

        tables = doc.extract(self.table_extractor, d)
        for t in tables:
            doc.store([t], t.tag, group_by_tags=False)

        table_data_extractor = EntityTableDataExtraction()
        table_data_extractor.add_glossary(etk.load_glossary("./resources/address_dict.txt"), "address")
        table_data_extractor.add_glossary(etk.load_glossary("./resources/calibre_dict.txt"), "caliber")
        table_data_extractor.add_glossary(etk.load_glossary("./resources/capacity_dict.txt"), "capacity")
        table_data_extractor.add_glossary(etk.load_glossary("./resources/manufacturer_dict.txt"), "manufacturer")
        table_data_extractor.add_glossary(etk.load_glossary("./resources/price_dict.txt"), "price")

        tables = doc.select_segments("$.tables[*]")

        for t in tables:
            extractions = doc.extract(table_data_extractor, t)
            doc.store(extractions, "table_data_extraction")
        return list()
235532
protected void processData(RI data) {
        // Check data against all rules
        Collection<RO> results = new ArrayList<RO>(resultHandlers.size());
        for (Rule<RI, RO> rule : rules) {
            results.add(rule.validate(data));
        }

        // Aggregate all results and process the output
        RHI aggregatedResult = resultAggregator.transform(results);
        processResult(aggregatedResult);
    }
1326224
private void processPredecessors() throws SQLException
   {
      List<Row> rows = getTable("LINK");
      List<Row> completedSections = getTable("TASK_COMPLETED_SECTION");
      Collections.sort(rows, LINK_COMPARATOR);
      m_reader.processPredecessors(rows, completedSections);
   }
661978
def run(self, lines):
        """"""
        ret = []

        for block in self.blocks(lines):
            ret.extend(self.convert_table(block))

        return ret
1109709
def process(self, *args, **kwargs):
        """"""
        super(RawIDField, self).process(*args, **kwargs)
        if self.object_data:
            self.description = self.description or str(self.object_data)
829013
def process_set(line, annotations):
    """"""

    matches = re.match('SET\s+(\w+)\s*=\s*"?(.*?)"?\s*$', line)

    key = None
    if matches:
        key = matches.group(1)
        val = matches.group(2)

    if key == "STATEMENT_GROUP":
        annotations["statement_group"] = val
    elif key == "Citation":
        annotations["citation"] = process_citation(val)
    elif key.lower() == "support" or key.lower() == "evidence":
        annotations["evidence"] = val
    elif re.match("\s*{.*?}", val):
        vals = convert_csv_str_to_list(val)
        annotations[key] = vals
    else:
        annotations[key] = val

    return annotations
960145
def extract_statements(self):
        """"""
        for p_info in self._json:
            para = RlimspParagraph(p_info, self.doc_id_type)
            self.statements.extend(para.get_statements())
        return
932574
private void processAssignments() throws SQLException
   {
      List<Row> rows = getRows("select * from " + m_schema + "taskrsrc where proj_id=? and delete_date is null", m_projectID);
      m_reader.processAssignments(rows);
   }
1217170
public void process(JCas jcas) {
		try {
			tagger.process(jcas);
		} catch(AnalysisEngineProcessException e) {
			e.printStackTrace();
		}
	}
98545
protected void processCell() {
        final ObjectMap<String, String> attributes = getNamedAttributes();
        if (GdxMaps.isEmpty(attributes)) {
            processCellWithNoAttributes(getTable());
            return;
        }
        final LmlActorBuilder builder = new LmlActorBuilder(); // Used to determine table.
        final ObjectSet<String> processedAttributes = GdxSets.newSet();
        processBuildingAttributeToDetermineTable(attributes, processedAttributes, builder);
        final Table targetTable = getTarget(builder).extract(getTable());
        final Cell<?> cell = extractCell(targetTable);
        processCellAttributes(attributes, processedAttributes, targetTable, cell);
    }
564742
private void processTableData() throws IOException
   {
      DirectoryEntry dir = (DirectoryEntry) m_viewDir.getEntry("CTable");
      FixFix ff = new FixFix(126, new DocumentInputStream(((DocumentEntry) dir.getEntry("FixFix   0"))));
      FixDeferFix fdf = new FixDeferFix(new DocumentInputStream(((DocumentEntry) dir.getEntry("FixDeferFix   0"))));
      int items = ff.getItemCount();
      StringBuilder sb = new StringBuilder();
      TableContainer container = m_file.getTables();

      for (int loop = 0; loop < items; loop++)
      {
         byte[] data = ff.getByteArrayValue(loop);
         Table table = new Table();

         table.setID(MPPUtility.getInt(data, 0));

         String name = MPPUtility.getUnicodeString(data, 4);
         if (name.indexOf('&') != -1)
         {
            sb.setLength(0);
            int index = 0;
            char c;

            while (index < name.length())
            {
               c = name.charAt(index);
               if (c != '&')
               {
                  sb.append(c);
               }
               ++index;
            }

            name = sb.toString();
         }

         table.setName(MPPUtility.removeAmpersands(name));
         container.add(table);

         byte[] extendedData = fdf.getByteArray(getOffset(data, 122));
         if (extendedData != null)
         {
            byte[] columnData = fdf.getByteArray(getOffset(extendedData, 8));
            processColumnData(table, columnData);
         }

         //System.out.println(table);
      }
   }