home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 February / maximum-cd-2011-02.iso / DiscContents / digsby_setup85.exe / lib / digsby / blobs.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-11-24  |  11.4 KB  |  326 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from __future__ import with_statement
  5. from digsby.abstract_blob import AbstractBlob
  6. import cPickle
  7. from pyxmpp.utils import to_utf8
  8. from copy import deepcopy
  9. from util import Storage
  10. from logging import getLogger
  11. log = getLogger('blobs')
  12. info = log.info
  13. from util.observe import ObservableDict, ObservableList
  14. from struct import pack, unpack
  15. import struct
  16. from os.path import join as pathjoin
  17. from zlib import compress, decompress
  18. import util
  19. import syck
  20. import prefs
  21. import common.notifications as comnot
  22. DIGSBY_PREFS_NS = 'digsby:prefs'
  23. DIGSBY_DEFAULT_PREFS_NS = 'digsby:defaultprefs'
  24. DIGSBY_ICON_NS = 'digsby:icon'
  25. DIGSBY_EVENTS_NS = 'digsby:events'
  26. DIGSBY_STATUS_NS = 'digsby:status'
  27. DIGSBY_BUDDYLIST_NS = 'digsby:blist'
  28. DIGSBY_PROFILE_NS = 'digsby:profile'
  29.  
  30. def to_primitive(thing):
  31.     if isinstance(thing, ObservableDict):
  32.         return dict(thing)
  33.     if isinstance(thing, ObservableList):
  34.         return list(thing)
  35.     return thing
  36.  
  37.  
  38. def maybe_copy(thing):
  39.     if isinstance(thing, (dict, list)):
  40.         return deepcopy(thing)
  41.     return thing
  42.  
  43.  
  44. class NetData(AbstractBlob):
  45.     timeout = 300
  46.     
  47.     def pack(cls, data):
  48.         return cPickle.dumps(data)
  49.  
  50.     pack = classmethod(pack)
  51.     
  52.     def unpack(cls, data):
  53.         return cPickle.loads(data)
  54.  
  55.     unpack = classmethod(unpack)
  56.     
  57.     def set_data(self, data):
  58.         
  59.         try:
  60.             return AbstractBlob.set_data(self, self.pack(data))
  61.         except:
  62.             import sys
  63.             print >>sys.stderr, 'Error pickling %r: %s' % (self, repr(data)[:200])
  64.             print >>sys.stderr, '  %s' % type(data)
  65.             raise 
  66.  
  67.  
  68.     
  69.     def get_data(self):
  70.         
  71.         try:
  72.             retval = self.unpack(AbstractBlob.get_data(self))
  73.             return retval
  74.         except Exception:
  75.             e = None
  76.             import traceback
  77.             traceback.print_exc()
  78.             log.error('Could not unpickle %s', type(self).__name__)
  79.             self.set_data(to_primitive(self.fallback()))
  80.             return self.get_data()
  81.  
  82.  
  83.     
  84.     def del_data(self):
  85.         self._data = None
  86.  
  87.     data = property(get_data, set_data, del_data)
  88.     
  89.     def fallback(self):
  90.         return list()
  91.  
  92.  
  93.  
  94. class SerializableNetData(NetData):
  95.     __VERSION = 3
  96.     
  97.     def pack(cls, data):
  98.         pydumps = pydumps
  99.         import util.json
  100.         d = pydumps(data).encode('z')
  101.         v = cls._SerializableNetData__VERSION
  102.         log.info('packing version %d of %s', v, cls.__name__)
  103.         return pack('!I', v) + d
  104.  
  105.     pack = classmethod(pack)
  106.     
  107.     def unpack(cls, data):
  108.         if len(data) < 4:
  109.             version = 0
  110.         else:
  111.             (version,) = unpack('!I', data[:4])
  112.         if version not in (1, 2, 3):
  113.             log.info('unpacking version %d of %s', version, cls.__name__)
  114.             data = pack('I', 1) + data
  115.             version = 1
  116.         
  117.         if version == 1:
  118.             log.info('unpacking version %d of %s', version, cls.__name__)
  119.             data = data[4:]
  120.             
  121.             try:
  122.                 data = data.decode('z')
  123.             except Exception:
  124.                 pass
  125.             except:
  126.                 None<EXCEPTION MATCH>Exception
  127.             
  128.  
  129.         None<EXCEPTION MATCH>Exception
  130.         if version == 2:
  131.             log.info('unpacking version %d of %s', version, cls.__name__)
  132.             data = data[4:]
  133.             data = data.decode('z')
  134.         
  135.         if version != 3:
  136.             d = NetData.unpack(data)
  137.             if isinstance(d, (SerializedDict, SerializedSet)):
  138.                 return unserialize(d)
  139.             if isinstance(d, cls.basetype):
  140.                 return d
  141.             return cls.upgrade(d)
  142.         version != 3
  143.         if version == 3:
  144.             log.info('unpacking version %d of %s', version, cls.__name__)
  145.             pyloads = pyloads
  146.             import util.json
  147.             return pyloads(data[4:].decode('z'))
  148.  
  149.     unpack = classmethod(unpack)
  150.     
  151.     def upgrade(cls, d):
  152.         return cls.basetype(d)
  153.  
  154.     upgrade = classmethod(upgrade)
  155.  
  156.  
  157. class ODictNetData(NetData):
  158.     
  159.     fallback = lambda self: ObservableDict()
  160.     basetype = dict
  161.  
  162.  
  163. class Prefs(ODictNetData, SerializableNetData):
  164.     xml_element_namespace = DIGSBY_PREFS_NS
  165.  
  166.  
  167. class DefaultPrefs(NetData):
  168.     xml_element_namespace = DIGSBY_DEFAULT_PREFS_NS
  169.     diskdata = None
  170.     
  171.     def complete_xml_element(self, xmlnode, _unused):
  172.         None if self.tstamp is not None else None
  173.  
  174.     
  175.     def set_data(self, data):
  176.         pass
  177.  
  178.     
  179.     def get_data(self):
  180.         if self.diskdata is None:
  181.             defaults = prefs.defaultprefs()
  182.             self.diskdata = defaults
  183.         
  184.         return self.diskdata
  185.  
  186.     
  187.     def del_data(self):
  188.         pass
  189.  
  190.     data = property(get_data, set_data, del_data)
  191.  
  192.  
  193. class BuddyList(ODictNetData, SerializableNetData):
  194.     xml_element_namespace = DIGSBY_BUDDYLIST_NS
  195.  
  196.  
  197. class Statuses(SerializableNetData):
  198.     xml_element_namespace = DIGSBY_STATUS_NS
  199.     
  200.     fallback = lambda self: ObservableList()
  201.     basetype = list
  202.  
  203.  
  204. class Profile(SerializableNetData):
  205.     xml_element_namespace = DIGSBY_PROFILE_NS
  206.     basetype = dict
  207.     
  208.     fallback = lambda self: dict(plaintext = '')
  209.     
  210.     def upgrade(cls, d):
  211.         if isinstance(d, basestring):
  212.             return d
  213.         return cls.basetype(d)
  214.  
  215.     upgrade = classmethod(upgrade)
  216.  
  217.  
  218. class Icon(NetData):
  219.     xml_element_namespace = DIGSBY_ICON_NS
  220.     
  221.     fallback = lambda self: ''
  222.     
  223.     def pack(cls, data):
  224.         return data
  225.  
  226.     pack = classmethod(pack)
  227.     
  228.     def unpack(cls, data):
  229.         return data
  230.  
  231.     unpack = classmethod(unpack)
  232.  
  233.  
  234. class Notifications(ODictNetData, SerializableNetData):
  235.     xml_element_namespace = DIGSBY_EVENTS_NS
  236.     
  237.     fallback = lambda self: deepcopy(comnot.default_notifications)
  238.  
  239.  
  240. def load_cache_from_data_disk(name, data):
  241.     StringIO = StringIO
  242.     import StringIO
  243.     f = StringIO(data)
  244.     
  245.     try:
  246.         plen = struct.unpack('!H', f.read(2))[0]
  247.         tstamp = f.read(plen)
  248.         data = f.read()
  249.     except IOError:
  250.         tstamp = '0001-01-01 00:00:00'
  251.         data = None
  252.  
  253.     return name_to_obj[name](tstamp, rawdata = data)
  254.  
  255.  
  256. def load_cache_from_data_db(name, data):
  257.     tstamp = '0001-01-01 00:00:00'
  258.     return name_to_obj[name](tstamp, rawdata = data)
  259.  
  260.  
  261. class SerializedDict(list):
  262.     
  263.     def __init__(self, dict_):
  264.         self[:] = sorted(dict_.iteritems())
  265.  
  266.  
  267.  
  268. class SerializedSet(list):
  269.     
  270.     def __init__(self, set_):
  271.         self[:] = sorted(set_)
  272.  
  273.  
  274. PrimitiveTypes = frozenset((int, bool, float, long, str, unicode, type(None), type))
  275.  
  276. def serialize(thing):
  277.     t = type(thing)
  278.     if t in PrimitiveTypes:
  279.         return thing
  280.     if t is tuple:
  281.         return tuple((lambda .0: for foo in .0:
  282. serialize(foo))(thing))
  283.     if t is list:
  284.         return list((lambda .0: for foo in .0:
  285. serialize(foo))(thing))
  286.     if issubclass(t, dict):
  287.         bar = SerializedDict(thing)
  288.         bar[:] = [ serialize(foo) for foo in bar ]
  289.         return bar
  290.     if t is set:
  291.         bar = SerializedSet(thing)
  292.         bar[:] = [ serialize(foo) for foo in bar ]
  293.         return bar
  294.  
  295.  
  296. def unserialize(thing):
  297.     t = type(thing)
  298.     if t is SerializedDict:
  299.         return dict((lambda .0: for foo in .0:
  300. unserialize(foo))(thing))
  301.     if t is SerializedSet:
  302.         return set((lambda .0: for foo in .0:
  303. unserialize(foo))(thing))
  304.     if t is tuple:
  305.         return tuple((lambda .0: for foo in .0:
  306. unserialize(foo))(thing))
  307.     if t is list:
  308.         return list((lambda .0: for foo in .0:
  309. unserialize(foo))(thing))
  310.     if t in PrimitiveTypes:
  311.         return thing
  312.  
  313. ns_to_obj = {
  314.     DIGSBY_PREFS_NS: Prefs,
  315.     DIGSBY_ICON_NS: Icon,
  316.     DIGSBY_EVENTS_NS: Notifications,
  317.     DIGSBY_STATUS_NS: Statuses,
  318.     DIGSBY_BUDDYLIST_NS: BuddyList,
  319.     DIGSBY_PROFILE_NS: Profile }
  320. name_to_ns = dict((lambda .0: for key, value in .0:
  321. (value.__name__.lower(), key))(ns_to_obj.iteritems()))
  322. name_to_obj = dict((lambda .0: for name in .0:
  323. (name, ns_to_obj[name_to_ns[name]]))(name_to_ns))
  324. from util import dictreverse
  325. ns_to_name = dictreverse(name_to_ns)
  326.