diaspy/people.py

   1 import re
   2 from diaspy.streams import Outer
   3 from diaspy.models import Aspect
   4 from diaspy import errors
   5 from diaspy import search
   6
   7
   8 def sephandle(handle):
   9     """Separate Diaspora* handle into pod pod and user.
  10
  11     :returns: two-tuple (pod, user)
  12     """
  13     if re.match('^[a-zA-Z]+[a-zA-Z0-9_-]*@[a-z0-9.]+\.[a-z]+$', handle) is None:
  14         raise errors.InvalidHandleError('{0}'.format(handle))
  15     handle = handle.split('@')
  16     pod, user = handle[1], handle[0]
  17     return (pod, user)
  18
  19
  20 class User():
  21     """This class abstracts a D* user.
  22     This object goes around the limitations of current D* API and will
  23     extract user data using black magic.
  24     However, no chickens are harmed when you use it.
  25
  26     The parameter fetch should be either 'posts', 'data' or 'none'. By
  27     default it is 'posts' which means in addition to user data, stream
  28     will be fetched. If user has not posted yet diaspy will not be able
  29     to extract the information from his/her posts. Since there is no official
  30     way to do it we rely on user posts. If this will be the case user
  31     will be notified with appropriate exception message.
  32
  33     If fetch is 'data', only user data will be fetched. If the user is
  34     not found, no exception will be returned.
  35
  36     When creating new User() one can pass either guid, handle and/or id as
  37     optional parameters. GUID takes precedence over handle when fetching
  38     user stream. When fetching user data, handle is required.
  39     """
  40     def __init__(self, connection, guid='', handle='', fetch='posts', id=0):
  41         self._connection = connection
  42         self.stream = []
  43         self.handle = handle
  44         self.guid = guid
  45         self.data = {
  46             'guid': guid,
  47             'handle': handle,
  48             'id': id,
  49         }
  50         self._fetch(fetch)
  51
  52     def __getitem__(self, key):
  53         return self.data[key]
  54
  55     def __str__(self):
  56         return self['guid']
  57
  58     def __repr__(self):
  59         return '{0} ({1})'.format(self['diaspora_name'], self['guid'])
  60
  61     def _fetch(self, fetch):
  62         """Fetch user posts or data.
  63         """
  64         if fetch == 'posts':
  65             if self.handle and not self.guid: self.fetchhandle()
  66             else: self.fetchguid()
  67         elif fetch == 'data' and self.handle:
  68             self.fetchprofile()
  69
  70     def _finalize_data(self, data):
  71         """Adjustments are needed to have similar results returned
  72         by search feature and fetchguid/handle().
  73         """
  74         names = [   ('id', 'id'),
  75                     ('guid', 'guid'),
  76                     ('name', 'name'),
  77                     ('avatar', 'avatar'),
  78                     ('handle', 'diaspora_id'),
  79                     ]
  80         final = {}
  81         for f, d in names:
  82             final[f] = data[d]
  83         return final
  84
  85     def _postproc(self, request):
  86         """Makes necessary modifications to user data and
  87         sets up a stream.
  88
  89         :param request: request object
  90         :type request: request
  91         """
  92         if request.status_code != 200: raise Exception('wrong error code: {0}'.format(request.status_code))
  93         else: request = request.json()
  94         if not len(request): raise errors.UserError('cannot extract user data: no posts to analyze')
  95         self.data = self._finalize_data(request[0]['author'])
  96         self.stream = Outer(self._connection, location='people/{0}.json'.format(self['guid']))
  97
  98     def fetchhandle(self, protocol='https'):
  99         """Fetch user data and posts using Diaspora handle.
 100         """
 101         pod, user = sephandle(self.handle)
 102         request = self._connection.session.get('{0}://{1}/u/{2}.json'.format(protocol, pod, user))
 103         self._postproc(request)
 104
 105     def fetchguid(self):
 106         """Fetch user data and posts using guid.
 107         """
 108         if self.guid:
 109             request = self._connection.get('people/{0}.json'.format(self.guid))
 110             self._postproc(request)
 111         else:
 112             raise errors.UserError('GUID not set')
 113
 114     def fetchprofile(self):
 115         """Fetches user data.
 116         """
 117         data = search.Search(self._connection).user(self.handle)[0]
 118         self.data = data
 119
 120
 121 class Contacts():
 122     """This class represents user's list of contacts.
 123     """
 124     def __init__(self, connection):
 125         self._connection = connection
 126
 127     def add(self, user_id, aspect_ids):
 128         """Add user to aspects of given ids.
 129
 130         :param user_id: user guid
 131         :type user_id: str
 132         :param aspect_ids: list of aspect ids
 133         :type aspect_ids: list
 134         """
 135         for aid in aspect_ids: Aspect(self._connection, aid).addUser(user_id)
 136
 137     def remove(self, user_id, aspect_ids):
 138         """Remove user from aspects of given ids.
 139
 140         :param user_id: user guid
 141         :type user_id: str
 142         :param aspect_ids: list of aspect ids
 143         :type aspect_ids: list
 144         """
 145         for aid in aspect_ids: Aspect(self._connection, aid).removeUser(user_id)
 146
 147     def get(self, set=''):
 148         """Returns list of user contacts.
 149         Contact is a User() who is in one or more of user's
 150         aspects.
 151
 152         By default, it will return list of users who are in
 153         user's aspects.
 154
 155         If `set` is `all` it will also include users who only share
 156         with logged user and are not in his/hers aspects.
 157
 158         If `set` is `only_sharing` it will return users who are only
 159         sharing with logged user and ARE NOT in his/hers aspects.
 160
 161         :param set: if passed could be 'all' or 'only_sharing'
 162         :type set: str
 163         """
 164         params = {}
 165         if set: params['set'] = set
 166
 167         request = self._connection.get('contacts.json', params=params)
 168         if request.status_code != 200:
 169             raise Exception('status code {0}: cannot get contacts'.format(request.status_code))
 170         contacts = [User(self._connection, guid=user['guid'], handle=user['handle'], fetch=None, id=user['id']) for user in request.json()]
 171         return contacts