PyScore

01: ######## ######## ######## simple enumerations ######## ######## ########
02: 
03: class EnumEntry(tuple):
04:     """a single data base entry in an enumerated list."""
05: 
06:     # ( enum, 0, i ) such that enum.sequence[i] == s
07:     # ( enum, 1, s ) where s not in enum.sequence
08: 
09:     # inherits lexicographic sorting of the base tuple type and
10:     # so the sort order supplied by the master list in the enum field
11: 
12:     def __str__(self):
13:         """For display."""
14:         if self[1]:
15:             return str(self[2])
16:         else:
17:             return str(self[0].sequence[self[2]])
18: 
19:     def __repr__(self):
20:         """For later eval."""
21:         if self[1]:
22:             return repr(self[2])
23:         else:
24:             return repr(self[0].sequence[self[2]])
25: 
26:     def __getattr__(self,attr):
27:         """Just passing through."""
28:         if self[1]:
29:             return getattr(self[2],attr)
30:         else:
31:             return getattr(self[0].sequence[self[2]],attr)
32: 
33:     def canonical_tuple(self):
34:         return self[1:]
35: 
36: class Enum(object):
37:     """A master list for an enumeration."""
38: 
39:     def __init__(
40:         self,sequence=(),casesensitive=False,refilter=None,strict=False
41:     ):
42:         self.sequence=sequence
43:         self.casesensitive=casesensitive
44:         self.refilter=refilter
45:         self.strict=strict
46:         self.hashseed=reduce(lambda x,y: x^hash(y),sequence,0)
47:         self.dictlowered=self.dictenum={}
48: 
49:     def create_dict(self):
50:         for (i,e) in enumerate(self.sequence):
51:             self.dictenum[e]=i
52:         if not self.casesensitive:
53:             for (i,e) in enumerate(self.sequence):
54:                 self.dictenum[e.lower()]=i
55: 
56: class Enumeration(EnumEntry):
57:     """A base class for an enumeration."""
58: 
59:     def __new__(Self,s,strict=False):
60:         assert isinstance(Self.enum,Enum)
61:         i=None
62:         if isinstance(s,str) and Self.enum.refilter:
63:             for (i,f) in Self.enum.refilter:
64:                 if f.match(s):
65:                     break
66:             else:
67:                 i=None
68:         elif isinstance(s,str) and Self.enum.dictlowered:
69:             l=s.lower()
70:             if l in Self.enum.dictlowered:
71:                 i=Self.enum.dictlowered[l]
72:         elif Self.enum.dictenum:
73:             if s in Self.enum.dictenum:
74:                 i=Self.enum.dictenum[s]
75:         else:
76:             try:
77:                 i=Self.enum.sequence.index(s)
78:             except ValueError:
79:                 pass
80:         if i<>None:
81:             try:
82:                 Self.enumcache
83:             except AttributeError:
84:                 Self.enumcache=[None]*len(Self.enum.sequence)
85:             if not Self.enumcache[i]:
86:                 Self.enumcache[i]=EnumEntry.__new__(Self,(Self.enum,0,i))
87:                 # Self((enum,0,i)) without infinite recursion
88:             return Self.enumcache[i]
89:         else:
90:             if strict or Self.enum.strict:
91:                 raise ValueError
92:             return EnumEntry.__new__(Self,(Self.enum,1,s))
93:             # Self((enum,1,s)) without infinite recursion
94: