Añotador
Temporal Tagger
Main.java
Go to the documentation of this file.
1 package oeg.tagger.main;
2 
3 import edu.stanford.nlp.util.logging.RedwoodConfiguration;
4 import java.io.BufferedWriter;
5 import java.io.File;
6 import java.io.FileOutputStream;
7 import java.io.FileReader;
8 import java.io.OutputStream;
9 import java.io.OutputStreamWriter;
10 import java.text.DateFormat;
11 import java.text.SimpleDateFormat;
12 import java.util.Arrays;
13 import java.util.Calendar;
14 import java.util.Date;
15 import oeg.tagger.core.time.tictag.Annotador;
16 import org.apache.commons.cli.BasicParser;
17 import org.apache.commons.cli.CommandLine;
18 import org.apache.commons.cli.CommandLineParser;
19 import org.apache.commons.cli.HelpFormatter;
20 import org.apache.commons.cli.Options;
21 import org.apache.commons.io.FileUtils;
22 import java.io.PrintStream;
23 import java.util.logging.Level;
24 import java.util.logging.Logger;
25 import oeg.tagger.core.time.tictag.AnnotadorLegal;
26 import oeg.tagger.core.time.tictag.AnnotadorStandard;
27 import org.apache.maven.model.Model;
28 import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
29 
36 public class Main {
37 
38  static final Logger logger = Logger.getLogger(Main.class.getName());
39  static boolean logs = false;
40  static String lang = "es";
41  static String domain = "standard";
42  static String date = "";
43  static String format = "timeml";
44  static String outpfilename = null;
45 
46  public static void main(String[] args) {
47 
48  // We do this to avoid the Ixa-Pipes debugging messages...
49  PrintStream systemerr = System.err;
50 
51  init(args);
52 
53  if (args.length != 0) {
54  String res = parsear(args);
55  if (!res.isEmpty()) {
56  System.out.println(res);
57  }
58  }
59 
60  System.setErr(systemerr);
61  }
62 
63  public static void init(String[] args) {
64  logs = Arrays.asList(args).contains("-logs");
65  initLogger(logs);
66 
67 
68  //Welcome message
69  try {
70  MavenXpp3Reader reader = new MavenXpp3Reader();
71  Model model = reader.read(new FileReader("pom.xml"));
72  String welcome = model.getArtifactId() + " " + model.getVersion() + "\n-----------------------------------------------------\n";
73  logger.info(welcome);
74  } catch (Exception e) {
75  }
76 
77  }
78 
79  public static String parsear(String[] args) {
81  StringBuilder res = new StringBuilder();
82  CommandLineParser parser = null;
83  CommandLine cmd = null;
84  try {
85 
86  Options options = new Options();
87  options.addOption("nologs", false, "OPTION to disables logs");
88  options.addOption("logs", false, "OPTION to enable logs");
89  options.addOption("lang", true, "OPTION to change language [ES, EN] (Spanish by default)");
90  options.addOption("domain", true, "OPTION to change domain [standard, legal] (Standard by default)");
91  options.addOption("date", true, "OPTION to add an anchor date in the format yyyy-mm-dd (today by default)");
92  options.addOption("text", true, "COMMAND to parse a text");
93  options.addOption("f", true, "COMMAND to parse a file");
94  options.addOption("outf", true, "COMMAND to save the output to a file");
95  options.addOption("format", true, "COMMAND to choose the output format [timeml,json,nif] (TimeML by default)");
96  options.addOption("help", false, "COMMAND to show help (Help)");
97  parser = new BasicParser();
98  cmd = parser.parse(options, args);
99  String outp = "";
100 
101  if (cmd.hasOption("help") || args.length == 0) {
102  new HelpFormatter().printHelp(Main.class.getCanonicalName(), options);
103  }
104  if (cmd.hasOption("lang")) {
105  lang = cmd.getOptionValue("lang");
106  }
107  if (cmd.hasOption("domain")) {
108  domain = cmd.getOptionValue("domain");
109  }
110 // if (!cmd.hasOption("logs")) {
111 // initLoggerDisabled();
112 // }
113  if (cmd.hasOption("date")) {
114  date = cmd.getOptionValue("date");
115  }
116  if (cmd.hasOption("format")) {
117  format = cmd.getOptionValue("format");
118  }
119  if (cmd.hasOption("f")) {
120  String filename = cmd.getOptionValue("f");
121  logger.info("Trying to parse the file " + filename);
122  outp = parse(filename);
123  }
124  if (cmd.hasOption("text")) {
125  String text = cmd.getOptionValue("text");
126  logger.info("Trying to process the text " + text);
127  outp = parseText(text);
128  }
129  if(cmd.hasOption("outf")){
130  outpfilename = cmd.getOptionValue("outf");
131  if(!writeFile(outp, outpfilename)){
132  logger.warning("Error while writing."); // ERROR
133  } else{
134  logger.info("Output correctly written to " + outpfilename);
135  }
136  }
137  if(outp != null){
138  if(logs){
139  System.out.println("\n----------------\n");
140  }
141  System.out.println(outp);
142  if(logs){
143  System.out.println("\n----------------\n");
144  }
145  }
146 
147  } catch (Exception e) {
148 System.out.println(e.toString());
149  }
150 
151  return res.toString();
152  }
153 
154  public static String parse(String filename) {
155  String res = "";
156  try {
157  File f = new File(filename);
158  logger.info("parsing the folder " + filename); // DEBUG
159  String input = FileUtils.readFileToString(f, "UTF-8");
160  res = parseText(input);
161 
162  } catch (Exception e) {
163  logger.warning("error opening file"); // ERROR
164  return "";
165  }
166  logger.info("Parsing correct\n\n");
167  return res;
168  }
169 
170  public static String parseText(String txt) {
171  String res = "";
172  Date dct = null;
173  try{
174  if (!date.matches("\\d\\d\\d\\d-(1[012]|0\\d)-(3[01]|[012]\\d)")) // Is it valid?
175  {
176  logger.info("No correct date provided, ");
177  dct = Calendar.getInstance().getTime();
178  DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
179  date = df.format(dct);
180  }
181 
182  Annotador annotador;
183 
184  if(domain.equalsIgnoreCase("standard")){
185  if(lang.equalsIgnoreCase("ES")){
186  // We innitialize the tagger in Spanish
187  annotador = new AnnotadorStandard("es");
188  }
189  else if(lang.equalsIgnoreCase("EN")){
190  annotador = new AnnotadorStandard("en");
191  }
192  else{
193  logger.warning("error in language; for now, just available ES and EN"); // ERROR
194  return res;
195  }
196  } else if(domain.equalsIgnoreCase("legal")){
197  if(lang.equalsIgnoreCase("ES")){
198  // We innitialize the tagger in Spanish
199  annotador = new AnnotadorLegal("es");
200  }
201  else if(lang.equalsIgnoreCase("EN")){
202  annotador = new AnnotadorLegal("en");
203  }
204  else{
205  logger.warning("error in language; for now, just available ES and EN"); // ERROR
206  return res;
207  }
208  } else{
209  logger.warning("error in domain; for now, just available standard and legal"); // ERROR
210  return res;
211  }
212 
213  if(format.equalsIgnoreCase("timeml")){
214  res = annotador.annotate(txt, date);
215  } else if(format.equalsIgnoreCase("nif")){
216  res = annotador.annotateNIF(txt, date, "ref", lang);
217  } else if(format.equalsIgnoreCase("json")){
218  res = annotador.annotateJSON(txt, date);
219  } else{
220  logger.warning("Incorrect format; TimeML will be used."); // ERROR
221  res = annotador.annotate(txt, date);
222  }
223 
224  } catch (Exception e) {
225  logger.warning("error processing text:\n" + res); // ERROR
226  return "";
227  }
228  logger.info("Text processing correct:\n" + res);
229 
230  return res;
231  }
232 
233  public static void initLogger(boolean logs) {
234  if (logs) {
235  initLoggerDebug();
236  } else {
237  initLoggerDisabled();
238  }
239 
240  }
241 
246  private static void initLoggerDisabled() {
247  Logger.getLogger("").setLevel(Level.FINEST);
248 //
249 // List<Logger> loggers = Collections.<Logger>list(LogManager.getCurrentLoggers());
250 // loggers.add(LogManager.getRootLogger());
251 // for (Logger log : loggers) {
252 // log.setLevel(Level.OFF);
253 // }
254 // Logger.getRootLogger().setLevel(Level.OFF);
255 
256  // We do this to void IxaPipes messages...
257  PrintStream falseerr = new PrintStream(new OutputStream(){
258  public void write(int b) {
259  }
260  });
261  System.setErr(falseerr);
262 
263  // We turn off CoreNLP logger
264  RedwoodConfiguration.current().clear().apply();
265 
266  // We turn off some inner IxaPipes loggers
267 // ch.qos.logback.classic.Logger logger1 = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(SpanishReadabilityModel.class);
268 // logger1.setLevel(ch.qos.logback.classic.Level.OFF);
269 // ch.qos.logback.classic.Logger logger2 = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Hyphenator.class);
270 // logger2.setLevel(ch.qos.logback.classic.Level.OFF);
271 // ch.qos.logback.classic.Logger logger3 = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(BasicAnnotator.class);
272 // logger3.setLevel(ch.qos.logback.classic.Level.OFF);
273 //
274 // logger.setLevel(Level.OFF);
275 
276 // Logger.getRootLogger().removeAllAppenders();
277 //Logger.getRootLogger().addAppender(new NullAppender());
278  }
279 
284  private static void initLoggerDebug() {
285 
286 // Enumeration currentLoggers = LogManager.getCurrentLoggers();
287 // List<Logger> loggers = Collections.<Logger>list(currentLoggers);
288 // loggers.add(LogManager.getRootLogger());
289 // for (Logger log : loggers) {
290 // log.setLevel(Level.OFF);
291 // }
292 //
293 // Logger root = Logger.getRootLogger();
294 // root.setLevel((Level) Level.DEBUG);
295 //
296 // //APPENDER DE CONSOLA (INFO)%d{ABSOLUTE}
297 // PatternLayout layout = new PatternLayout("%d{HH:mm:ss} [%5p] %13.13C{1}:%-4L %m%n");
298 // ConsoleAppender appenderconsole = new ConsoleAppender(); //create appender
299 // appenderconsole.setLayout(layout);
300 // appenderconsole.setThreshold(Level.INFO);
301 // appenderconsole.activateOptions();
302 // appenderconsole.setName("console");
303 // root.addAppender(appenderconsole);
304 //
305 // //APPENDER DE ARCHIVO (DEBUG)
306 // PatternLayout layout2 = new PatternLayout("%d{ISO8601} [%5p] %13.13C{1}:%-4L %m%n");
307 // FileAppender appenderfile = null;
308 // String filename = "./logs/logs.txt";
309 // try {
310 // MavenXpp3Reader reader = new MavenXpp3Reader();
311 // Model model = reader.read(new FileReader("pom.xml"));
312 // filename = "./logs/" + model.getArtifactId() + ".txt";
313 // } catch (Exception e) {
314 // }
315 // try {
316 // appenderfile = new FileAppender(layout2, filename, false);
317 // appenderfile.setName("file");
318 // appenderfile.setThreshold(Level.DEBUG);
319 // appenderfile.activateOptions();
320 // } catch (Exception e) {
321 // }
322 //
323 // root.addAppender(appenderfile);
324 //
325 //
326 // logger = Logger.getLogger(Main.class.getName());
327  }
328  public static boolean writeFile(String input, String path) {
329  try {
330  FileOutputStream fos = new FileOutputStream(path);
331  OutputStreamWriter w = new OutputStreamWriter(fos, "UTF-8");
332  BufferedWriter bw = new BufferedWriter(w);
333  bw.write(input);
334  bw.flush();
335  bw.close();
336  return true;
337  } catch (Exception ex) {
338  java.util.logging.Logger.getLogger(Annotador.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
339  }
340  return false;
341  }
342 
343 }
oeg.tagger.core.time
oeg.tagger.core.time.tictag.Annotador.annotateJSON
String annotateJSON(String input, String anchorDate)
oeg.tagger.main.Main.writeFile
static boolean writeFile(String input, String path)
Definition: Main.java:328
oeg.tagger.core.time.tictag.AnnotadorStandard
Definition: AnnotadorStandard.java:49
oeg.tagger.core
oeg.tagger.core.time.tictag
Definition: Annotador.java:1
oeg.tagger.main.Main.parsear
static String parsear(String[] args)
Definition: Main.java:79
oeg.tagger.core.time.tictag.Annotador.annotateNIF
String annotateNIF(String input, String anchorDate, String reference, String lang)
oeg
oeg.tagger
oeg.tagger.core.time.tictag.Annotador
Definition: Annotador.java:9
oeg.tagger.core.time.tictag.Annotador.annotate
String annotate(String input, String anchorDate)
oeg.tagger.main.Main.init
static void init(String[] args)
Definition: Main.java:63
oeg.tagger.main.Main.initLogger
static void initLogger(boolean logs)
Definition: Main.java:233
oeg.tagger.main.Main.main
static void main(String[] args)
Definition: Main.java:46
oeg.tagger.main.Main.parse
static String parse(String filename)
Definition: Main.java:154
oeg.tagger.main.Main.parseText
static String parseText(String txt)
Definition: Main.java:170
oeg.tagger.main.Main
Definition: Main.java:36