lists.py

Go to the documentation of this file.
00001 import sys
00002 import logging
00003 import types
00004 
00005 from vyperlogix.classes import CooperativeClass
00006 from vyperlogix import misc
00007 from vyperlogix.misc import ObjectTypeName
00008 from vyperlogix.misc.ObjectTypeName import __typeName as ObjectTypeName__typeName
00009 
00010 __copyright__ = """\
00011 (c). Copyright 1990-2008, Vyper Logix Corp., All Rights Reserved.
00012 
00013 Published under Creative Commons License 
00014 (http://creativecommons.org/licenses/by-nc/3.0/) 
00015 restricted to non-commercial educational use only., 
00016 
00017 See also: http://www.VyperLogix.com and http://www.pypi.info for details.
00018 
00019 THE AUTHOR VYPER LOGIX CORP DISCLAIMS ALL WARRANTIES WITH REGARD TO
00020 THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
00021 FITNESS, IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL,
00022 INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
00023 FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
00024 NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
00025 WITH THE USE OR PERFORMANCE OF THIS SOFTWARE !
00026 
00027 USE AT YOUR OWN RISK.
00028 """
00029 get = lambda source,key,default:source[key] if (source[key] is not None) else default
00030 
00031 def isDict(foo):
00032     bool = False
00033     try:
00034         bool = (foo.iteritems != None)
00035     except:
00036         pass
00037     return bool
00038 
00039 def can_asDict(foo):
00040     bool = False
00041     try:
00042         bool = (callable(foo.asDict))
00043     except:
00044         pass
00045     return bool
00046 
00047 def copyAsDict(obj):
00048     if (isDict(obj)):
00049         d = HashedLists2()
00050         for k,v in obj.iteritems():
00051             d[k] = '' if (v is None) else str(v)
00052         return d
00053     return obj
00054 
00055 def asDict(__dict__,insideOut=False,isCopy=False):
00056     cl = ObjectTypeName.typeClassName(__dict__)
00057     clName = cl.split('.')[-1]
00058     dObj = {} if (not isCopy) else eval('%s()' % (clName))
00059     for k,v in __dict__.iteritems():
00060         if (insideOut):
00061             if (isinstance(v,list)):
00062                 for item in v:
00063                     if (not callable(item)) and (not isDict(item)):
00064                         dObj[item] = k
00065             else:
00066                 if (not callable(v)) and (not isDict(v)):
00067                     dObj[v] = k
00068         else:
00069             if (not callable(v)):
00070                 try:
00071                     if ((callable(v.asDict))):
00072                         v = v.asDict(isCopy=isCopy,insideOut=insideOut)
00073                 except:
00074                     pass
00075                 dObj[k] = v
00076     return dObj
00077 
00078 def asJSONSerializable(__dict__):
00079     dObj = {}
00080     def asJSON(vv):
00081         return misc._unpack_([asJSONSerializable(_vv) for _vv in vv]) if (misc.isList(vv)) else vv
00082     try:
00083         iterable = __dict__
00084         is_or_has_dict = False
00085         if (isDict(__dict__)):
00086             is_or_has_dict = True
00087             iterable = __dict__
00088         else:
00089             try:
00090                 __dict__.__dict__
00091                 is_or_has_dict = True
00092                 iterable = __dict__.__dict__
00093             except:
00094                 pass
00095         if (is_or_has_dict):
00096             for k,v in iterable.iteritems():
00097                 if (not callable(v)):
00098                     try:
00099                         if (isDict(v)) or (isDict(v.__dict__)):
00100                             dObj[k] = asJSONSerializable(v)
00101                         else:
00102                             dObj[k] = asJSON(v)
00103                     except AttributeError:
00104                         dObj[k] = asJSON(v)
00105         else:
00106             return iterable
00107     except:
00108         pass
00109     return dObj
00110 
00111 def prettyPrint(item,prefix='',title='',tab_width=4,delay_end=False,asCSV=False,isHorizontal=False,csv_callback=None,fOut=sys.stdout):
00112     import types
00113     from vyperlogix.misc import ReportTheList
00114 
00115     _type_name = ObjectTypeName._typeName(item.__class__)
00116     ret = []
00117     try:
00118         if (isDict(item)):
00119             tab_width = 4 if (not str(tab_width).isdigit()) else tab_width
00120             if (asCSV):
00121                 if (isHorizontal):
00122                     print >>fOut, '%s' % (misc.asCSV(item.keys()))
00123                     print >>fOut, '%s' % (misc.asCSV(item.values()))
00124                     print >>fOut, ''
00125                 else:
00126                     isCallback = ( (csv_callback) and (callable(csv_callback)) )
00127                     i = 1
00128                     for kk,vv in item.iteritems():
00129                         l = [i,kk,vv]
00130                         if (isCallback):
00131                             try:
00132                                 l = csv_callback(l)
00133                             except:
00134                                 pass
00135                         print >>fOut, '%s' % (misc.asCSV(l))
00136                         i += 1
00137             else:
00138                 l_keys = [len(kk) for kk,vv in item.iteritems()]
00139                 if (len(l_keys) > 0):
00140                     max_len = misc.sort(l_keys)[-1]
00141                     print >>fOut, '%sBEGIN: %s (%d items)' % (prefix,title,len(item))
00142                     i = 1
00143                     for kk,vv in item.iteritems():
00144                         i_s_len = int(len(kk)/tab_width)
00145                         i_s_len = 1 if (i_s_len == 0) else i_s_len
00146                         i_spaces = (int(max_len/tab_width) - i_s_len) -1
00147                         if (isinstance(vv,tuple)):
00148                             vv = list(vv)
00149                         if (isinstance(vv,list)):
00150                             print >>fOut, '(%s' % ('-'*40)
00151                             ReportTheList.reportTheList(vv,title='%d :: (%s) %s' % (i,kk,title),fOut=fOut)
00152                             print >>fOut, ')%s' % ('-'*40)
00153                             print >>fOut, ''
00154                         elif (isDict(vv)):
00155                             print >>fOut, '{%s' % ('-'*40)
00156                             prettyPrint(vv,'\t\t',title='%d :: (%s) %s' % (i,kk,title),fOut=fOut)
00157                             print >>fOut, '}%s' % ('-'*40)
00158                             print >>fOut, ''
00159                         else:
00160                             try:
00161                                 print >>fOut, '%s\t\t%d :: %s%s-->%s' % (prefix,i,kk,'\t'*i_spaces,vv)
00162                             except:
00163                                 pass
00164                         i += 1
00165                     _end_msg = '%sEND! %s from %s' % (prefix,title,_type_name)
00166                     if (not delay_end):
00167                         print >>fOut, _end_msg
00168                         print >>fOut, ''
00169                     else:
00170                         ret.append(_end_msg)
00171                         ret.append('')
00172                 else:
00173                     logging.warning('(%s) :: Unable to process the object passed to this function due to lack of data.' % (misc.funcName()))
00174         else:
00175             logging.warning('(%s) :: Unable to process the object passed to this function because it is of type "%s" and a dictionary object was expected.' % (misc.funcName(),_type_name))
00176     except Exception, details:
00177         info_string = misc.formattedException(details=details)
00178         print >>sys.stderr, info_string
00179     return ret
00180 
00181 def _prettyPrint(item,prefix='',title='',tab_width=4,delay_end=False,fOut=sys.stdout):
00182     prettyPrint(item,prefix=prefix,title=title,tab_width=tab_width,delay_end=delay_end,fOut=fOut)
00183 
00184 class UnicodeMixin(CooperativeClass.Cooperative):
00185     ##
00186     # encodes the contents of the object using the named codec
00187     def encode(self,codec_name):
00188         if (isDict(self)):
00189             for k,v in self.iteritems():
00190                 self[k] = v.encode(codec_name)
00191         elif (isinstance(self,list)):
00192             for i in xrange(len(self)):
00193                 self[i] = self[i].encode(codec_name)
00194         elif (misc.isString(self)):
00195             self = self.encode(codec_name)
00196         else:
00197             self = str(self).encode(codec_name)
00198 
00199 class HashedLists(UnicodeMixin, CooperativeClass.Cooperative):
00200     def __init__(self,fromDict={},caseless=False):
00201         self.__dict = {}
00202         self.__caseless__ = caseless
00203         self.__make_key__ = lambda key:str(key) if (not caseless) else str(key).lower()
00204         if (isinstance(fromDict,list)):
00205             self.fromListOfPairs(fromDict)
00206         else:
00207             try:
00208                 if (fromDict.keys()) and (fromDict.values()):
00209                     self.fromDict(fromDict)
00210             except Exception, details:
00211                 info_string = misc.formattedException(details=details)
00212                 print >>sys.stderr, info_string
00213 
00214     def __repr__(self):
00215         return '(%s) storing %d keys.' % (ObjectTypeName__typeName(self),len(self.keys()))
00216 
00217     def prettyPrint(self,prefix='',title='',tab_width=4,delay_end=False,fOut=sys.stdout):
00218         _prettyPrint(self,prefix='',title='',tab_width=4,delay_end=delay_end,fOut=fOut)
00219 
00220     def fromDict(self, d):
00221         try:
00222             if (d.keys()) and (d.values()):
00223                 for k,v in d.iteritems():
00224                     try:
00225                         if (v.keys()) and (v.values()):
00226                             cc = '%s()' % ObjectTypeName.typeName(self).split('.')[-1]
00227                             new_d = eval(cc)
00228                             new_d.fromDict(v)
00229                             self[k] = new_d
00230                     except AttributeError:
00231                         if (isinstance(v,list)):
00232                             for item in v:
00233                                 self[k] = item
00234                         else:
00235                             self[k] = v
00236         except:
00237             pass
00238         return self
00239 
00240     ##
00241     # l_pairs is a list of pairs of values where the first value is the key and the next value is the value.
00242     def fromListOfPairs(self,l_pairs):
00243         for i in xrange(0,len(l_pairs),2):
00244             self[l_pairs[i]] = l_pairs[i+1]
00245         return self
00246 
00247     def asDict(self,insideOut=False,isCopy=False):
00248         return asDict(self,insideOut=insideOut,isCopy=isCopy)
00249     
00250     def asJSONSerializable(self,insideOut=False):
00251         return asJSONSerializable(self)
00252 
00253     def invert(self):
00254         return asDict(self,insideOut=True,isCopy=True)
00255 
00256     def insideOut(self):
00257         return asDict(self,insideOut=True,isCopy=True)
00258 
00259     def invert(self):
00260         return dict(zip(*zip(*self.items())[::-1]))
00261     
00262     def items(self):
00263         return ((k,v) for k,v in self.iteritems())
00264 
00265     def fileName():
00266         doc = "fileName"
00267         def fget(self):
00268             return ObjectTypeName.typeClassName(self)
00269         return locals()
00270     fileName = property(**fileName())
00271 
00272     def diff(self, other):
00273         d = {}
00274         for k,v in other.iteritems():
00275             key = self.__make_key__(k)
00276             if (self[key] != v):
00277                 d[key] = v
00278         return d
00279 
00280     def __add__(self, other):
00281         for k,v in other.iteritems():
00282             self[self.__make_key__(k)] = v
00283         return self
00284 
00285     def __iadd__(self, other):
00286         self.__add__(other)
00287         return self
00288 
00289     def sortedKeys(self):
00290         return misc.sort(self.keys())
00291 
00292     def get(self,key, default):
00293         v = self.__dict[_key]
00294         if (v is not None):
00295             return v
00296         return default
00297 
00298     def __getitem__(self, key):
00299         _key = self.__make_key__(key)
00300         return self.__dict[_key] if (self.has_key(_key)) else None
00301 
00302     def __setitem__(self, key, value):
00303         _key = self.__make_key__(key)
00304         if (self.has_key(_key)) and (value == None):
00305             self.__delitem__(_key)
00306         elif (value != None):
00307             if (not self.__dict.has_key(_key)):
00308                 self.__dict[_key] = []
00309             bucket = self.__dict[_key]
00310             bucket.append(value)
00311             self.__dict[_key] = bucket
00312 
00313     def __delitem__(self, key):
00314         _key = self.__make_key__(key)
00315         del self.__dict[_key]
00316 
00317     def pretty(self,delim=''):
00318         return ('{%s' % (delim))+(',%s' % (delim)).join(["'%s':%s%s%s" % (k,"'" if (not str(self[k]).isdigit()) else "",str(self[k]).replace("'",""),"'" if (not str(self[k]).isdigit()) else "") for k in self.keys()])+('%s}' % (delim))
00319     
00320     def __str__(self):
00321         return '(%s)%s' % (ObjectTypeName__typeName(self),self.pretty())
00322 
00323     def __len__(self):
00324         return len(self.keys())
00325 
00326     def length(self):
00327         n = 0
00328         for k,v in self.iteritems():
00329             n += len(v)
00330         return n
00331 
00332     def has_key(self, key):
00333         return self.__dict.has_key(self.__make_key__(key))
00334 
00335     def keys(self):
00336         return self.__dict.keys()
00337 
00338     def values(self):
00339         return self.__dict.values()
00340 
00341     def iteritems(self):
00342         return ((k,self.__getitem__(k)) for k in self.keys())
00343 
00344     def caseless():
00345         doc = "caseless flag, True if case is not used for keys otherwise False if case is used."
00346         def fget(self):
00347             return self.__caseless__
00348         def fset(self,isCaseless):
00349             self.__caseless__ = isCaseless if (isinstance(isCaseless,bool)) else False
00350         return locals()
00351     caseless = property(**caseless())
00352 
00353     def represent(self,level=0,output=False):
00354         s = []
00355         _indent = '\t'*level
00356         for k,v in self.iteritems():
00357             s.append('%s%s = ' % (_indent,k))
00358             if (isDict(v)):
00359                 t = represent(v,level+1)
00360                 s += t.split('\n')
00361             elif (isinstance(v,list)):
00362                 for i in v:
00363                     if (isDict(i)):
00364                         t = represent(i,level+1)
00365                         s += t.split('\n')
00366                     else:
00367                         s[-1] = s[-1]+'"%s"' % (i)
00368             else:
00369                 s[-1] = s[-1]+'"%s"' % (v)
00370         if (output):
00371             print '\n'.join(s)
00372         return '\n'.join(s)
00373 
00374 class HashedLists2(HashedLists):
00375     def __getitem__(self, key):
00376         return super(HashedLists2, self).__getitem__(key)[0] if (super(HashedLists2, self).has_key(key)) else None
00377 
00378     def __setitem__(self, key, value):
00379         if (super(HashedLists2, self).has_key(key)):
00380             super(HashedLists2, self).__delitem__(key)
00381         super(HashedLists2, self).__setitem__(key,value)
00382 
00383 class HashedFuzzyLists(HashedLists):
00384     def __init__(self,d={}):
00385         super(HashedFuzzyLists, self).__init__(fromDict=d,caseless=True)
00386 
00387     def __getitem__(self, key):
00388         _key = key.lower()
00389         for k in self.keys():
00390             if (k.lower() == _key):
00391                 val = super(HashedFuzzyLists, self).__getitem__(k)
00392                 return val
00393         return None
00394 
00395 class HashedFuzzyLists2(HashedLists2):
00396     def __init__(self,d={}):
00397         super(HashedFuzzyLists2, self).__init__(fromDict=d,caseless=True)
00398 
00399     def __getitem__(self, key):
00400         _key = key.lower()
00401         for k in self.keys():
00402             if (k.lower() == _key):
00403                 val = super(HashedFuzzyLists2, self).__getitem__(k)
00404                 return val if (not isinstance(val,list)) else val[0]
00405         return None
00406 
00407 ##
00408 # Takes a list of tuple items and makes an Ordered Dictionary from them.
00409 class HashedOrderedList(HashedLists2):
00410     def __init__(self,fromTupleList=[]):
00411         self.__list = fromTupleList
00412         d = {}
00413         for item in self.__list:
00414             d[item[0]] = item[-1]
00415         super(HashedOrderedList, self).__init__(d)
00416 
00417     def keys(self):
00418         return [n[0] for n in self.__list]
00419 
00420     def values(self):
00421         return [n[-1] for n in self.__list]
00422 
00423     def length(self):
00424         return len(self.keys())
00425 
00426 
00427 if (__name__ == '__main__'):
00428     import sys
00429     print >>sys.stdout, __copyright__
00430     print >>sys.stderr, __copyright__
00431 
00432
Notice: This source code contained in this document is NOT open source and is NOT being distributed as open source.