Source Code for Module grassyknoll.backend.lucene.LuceneConstants

  1  """contains L{Constants} for L{lucene}""" 
  2  from lucene import Field 
  3   
  4 -class LuceneConstantError(ValueError): 
  5      """error raised when something goes wrong converting""" 
  6      pass 
  7   
  8 -class Constants(object): 
  9      """parameters to control document storage 
 10       
 11      See nested classes at 
 12      http://lucene.apache.org/java/docs/api/org/apache/lucene/document/Field.html 
 13      """ 
 14      ## storage parameters 
 15      STORE_YES=Field.Store.YES 
 16      STORE_NO=Field.Store.NO 
 17      STORE_COMPRESS=Field.Store.COMPRESS 
 18       
 19      @classmethod 
 20 -    def validStore(cls, store): 
 21          return cls.toConstant(store, 'store') in (cls.STORE_YES, cls.STORE_NO, cls.STORE_COMPRESS) 
 22       
 23      ## indexing parameters 
 24      INDEX_NO=Field.Index.NO 
 25      INDEX_NO_NORMS=Field.Index.NO_NORMS 
 26      INDEX_TOKENIZED=Field.Index.TOKENIZED 
 27      INDEX_UNTOKENIZED=Field.Index.UN_TOKENIZED 
 28       
 29      @classmethod 
 30 -    def validIndex(cls, index): 
 31          return cls.toConstant(index, 'index') in (cls.INDEX_NO, cls.INDEX_NO_NORMS, 
 32                                                    cls.INDEX_TOKENIZED, cls.INDEX_UNTOKENIZED) 
 33       
 34      ## term vector parameters 
 35      TERMVECTOR_NO=Field.TermVector.NO 
 36      TERMVECTOR_YES=Field.TermVector.YES 
 37      TERMVECTOR_WITH_OFFSETS=Field.TermVector.WITH_OFFSETS 
 38      TERMVECTOR_WITH_POSITIONS=Field.TermVector.WITH_POSITIONS 
 39      TERMVECTOR_WITH_POSITIONS_OFFSETS=Field.TermVector.WITH_POSITIONS_OFFSETS 
 40       
 41      @classmethod 
 42 -    def validTermVector(cls, termvector): 
 43          return cls.toConstant(termvector, 'termvector') in (cls.TERMVECTOR_NO, cls.TERMVECTOR_YES, 
 44                                                              cls.TERMVECTOR_WITH_OFFSETS, cls.TERMVECTOR_WITH_POSITIONS, 
 45                                                              cls.TERMVECTOR_WITH_POSITIONS_OFFSETS) 
 46       
 47      @classmethod 
 48 -    def toString(cls, c, which): 
 49          """return a string""" 
 50          orig_c=c 
 51          which=which.upper() 
 52          assert which in ('INDEX', 'STORE', 'TERMVECTOR') 
 53           
 54          if isinstance(c, basestring): 
 55              c=c.upper() 
 56              if not (c.startswith('INDEX') or c.startswith('STORE') or 
 57                      c.startswith('TERMVECTOR')): 
 58                  c="%s_%s"%(which, c) 
 59               
 60              if c in cls.__dict__: return c 
 61              else: raise LuceneConstantError, orig_c 
 62           
 63          if isinstance(c, bool): 
 64              if c:  
 65                  if which=='INDEX': raise LuceneConstantError, orig_c 
 66                  else: return "%s_YES"%which 
 67              else: return "%s_NO"%which             
 68           
 69          # c should be an instance of Field.* (or it's an error) 
 70          try: 
 71              return cls.__reversedict__[c] 
 72          except KeyError: 
 73              raise LuceneConstantError, orig_c 
 74       
 75      @classmethod 
 76 -    def toConstant(cls, s, which): 
 77          """return a constant""" 
 78           
 79          if Field.Store.instance_(s) or Field.Index.instance_(s) or Field.TermVector.instance_(s): 
 80              return s 
 81           
 82          orig_s=s 
 83          which=which.upper() 
 84          assert which in ('INDEX', 'STORE', 'TERMVECTOR') 
 85           
 86          if isinstance(s, bool): 
 87              if s: s="%s_YES"%which # this isn't valid for INDEX, we'll raise below 
 88              else: s="%s_NO"%which 
 89          elif isinstance(s, basestring):  
 90              s=s.upper() 
 91              if not (s.startswith('INDEX') or s.startswith('STORE') or s.startswith('TERMVECTOR')): 
 92                  s="%s_%s"%(which, s) 
 93          else: 
 94              raise LuceneConstantError, orig_s 
 95           
 96          try: 
 97              return cls.__dict__[s] 
 98          except KeyError: 
 99              raise LuceneConstantError, orig_s 
100   
101 -def _build_reversedict(): 
102      # stuff a reverse mapping of attr to string in the class. 
103      Constants.__reversedict__=dict((v, k) for k, v in Constants.__dict__.iteritems() if k.isupper()) 
104   
105  _build_reversedict() 
106