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         request = self._connection.get('people/{0}.json'.format(self.guid))
 109         self._postproc(request)
 110
 111     def fetchprofile(self):
 112         """Fetches user data.
 113         """
 114         data = search.Search(self._connection).user(self.handle)[0]
 115         self.data = data
 116
 117
 118 class Contacts():
 119     """This class represents user's list of contacts.
 120     """
 121     def __init__(self, connection):
 122         self._connection = connection
 123
 124     def add(self, user_id, aspect_ids):
 125         """Add user to aspects of given ids.
 126
 127         :param user_id: user guid
 128         :type user_id: str
 129         :param aspect_ids: list of aspect ids
 130         :type aspect_ids: list
 131         """
 132         for aid in aspect_ids: Aspect(self._connection, aid).addUser(user_id)
 133
 134     def remove(self, user_id, aspect_ids):
 135         """Remove user from aspects of given ids.
 136
 137         :param user_id: user guid
 138         :type user_id: str
 139         :param aspect_ids: list of aspect ids
 140         :type aspect_ids: list
 141         """
 142         for aid in aspect_ids: Aspect(self._connection, aid).removeUser(user_id)
 143
 144     def get(self, set=''):
 145         """Returns list of user contacts.
 146         Contact is a User() who is in one or more of user's
 147         aspects.
 148
 149         By default, it will return list of users who are in
 150         user's aspects.
 151
 152         If `set` is `all` it will also include users who only share
 153         with logged user and are not in his/hers aspects.
 154
 155         If `set` is `only_sharing` it will return users who are only
 156         sharing with logged user and ARE NOT in his/hers aspects.
 157
 158         :param set: if passed could be 'all' or 'only_sharing'
 159         :type set: str
 160         """
 161         params = {}
 162         if set: params['set'] = set
 163
 164         request = self._connection.get('contacts.json', params=params)
 165         if request.status_code != 200:
 166             raise Exception('status code {0}: cannot get contacts'.format(request.status_code))
 167         contacts = [User(self._connection, guid=user['guid'], handle=user['handle'], fetch=None, id=user['id']) for user in request.json()]
 168         return contacts