home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2009 June / maximum-cd-2009-06.iso / DiscContents / digsby_setup.exe / lib / social / twitter / objects.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-02-26  |  12.7 KB  |  426 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from util.net import linkify
  5. from util.cacheable import urlcacheopen
  6. from social.twitter.interfaces import IDisplayableTweet
  7. from util.primitives import iproperty
  8. from social.twitter.interfaces import ITwitterFetcher
  9. from util.primitives import Storage
  10. from protocols.adapters import AdaptationFailure
  11. from util.primitives import preserve_newlines
  12. import traceback
  13. import calendar
  14. import urlparse
  15. import protocols
  16. import time
  17. import simplejson
  18. from interfaces import IDisplayableStatus, IDisplayableDirect, ICachingURLObj, ILinkifiedText
  19. import rfc822
  20. from logging import getLogger
  21. log = getLogger('twitter.objects')
  22.  
  23. class TwitterCacheable(protocols.AbstractBase):
  24.     protocols.advise(instancesProvide = [
  25.         ICachingURLObj])
  26.     get_cache_names = dict
  27.     
  28.     def _get_cache_names(self):
  29.         
  30.         try:
  31.             return self._cache_names
  32.         except AttributeError:
  33.             KeyError = None
  34.             self._cache_names = self.get_cache_names()
  35.  
  36.         return self._cache_names
  37.  
  38.     cache_names = property(fget = _get_cache_names, doc = 'dict of attributes to map cache URLs as')
  39.     
  40.     def _get_cache_values(self):
  41.         
  42.         try:
  43.             return self._cache_values
  44.         except AttributeError:
  45.             KeyError = None
  46.             self._cache_values = { }
  47.  
  48.         return self._cache_values
  49.  
  50.     cache_values = property(fget = _get_cache_values, doc = 'completed values')
  51.     
  52.     def do_cache(self, cache = None):
  53.         for name, location in self.cache_names.iteritems():
  54.             if cache is not None:
  55.                 
  56.                 try:
  57.                     self.cache_values[name] = cache[location]
  58.                 continue
  59.                 except KeyError:
  60.                     pass
  61.                 except:
  62.                     None<EXCEPTION MATCH>KeyError
  63.                 
  64.  
  65.             
  66.             if self.cache_values.get(name, sentinel) is sentinel:
  67.                 
  68.                 try:
  69.                     (resp, _data) = urlcacheopen(location)
  70.                 except Exception:
  71.                     self.cache_values[name] = None
  72.  
  73.                 if resp.status <= resp.status:
  74.                     pass
  75.                 elif resp.status < 300:
  76.                     self.cache_values[name] = resp.cache_path
  77.                     if cache is not None:
  78.                         cache[location] = resp.cache_path
  79.                     
  80.                 else:
  81.                     self.cache_values[name] = None
  82.             resp.status < 300
  83.         
  84.  
  85.  
  86.  
  87. class StatusMixin(object):
  88.     
  89.     def _tweet(self):
  90.         return self
  91.  
  92.     _tweet = property(_tweet)
  93.     
  94.     def get_cache_names(self):
  95.         return {
  96.             'cache_url': self._tweet.user.profile_image_url }
  97.  
  98.     
  99.     def user_screen_name(self):
  100.         return self._tweet.user.screen_name
  101.  
  102.     user_screen_name = property(user_screen_name)
  103.     
  104.     def linkified_text(self):
  105.         
  106.         try:
  107.             return self._linkified_text
  108.         except AttributeError:
  109.             import social.twitter.functions as f
  110.             pieces = f.at_someone.split(preserve_newlines(self.text))
  111.             pieces = filter(None, pieces)
  112.             pieces = [ f.namelink(linkify(piece)) for piece in pieces ]
  113.             self._linkified_text = u''.join(pieces)
  114.             return self._linkified_text
  115.         except:
  116.             []
  117.  
  118.  
  119.     linkified_text = property(linkified_text)
  120.  
  121.  
  122. class DirectMixin(object):
  123.     
  124.     def _tweet(self):
  125.         return self
  126.  
  127.     _tweet = property(_tweet)
  128.     
  129.     def get_cache_names(self):
  130.         return {
  131.             'sender_cache_url': self._tweet.sender.profile_image_url,
  132.             'recipient_cache_url': self._tweet.recipient.profile_image_url }
  133.  
  134.     
  135.     def linkified_text(self):
  136.         
  137.         try:
  138.             return self._linkified_text
  139.         except AttributeError:
  140.             self._linkified_text = linkify(preserve_newlines(self.text))
  141.             return self._linkified_text
  142.  
  143.  
  144.     linkified_text = property(linkified_text)
  145.  
  146.  
  147. class UpdateFetcherMixin(object):
  148.     
  149.     def get_updatefreq(self):
  150.         return self._updatefreq
  151.  
  152.     
  153.     def set_updatefreq(self, value):
  154.         self._updatefreq = value
  155.  
  156.     
  157.     def del_updatefreq(self):
  158.         del self._updatefreq
  159.  
  160.     updatefreq = iproperty('get_updatefreq', 'set_updatefreq', 'del_updatefreq')
  161.  
  162.  
  163. class StringTwitterFetcher(object):
  164.     protocols.advise(instancesProvide = [
  165.         ITwitterFetcher])
  166.     
  167.     def __init__(self, url):
  168.         self.url = url
  169.  
  170.     
  171.     def id(self):
  172.         return self.url
  173.  
  174.     id = property(id)
  175.     
  176.     def Fetch(self, api):
  177.         json = api._FetchUrl(self.url)
  178.         data = simplejson.loads(json)
  179.         ret = []
  180.         for d in filter(None, data):
  181.             
  182.             try:
  183.                 ret.append(IDisplayableTweet(d))
  184.             continue
  185.             except AdaptationFailure:
  186.                 log.error('there was an error adapting %r', d)
  187.                 continue
  188.             
  189.  
  190.         
  191.         return ret
  192.  
  193.  
  194.  
  195. def fetcherFromString(s):
  196.     if s.endswith('.json') or s.endswith('.xml'):
  197.         return StringTwitterFetcher(s)
  198.     else:
  199.         return None
  200.  
  201.  
  202. class TwitterStatusMsg(StatusMixin, TwitterCacheable, Storage):
  203.     protocols.advise(instancesProvide = [
  204.         IDisplayableStatus])
  205.     direct = False
  206.     
  207.     def __init__(self, *a, **k):
  208.         Storage.__init__(self, *a, **k)
  209.         if 'user' in self:
  210.             self.user = Storage(self.user)
  211.         
  212.  
  213.     
  214.     def AsDict(self):
  215.         d = dict(self)
  216.         if 'user' in d:
  217.             d['user'] = dict(d['user'])
  218.         
  219.         d.pop('twitter', None)
  220.         d.pop('_cache_names', None)
  221.         d.pop('_cache_values', None)
  222.         d.pop('_linkified_text', None)
  223.         d.pop('_kind', None)
  224.         return d
  225.  
  226.     
  227.     def shouldShow(self, icon_type):
  228.         return self.twitter.shouldShow(self, icon_type)
  229.  
  230.     
  231.     def kind(self):
  232.         
  233.         try:
  234.             return self._kind
  235.         except AttributeError:
  236.             if self.user.get('screen_name', '').lower() == self.twitter.name.lower() and self.in_reply_to_user_id:
  237.                 self._kind = 'self_reply'
  238.             elif self.user.get('screen_name', '').lower() == self.twitter.name.lower():
  239.                 self._kind = 'self_tweet'
  240.             elif self.in_reply_to_user_id and '@' + self.twitter.name.lower() in self.text.lower():
  241.                 self._kind = 'friend_reply'
  242.             else:
  243.                 self._kind = 'friend_tweet'
  244.             return self._kind
  245.  
  246.  
  247.     kind = property(kind)
  248.     
  249.     def created_at_in_seconds(self):
  250.         if self.created_at is None:
  251.             return 0
  252.         
  253.         return calendar.timegm(rfc822.parsedate(self.created_at))
  254.  
  255.     created_at_in_seconds = property(created_at_in_seconds)
  256.     
  257.     def relative_created_at(self):
  258.         fudge = 1.5
  259.         delta = int(time.time()) - int(self.created_at_in_seconds)
  260.         if delta < 60 * fudge:
  261.             return 'about a minute ago'
  262.         elif delta < 3600 * (1 / fudge):
  263.             return 'about %d minutes ago' % (delta / 60 + 1)
  264.         elif delta < 3600 * fudge:
  265.             return 'about an hour ago'
  266.         elif delta < 86400 * (1 / fudge):
  267.             return 'about %d hours ago' % (delta / 3600 + 1)
  268.         elif delta < 86400 * fudge:
  269.             return 'about a day ago'
  270.         else:
  271.             return 'about %d days ago' % (delta / 86400 + 1)
  272.  
  273.     relative_created_at = property(relative_created_at)
  274.     
  275.     def __repr__(self):
  276.         return '<StatusMessage id: %s>' % self.id
  277.  
  278.  
  279.  
  280. class TwitterDirectMsg(DirectMixin, TwitterCacheable, Storage):
  281.     protocols.advise(instancesProvide = [
  282.         IDisplayableDirect])
  283.     direct = True
  284.     
  285.     def __init__(self, *a, **k):
  286.         Storage.__init__(self, *a, **k)
  287.         if 'sender' in self:
  288.             self.sender = Storage(self.sender)
  289.         
  290.         if 'recipient' in self:
  291.             self.recipient = Storage(self.recipient)
  292.         
  293.  
  294.     
  295.     def AsDict(self):
  296.         d = dict(self)
  297.         if 'sender' in d:
  298.             d['sender'] = dict(d['sender'])
  299.         
  300.         if 'recipient' in d:
  301.             d['recipient'] = dict(d['recipient'])
  302.         
  303.         d.pop('twitter', None)
  304.         d.pop('_cache_names', None)
  305.         d.pop('_cache_values', None)
  306.         d.pop('_linkified_text', None)
  307.         d.pop('_kind', None)
  308.         return d
  309.  
  310.     
  311.     def shouldShow(self, icon_type):
  312.         return self.twitter.shouldShow(self, icon_type)
  313.  
  314.     
  315.     def kind(self):
  316.         
  317.         try:
  318.             return self._kind
  319.         except AttributeError:
  320.             if self.sender.get('screen_name', '').lower() == self.twitter.name.lower():
  321.                 self._kind = 'direct_sent'
  322.             else:
  323.                 self._kind = 'direct_recieved'
  324.             return self._kind
  325.  
  326.  
  327.     kind = property(kind)
  328.     
  329.     def created_at_in_seconds(self):
  330.         return calendar.timegm(rfc822.parsedate(self.created_at))
  331.  
  332.     created_at_in_seconds = property(created_at_in_seconds)
  333.     
  334.     def relative_created_at(self):
  335.         fudge = 1.5
  336.         delta = int(time.time()) - int(self.created_at_in_seconds)
  337.         if delta < 60 * fudge:
  338.             return 'about a minute ago'
  339.         elif delta < 3600 * (1 / fudge):
  340.             return 'about %d minutes ago' % (delta / 60 + 1)
  341.         elif delta < 3600 * fudge:
  342.             return 'about an hour ago'
  343.         elif delta < 86400 * (1 / fudge):
  344.             return 'about %d hours ago' % (delta / 3600 + 1)
  345.         elif delta < 86400 * fudge:
  346.             return 'about a day ago'
  347.         else:
  348.             return 'about %d days ago' % (delta / 86400 + 1)
  349.  
  350.     relative_created_at = property(relative_created_at)
  351.     
  352.     def __repr__(self):
  353.         return '<DirectMessage id: %s>' % self.id
  354.  
  355.  
  356.  
  357. def validate_user(user):
  358.     int(user.id)
  359.     unicode(user.name)
  360.     unicode(user.screen_name)
  361.     if isinstance(user.profile_image_url, unicode):
  362.         user.profile_image_url = fix_unicode_url(user.profile_image_url)
  363.     
  364.     str(user.profile_image_url)
  365.  
  366.  
  367. def fix_unicode_url(url):
  368.     parsed = urlparse.urlsplit(url)
  369.     newpath = [] + []([ x.encode('utf-8').encode('url') for x in parsed.path.split('/')[1:] ])
  370.     url = urlparse.urlunsplit((parsed.scheme, parsed.netloc, newpath, parsed.query, parsed.fragment))
  371.     return url
  372.  
  373.  
  374. def validate_direct(tweet):
  375.     
  376.     try:
  377.         validate_user(tweet.sender)
  378.         validate_user(tweet.recipient)
  379.         unicode(tweet.sender_screen_name)
  380.         unicode(tweet.recipient_screen_name)
  381.         int(tweet.id)
  382.         unicode(tweet.text)
  383.         tweet.relative_created_at
  384.     except Exception:
  385.         traceback.print_exc()
  386.         return False
  387.  
  388.     return True
  389.  
  390.  
  391. def validate_status(tweet):
  392.     
  393.     try:
  394.         int(tweet.id)
  395.         unicode(tweet.text)
  396.         tweet.relative_created_at
  397.         
  398.         try:
  399.             bool(tweet.favorited)
  400.         except (KeyError, AttributeError):
  401.             tweet.favorited = False
  402.  
  403.         str(tweet.source)
  404.         validate_user(tweet.user)
  405.     except Exception:
  406.         traceback.print_exc()
  407.         return False
  408.  
  409.     return True
  410.  
  411.  
  412. def tweetFromDict(d):
  413.     if 'user' in d:
  414.         t = TwitterStatusMsg(d)
  415.         if validate_status(t):
  416.             return t
  417.         
  418.     elif 'sender' in d:
  419.         t = TwitterDirectMsg(d)
  420.         if validate_direct(t):
  421.             return t
  422.         
  423.     else:
  424.         return None
  425.  
  426.