home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2012 January / maximum-cd-2012-01.iso / DiscContents / digsby_setup.exe / lib / oscar / ssi / SSIItem.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-10-05  |  15.6 KB  |  461 lines

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