コード例 #1
0
    private SUTime.Duration extractDuration(MatchResult results, String val) {
      String unit = null;
      if (unitMatchGroup >= 0) unit = results.group(unitMatchGroup);
      if (val == null) {
        val = (unit.endsWith("s")) ? "X" : "1";
        //        val = "1";
      }
      if (underspecifiedValMatchGroup >= 0) {
        val = defaultUnderspecifiedValue;
        if (results.groupCount() >= underspecifiedValMatchGroup) {
          if (results.group(underspecifiedValMatchGroup) != null) {
            val = "X";
          }
        }
      }

      SUTime.Duration d = patterns.getDuration(val, unit);
      if (d == null) {
        logger.warning(
            "Unable to get duration with: val="
                + val
                + ", unit="
                + unit
                + ", matched="
                + results.group());
      }
      return d;
    }
コード例 #2
0
 public SUTime.TemporalOp apply(MatchResult in) {
   if (group >= 0) {
     String expr = in.group(group);
     if (expr != null) {
       return patterns.lookupTemporalOp(expr);
     }
   }
   return null;
 }
コード例 #3
0
  public List<TimeExpression> extractTimeExpressions(CoreMap annotation, String docDateStr) {
    List<CoreMap> mergedNumbers = NumberNormalizer.findAndMergeNumbers(annotation);
    annotation.set(CoreAnnotations.NumerizedTokensAnnotation.class, mergedNumbers);

    // TODO: docDate may not have century....
    SUTime.Time docDate = timexPatterns.parseDateTime(docDateStr);

    List<? extends MatchedExpression> matchedExpressions =
        expressionExtractor.extractExpressions(annotation);
    List<TimeExpression> timeExpressions = new ArrayList<TimeExpression>(matchedExpressions.size());
    for (MatchedExpression expr : matchedExpressions) {
      if (expr instanceof TimeExpression) {
        timeExpressions.add((TimeExpression) expr);
      } else {
        timeExpressions.add(new TimeExpression(expr));
      }
    }

    // Add back nested time expressions for ranges....
    // For now only one level of nesting...
    if (options.includeNested) {
      List<TimeExpression> nestedTimeExpressions = new ArrayList<TimeExpression>();
      for (TimeExpression te : timeExpressions) {
        if (te.isIncludeNested()) {
          List<? extends CoreMap> children =
              te.getAnnotation().get(TimeExpression.ChildrenAnnotation.class);
          if (children != null) {
            for (CoreMap child : children) {
              TimeExpression childTe = child.get(TimeExpression.Annotation.class);
              if (childTe != null) {
                nestedTimeExpressions.add(childTe);
              }
            }
          }
        }
      }
      timeExpressions.addAll(nestedTimeExpressions);
    }
    Collections.sort(timeExpressions, MatchedExpression.EXPR_TOKEN_OFFSETS_NESTED_FIRST_COMPARATOR);
    timeExpressions = filterInvalidTimeExpressions(timeExpressions);

    // Some resolving is done even if docDate null...
    if (
    /*docDate != null && */ timeExpressions != null) {
      resolveTimeExpressions(annotation, timeExpressions, docDate);
    }
    // Annotate timex
    return timeExpressions;
  }
コード例 #4
0
 public void init(Options options) {
   this.options = options;
   timexPatterns = new TimeExpressionPatterns(options);
   // TODO: does not allow for multiple loggers
   if (options.verbose) {
     logger.setLevel(Level.FINE);
   } else {
     logger.setLevel(Level.SEVERE);
   }
   NumberNormalizer.setVerbose(options.verbose);
   if (options.grammarFilename != null) {
     List<String> filenames = StringUtils.split(options.grammarFilename, "\\s*[,;]\\s*");
     this.expressionExtractor =
         CoreMapExpressionExtractor.createExtractorFromFiles(timexPatterns.env, filenames);
     // this.expressionExtractor =
     // CoreMapExpressionExtractor.createExtractorFromFile(timexPatterns.env,
     // options.grammarFilename);
   } else {
     this.expressionExtractor = new CoreMapExpressionExtractor();
     this.expressionExtractor.setExtractRules(
         timexPatterns.getTimeExtractionRule(), timexPatterns.getCompositeTimeExtractionRule());
   }
   this.expressionExtractor.setLogger(logger);
 }
コード例 #5
0
 private List<TimeExpression> filterInvalidTimeExpressions(List<TimeExpression> timeExprs) {
   int nfiltered = 0;
   List<TimeExpression> filtered =
       new ArrayList<TimeExpression>(timeExprs.size()); // Approximate size
   for (TimeExpression timeExpr : timeExprs) {
     if (timexPatterns.checkTimeExpression(timeExpr)) {
       filtered.add(timeExpr);
     } else {
       nfiltered++;
     }
   }
   if (nfiltered > 0) {
     logger.finest("Filtered " + nfiltered);
   }
   return filtered;
 }
コード例 #6
0
 private void resolveTimeExpressions(
     CoreMap annotation, List<TimeExpression> timeExpressions, SUTime.Time docDate) {
   for (TimeExpression te : timeExpressions) {
     SUTime.Temporal temporal = te.getTemporal();
     if (temporal != null) {
       // TODO: use correct time for anchor
       try {
         int flags = timexPatterns.determineRelFlags(annotation, te);
         // int flags = 0;
         SUTime.Temporal grounded = temporal.resolve(docDate, flags);
         if (grounded == null) {
           logger.warning("Error resolving " + temporal + ", using docDate=" + docDate);
         }
         if (grounded != temporal) {
           te.origTemporal = temporal;
           te.setTemporal(grounded);
         }
       } catch (Exception ex) {
         logger.log(Level.WARNING, "Error resolving " + temporal, ex);
       }
     }
   }
 }