home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2009 June / maximum-cd-2009-06.iso / DiscContents / digsby_setup.exe / lib / oscar / ssi / SSIItem.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-02-26  |  14.5 KB  |  426 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from __future__ import with_statement
  5. from util.primitives import odict
  6. import struct
  7. import oscar
  8. import contacts
  9. import warnings
  10. import logging
  11. from oscar.OscarBuddies import OscarBuddy
  12. import common
  13. from contacts import Contact
  14. log = logging.getLogger('oscar.ssiitem')
  15.  
  16. byteswap = lambda x: struct.unpack('<H', struct.pack('>H', x))[0]
  17.  
  18. class OscarContact(Contact):
  19.     _renderer = 'Contact'
  20.     inherited_actions = [
  21.         OscarBuddy]
  22.     
  23.     def __init__(self, *a, **k):
  24.         Contact.__init__(self, *a, **k)
  25.         self.ssis = self.protocol.ssimanager.ssis
  26.  
  27.     
  28.     def get_remote_alias(self):
  29.         
  30.         try:
  31.             friendly = self.ssis[self.id].get_alias().decode('fuzzy utf-8')
  32.             if self.buddy._friendly_name is None:
  33.                 self.buddy._friendly_name = friendly
  34.             
  35.             return friendly
  36.         except KeyError:
  37.             return None
  38.  
  39.  
  40.     
  41.     def set_remote_alias(self, newname):
  42.         self.protocol.set_remote_alias(self, newname)
  43.  
  44.     remote_alias = property(get_remote_alias, set_remote_alias)
  45.     
  46.     def rename_gui(self):
  47.         s = Contact.rename_gui(self)
  48.         if s is not None:
  49.             self.remote_alias = s
  50.         
  51.  
  52.     rename_gui = common.action()(rename_gui)
  53.     
  54.     def block(self, *a, **k):
  55.         return Contact.block(self, *a, **k)
  56.  
  57.     block = common.action(Contact._block_pred)(block)
  58.     
  59.     def unblock(self, *a, **k):
  60.         return Contact.unblock(self, *a, **k)
  61.  
  62.     unblock = common.action(Contact._unblock_pred)(unblock)
  63.  
  64.  
  65. class SSIItem(object):
  66.     
  67.     def __init__(self, name, group_id, item_id, type_ = None, tlvs = None, **k):
  68.         if not isinstance(name, str):
  69.             raise TypeError('SSIItem.name must be str, not %s' % type(name))
  70.         
  71.         type_ = k.pop('type', type_)
  72.         if k:
  73.             raise Exception('Only one extra keyword argument ("type") is allowed for SSIItems')
  74.         
  75.         self.name = name
  76.         self.group_id = group_id
  77.         self.item_id = item_id
  78.         if not type_:
  79.             pass
  80.         self.type = 0
  81.         if not tlvs:
  82.             pass
  83.         self.tlvs = odict({ })
  84.         self.c8_to_ints()
  85.  
  86.     
  87.     def set_name(self, name):
  88.         if not isinstance(name, str):
  89.             raise TypeError('setting SSIItem.name to something that is not str: %s' % type(name))
  90.         
  91.         self._name = name
  92.  
  93.     
  94.     def get_name(self):
  95.         return self._name
  96.  
  97.     name = property(get_name, set_name)
  98.     
  99.     def tlv_tuple(self):
  100.         return (self.group_id, self.item_id)
  101.  
  102.     tlv_tuple = property(tlv_tuple)
  103.     
  104.     def to_bytes(self):
  105.         tlvs_string = ''
  106.         for type, val in self.tlvs.items():
  107.             if type != 200:
  108.                 if hasattr(val, 'value'):
  109.                     tlvs_string += oscar.util.tlv(val.type, val.length, val.value)
  110.                 else:
  111.                     tlvs_string += oscar.util.tlv(type, val)
  112.             hasattr(val, 'value')
  113.             type += ''.join([], []([ struct.pack('!H', short) for short in val ]))
  114.         
  115.         nlen = len(self.name)
  116.         tlen = len(tlvs_string)
  117.         return struct.pack('!H%dsHHHH%ds' % (nlen, tlen), nlen, self.name, self.group_id, self.item_id, self.type, tlen, tlvs_string)
  118.  
  119.     
  120.     def c8_to_ints(self):
  121.         if 200 in self.tlvs and isinstance(self.tlvs[200], basestring):
  122.             self.tlvs[200] = oscar.unpack((('list', 'list', 'H'),), self.tlvs[200])[0]
  123.         
  124.  
  125.     
  126.     def clone(self):
  127.         return oscar.unpack((('ssi', 'ssi'),), self.to_bytes())[0]
  128.  
  129.     
  130.     def add_item_to_group(self, id_to_add, position = 0):
  131.         if self.type != 1:
  132.             raise AssertionError(repr(self) + ' is not a group')
  133.         else:
  134.             self.tlvs.setdefault(200, []).insert(position, id_to_add)
  135.  
  136.     
  137.     def remove_item_from_group(self, id_to_remove):
  138.         if self.type != 1:
  139.             raise AssertionError(repr(self) + ' is not a group')
  140.         
  141.         
  142.         try:
  143.             self.tlvs.setdefault(200, [
  144.                 id_to_remove]).remove(id_to_remove)
  145.         except ValueError:
  146.             pass
  147.  
  148.         if not self.tlvs[200]:
  149.             del self.tlvs[200]
  150.         
  151.  
  152.     
  153.     def get_item_position(self, id_to_find):
  154.         if self.type != 1:
  155.             raise AssertionError(repr(self) + ' is not a group')
  156.         
  157.         
  158.         try:
  159.             return self.tlvs.get(200, []).index(id_to_find)
  160.         except ValueError:
  161.             return None
  162.  
  163.  
  164.     
  165.     def move_item_to_position(self, id_to_move, position):
  166.         curposition = self.get_item_position(id_to_move)
  167.         if curposition is None:
  168.             raise AssertionError(repr(self) + ' does not contain %d' % id_to_move)
  169.         
  170.         if position != curposition:
  171.             self.remove_item_from_group(id_to_move)
  172.             self.add_item_to_group(id_to_move, position)
  173.         
  174.  
  175.     
  176.     def get_alias(self):
  177.         return self.tlvs.get(305, None)
  178.  
  179.     
  180.     def set_alias(self, alias):
  181.         if alias:
  182.             self.tlvs[305] = alias
  183.         else:
  184.             self.remove_alias()
  185.  
  186.     
  187.     def remove_alias(self):
  188.         self.remove_tlv(305)
  189.  
  190.     alias = property(get_alias, doc = 'this is the alias of the buddy')
  191.     
  192.     def get_comment(self):
  193.         return self.tlvs.get(316, None)
  194.  
  195.     
  196.     def set_comment(self, comment):
  197.         if comment:
  198.             self.tlvs[316] = comment
  199.         else:
  200.             self.remove_comment()
  201.  
  202.     
  203.     def remove_comment(self):
  204.         self.remove_tlv(316)
  205.  
  206.     comment = property(get_comment, doc = 'this is the comment about the buddy')
  207.     
  208.     def remove_tlv(self, type):
  209.         
  210.         try:
  211.             del self.tlvs[type]
  212.         except KeyError:
  213.             pass
  214.  
  215.  
  216.     
  217.     def __repr__(self):
  218.         return '<SSI Item: name: %s, group_id: %d, item_id: %d, type: %d>' % (self.name, self.group_id, self.item_id, self.type)
  219.  
  220.  
  221.  
  222. class OscarSSIs(dict):
  223.     
  224.     def __init__(self, manager):
  225.         self.manager = manager
  226.         self.root_group = SSIGroup(None, self.manager)
  227.         self.groups = {
  228.             (0, 0): self.root_group }
  229.         return dict.__init__(self)
  230.  
  231.     
  232.     def __setitem__(self, key, ssi, modify = False):
  233.         tupled_key = tuple_key(ssi)
  234.         if isinstance(key, SSIItem):
  235.             pass
  236.         
  237.         if ssi.type == 1:
  238.             self.root_group.frozen().__enter__()
  239.             
  240.             try:
  241.                 if tupled_key in self.groups:
  242.                     self.groups[tupled_key].set_ssi(ssi)
  243.                 else:
  244.                     self.groups[tupled_key] = SSIGroup(ssi, self.manager)
  245.             finally:
  246.                 pass
  247.  
  248.         elif modify and ssi.type == 0:
  249.             if 348 in ssi.tlvs or 349 in ssi.tlvs:
  250.                 self.manager.o.get_buddy_info(ssi)
  251.             
  252.         
  253.         return dict.__setitem__(self, tupled_key, ssi)
  254.  
  255.     
  256.     def get_group(self, key):
  257.         return self.groups[tuple_key(key)]
  258.  
  259.     
  260.     def __getitem__(self, key):
  261.         return dict.__getitem__(self, tuple_key(key))
  262.  
  263.     
  264.     def __contains__(self, key):
  265.         return dict.__contains__(self, tuple_key(key))
  266.  
  267.     
  268.     def __delitem__(self, key):
  269.         return dict.__delitem__(self, tuple_key(key))
  270.  
  271.     
  272.     def update(self, hash, modify = False):
  273.         self.root_group.frozen().__enter__()
  274.         
  275.         try:
  276.             for k, v in hash.items():
  277.                 self.__setitem__(k, v, modify = modify)
  278.             
  279.             self.fix_group_c8()
  280.         finally:
  281.             pass
  282.  
  283.  
  284.     
  285.     def fix_group_c8(self):
  286.         groups = _[1]
  287.         dgi = dict.__getitem__
  288.         for g_id, i_id in groups:
  289.             known_locs = dict((lambda .0: for x, y in .0:
  290. (y, x))(enumerate(gm_ids)))
  291.             locations = { }
  292.             for possible in m_ids:
  293.                 inverted = byteswap(possible)
  294.                 if inverted in known_locs:
  295.                     locations[possible] = known_locs[inverted]
  296.                     continue
  297.                 
  298.                 locations[possible] = len(m_ids)
  299.             
  300.             new_gm_ids = sorted(m_ids, key = locations.__getitem__)
  301.             dgi(self, (g_id, i_id)).tlvs[200] = new_gm_ids
  302.         
  303.  
  304.  
  305.  
  306. def tuple_key(key):
  307.     
  308.     try:
  309.         (a, b) = key
  310.         (int(a), int(b))
  311.         return key
  312.     except (TypeError, ValueError):
  313.         
  314.         try:
  315.             t = (key.group_id, key.item_id)
  316.             return t
  317.         except AttributeError:
  318.             
  319.             try:
  320.                 int(key)
  321.                 return (key, 0)
  322.             except TypeError:
  323.                 raise AssertionError(repr(key) + ' is not a valid ssi key')
  324.             except:
  325.                 None<EXCEPTION MATCH>TypeError
  326.             
  327.  
  328.             None<EXCEPTION MATCH>TypeError
  329.         
  330.  
  331.         None<EXCEPTION MATCH>AttributeError
  332.  
  333.  
  334.  
  335. class SSIGroup(contacts.Group):
  336.     _renderer = 'Group'
  337.     
  338.     def __init__(self, new_ssi, ssi_manager):
  339.         self.my_ssi = new_ssi
  340.         self.ssi_manager = ssi_manager
  341.         if self.my_ssi is None:
  342.             self.my_ssi = SSIItem('root', 0, 0, 1)
  343.         
  344.         groupname = self.my_ssi.name.decode('utf-8', 'replace')
  345.         contacts.Group.__init__(self, groupname, ssi_manager.o, self.my_ssi.group_id)
  346.  
  347.     
  348.     def set_ssi(self, new_ssi):
  349.         oldname = self.my_ssi.name
  350.         self.my_ssi = new_ssi
  351.         self.name = self.my_ssi.name.decode('utf-8', 'replace')
  352.         if oldname != self.name:
  353.             self.notify('name', oldname, self.name)
  354.         
  355.  
  356.     
  357.     def __getitem__(self, index):
  358.         g_id = self.my_ssi.group_id
  359.         tlv = self.my_ssi.tlvs.get(200, [])
  360.         start_index = index
  361.         ssi = None
  362.         while ssi is None:
  363.             
  364.             try:
  365.                 i_id = tlv[index]
  366.             except IndexError:
  367.                 break
  368.  
  369.             if g_id:
  370.                 
  371.                 try:
  372.                     ssi = self.ssi_manager.ssis[(g_id, i_id)]
  373.                 except KeyError:
  374.                     e = None
  375.                     index += 1
  376.                     continue
  377.  
  378.                 return OscarContact(self.ssi_manager.o.buddies[ssi.name], (g_id, i_id))
  379.                 continue
  380.             return self.ssi_manager.ssis.get_group((i_id, 0))
  381.         if ssi is None:
  382.             warnings.warn('Error finding SSI %r in group (id=%r)' % (start_index, g_id))
  383.             raise IndexError('SSI Item not found in group(id=%r): %r', index, g_id)
  384.         
  385.  
  386.     
  387.     def __iter__(self):
  388.         for i in xrange(len(self)):
  389.             
  390.             try:
  391.                 yield self[i]
  392.             continue
  393.             except (KeyError, IndexError):
  394.                 e = None
  395.                 warnings.warn('Error iterating over group: %r' % e)
  396.                 continue
  397.                 continue
  398.             
  399.  
  400.         
  401.  
  402.     
  403.     def online(self):
  404.         return bool(self.num_online)
  405.  
  406.     online = property(online)
  407.     
  408.     def num_online(self):
  409.         ss = self.ssi_manager.ssis
  410.         bs = self.ssi_manager.o.buddies
  411.         total = 0
  412.         g_id = self.my_ssi.group_id
  413.         tlv = self.my_ssi.tlvs.get(200, [])
  414.         return total
  415.  
  416.     num_online = property(num_online)
  417.     
  418.     def find(self, obj):
  419.         return list.find(self, obj)
  420.  
  421.     
  422.     def __len__(self):
  423.         return len(self.my_ssi.tlvs.get(200, []))
  424.  
  425.  
  426.