Révision 4022
| TXM/trunk/bundles/org.txm.analec.rcp/src/org/txm/annotation/urs/URSCorpora.java (revision 4022) | ||
|---|---|---|
| 263 | 263 |
public String getName() {
|
| 264 | 264 |
return "URS"; //$NON-NLS-1$ |
| 265 | 265 |
} |
| 266 |
|
|
| 267 |
@Override |
|
| 268 |
public boolean isAutomatic() {
|
|
| 269 | 266 |
|
| 270 |
return false; |
|
| 271 |
} |
|
| 272 |
|
|
| 273 | 267 |
@Override |
| 274 |
public boolean processFile(File xmlFile, File binaryCorpusDirectory, HashMap<String, Object> parameters) {
|
|
| 275 |
|
|
| 276 |
return false; |
|
| 277 |
} |
|
| 278 |
|
|
| 279 |
@Override |
|
| 280 | 268 |
public String getDetails() {
|
| 281 | 269 |
|
| 282 | 270 |
return corpora.toString(); |
| TXM/trunk/bundles/org.txm.groovy.core/src/groovy/org/txm/scripts/importer/hyperbase/importer.groovy (revision 4022) | ||
|---|---|---|
| 114 | 114 |
SimpleTokenizerXml tokenizer = new SimpleTokenizerXml(pfile, tfile, TokenizerClasses.newTokenizerClasses(project.getPreferencesScope(), lang)); |
| 115 | 115 |
if (project.getAnnotate()) { // an annotation will be done, does the annotation engine needs another tokenizer ?
|
| 116 | 116 |
String engineName = project.getImportParameters().node("annotate").get("engine", "TreeTagger")
|
| 117 |
def engine = Toolbox.getEngineManager(EngineType.ANNOTATION).getEngine(engineName)
|
|
| 117 |
def engine = Toolbox.getEngineManager(EngineType.NLP).getEngine(engineName)
|
|
| 118 | 118 |
def stringTokenizer = engine.getStringTokenizer(lang) |
| 119 | 119 |
if (stringTokenizer != null) {
|
| 120 | 120 |
tokenizer.setStringTokenizer(stringTokenizer) |
| TXM/trunk/bundles/org.txm.groovy.core/src/groovy/org/txm/scripts/importer/hyperbase/hyperbaseLoader.groovy (revision 4022) | ||
|---|---|---|
| 89 | 89 |
boolean annotationSuccess = false; |
| 90 | 90 |
if (annotate) {
|
| 91 | 91 |
String engineName = project.getImportParameters().node("annotate").get("engine", "TreeTagger")
|
| 92 |
def engine = Toolbox.getEngineManager(EngineType.ANNOTATION).getEngine(engineName)
|
|
| 92 |
def engine = Toolbox.getEngineManager(EngineType.NLP).getEngine(engineName)
|
|
| 93 | 93 |
if (engine.processDirectory(txmDir, binDir, ["lang":model])) {
|
| 94 | 94 |
annotationSuccess = true; |
| 95 | 95 |
if (project.getCleanAfterBuild()) {
|
| TXM/trunk/bundles/org.txm.groovy.core/src/groovy/org/txm/scripts/importer/xtz/XTZImporter.groovy (revision 4022) | ||
|---|---|---|
| 434 | 434 |
SimpleTokenizerXml tokenizer = new SimpleTokenizerXml(infile, outfile, tc) |
| 435 | 435 |
if (module.getProject().getAnnotate()) { // an annotation will be done, does the annotation engine needs another tokenizer ?
|
| 436 | 436 |
String engineName = module.getProject().getImportParameters().node("annotate").get("engine", "TreeTagger")
|
| 437 |
def engine = Toolbox.getEngineManager(EngineType.ANNOTATION).getEngine(engineName)
|
|
| 437 |
def engine = Toolbox.getEngineManager(EngineType.NLP).getEngine(engineName)
|
|
| 438 | 438 |
def stringTokenizer = engine.getStringTokenizer(lang) |
| 439 | 439 |
if (stringTokenizer != null) {
|
| 440 | 440 |
tokenizer.setStringTokenizer(stringTokenizer) |
| TXM/trunk/bundles/org.txm.groovy.core/src/groovy/org/txm/scripts/importer/xtz/TTAnnotater.groovy (revision 4022) | ||
|---|---|---|
| 33 | 33 |
String lang = module.getProject().getLang(); |
| 34 | 34 |
|
| 35 | 35 |
String engineName = module.getProject().getImportParameters().node("annotate").get("engine", "TreeTagger")
|
| 36 |
def engine = Toolbox.getEngineManager(EngineType.ANNOTATION).getEngine(engineName)
|
|
| 36 |
def engine = Toolbox.getEngineManager(EngineType.NLP).getEngine(engineName)
|
|
| 37 | 37 |
if (module.isMultiThread()) {
|
| 38 | 38 |
def hash = [:] |
| 39 | 39 |
for (File txmFile : inputDirectory.listFiles()) {
|
| TXM/trunk/bundles/org.txm.groovy.core/src/groovy/org/txm/scripts/importer/hyperprince/hyperprinceLoader.groovy (revision 4022) | ||
|---|---|---|
| 81 | 81 |
println "-- ANNOTATE - Running NLP tools" |
| 82 | 82 |
if (annotate) {
|
| 83 | 83 |
String engineName = project.getImportParameters().node("annotate").get("engine", "TreeTagger")
|
| 84 |
def engine = Toolbox.getEngineManager(EngineType.ANNOTATION).getEngine(engineName)
|
|
| 84 |
def engine = Toolbox.getEngineManager(EngineType.NLP).getEngine(engineName)
|
|
| 85 | 85 |
if (engine.processDirectory(txmDir, binDir, ["lang":model])) {
|
| 86 | 86 |
annotationSuccess = true; |
| 87 | 87 |
} |
| TXM/trunk/bundles/org.txm.groovy.core/src/groovy/org/txm/scripts/importer/frantext/frantextLoader.groovy (revision 4022) | ||
|---|---|---|
| 157 | 157 |
if (annotate) {
|
| 158 | 158 |
println "-- ANNOTATE - Running NLP tools - $model model" |
| 159 | 159 |
String engineName = project.getImportParameters().node("annotate").get("engine", "TreeTagger")
|
| 160 |
def engine = Toolbox.getEngineManager(EngineType.ANNOTATION).getEngine(engineName)
|
|
| 160 |
def engine = Toolbox.getEngineManager(EngineType.NLP).getEngine(engineName)
|
|
| 161 | 161 |
if (engine.processDirectory(txmDir, binDir, ["lang":model])) {
|
| 162 | 162 |
annotate_status = true; |
| 163 | 163 |
if (project.getCleanAfterBuild()) {
|
| TXM/trunk/bundles/org.txm.groovy.core/src/groovy/org/txm/scripts/importer/xml/xmlLoader.groovy (revision 4022) | ||
|---|---|---|
| 235 | 235 |
if (annotate) {
|
| 236 | 236 |
println "-- ANNOTATE - Running NLP tools" |
| 237 | 237 |
String engineName = project.getImportParameters().node("annotate").get("engine", "TreeTagger")
|
| 238 |
def engine = Toolbox.getEngineManager(EngineType.ANNOTATION).getEngine(engineName)
|
|
| 238 |
def engine = Toolbox.getEngineManager(EngineType.NLP).getEngine(engineName)
|
|
| 239 | 239 |
if (engine.processDirectory(txmDir, binDir, ["lang":model])) {
|
| 240 | 240 |
annotationSuccess = true |
| 241 | 241 |
if (project.getCleanAfterBuild()) {
|
| TXM/trunk/bundles/org.txm.groovy.core/src/groovy/org/txm/scripts/importer/bfm/bfmLoader.groovy (revision 4022) | ||
|---|---|---|
| 137 | 137 |
if (annotate) {
|
| 138 | 138 |
println "-- ANNOTATE - Running NLP tools - $model model" |
| 139 | 139 |
String engineName = project.getImportParameters().node("annotate").get("engine", "TreeTagger")
|
| 140 |
def engine = Toolbox.getEngineManager(EngineType.ANNOTATION).getEngine(engineName)
|
|
| 140 |
def engine = Toolbox.getEngineManager(EngineType.NLP).getEngine(engineName)
|
|
| 141 | 141 |
if (engine.processDirectory(txmDir, binDir, ["lang":model])) {
|
| 142 | 142 |
annotate_status = true; |
| 143 | 143 |
|
| TXM/trunk/bundles/org.txm.groovy.core/src/groovy/org/txm/scripts/importer/doc/docLoader.groovy (revision 4022) | ||
|---|---|---|
| 256 | 256 |
if (annotate) {
|
| 257 | 257 |
println "-- ANNOTATE - Running NLP tools" |
| 258 | 258 |
String engineName = project.getImportParameters().node("annotate").get("engine", "TreeTagger")
|
| 259 |
def engine = Toolbox.getEngineManager(EngineType.ANNOTATION).getEngine(engineName)
|
|
| 259 |
def engine = Toolbox.getEngineManager(EngineType.NLP).getEngine(engineName)
|
|
| 260 | 260 |
if (engine.processDirectory(txmDir, binDir, ["lang":model])) {
|
| 261 | 261 |
annotationSuccess = true; |
| 262 | 262 |
if (project.getCleanAfterBuild()) {
|
| TXM/trunk/bundles/org.txm.groovy.core/src/groovy/org/txm/scripts/importer/tmx/tmxLoader.groovy (revision 4022) | ||
|---|---|---|
| 88 | 88 |
if (annotate) {
|
| 89 | 89 |
println "-- ANNOTATE - Running NLP tools" |
| 90 | 90 |
String engineName = project.getImportParameters().node("annotate").get("engine", "TreeTagger")
|
| 91 |
def engine = Toolbox.getEngineManager(EngineType.ANNOTATION).getEngine(engineName)
|
|
| 91 |
def engine = Toolbox.getEngineManager(EngineType.NLP).getEngine(engineName)
|
|
| 92 | 92 |
def mapForTreeTagger = [:] |
| 93 | 93 |
for (def k : textLangs.keySet()) mapForTreeTagger[k] = textLangs[k].toLowerCase(); |
| 94 | 94 |
println "TreeTagger models to use per text: $mapForTreeTagger" |
| TXM/trunk/bundles/org.txm.groovy.core/src/groovy/org/txm/scripts/importer/factiva/factivaLoader.groovy (revision 4022) | ||
|---|---|---|
| 217 | 217 |
if (annotate) {
|
| 218 | 218 |
println "-- ANNOTATE - Running NLP tools" |
| 219 | 219 |
String engineName = project.getImportParameters().node("annotate").get("engine", "TreeTagger")
|
| 220 |
def engine = Toolbox.getEngineManager(EngineType.ANNOTATION).getEngine(engineName)
|
|
| 220 |
def engine = Toolbox.getEngineManager(EngineType.NLP).getEngine(engineName)
|
|
| 221 | 221 |
if (engine.processDirectory(txmDir, binDir, ["lang":model])) {
|
| 222 | 222 |
annotationSuccess = true; |
| 223 | 223 |
if (project.getCleanAfterBuild()) {
|
| TXM/trunk/bundles/org.txm.groovy.core/src/groovy/org/txm/scripts/importer/factiva/factivamailLoader.groovy (revision 4022) | ||
|---|---|---|
| 105 | 105 |
if (annotate) {
|
| 106 | 106 |
println "-- ANNOTATE - Running NLP tools" |
| 107 | 107 |
String engineName = project.getImportParameters().node("annotate").get("engine", "TreeTagger")
|
| 108 |
def engine = Toolbox.getEngineManager(EngineType.ANNOTATION).getEngine(engineName)
|
|
| 108 |
def engine = Toolbox.getEngineManager(EngineType.NLP).getEngine(engineName)
|
|
| 109 | 109 |
if (engine.processDirectory(txmDir, binDir, ["lang":model])) {
|
| 110 | 110 |
annotationSuccess = true; |
| 111 | 111 |
} |
| TXM/trunk/bundles/org.txm.groovy.core/src/groovy/org/txm/scripts/importer/transcriber/transcriberLoader.groovy (revision 4022) | ||
|---|---|---|
| 204 | 204 |
if (annotate) {
|
| 205 | 205 |
println "-- ANNOTATE - Running NLP tools" |
| 206 | 206 |
String engineName = project.getImportParameters().node("annotate").get("engine", "TreeTagger")
|
| 207 |
def engine = Toolbox.getEngineManager(EngineType.ANNOTATION).getEngine(engineName)
|
|
| 207 |
def engine = Toolbox.getEngineManager(EngineType.NLP).getEngine(engineName)
|
|
| 208 | 208 |
if (engine.processDirectory(txmDir, binDir, ["lang":model])) {
|
| 209 | 209 |
annotationSuccess = true; |
| 210 | 210 |
|
| TXM/trunk/bundles/org.txm.groovy.core/src/groovy/org/txm/scripts/importer/txt/txtLoader.groovy (revision 4022) | ||
|---|---|---|
| 132 | 132 |
if (annotate) {
|
| 133 | 133 |
println "-- ANNOTATE - Running NLP tools" |
| 134 | 134 |
String engineName = project.getImportParameters().node("annotate").get("engine", "TreeTagger")
|
| 135 |
def engine = Toolbox.getEngineManager(EngineType.ANNOTATION).getEngine(engineName)
|
|
| 135 |
def engine = Toolbox.getEngineManager(EngineType.NLP).getEngine(engineName)
|
|
| 136 | 136 |
if (engine.processDirectory(txmDir, binDir, ["lang":model])) {
|
| 137 | 137 |
annotationSuccess = true |
| 138 | 138 |
if (project.getCleanAfterBuild()) {
|
| TXM/trunk/bundles/org.txm.groovy.core/src/groovy/org/txm/scripts/importer/alceste/alcesteLoader.groovy (revision 4022) | ||
|---|---|---|
| 91 | 91 |
if (annotate) {
|
| 92 | 92 |
println "-- ANNOTATE - Running NLP tools" |
| 93 | 93 |
String engineName = project.getImportParameters().node("annotate").get("engine", "TreeTagger")
|
| 94 |
def engine = Toolbox.getEngineManager(EngineType.ANNOTATION).getEngine(engineName)
|
|
| 94 |
def engine = Toolbox.getEngineManager(EngineType.NLP).getEngine(engineName)
|
|
| 95 | 95 |
if (engine.processDirectory(txmDir, binDir, ["lang":model])) {
|
| 96 | 96 |
annotationSuccess = true; |
| 97 | 97 |
} |
| TXM/trunk/bundles/org.txm.groovy.core/src/groovy/org/txm/scripts/importer/alceste/importer.groovy (revision 4022) | ||
|---|---|---|
| 114 | 114 |
def tokenizer = new SimpleTokenizerXml(f, resultfile, TokenizerClasses.newTokenizerClasses(project.getPreferencesScope(), lang)); |
| 115 | 115 |
if (project.getAnnotate()) { // an annotation will be done, does the annotation engine needs another tokenizer ?
|
| 116 | 116 |
String engineName = project.getImportParameters().node("annotate").get("engine", "TreeTagger")
|
| 117 |
def engine = Toolbox.getEngineManager(EngineType.ANNOTATION).getEngine(engineName)
|
|
| 117 |
def engine = Toolbox.getEngineManager(EngineType.NLP).getEngine(engineName)
|
|
| 118 | 118 |
def stringTokenizer = engine.getStringTokenizer(lang) |
| 119 | 119 |
if (stringTokenizer != null) {
|
| 120 | 120 |
tokenizer.setStringTokenizer(stringTokenizer) |
| TXM/trunk/bundles/org.txm.groovy.core/src/java/org/txm/groovy/core/GroovyScriptedImportEngine.java (revision 4022) | ||
|---|---|---|
| 8 | 8 |
import org.eclipse.core.runtime.Status; |
| 9 | 9 |
import org.eclipse.osgi.util.NLS; |
| 10 | 10 |
import org.txm.Toolbox; |
| 11 |
import org.txm.annotation.core.AnnotationEngine; |
|
| 12 | 11 |
import org.txm.core.engines.Engine; |
| 13 | 12 |
import org.txm.core.engines.EngineType; |
| 14 | 13 |
import org.txm.core.engines.ScriptedImportEngine; |
| 15 | 14 |
import org.txm.core.messages.TXMCoreMessages; |
| 16 | 15 |
import org.txm.core.results.TXMResult; |
| 17 | 16 |
import org.txm.groovy.core.messages.GroovyMessages; |
| 17 |
import org.txm.nlp.core.NLPEngine; |
|
| 18 | 18 |
import org.txm.objects.Project; |
| 19 | 19 |
import org.txm.objects.Workspace; |
| 20 | 20 |
import org.txm.tokenizer.TokenizerClasses; |
| ... | ... | |
| 45 | 45 |
Workspace w = Toolbox.workspace; |
| 46 | 46 |
boolean annotate = project.getAnnotate(); |
| 47 | 47 |
if (annotate && !project.getDoUpdate()) { // test TreeTagger only if not updating the corpus
|
| 48 |
Engine e = Toolbox.getEngineManager(EngineType.ANNOTATION).getEngine("TreeTagger");
|
|
| 48 |
Engine e = Toolbox.getEngineManager(EngineType.NLP).getEngine("TreeTagger");
|
|
| 49 | 49 |
if (e == null) {
|
| 50 | 50 |
Log.warning("Error: no TreeTagger annotation engine found to annotate the corpus. Aborting");
|
| 51 | 51 |
return Status.CANCEL_STATUS; |
| 52 | 52 |
} |
| 53 |
AnnotationEngine engine = (AnnotationEngine) e;
|
|
| 53 |
NLPEngine engine = (NLPEngine) e;
|
|
| 54 | 54 |
if (!engine.isRunning()) {
|
| 55 | 55 |
Log.warning(GroovyMessages.errorTreeTaggerAnnotationEngineIsNotReady); |
| 56 | 56 |
return Status.CANCEL_STATUS; |
| TXM/trunk/bundles/org.txm.groovy.core/META-INF/MANIFEST.MF (revision 4022) | ||
|---|---|---|
| 10 | 10 |
org.txm.searchengine.cqp.core;visibility:=reexport, |
| 11 | 11 |
org.txm.tokenizer.core;visibility:=reexport, |
| 12 | 12 |
org.eclipse.osgi;visibility:=reexport, |
| 13 |
org.txm.utils.core;bundle-version="1.0.0" |
|
| 13 |
org.txm.utils.core;bundle-version="1.0.0", |
|
| 14 |
org.txm.nlp.core |
|
| 14 | 15 |
Bundle-ActivationPolicy: lazy |
| 15 | 16 |
Bundle-ManifestVersion: 2 |
| 16 | 17 |
Bundle-RequiredExecutionEnvironment: JavaSE-16 |
| TXM/trunk/bundles/org.txm.treetagger.core/plugin.xml (revision 4022) | ||
|---|---|---|
| 8 | 8 |
</initializer> |
| 9 | 9 |
</extension> |
| 10 | 10 |
<extension |
| 11 |
point="org.txm.annotation.core.AnnotationEngine">
|
|
| 11 |
point="org.txm.nlp.core.NLPEngine">
|
|
| 12 | 12 |
<AnnotationEngine |
| 13 | 13 |
class="org.txm.treetagger.core.TreeTaggerEngine" |
| 14 | 14 |
description="Call TreeTagger treetagger train processus to annotate corpus"> |
| TXM/trunk/bundles/org.txm.treetagger.core/META-INF/MANIFEST.MF (revision 4022) | ||
|---|---|---|
| 5 | 5 |
Bundle-SymbolicName: org.txm.treetagger.core;singleton:=true |
| 6 | 6 |
Bundle-Version: 1.0.0.qualifier |
| 7 | 7 |
Bundle-Name: TreeTagger Core |
| 8 |
Require-Bundle: org.txm.annotation.core;visibility:=reexport |
|
| 8 |
Require-Bundle: org.txm.nlp.core;bundle-version="1.0.0", |
|
| 9 |
org.txm.core |
|
| 9 | 10 |
Bundle-ActivationPolicy: lazy |
| 10 | 11 |
Bundle-ManifestVersion: 2 |
| 11 | 12 |
Bundle-RequiredExecutionEnvironment: JavaSE-16 |
| TXM/trunk/bundles/org.txm.treetagger.core/src/org/txm/treetagger/core/TreeTaggerEngine.java (revision 4022) | ||
|---|---|---|
| 6 | 6 |
|
| 7 | 7 |
import org.eclipse.core.runtime.IProgressMonitor; |
| 8 | 8 |
import org.eclipse.osgi.util.NLS; |
| 9 |
import org.txm.annotation.core.AnnotationEngine; |
|
| 10 | 9 |
import org.txm.core.results.TXMResult; |
| 11 | 10 |
import org.txm.importer.xmltxm.Annotate; |
| 12 | 11 |
import org.txm.importer.xmltxm.AnnotateCQP; |
| 13 |
import org.txm.objects.CorpusBuild;
|
|
| 12 |
import org.txm.nlp.core.NLPEngine;
|
|
| 14 | 13 |
import org.txm.treetagger.core.preferences.TreeTaggerPreferences; |
| 15 | 14 |
import org.txm.utils.FileUtils; |
| 16 | 15 |
import org.txm.utils.logger.Log; |
| 17 | 16 |
import org.txm.utils.treetagger.TreeTagger; |
| 18 | 17 |
|
| 19 |
public class TreeTaggerEngine extends AnnotationEngine {
|
|
| 18 |
|
|
| 19 |
public class TreeTaggerEngine extends NLPEngine {
|
|
| 20 | 20 |
|
| 21 | 21 |
private File ttModelsDirectory; |
| 22 | 22 |
|
| ... | ... | |
| 186 | 186 |
} |
| 187 | 187 |
|
| 188 | 188 |
@Override |
| 189 |
public boolean isAutomatic() {
|
|
| 190 |
|
|
| 191 |
return true; |
|
| 192 |
} |
|
| 193 |
|
|
| 194 |
@Override |
|
| 195 | 189 |
public void notify(TXMResult r, String state) {
|
| 196 | 190 |
|
| 197 | 191 |
} |
| ... | ... | |
| 202 | 196 |
return "TreeTagger files: binaries=" + ttBinaryDirectory + " models=" + ttModelsDirectory + " current instances=" + instances.toString(); |
| 203 | 197 |
} |
| 204 | 198 |
|
| 205 |
/** |
|
| 206 |
* Currently returning false, but could return true if new usages come up |
|
| 207 |
*/ |
|
| 208 |
@Override |
|
| 209 |
public boolean hasAnnotationsToSave(CorpusBuild corpus) {
|
|
| 210 |
|
|
| 211 |
return false; |
|
| 212 |
} |
|
| 213 | 199 |
} |
| TXM/trunk/bundles/org.txm.rcp/src/main/java/org/txm/rcp/editors/imports/sections/LangSection.java (revision 4022) | ||
|---|---|---|
| 19 | 19 |
import org.eclipse.ui.forms.widgets.TableWrapData; |
| 20 | 20 |
import org.eclipse.ui.forms.widgets.TableWrapLayout; |
| 21 | 21 |
import org.txm.Toolbox; |
| 22 |
import org.txm.annotation.core.AnnotationEngine; |
|
| 23 | 22 |
import org.txm.core.engines.Engine; |
| 24 | 23 |
import org.txm.core.engines.EngineType; |
| 25 | 24 |
import org.txm.core.engines.EnginesManager; |
| 25 |
import org.txm.nlp.core.NLPEngine; |
|
| 26 | 26 |
import org.txm.objects.Project; |
| 27 | 27 |
import org.txm.rcp.editors.imports.ImportFormEditor; |
| 28 | 28 |
import org.txm.rcp.messages.TXMUIMessages; |
| ... | ... | |
| 118 | 118 |
btnSelectAnnotate = toolkit.createButton(sectionClient, TXMUIMessages.lemmatizeTheCorpus, SWT.CHECK); |
| 119 | 119 |
toolkit.createLabel(sectionClient, ""); //$NON-NLS-1$ |
| 120 | 120 |
|
| 121 |
EnginesManager<? extends Engine> ema = Toolbox.getEngineManager(EngineType.ANNOTATION);
|
|
| 121 |
EnginesManager<? extends Engine> ema = Toolbox.getEngineManager(EngineType.NLP);
|
|
| 122 | 122 |
ArrayList<String> engines = new ArrayList<>(); |
| 123 | 123 |
for (String engine : ema.getEngines().keySet()) {
|
| 124 |
AnnotationEngine e = (AnnotationEngine) ema.getEngine(engine); |
|
| 125 |
if (e.isAutomatic()) {
|
|
| 126 |
engines.add(engine); |
|
| 127 |
} |
|
| 124 |
NLPEngine e = (NLPEngine) ema.getEngine(engine); |
|
| 125 |
engines.add(engine); |
|
| 128 | 126 |
} |
| 129 | 127 |
if (engines.size() > 1) {
|
| 130 | 128 |
|
| TXM/trunk/bundles/org.txm.rcp/META-INF/MANIFEST.MF (revision 4022) | ||
|---|---|---|
| 160 | 160 |
org.eclipse.e4.ui.widgets;bundle-version="1.3.0";visibility:=reexport, |
| 161 | 161 |
org.eclipse.e4.ui.workbench.addons.swt;bundle-version="1.4.400";visibility:=reexport, |
| 162 | 162 |
org.eclipse.e4.ui.workbench.swt;bundle-version="0.16.600";visibility:=reexport, |
| 163 |
org.eclipse.debug.core;bundle-version="3.20.0";visibility:=reexport |
|
| 163 |
org.eclipse.debug.core;bundle-version="3.20.0";visibility:=reexport, |
|
| 164 |
org.txm.nlp.core;visibility:=reexport |
|
| 164 | 165 |
Bundle-ActivationPolicy: lazy |
| 165 | 166 |
Bundle-ManifestVersion: 2 |
| 166 | 167 |
Bundle-Activator: org.txm.rcp.Activator |
| TXM/trunk/bundles/org.txm.udpipe.core/META-INF/MANIFEST.MF (revision 4022) | ||
|---|---|---|
| 4 | 4 |
Bundle-SymbolicName: org.txm.udpipe.core;singleton:=true |
| 5 | 5 |
Bundle-Version: 1.0.0.qualifier |
| 6 | 6 |
Require-Bundle: org.txm.libs.udpipe;bundle-version="1.0.0";visibility:=reexport, |
| 7 |
org.txm.annotation.core;bundle-version="1.0.0";visibility:=reexport
|
|
| 7 |
org.txm.nlp.core;bundle-version="1.0.0"
|
|
| 8 | 8 |
BBundle-RequiredExecutionEnvironment: JavaSE-10 |
| 9 | 9 |
Automatic-Module-Name: org.txm.udpipe.core |
| 10 | 10 |
Bundle-ActivationPolicy: lazy |
| TXM/trunk/bundles/org.txm.udpipe.core/src/org/txm/udpipe/core/UDPipeEngine.java (revision 4022) | ||
|---|---|---|
| 11 | 11 |
import org.eclipse.core.runtime.IProgressMonitor; |
| 12 | 12 |
import org.eclipse.osgi.util.NLS; |
| 13 | 13 |
import org.osgi.framework.Bundle; |
| 14 |
import org.txm.annotation.core.AnnotationEngine; |
|
| 15 | 14 |
import org.txm.core.results.TXMResult; |
| 15 |
import org.txm.nlp.core.NLPEngine; |
|
| 16 | 16 |
import org.txm.objects.CorpusBuild; |
| 17 | 17 |
import org.txm.tokenizer.StringTokenizer; |
| 18 | 18 |
import org.txm.utils.BundleUtils; |
| ... | ... | |
| 30 | 30 |
import cz.cuni.mff.ufal.udpipe.udpipe_java; |
| 31 | 31 |
|
| 32 | 32 |
|
| 33 |
public class UDPipeEngine extends AnnotationEngine {
|
|
| 33 |
public class UDPipeEngine extends NLPEngine {
|
|
| 34 | 34 |
|
| 35 | 35 |
public static final String XMLIDMISC = "XmlID="; |
| 36 | 36 |
|
| ... | ... | |
| 103 | 103 |
return "UDPipe"; |
| 104 | 104 |
} |
| 105 | 105 |
|
| 106 |
@Override |
|
| 107 |
public boolean isAutomatic() {
|
|
| 108 |
return true; |
|
| 109 |
} |
|
| 110 |
|
|
| 111 |
@Override |
|
| 112 |
public boolean hasAnnotationsToSave(CorpusBuild corpus) {
|
|
| 113 |
return false; |
|
| 114 |
} |
|
| 115 |
|
|
| 116 | 106 |
/** |
| 117 | 107 |
* the UD property suffixes, will be used to create the CQP properties like propertiesPrefix + suffix |
| 118 | 108 |
*/ |
| TXM/trunk/bundles/org.txm.annotation.core/src/org/txm/annotation/core/AnnotationEngine.java (revision 4022) | ||
|---|---|---|
| 1 | 1 |
package org.txm.annotation.core; |
| 2 | 2 |
|
| 3 |
import java.io.File; |
|
| 4 |
import java.io.FileFilter; |
|
| 5 |
import java.util.HashMap; |
|
| 6 |
import java.util.List; |
|
| 7 |
|
|
| 8 |
import org.eclipse.osgi.util.NLS; |
|
| 9 | 3 |
import org.txm.core.engines.Engine; |
| 10 | 4 |
import org.txm.core.results.TXMResult; |
| 11 | 5 |
import org.txm.objects.CorpusBuild; |
| 12 |
import org.txm.tokenizer.SimpleStringTokenizer; |
|
| 13 |
import org.txm.tokenizer.StringTokenizer; |
|
| 14 |
import org.txm.utils.ConsoleProgressBar; |
|
| 15 |
import org.txm.utils.DeleteDir; |
|
| 16 |
import org.txm.utils.logger.Log; |
|
| 17 | 6 |
|
| 18 | 7 |
public abstract class AnnotationEngine implements Engine {
|
| 19 | 8 |
|
| ... | ... | |
| 24 | 13 |
|
| 25 | 14 |
/** |
| 26 | 15 |
* |
| 27 |
* @return true if the Annotation Engine can be used in the "importer" step of import modules |
|
| 28 |
*/ |
|
| 29 |
public abstract boolean isAutomatic(); |
|
| 30 |
|
|
| 31 |
/** |
|
| 32 |
* |
|
| 33 | 16 |
* @return true if the Annotation Engine has some annotations not saved (that will be lost if not saved) |
| 34 | 17 |
*/ |
| 35 | 18 |
public abstract boolean hasAnnotationsToSave(CorpusBuild corpus); |
| 36 | 19 |
|
| 37 |
/** |
|
| 38 |
* |
|
| 39 |
* @return a StringTokenizer, override this method if the engine needs a speciq tokenization |
|
| 40 |
* @throws Exception |
|
| 41 |
*/ |
|
| 42 |
public StringTokenizer getStringTokenizer(String lang) throws Exception {
|
|
| 43 |
return null; |
|
| 44 |
} |
|
| 45 |
|
|
| 46 |
/** |
|
| 47 |
* Automatically annotate a XML-TXM file |
|
| 48 |
* |
|
| 49 |
* @param xmlFile to annotate |
|
| 50 |
* @param binaryCorpusDirectory |
|
| 51 |
* @param parameters |
|
| 52 |
* @return |
|
| 53 |
*/ |
|
| 54 |
public abstract boolean processFile(File xmlFile, File binaryCorpusDirectory, HashMap<String, Object> parameters); |
|
| 55 |
|
|
| 56 |
/** |
|
| 57 |
* |
|
| 58 |
* @param xmlFilesDirectory contains the *.xml files to process |
|
| 59 |
* @param binaryCorpusDirectory the output directory |
|
| 60 |
* @param parameters ["lang": model_file_name_without_extension] |
|
| 61 |
* @return |
|
| 62 |
*/ |
|
| 63 |
public boolean processDirectory(File xmlFilesDirectory, File binaryCorpusDirectory, HashMap<String, Object> parameters) {
|
|
| 64 |
File[] files = xmlFilesDirectory.listFiles(new FileFilter() {
|
|
| 65 |
|
|
| 66 |
@Override |
|
| 67 |
public boolean accept(File pathname) {
|
|
| 68 |
return pathname.isFile() && !pathname.isHidden() && !pathname.getName().startsWith(".") && pathname.getName().endsWith(".xml"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
| 69 |
} |
|
| 70 |
}); |
|
| 71 |
if (files == null || files.length == 0) {
|
|
| 72 |
Log.warning(NLS.bind(Messages.ErrorNoSuitableFileToProcessInP0, xmlFilesDirectory)); |
|
| 73 |
return false; |
|
| 74 |
} |
|
| 75 |
boolean ret = true; |
|
| 76 |
ConsoleProgressBar cpb = new ConsoleProgressBar(files.length); |
|
| 77 |
|
|
| 78 |
File annotDir = new File(binaryCorpusDirectory, "annotations"); //$NON-NLS-1$ |
|
| 79 |
DeleteDir.deleteDirectory(annotDir); |
|
| 80 |
annotDir.mkdir(); |
|
| 81 |
File ptreetaggerDir = new File(binaryCorpusDirectory, "ptreetagger"); //$NON-NLS-1$ |
|
| 82 |
DeleteDir.deleteDirectory(ptreetaggerDir); |
|
| 83 |
ptreetaggerDir.mkdir(); |
|
| 84 |
File treetaggerDir = new File(binaryCorpusDirectory, "treetagger"); //$NON-NLS-1$ |
|
| 85 |
DeleteDir.deleteDirectory(treetaggerDir); |
|
| 86 |
treetaggerDir.mkdir(); |
|
| 87 |
|
|
| 88 |
for (File xmlFile : files) {
|
|
| 89 |
ret = processFile(xmlFile, binaryCorpusDirectory, parameters) && ret; |
|
| 90 |
|
|
| 91 |
cpb.tick(); |
|
| 92 |
} |
|
| 93 |
cpb.done(); |
|
| 94 |
return ret; |
|
| 95 |
} |
|
| 96 |
|
|
| 97 | 20 |
public String hasAdditionalDetailsForResult(TXMResult result) {
|
| 98 | 21 |
return null; |
| 99 | 22 |
} |
| TXM/trunk/bundles/org.txm.annotation.kr.core/src/org/txm/annotation/kr/core/KRAnnotationEngine.java (revision 4022) | ||
|---|---|---|
| 414 | 414 |
ams.clear(); |
| 415 | 415 |
return success; |
| 416 | 416 |
} |
| 417 |
|
|
| 418 |
/** |
|
| 419 |
* The KR Annotation engine is an assisted oriented annotation engine |
|
| 420 |
* |
|
| 421 |
* @return false |
|
| 422 |
*/ |
|
| 417 |
|
|
| 423 | 418 |
@Override |
| 424 |
public boolean isAutomatic() {
|
|
| 425 |
return false; |
|
| 426 |
} |
|
| 427 |
|
|
| 428 |
@Override |
|
| 429 |
public boolean processFile(File xmlFile, File binaryCorpusDirectory, HashMap<String, Object> parameters) {
|
|
| 430 |
return false; |
|
| 431 |
} |
|
| 432 |
|
|
| 433 |
@Override |
|
| 434 | 419 |
public void notify(TXMResult r, String state) {
|
| 435 | 420 |
|
| 436 | 421 |
if (r instanceof MainCorpus && "before_clean".equals(state)) { //$NON-NLS-1$
|
| TXM/trunk/bundles/org.txm.core/src/java/org/txm/Toolbox.java (revision 4022) | ||
|---|---|---|
| 136 | 136 |
Log.fine("Registering " + enginesManager.getEnginesDescription() + " engines manager..."); //$NON-NLS-1$ //$NON-NLS-2$
|
| 137 | 137 |
addEngineManager(enginesManager); |
| 138 | 138 |
if (enginesManager.fetchEngines()) {
|
| 139 |
Log.fine(NLS.bind("{0} {1} engine(s) loaded.", enginesManager.size(), EngineType.TAL)); //$NON-NLS-1$
|
|
| 139 |
Log.fine(NLS.bind("{0} {1} engine(s) loaded.", enginesManager.size(), EngineType.NLP)); //$NON-NLS-1$
|
|
| 140 | 140 |
} |
| 141 | 141 |
else {
|
| 142 | 142 |
Log.fine("No engine found for " + enginesManager + ", installation failed."); //$NON-NLS-1$ //$NON-NLS-2$
|
| TXM/trunk/bundles/org.txm.core/src/java/org/txm/core/engines/EngineType.java (revision 4022) | ||
|---|---|---|
| 16 | 16 |
CHARTS("charts"),
|
| 17 | 17 |
SCRIPT("scripts"),
|
| 18 | 18 |
ANNOTATION("annotations"),
|
| 19 |
TAL("tal"),
|
|
| 19 |
NLP("nlp"),
|
|
| 20 | 20 |
OTHER("others engines"), IMPORT("import");
|
| 21 | 21 |
|
| 22 | 22 |
/** |
| TXM/trunk/features/org.txm.rcp.feature/feature.xml (revision 4022) | ||
|---|---|---|
| 155 | 155 |
<import plugin="org.eclipse.e4.ui.workbench.addons.swt" version="1.4.400" match="greaterOrEqual"/> |
| 156 | 156 |
<import plugin="org.eclipse.e4.ui.workbench.swt" version="0.16.600" match="greaterOrEqual"/> |
| 157 | 157 |
<import plugin="org.eclipse.debug.core" version="3.20.0" match="greaterOrEqual"/> |
| 158 |
<import plugin="org.txm.rcp" version="0.8.3" match="greaterOrEqual"/> |
|
| 158 | 159 |
<import plugin="org.txm.core" version="0.8.3" match="greaterOrEqual"/> |
| 159 |
<import plugin="org.txm.rcp" version="0.8.3" match="greaterOrEqual"/>
|
|
| 160 |
<import plugin="org.txm.nlp.core"/>
|
|
| 160 | 161 |
</requires> |
| 161 | 162 |
|
| 162 | 163 |
<plugin |
Formats disponibles : Unified diff