home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2009 June / maximum-cd-2009-06.iso / DiscContents / digsby_setup.exe / lib / contacts / buddylistsort.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-02-26  |  12.6 KB  |  380 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from util import isiterable, groupby, do, dictreverse
  5. from util.xml_tag import tag
  6. from logging import getLogger
  7. log = getLogger('blistsort')
  8. info = log.info
  9. from util.observe import Observable
  10. from functools import wraps
  11. from common import profile, pref
  12. from traceback import print_exc
  13. from contacts.Group import DGroup, GroupTypes, merge_groups, Group
  14. from contacts.Contact import Contact
  15. from contacts.metacontacts import MetaContact
  16. from common import prefprop
  17. from common.protocolmeta import protocols
  18. from util.primitives import oset
  19.  
  20. def grouping():
  21.     s = pref('buddylist.sortby', 'none none').startswith
  22.     if not s('*status'):
  23.         pass
  24.     return s('*service')
  25.  
  26.  
  27. class SpecialGroup(DGroup):
  28.     _renderer = 'DGroup'
  29.     
  30.     def groupkey(self):
  31.         return self.__class__.__name__ + '_' + DGroup.groupkey(self)
  32.  
  33.     
  34.     def renamable(self):
  35.         pass
  36.  
  37.  
  38. STATUS_ORDER = [
  39.     'available',
  40.     'away',
  41.     'idle',
  42.     'mobile',
  43.     'offline',
  44.     'unknown']
  45. STATUS_ORDER_INDEXES = dict((lambda .0: for i in .0:
  46. (STATUS_ORDER[i], i))(xrange(len(STATUS_ORDER))))
  47.  
  48. def issortable(obj):
  49.     JabberContact = JabberContact
  50.     import jabber.JabberContact
  51.     if not isinstance(obj, (MetaContact, JabberContact)):
  52.         pass
  53.     return isiterable(obj)
  54.  
  55.  
  56. def grp_order(obj):
  57.     order = profile.blist.order['groups']
  58.     
  59.     try:
  60.         return order.index(obj.groupkey())
  61.     except ValueError:
  62.         order.append(obj.groupkey())
  63.         return len(order) - 1
  64.  
  65.  
  66.  
  67. def by_name(obj):
  68.     if isinstance(obj, GroupTypes):
  69.         return grp_order(obj)
  70.     
  71.     return obj.alias.lower()
  72.  
  73.  
  74. def by_status(obj):
  75.     if isinstance(obj, GroupTypes):
  76.         if grouping():
  77.             order = profile.blist.order['groups']
  78.             
  79.             try:
  80.                 return order.index(obj.groupkey())
  81.             except ValueError:
  82.                 if isinstance(obj, SpecialGroup):
  83.                     
  84.                     try:
  85.                         stats = oset()
  86.                         for status in STATUS_ORDER:
  87.                             stats.add(SpecialGroup(status).groupkey())
  88.                         
  89.                         stats.difference_update(order)
  90.                         for status in stats:
  91.                             order.append(status)
  92.                         
  93.                         if obj.groupkey() not in stats:
  94.                             order.append(obj.groupkey())
  95.                         
  96.                         return by_status(obj)
  97.                     except ValueError:
  98.                         order.append(obj.groupkey())
  99.                         return len(order) - 1
  100.                     except:
  101.                         None<EXCEPTION MATCH>ValueError
  102.                     
  103.  
  104.                 None<EXCEPTION MATCH>ValueError
  105.                 order.append(obj.groupkey())
  106.                 return len(order) - 1
  107.             except Exception:
  108.                 e = None
  109.                 print obj.name.lower()
  110.                 raise e
  111.             except:
  112.                 None<EXCEPTION MATCH>ValueError
  113.             
  114.  
  115.         None<EXCEPTION MATCH>ValueError
  116.         return grp_order(obj)
  117.     
  118.     status = obj.status_orb
  119.     
  120.     try:
  121.         if status == 'unknown':
  122.             status = 'offline'
  123.         
  124.         return (STATUS_ORDER.index(status), _(status.title()))
  125.     except:
  126.         import sys
  127.         print >>sys.stderr, 'ERROR STATUS:', status
  128.         raise 
  129.  
  130.  
  131.  
  132. def by_log(obj):
  133.     if isinstance(obj, GroupTypes):
  134.         return grp_order(obj)
  135.     
  136.     
  137.     try:
  138.         return -(obj.log_size)
  139.     except AttributeError:
  140.         return 1
  141.  
  142.  
  143.  
  144. def by_service(obj):
  145.     if isinstance(obj, GroupTypes):
  146.         return grp_order(obj)
  147.     
  148.     if hasattr(obj, 'protocols') and hasattr(obj, 'first_online'):
  149.         return protocols[obj.first_online.service]['name']
  150.     
  151.     
  152.     try:
  153.         return protocols[obj.service]['name']
  154.     except AttributeError:
  155.         return None
  156.  
  157.  
  158.  
  159. def no_sorting(obj):
  160.     pass
  161.  
  162. sortfuncs = dict(name = (by_name, ('alias',)), status = (by_status, ('status', 'idle', 'away', 'mobile', 'online')), log = (by_log, ('log_size',)), service = (by_service, ('protocol',)), none = (None, ()))
  163. sortnames = dictreverse(sortfuncs)
  164.  
  165. class BuddyListSorter(Observable):
  166.     MAX_SORTERS = 2
  167.     
  168.     def __init__(self):
  169.         Observable.__init__(self)
  170.         self.sorters = [
  171.             (None, ()),
  172.             (None, ())]
  173.         self.view = []
  174.         self.needed_attrs = [
  175.             'status']
  176.         self.hide_group_titles = False
  177.         self.make_groups = False
  178.         self.attr_observers = []
  179.  
  180.     
  181.     def getsortnames(self):
  182.         if not [ sortnames.get(s) for s in self.sorters ]:
  183.             pass
  184.         return [
  185.             'none']
  186.  
  187.     
  188.     def sort_buddylist(self, L):
  189.         if not pref('buddylist.sorting', True):
  190.             return None
  191.         
  192.         if self.make_groups:
  193.             self.group(L)
  194.         
  195.         self.sort(L)
  196.  
  197.     
  198.     def sortby(self, sorters_str):
  199.         log.info('sortby got %r', sorters_str)
  200.         
  201.         try:
  202.             sorters_str = sorters_str.split()
  203.             sorters = []
  204.             allattrs = []
  205.             for i, sorter in enumerate(sorters_str):
  206.                 if i == 0:
  207.                     if sorter.startswith('*'):
  208.                         sorter = sorter[1:]
  209.                         self.make_groups = True
  210.                     else:
  211.                         self.make_groups = False
  212.                 
  213.                 (func, attrs) = sortfuncs[sorter]
  214.                 sorters.append((func, attrs))
  215.                 allattrs += attrs
  216.             
  217.             self.sorters = sorters
  218.             self.needed_attrs = list(set(allattrs))
  219.             self.rebuild()
  220.         except:
  221.             print_exc()
  222.             return self.sortby('none none')
  223.  
  224.  
  225.     
  226.     def allow_group_ordering(self):
  227.         if grouping():
  228.             pass
  229.         return not (sortfuncs['status'] in self.sorters)
  230.  
  231.     allow_group_ordering = property(allow_group_ordering)
  232.     
  233.     def group(self, L):
  234.         funcs = [
  235.             self.sorters[0][0]]
  236.         
  237.         keyfunc = lambda x: (tuple,)((lambda .0: for f in .0:
  238. None if f is not None else 0)(funcs))
  239.  
  240.         L[:] = [ SpecialGroup(unicode(key[-1]), getattr(grp, 'protocols', []), getattr(grp, 'ids', []), list(grp)) for key, grp in groupby(self.flatten(L), keyfunc) ]
  241.         if self.sorters[0][0] is by_status:
  242.             for group in filter((lambda x: isinstance(x, GroupTypes)), L):
  243.                 group._show_offline_count = False
  244.                 group.name = eval(group.name)[1]
  245.                 if group.name == 'away':
  246.                     group.away = True
  247.                     continue
  248.                 []
  249.                 if group.name == 'online':
  250.                     group.online = True
  251.                     continue
  252.                 []
  253.                 group.online = False
  254.             
  255.         
  256.         return L
  257.  
  258.     
  259.     def user_ordering(self):
  260.         ns = sortfuncs['none']
  261.         if not self.sorters == [] and self.sorters == [
  262.             ns] and self.sorters == [
  263.             ns,
  264.             ns]:
  265.             pass
  266.         return not pref('buddylist.sorting', True)
  267.  
  268.     user_ordering = property(user_ordering)
  269.     sortby_val = prefprop('buddylist.sortby')
  270.     
  271.     def sortstatus(self):
  272.         return self.sortby_val.startswith('*status')
  273.  
  274.     sortstatus = property(sortstatus)
  275.     showoffline = prefprop('buddylist.show_offline')
  276.     hidegroups = prefprop('buddylist.hide_offline_groups')
  277.     groupoff = prefprop('buddylist.group_offline')
  278.     
  279.     def do_group_offline(self):
  280.         if self.groupoff and not (self.sortstatus):
  281.             pass
  282.         return self.showoffline
  283.  
  284.     do_group_offline = property(do_group_offline)
  285.     
  286.     def hideoffline(self):
  287.         if (self.sortstatus or not (self.showoffline)) and not (self.sortstatus):
  288.             pass
  289.         return self.hidegroups
  290.  
  291.     hideoffline = property(hideoffline)
  292.     
  293.     def sort(self, L):
  294.         funcs = []([], [ x[0] for x in self.sorters ])
  295.         L.sort(key = keyfunc)
  296.         for obj in L:
  297.             if issortable(obj):
  298.                 self.sort(obj)
  299.                 continue
  300.             None if funcs and (None, ()) != funcs[0] else filter
  301.         
  302.  
  303.     
  304.     def flatten(self, L):
  305.         i = 0
  306.         size = len(L)
  307.         while i < size:
  308.             if isinstance(L[i], GroupTypes):
  309.                 L[i:i + 1] = L[i]
  310.                 size = len(L)
  311.                 continue
  312.             i += 1
  313.         return L
  314.  
  315.     
  316.     def gui_toggle_grouping(self, v = None):
  317.         self.make_groups = None if v is None else bool(v)
  318.         self.rebuild()
  319.  
  320.     
  321.     def make_xml(self, root = None):
  322.         if root is None:
  323.             root = self.view
  324.         
  325.         t = tag(type(root).__name__, name = getattr(root, 'name', 'unknown'))
  326.         if isiterable(root):
  327.             for thing in root:
  328.                 t(self.make_xml(thing))
  329.             
  330.         
  331.         return t._to_xml()
  332.  
  333.     
  334.     def rebuild(self):
  335.         profile = profile
  336.         import common
  337.         profile.blist.rebuild()
  338.  
  339.  
  340.  
  341. def sort_by_status_and_proto():
  342.     
  343.     def by_status(obj):
  344.         
  345.         try:
  346.             return (dict(online = 0, idle = 1, away = 2, NA = 3, offline = 4).get(obj.status.lower(), 3), obj.status.lower())
  347.         except:
  348.             
  349.             try:
  350.                 return None if obj.online else (4, 'offline')
  351.             return (4, 'offline')
  352.  
  353.  
  354.  
  355.     
  356.     def by_name(obj):
  357.         return obj.name.lower()
  358.  
  359.     return ((by_status, ('status',), True), (by_name, ('name',)))
  360.  
  361. if __name__ == '__main__':
  362.     from tests.testapp import testapp
  363.     app = testapp('../../')
  364.     import digsbyprofile
  365.     names = ('dotsyntax1', 'digsby04')
  366.     accts = filter((lambda x: x.name in names), digsbyprofile.profile.account_manager.accounts)
  367.     do((lambda .0: for acct in .0:
  368. acct())(accts))
  369.     sorter = BuddyListSorter()
  370.     do((lambda .0: for a in .0:
  371. sorter.add_buddylist(a.connection, a.connection.root_group))(accts))
  372.     sorter.add_filter(*filter_offline())
  373.     do((lambda .0: for a in .0:
  374. sorter.add_sorter(*a))(sort_by_status_and_proto()))
  375.     from wx.py.PyWrap import wrap
  376.     wrap(app)
  377.     do((lambda .0: for acct in .0:
  378. acct())(accts))
  379.  
  380.