apertium-forms-server/pair.py

   1 #!/usr/bin/python2.5
   2 # coding=utf-8
   3 # -*- encoding: utf-8 -*-
   4
   5 import sys, string, codecs, xml, re, Ft;
   6 from Ft.Xml.Domlette import NonvalidatingReader;
   7 from Ft.Xml.Domlette import Print, PrettyPrint;
   8 from Ft.Xml.XPath import Evaluate;
   9
  10 sys.stdout = codecs.getwriter('utf-8')(sys.stdout);
  11 sys.stderr = codecs.getwriter('utf-8')(sys.stderr);
  12
  13 class Tag: #{
  14         name = None;
  15
  16         def __init__(self, _name, _list): #{
  17                 self.name = _name;
  18                 self.list = _list;
  19
  20                 for s in self.list: #{
  21                         print '% ' + s;
  22                 #}
  23         #}
  24
  25         def get_list(self): #{
  26                 return self.list;
  27         #}
  28 #}
  29
  30 class Paradigm: #{
  31         name = None;
  32
  33         def __init__(self, _name): #{
  34                 self.name = _name;
  35                 self.stems = [];
  36         #}
  37
  38         def add_gloss(self, _gloss): #{
  39                 self.gloss = _gloss;
  40         #}
  41
  42         def add_stem(self, _stem, _symlist): #{
  43                 #print >> sys.stderr, 'add_stem(' + _stem + ', ' + _symlist + ')';
  44                 self.stems.append((_stem, _symlist));
  45         #}
  46
  47         def get_stems(self): #{
  48                 #print >> sys.stderr, self.stems;
  49                 return self.stems;
  50         #}
  51 #}
  52
  53 class Dictionary: #{
  54         display = None;
  55         language = None;
  56         file = None;
  57         side = None;
  58
  59         def __init__(self, _side, _language, _file, _doc, _tags): #{
  60                 self.display = {};
  61                 self.language = _language;
  62                 self.file = _file;
  63                 self.doc = _doc;
  64                 self.side = _side;
  65                 self.paradigms = {};
  66                 self.glosses = {};
  67                 self.tags = _tags;
  68         #}
  69
  70         def get_tags(self): #{
  71                 return self.tags;
  72         #}
  73
  74         def get_tag_by_tag(self, _tag): #{
  75                 return self.tags[_tag];
  76         #}
  77
  78         def get_paradigms(self): #{
  79                 return self.paradigms;
  80         #}
  81
  82         def get_glosses(self): #{
  83                 return self.glosses;
  84         #}
  85
  86         def get_paradigms_by_tag(self, _tag): #{
  87                 return self.paradigms[_tag];
  88         #}
  89
  90         def get_paradigm(self, _name, _tag): #{
  91                 paradigm = None;
  92
  93                 paradigm = self.paradigms[_tag].get(_name);
  94
  95                 if paradigm == None: #{
  96                         print >> sys.stderr, 'We didn`t find the paradigm in the hash';
  97                         for _paradigm in self.paradigms[_tag].values(): #{
  98                                 if _paradigm.name == _name: #{
  99                                         paradigm = _paradigm;
 100                                 #}
 101                         #}
 102
 103                         if paradigm == None: #{
 104                                 return None;
 105                         #}
 106                 #}
 107
 108                 # paradigm stems already loaded
 109                 if len(paradigm.stems) > 0: #{
 110                         return paradigm;
 111                 #}
 112
 113                 print >> sys.stderr, 'get_paradigm ' , paradigm.name , _name;
 114                 path = ".//pardef[@n='" + _name + "']";
 115                 res = self.doc.xpath(path)[0];
 116
 117                 for entrada in Ft.Xml.XPath.Evaluate('.//e', contextNode=res): #{
 118                         symlist = '';
 119
 120                         pair = Ft.Xml.XPath.Evaluate('.//p', contextNode=entrada)[0];
 121                         left = Ft.Xml.XPath.Evaluate('.//l', contextNode=pair)[0].firstChild;
 122
 123                         if type(left) != type(None): #{
 124                                 left = Ft.Xml.XPath.Evaluate('.//l', contextNode=pair)[0].firstChild.nodeValue;
 125                         #}
 126
 127                         if type(left) == type(None): #{
 128                                 left = '';
 129                         #}
 130
 131                         right = Ft.Xml.XPath.Evaluate('.//r', contextNode=pair)[0];
 132
 133                         for symbol in Ft.Xml.XPath.Evaluate('.//s', contextNode=right): #{
 134                                 if symlist != '': #{
 135                                         symlist = symlist + '.' + symbol.getAttributeNS(None, 'n');
 136                                 #}
 137                                 if symlist == '': #{
 138                                         symlist = symlist + symbol.getAttributeNS(None, 'n');
 139                                 #}
 140                         #}
 141
 142                         print >> sys.stderr, 'get_paradigm ' , left , symlist;
 143                         paradigm.add_stem(left, symlist);
 144                 #}
 145
 146                 return paradigm;
 147         #}
 148
 149         def set_paradigms_by_tag(self, _tag): #{
 150                 print self.side + ' set_paradigms_by_tag(' + _tag + ')';
 151                 paradigms = self.doc.xpath('//pardef');
 152                 self.paradigms[_tag] = {};
 153                 needle = '.*__' + _tag + '$';
 154                 patron = re.compile(needle);
 155                 for paradigm in paradigms: #{
 156                         n = paradigm.getAttributeNS(None, 'n');
 157                         if(patron.match(n)): #{
 158                                 p = Paradigm(n);
 159                                 self.paradigms[_tag][n] = p;
 160                         #}
 161                 #}
 162
 163                 print self.side + '  set ' , len(self.paradigms[_tag]) , 'paradigms';
 164         #}
 165
 166         def set_display(self, _tag, _mode): #{
 167                 if _mode == None or _mode == '': #{
 168                         self.display[_tag] = 'all';
 169                 #}
 170
 171                 if _mode != None and _mode != '': #{
 172                         self.display[_tag] = _mode;
 173                 #}
 174         #}
 175
 176         def get_display_by_tag(self, _tag): #{
 177                 if _tag in self.display: #{
 178                         return self.display[_tag];
 179                 #}
 180
 181                 return 'all';
 182         #}
 183
 184         def get_displays(self): #{
 185                 return self.display;
 186         #}
 187
 188
 189         def add_gloss(self, _paradigm, _gloss): #{
 190                 self.glosses[_paradigm] = _gloss;
 191         #}
 192
 193         def generate_monodix_entrada(self, _lemma, _paradigm, _restriction, _comment, _author): #{
 194                 incondicional = self.incondicional(_lemma, _paradigm);
 195
 196                 print >> sys.stderr, 'lemma: ' + _lemma + ', paradigm: ' + _paradigm + ', comment: ' + _comment + ', author: ' + _author;
 197
 198                 entrada = '';
 199                 if _restriction == "none" or _restriction == '': #{
 200                         entrada = entrada + '<e lm="' + _lemma + '" a="' + _author + '">' + "\n";
 201                 else: #{
 202                         entrada = entrada + '<e r="' + _restriction + '" lm="' + _lemma + '" a="' + _author + '">' + "\n";
 203                 #}
 204
 205                 entrada = entrada + '  <i>' + incondicional + '</i>' + "\n";
 206                 entrada = entrada + '  <par n="' + _paradigm + '"/>' + "\n";
 207                 entrada = entrada + '</e>';
 208
 209                 if _comment != '': #{
 210                         entrada = entrada +  '<!-- ' + _comment + ' -->' + "\n";
 211                 #}
 212
 213                 print >> sys.stderr, entrada;
 214
 215                 return entrada;
 216         #}
 217
 218         def generate_bidix_entrada(self, _lemma1, _lemma2, _paradigm1, _paradigm2, _restriction, _comment, _author): #{
 219                 # <e><p><l>lemma1<s n="tag"/></l><r>lemma2<s n="tag"/></r></p></e>
 220                 _tag = '';
 221
 222                 entrada = '';
 223
 224                 if _restriction == "none" or _restriction == '': #{
 225                         entrada = entrada + '<e a="' + _author + '">' + "\n";
 226
 227                 else: #{
 228                         entrada = entrada + '<e r="' + _restriction + '" a="' + _author + '">' + "\n";
 229                 #}
 230
 231                 entrada = entrada + '  <p>' + "\n";
 232                 entrada = entrada + '    <l>' + _lemma1 + '<s n="' + _tag + '"/></l>' + "\n";
 233                 entrada = entrada + '    <r>' + _lemma2 + '<s n="' + _tag + '"/></r>' + "\n";
 234                 entrada = entrada + '  </p>' + "\n";
 235                 entrada = entrada + '</e>' + "\n";
 236
 237                 if _comment != "": #{
 238                         entrada = entrada + '<!-- ' + _comment + ' -->' + "\n";
 239                 #}
 240
 241                 print >> sys.stderr, entrada;
 242
 243                 return entrada;
 244         #}
 245
 246         def incondicional(self, _lemma, _paradigm): #{
 247                 if _paradigm.count('/') < 1: #{
 248                         return _lemma;
 249                 #}
 250
 251                 paradigm = _paradigm.decode('utf-8');
 252                 bar_pos = paradigm.find('/');
 253                 und_pos = paradigm.find('_');
 254                 chr_str = (und_pos - bar_pos) - 1;
 255                 l = _lemma.decode('utf-8');
 256                 r = l[0:(len(l) - chr_str)];
 257
 258                 return r.encode('utf-8');
 259         #}
 260
 261         def commit(self, _entrada): #{
 262                 print >> sys.stderr, '> ' , self.file;
 263                 print >> sys.stderr, self.side + ' commit(';
 264                 print >> sys.stderr, _entrada;
 265                 print >> sys.stderr, ')';
 266
 267                 for section in self.doc.xpath('.//section'): #{
 268                         print >> sys.stderr , '+ section : ' + section.getAttributeNS(None, 'id');
 269                         if section.getAttributeNS(None, 'id') == 'main': #{
 270                                 print >> sys.stderr , 'Writing to file....';
 271                                 insertion_point = section;
 272                                 child_doc = NonvalidatingReader.parseString(_entrada.encode('utf-8'), 'urn:bogus:dummy');
 273                                 child_node = child_doc.xpath('.//e')[0];
 274                                 insertion_point.appendChild(child_node);
 275
 276                                 f = open(self.file, 'w');
 277                                 Print(self.doc, stream=f);
 278                                 f.close();
 279                                 print >> sys.stderr, 'Written.';
 280                         #}
 281                 #}
 282
 283                 print >> sys.stderr, 'Failed :(';
 284         #}
 285 #}
 286
 287 class Pair: #{
 288         name = None;
 289
 290         def __init__(self, _working, _name, _parent): #{
 291                 self.working = _working;
 292                 self.name = _name;
 293                 self.parent = _parent;
 294                 self.dictionary = {};
 295                 self.cache = {};
 296                 self.tags = {};
 297
 298                 self.populate();
 299         #}
 300
 301         def populate(self): #{
 302                 print self.name + ' populate()';
 303                 for dictionary in self.parent.xpath('.//dictionary'): #{
 304                         current_dict = dictionary.getAttributeNS(None, 'n');
 305                         side = dictionary.getAttributeNS(None, 'side');
 306                         filename = dictionary.getAttributeNS(None, 'file');
 307                         filename = self.working + '/cache/' + self.name + '/' + filename;
 308
 309                         print ' % (' + current_dict + ') ' + side + ', ' + filename;
 310                         doc = NonvalidatingReader.parseUri('file:///' + filename);
 311                         self.dictionary[side] = Dictionary(side, current_dict, filename, doc, self.tags);
 312                 #}
 313
 314         #}
 315
 316         def dictionary(self, _side): #{
 317                 return self.dictionaries[_side];
 318         #}
 319
 320         def add_tag(self, _name, _list): #{
 321                 print 'add_tag(' + _name + ')';
 322                 self.tags[_name] = Tag(_name, _list);
 323                 self.dictionary['left'].set_paradigms_by_tag(_name);
 324                 self.dictionary['right'].set_paradigms_by_tag(_name);
 325         #}
 326
 327         def get_tags(self): #{
 328                 return self.tags;
 329         #}
 330
 331         def commit(self, _left, _bidix, _right): #{
 332                 print >> sys.stderr , 'commit()';
 333                 self.dictionary['left'].commit(_left);
 334                 self.dictionary['bidix'].commit(_bidix);
 335                 self.dictionary['right'].commit(_right);
 336         #}
 337 #}