Version up, thanks to @gave92

Properly fixed `markAsRead`, @gave92  reminded me that I forgot to change the `True` to `'true'` when removing `encode_params`

.gitignore

@@ -24,7 +24,8 @@ develop-eggs
 # Sphinx documentation
 docs/_build/
 
-# Data for tests
+# Scripts and data for tests
+my_tests.py
 my_test_data.json
 my_data.json
 tests.data

README.rst

@@ -27,4 +27,8 @@ Installation:
 
     $ pip install fbchat
 
-Copyright 2015 - 2017 by Taehoon Kim / `@carpedm20 <http://carpedm20.github.io/about/>`__
+Maintainer
+----------
+
+- Mads Marquart / `@madsmtm <https://github.com/madsmtm>`__
+- Taehoon Kim / `@carpedm20 <http://carpedm20.github.io/about/>`__

examples/echobot.py

@@ -5,8 +5,8 @@ from fbchat import log, Client
 # Subclass fbchat.Client and override required methods
 class EchoBot(Client):
     def onMessage(self, author_id, message_object, thread_id, thread_type, **kwargs):
-        self.markAsDelivered(author_id, thread_id)
+        self.markAsDelivered(thread_id, message_object.uid)
-        self.markAsRead(author_id)
+        self.markAsRead(thread_id)
 
         log.info("{} from {} in {}".format(message_object, thread_id, thread_type.name))
 

fbchat/__init__.py

@@ -17,7 +17,7 @@ from .client import *
 
 
 __copyright__ = 'Copyright 2015 - {} by Taehoon Kim'.format(datetime.now().year)
-__version__ = '1.1.1'
+__version__ = '1.3.6'
 __license__ = 'BSD'
 __author__ = 'Taehoon Kim; Moreels Pieter-Jan; Mads Marquart'
 __email__ = 'carpedm20@gmail.com'

fbchat/client.py

@@ -20,6 +20,8 @@ class Client(object):
     See https://fbchat.readthedocs.io for complete documentation of the API.
     """
 
+    ssl_verify = True
+    """Verify ssl certificate, set to False to allow debugging with a proxy"""
     listening = False
     """Whether the client is listening. Used when creating an external event loop to determine when to stop listening"""
     uid = None
@@ -105,7 +107,7 @@ class Client(object):
 
     def _get(self, url, query=None, timeout=30, fix_request=False, as_json=False, error_retries=3):
         payload = self._generatePayload(query)
-        r = self._session.get(url, headers=self._header, params=payload, timeout=timeout)
+        r = self._session.get(url, headers=self._header, params=payload, timeout=timeout, verify=self.ssl_verify)
         if not fix_request:
             return r
         try:
@@ -117,7 +119,7 @@ class Client(object):
 
     def _post(self, url, query=None, timeout=30, fix_request=False, as_json=False, error_retries=3):
         payload = self._generatePayload(query)
-        r = self._session.post(url, headers=self._header, data=payload, timeout=timeout)
+        r = self._session.post(url, headers=self._header, data=payload, timeout=timeout, verify=self.ssl_verify)
         if not fix_request:
             return r
         try:
@@ -137,17 +139,17 @@ class Client(object):
             raise e
 
     def _cleanGet(self, url, query=None, timeout=30):
-        return self._session.get(url, headers=self._header, params=query, timeout=timeout)
+        return self._session.get(url, headers=self._header, params=query, timeout=timeout, verify=self.ssl_verify)
 
     def _cleanPost(self, url, query=None, timeout=30):
         self.req_counter += 1
-        return self._session.post(url, headers=self._header, data=query, timeout=timeout)
+        return self._session.post(url, headers=self._header, data=query, timeout=timeout, verify=self.ssl_verify)
 
     def _postFile(self, url, files=None, query=None, timeout=30, fix_request=False, as_json=False, error_retries=3):
         payload=self._generatePayload(query)
         # Removes 'Content-Type' from the header
         headers = dict((i, self._header[i]) for i in self._header if i != 'Content-Type')
-        r = self._session.post(url, headers=headers, data=payload, timeout=timeout, files=files)
+        r = self._session.post(url, headers=headers, data=payload, timeout=timeout, files=files, verify=self.ssl_verify)
         if not fix_request:
             return r
         try:
@@ -479,7 +481,7 @@ class Client(object):
                 if k['id'] in ['0', 0]:
                     # Skip invalid users
                     pass
-                users.append(User(k['id'], first_name=k.get('firstName'), url=k.get('uri'), photo=k.get('thumbSrc'), name=k.get('name'), is_friend=k.get('is_friend'), gender=GENDERS[k.get('gender')]))
+                users.append(User(k['id'], first_name=k.get('firstName'), url=k.get('uri'), photo=k.get('thumbSrc'), name=k.get('name'), is_friend=k.get('is_friend'), gender=GENDERS.get(k.get('gender'))))
 
         return users
 
@@ -754,19 +756,23 @@ class Client(object):
 
         return list(reversed([graphql_to_message(message) for message in j['message_thread']['messages']['nodes']]))
 
-    def fetchThreadList(self, offset=0, limit=20, thread_location=ThreadLocation.INBOX):
+    def fetchThreadList(self, offset=None, limit=20, thread_location=ThreadLocation.INBOX, before=None):
         """Get thread list of your facebook account
 
-        :param offset: The offset, from where in the list to recieve threads from
+        :param offset: Deprecated. Do not use!
         :param limit: Max. number of threads to retrieve. Capped at 20
         :param thread_location: models.ThreadLocation: INBOX, PENDING, ARCHIVED or OTHER
-        :type offset: int
+        :param before: A timestamp (in milliseconds), indicating from which point to retrieve threads
         :type limit: int
+        :type before: int
         :return: :class:`models.Thread` objects
         :rtype: list
         :raises: FBchatException if request failed
         """
 
+        if offset is not None:
+            log.warning('Using `offset` in `fetchThreadList` is no longer supported, since Facebook migrated to the use of GraphQL in this request. Use `before` instead')
+
         if limit > 20 or limit < 1:
             raise FBchatUserError('`limit` should be between 1 and 20')
 
@@ -775,73 +781,46 @@ class Client(object):
         else:
             raise FBchatUserError('"thread_location" must be a value of ThreadLocation')
 
-        data = {
+        j = self.graphql_request(GraphQL(doc_id='1349387578499440', params={
-            'client' : self.client,
+            'limit': limit,
-            loc_str + '[offset]' : offset,
+            'tags': [loc_str],
-            loc_str + '[limit]' : limit,
+            'before': before,
-        }
+            'includeDeliveryReceipts': True,
+            'includeSeqID': False
+        }))
 
-        j = self._post(self.req_url.THREADS, data, fix_request=True, as_json=True)
+        return [graphql_to_thread(node) for node in j['viewer']['message_threads']['nodes']]
-        if j.get('payload') is None:
-            raise FBchatException('Missing payload: {}, with data: {}'.format(j, data))
-
-        participants = {}
-        if 'participants' in j['payload']:
-            for p in j['payload']['participants']:
-                if p['type'] == 'page':
-                    participants[p['fbid']] = Page(p['fbid'], url=p['href'], photo=p['image_src'], name=p['name'])
-                elif p['type'] == 'user':
-                    participants[p['fbid']] = User(p['fbid'], url=p['href'], first_name=p['short_name'], is_friend=p['is_friend'], gender=GENDERS[p['gender']], photo=p['image_src'], name=p['name'])
-                else:
-                    raise FBchatException('A participant had an unknown type {}: {}'.format(p['type'], p))
-
-        entries = []
-        if 'threads' in j['payload']:
-            for k in j['payload']['threads']:
-                if k['thread_type'] == 1:
-                    if k['other_user_fbid'] not in participants:
-                        raise FBchatException('The thread {} was not in participants: {}'.format(k, j['payload']))
-                    participants[k['other_user_fbid']].message_count = k['message_count']
-                    entries.append(participants[k['other_user_fbid']])
-                elif k['thread_type'] == 2:
-                    entries.append(Group(k['thread_fbid'], participants=set([p.strip('fbid:') for p in k['participants']]), photo=k['image_src'], name=k['name'], message_count=k['message_count']))
-                elif k['thread_type'] == 3:
-                    entries.append(Room(
-                        k['thread_fbid'],
-                        participants = set(p.lstrip('fbid:') for p in k['participants']),
-                        photo = k['image_src'],
-                        name = k['name'],
-                        message_count = k['message_count'],
-                        admins = set(p.lstrip('fbid:') for p in k['admin_ids']),
-                        approval_mode = k['approval_mode'],
-                        approval_requests = set(p.lstrip('fbid:') for p in k['approval_queue_ids']),
-                        join_link = k['joinable_mode']['link']
-                        ))
-                else:
-                    raise FBchatException('A thread had an unknown thread type: {}'.format(k))
-
-        return entries
 
     def fetchUnread(self):
         """
-        .. todo::
+        Get the unread thread list
-            Documenting this
 
+        :return: List of unread thread ids
+        :rtype: list
         :raises: FBchatException if request failed
         """
         form = {
-            'client': 'mercury_sync',
             'folders[0]': 'inbox',
+            'client': 'mercury',
             'last_action_timestamp': now() - 60*1000
             # 'last_action_timestamp': 0
         }
 
-        j = self._post(self.req_url.THREAD_SYNC, form, fix_request=True, as_json=True)
+        j = self._post(self.req_url.UNREAD_THREADS, form, fix_request=True, as_json=True)
 
-        return {
+        return j['payload']['unread_thread_fbids'][0]['other_user_fbids']
-            "message_counts": j['payload']['message_counts'],
+
-            "unseen_threads": j['payload']['unseen_thread_ids']
+    def fetchUnseen(self):
-        }
+        """
+        Get the unseen (new) thread list
+
+        :return: List of unseen thread ids
+        :rtype: list
+        :raises: FBchatException if request failed
+        """
+        j = self._post(self.req_url.UNSEEN_THREADS, None, fix_request=True, as_json=True)
+
+        return j['payload']['unseen_thread_fbids'][0]['other_user_fbids']
 
     def fetchImageUrl(self, image_id):
         """Fetches the url to the original image from an image attachment ID
@@ -853,7 +832,7 @@ class Client(object):
         :raises: FBChatException if request failed
         """
         image_id = str(image_id)
-        j = checkRequest(self._get(ReqUrl.ATTACHMENT_PHOTO, query={'photo_id': str(image_id)}))
+        j = check_request(self._get(ReqUrl.ATTACHMENT_PHOTO, query={'photo_id': str(image_id)}))
 
         url = get_jsmods_require(j, 3)
         if url is None:
@@ -987,7 +966,7 @@ class Client(object):
         Deprecated. Use :func:`fbchat.Client.send` instead
         """
         thread_id, thread_type = self._getThread(thread_id, thread_type)
-        data = self._getSendData(message=message, thread_id=thread_id, thread_type=thread_type)
+        data = self._getSendData(message=self._oldMessage(message), thread_id=thread_id, thread_type=thread_type)
 
         data['action_type'] = 'ma-type:user-generated-message'
         data['has_attachment'] = True
@@ -1248,7 +1227,7 @@ class Client(object):
         :type thread_type: models.ThreadType
         :raises: FBchatException if request failed
         """
-        thread_id, thread_type = self._getThread(thread_id, None)
+        thread_id, thread_type = self._getThread(thread_id, thread_type)
 
         data = {
             "typ": status.value,
@@ -1263,28 +1242,36 @@ class Client(object):
     END SEND METHODS
     """
 
-    def markAsDelivered(self, userID, threadID):
+    def markAsDelivered(self, thread_id, message_id):
         """
-        .. todo::
+        Mark a message as delivered
-            Documenting this
+
+        :param thread_id: User/Group ID to which the message belongs. See :ref:`intro_threads`
+        :param message_id: Message ID to set as delivered. See :ref:`intro_threads`
+        :return: Whether the request was successful
+        :raises: FBchatException if request failed
         """
         data = {
-            "message_ids[0]": threadID,
+            "message_ids[0]": message_id,
-            "thread_ids[%s][0]" % userID: threadID
+            "thread_ids[%s][0]" % thread_id: message_id
         }
 
         r = self._post(self.req_url.DELIVERED, data)
         return r.ok
 
-    def markAsRead(self, userID):
+    def markAsRead(self, thread_id):
         """
-        .. todo::
+        Mark a thread as read
-            Documenting this
+        All messages inside the thread will be marked as read
+
+        :param thread_id: User/Group ID to set as read. See :ref:`intro_threads`
+        :return: Whether the request was successful
+        :raises: FBchatException if request failed
         """
         data = {
+            "ids[%s]" % thread_id: 'true',
             "watermarkTimestamp": now(),
-            "shouldSendReadReceipt": True,
+            "shouldSendReadReceipt": 'true',
-            "ids[%s]" % userID: True
         }
 
         r = self._post(self.req_url.READ_STATUS, data)
@@ -1482,20 +1469,20 @@ class Client(object):
                             try:
                                 for a in delta['attachments']:
                                     mercury = a['mercury']
-                                    if mercury.get('attach_type'):
+                                    if mercury.get('blob_attachment'):
                                         image_metadata = a.get('imageMetadata', {})
-                                        attach_type = mercury['attach_type']
+                                        attach_type = mercury['blob_attachment']['__typename']
                                         attachment = graphql_to_attachment(mercury.get('blob_attachment', {}))
 
-                                        if attach_type == ['file', 'video']:
+                                        if attach_type == ['MessageFile', 'MessageVideo', 'MessageAudio']:
                                             # TODO: Add more data here for audio files
                                             attachment.size = int(a['fileSize'])
-                                        elif attach_type == 'share':
+                                        attachments.append(attachment)
+                                    elif mercury.get('sticker_attachment'):
+                                        sticker = graphql_to_sticker(a['mercury']['sticker_attachment'])
+                                    elif mercury.get('extensible_attachment'):
                                         # TODO: Add more data here for shared stuff (URLs, events and so on)
                                         pass
-                                        attachments.append(attachment)
-                                    if a['mercury'].get('sticker_attachment'):
-                                        sticker = graphql_to_sticker(a['mercury']['sticker_attachment'])
                             except Exception:
                                 log.exception('An exception occured while reading attachments: {}'.format(delta['attachments']))
 
@@ -1526,10 +1513,15 @@ class Client(object):
                     self.onInbox(unseen=m["unseen"], unread=m["unread"], recent_unread=m["recent_unread"], msg=m)
 
                 # Typing
-                # elif mtype == "typ":
+                elif mtype == "typ":
-                #     author_id = str(m.get("from"))
+                    author_id = str(m.get("from"))
-                #     typing_status = TypingStatus(m.get("st"))
+                    thread_id = str(m.get("to"))
-                #     self.onTyping(author_id=author_id, typing_status=typing_status)
+                    if thread_id == self.uid:
+                        thread_type = ThreadType.USER
+                    else:
+                        thread_type = ThreadType.GROUP
+                    typing_status = TypingStatus(m.get("st"))
+                    self.onTyping(author_id=author_id, status=typing_status, thread_id=thread_id, thread_type=thread_type, msg=m)
 
                 # Delivered
 
@@ -1538,9 +1530,9 @@ class Client(object):
                 #
                 #     self.onSeen(m.get('realtime_viewer_fbid'), m.get('reader'), m.get('time'))
 
-                # elif mtype in ['jewel_requests_add']:
+                elif mtype in ['jewel_requests_add']:
-                #         from_id = m['from']
+                    from_id = m['from']
-                #         self.on_friend_request(from_id)
+                    self.onFriendRequest(from_id=from_id, msg=m)
 
                 # Happens on every login
                 elif mtype == "qprimer":
@@ -1849,6 +1841,20 @@ class Client(object):
         """
         log.info('Inbox event: {}, {}, {}'.format(unseen, unread, recent_unread))
 
+    def onTyping(self, author_id=None, status=None, thread_id=None, thread_type=None, msg=None):
+        """
+        Called when the client is listening, and somebody starts or stops typing into a chat
+
+        :param author_id: The ID of the person who sent the action
+        :param status: The typing status
+        :param thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
+        :param thread_type: Type of thread that the action was sent to. See :ref:`intro_threads`
+        :param msg: A full set of the data recieved
+        :type typing_status: models.TypingStatus
+        :type thread_type: models.ThreadType
+        """
+        pass
+
     def onQprimer(self, ts=None, msg=None):
         """
         Called when the client just started listening

fbchat/graphql.py

@@ -109,6 +109,13 @@ def graphql_to_attachment(a):
             large_image=a.get('large_image'),
             uid=a.get('legacy_attachment_id')
         )
+    elif _type == 'MessageAudio':
+        return AudioAttachment(
+            filename=a.get('filename'),
+            url=a.get('playable_url'),
+            duration=a.get('playable_duration_in_ms'),
+            audio_type=a.get('audio_type')
+        )
     elif _type == 'MessageFile':
         return FileAttachment(
             url=a.get('url'),
@@ -154,7 +161,7 @@ def graphql_to_user(user):
         first_name=user.get('first_name'),
         last_name=user.get('last_name'),
         is_friend=user.get('is_viewer_friend'),
-        gender=GENDERS[user.get('gender')],
+        gender=GENDERS.get(user.get('gender')),
         affinity=user.get('affinity'),
         nickname=c_info.get('nickname'),
         color=c_info.get('color'),
@@ -165,10 +172,46 @@ def graphql_to_user(user):
         message_count=user.get('messages_count')
     )
 
+def graphql_to_thread(thread):
+    if thread['thread_type'] == 'GROUP':
+        return graphql_to_group(thread)
+    elif thread['thread_type'] == 'ONE_TO_ONE':
+        if thread.get('big_image_src') is None:
+            thread['big_image_src'] = {}
+        c_info = get_customization_info(thread)
+        participants = [node['messaging_actor'] for node in thread['all_participants']['nodes']]
+        user = next(p for p in participants if p['id'] == thread['thread_key']['other_user_id'])
+        last_message_timestamp = None
+        if 'last_message' in thread:
+            last_message_timestamp = thread['last_message']['nodes'][0]['timestamp_precise']
+
+        return User(
+            user['id'],
+            url=user.get('url'),
+            name=user.get('name'),
+            first_name=user.get('short_name'),
+            last_name=user.get('name').split(user.get('short_name'),1)[1].strip(),
+            is_friend=user.get('is_viewer_friend'),
+            gender=GENDERS.get(user.get('gender')),
+            affinity=user.get('affinity'),
+            nickname=c_info.get('nickname'),
+            color=c_info.get('color'),
+            emoji=c_info.get('emoji'),
+            own_nickname=c_info.get('own_nickname'),
+            photo=user['big_image_src'].get('uri'),
+            message_count=thread.get('messages_count'),
+            last_message_timestamp=last_message_timestamp
+        )
+    else:
+        raise FBchatException('Unknown thread type: {}, with data: {}'.format(thread.get('thread_type'), thread))
+
 def graphql_to_group(group):
     if group.get('image') is None:
         group['image'] = {}
     c_info = get_customization_info(group)
+    last_message_timestamp = None
+    if 'last_message' in group:
+        last_message_timestamp = group['last_message']['nodes'][0]['timestamp_precise']
     return Group(
         group['thread_key']['thread_fbid'],
         participants=set([node['messaging_actor']['id'] for node in group['all_participants']['nodes']]),
@@ -177,7 +220,8 @@ def graphql_to_group(group):
         emoji=c_info.get('emoji'),
         photo=group['image'].get('uri'),
         name=group.get('name'),
-        message_count=group.get('messages_count')
+        message_count=group.get('messages_count'),
+        last_message_timestamp=last_message_timestamp
     )
 
 def graphql_to_room(room):

fbchat/models.py

@@ -9,11 +9,11 @@ class FBchatException(Exception):
 
 class FBchatFacebookError(FBchatException):
     #: The error code that Facebook returned
-    fb_error_code = str
+    fb_error_code = None
     #: The error message that Facebook returned (In the user's own language)
-    fb_error_message = str
+    fb_error_message = None
     #: The status code that was sent in the http response (eg. 404) (Usually only set if not successful, aka. not 200)
-    request_status_code = int
+    request_status_code = None
     def __init__(self, message, fb_error_code=None, fb_error_message=None, request_status_code=None):
         super(FBchatFacebookError, self).__init__(message)
         """Thrown by fbchat when Facebook returns an error"""
@@ -26,17 +26,17 @@ class FBchatUserError(FBchatException):
 
 class Thread(object):
     #: The unique identifier of the thread. Can be used a `thread_id`. See :ref:`intro_threads` for more info
-    uid = str
+    uid = None
     #: Specifies the type of thread. Can be used a `thread_type`. See :ref:`intro_threads` for more info
     type = None
-    #: The thread's picture
+    #: A url to the thread's picture
-    photo = str
+    photo = None
     #: The name of the thread
-    name = str
+    name = None
     #: Timestamp of last message
-    last_message_timestamp = str
+    last_message_timestamp = None
     #: Number of messages in the thread
-    message_count = int
+    message_count = None
     def __init__(self, _type, uid, photo=None, name=None, last_message_timestamp=None, message_count=None):
         """Represents a Facebook thread"""
         self.uid = str(uid)
@@ -55,25 +55,25 @@ class Thread(object):
 
 class User(Thread):
     #: The profile url
-    url = str
+    url = None
     #: The users first name
-    first_name = str
+    first_name = None
     #: The users last name
-    last_name = str
+    last_name = None
     #: Whether the user and the client are friends
-    is_friend = bool
+    is_friend = None
     #: The user's gender
-    gender = str
+    gender = None
     #: From 0 to 1. How close the client is to the user
-    affinity = float
+    affinity = None
     #: The user's nickname
-    nickname = str
+    nickname = None
     #: The clients nickname, as seen by the user
-    own_nickname = str
+    own_nickname = None
     #: A :class:`ThreadColor`. The message color
     color = None
     #: The default emoji
-    emoji = str
+    emoji = None
 
     def __init__(self, uid, url=None, first_name=None, last_name=None, is_friend=None, gender=None, affinity=None, nickname=None, own_nickname=None, color=None, emoji=None, **kwargs):
         """Represents a Facebook user. Inherits `Thread`"""
@@ -92,13 +92,13 @@ class User(Thread):
 
 class Group(Thread):
     #: Unique list (set) of the group thread's participant user IDs
-    participants = set
+    participants = None
-    #: Dict, containing user nicknames mapped to their IDs
+    #: A dict, containing user nicknames mapped to their IDs
-    nicknames = dict
+    nicknames = None
     #: A :class:`ThreadColor`. The groups's message color
     color = None
     #: The groups's default emoji
-    emoji = str
+    emoji = None
 
     def __init__(self, uid, participants=None, nicknames=None, color=None, emoji=None, **kwargs):
         """Represents a Facebook group. Inherits `Thread`"""
@@ -115,15 +115,15 @@ class Group(Thread):
 
 class Room(Group):
     # Set containing user IDs of thread admins
-    admins = set
+    admins = None
     # True if users need approval to join
-    approval_mode = bool
+    approval_mode = None
     # Set containing user IDs requesting to join
-    approval_requests = set
+    approval_requests = None
     # Link for joining room
-    join_link = str
+    join_link = None
     # True is room is not discoverable
-    privacy_mode = bool
+    privacy_mode = None
 
     def __init__(self, uid, admins=None, approval_mode=None, approval_requests=None, join_link=None, privacy_mode=None, **kwargs):
         """Represents a Facebook room. Inherits `Group`"""
@@ -142,15 +142,15 @@ class Room(Group):
 
 class Page(Thread):
     #: The page's custom url
-    url = str
+    url = None
     #: The name of the page's location city
-    city = str
+    city = None
     #: Amount of likes the page has
-    likes = int
+    likes = None
     #: Some extra information about the page
-    sub_title = str
+    sub_title = None
     #: The page's category
-    category = str
+    category = None
 
     def __init__(self, uid, url=None, city=None, likes=None, sub_title=None, category=None, **kwargs):
         """Represents a Facebook page. Inherits `Thread`"""
@@ -166,7 +166,7 @@ class Message(object):
     #: The actual message
     text = None
     #: A list of :class:`Mention` objects
-    mentions = []
+    mentions = None
     #: A :class:`EmojiSize`. Size of a sent emoji
     emoji_size = None
     #: The message ID
@@ -178,13 +178,13 @@ class Message(object):
     #: Whether the message is read
     is_read = None
     #: A dict with user's IDs as keys, and their :class:`MessageReaction` as values
-    reactions = {}
+    reactions = None
     #: The actual message
     text = None
     #: A :class:`Sticker`
     sticker = None
     #: A list of attachments
-    attachments = []
+    attachments = None
 
     def __init__(self, text=None, mentions=None, emoji_size=None, sticker=None, attachments=None):
         """Represents a Facebook message"""
@@ -207,7 +207,7 @@ class Message(object):
 
 class Attachment(object):
     #: The attachment ID
-    uid = str
+    uid = None
 
     def __init__(self, uid=None):
         """Represents a Facebook attachment"""
@@ -251,13 +251,13 @@ class ShareAttachment(Attachment):
 
 class FileAttachment(Attachment):
     #: Url where you can download the file
-    url = str
+    url = None
     #: Size of the file in bytes
-    size = int
+    size = None
     #: Name of the file
-    name = str
+    name = None
     #: Whether Facebook determines that this file may be harmful
-    is_malicious = bool
+    is_malicious = None
 
     def __init__(self, url=None, size=None, name=None, is_malicious=None, **kwargs):
         """Represents a file that has been sent as a Facebook attachment"""
@@ -267,45 +267,58 @@ class FileAttachment(Attachment):
         self.name = name
         self.is_malicious = is_malicious
 
-class AudioAttachment(FileAttachment):
+class AudioAttachment(Attachment):
-    def __init__(self, **kwargs):
+    #: Name of the file
-        """Represents an audio file that has been sent as a Facebook attachment - *Currently Incomplete!*"""
+    filename = None
-        super(StickerAttachment, self).__init__(**kwargs)
+    #: Url of the audio file
+    url = None
+    #: Duration of the audioclip in milliseconds
+    duration = None
+    #: Audio type
+    audio_type = None
+
+    def __init__(self, filename=None, url=None, duration=None, audio_type=None, **kwargs):
+        """Represents an audio file that has been sent as a Facebook attachment"""
+        super(AudioAttachment, self).__init__(**kwargs)
+        self.filename = filename
+        self.url = url
+        self.duration = duration
+        self.audio_type = audio_type
 
 class ImageAttachment(Attachment):
     #: The extension of the original image (eg. 'png')
-    original_extension = str
+    original_extension = None
     #: Width of original image
-    width = int
+    width = None
     #: Height of original image
-    height = int
+    height = None
 
     #: Whether the image is animated
-    is_animated = bool
+    is_animated = None
 
     #: URL to a thumbnail of the image
-    thumbnail_url = str
+    thumbnail_url = None
 
     #: URL to a medium preview of the image
-    preview_url = str
+    preview_url = None
     #: Width of the medium preview image
-    preview_width = int
+    preview_width = None
     #: Height of the medium preview image
-    preview_height = int
+    preview_height = None
 
     #: URL to a large preview of the image
-    large_preview_url = str
+    large_preview_url = None
     #: Width of the large preview image
-    large_preview_width = int
+    large_preview_width = None
     #: Height of the large preview image
-    large_preview_height = int
+    large_preview_height = None
 
     #: URL to an animated preview of the image (eg. for gifs)
-    animated_preview_url = str
+    animated_preview_url = None
     #: Width of the animated preview image
-    animated_preview_width = int
+    animated_preview_width = None
     #: Height of the animated preview image
-    animated_preview_height = int
+    animated_preview_height = None
 
     def __init__(self, original_extension=None, width=None, height=None, is_animated=None, thumbnail_url=None, preview=None, large_preview=None, animated_preview=None, **kwargs):
         """
@@ -344,36 +357,36 @@ class ImageAttachment(Attachment):
 
 class VideoAttachment(Attachment):
     #: Size of the original video in bytes
-    size = int
+    size = None
     #: Width of original video
-    width = int
+    width = None
     #: Height of original video
-    height = int
+    height = None
     #: Length of video in milliseconds
-    duration = int
+    duration = None
     #: URL to very compressed preview video
-    preview_url = str
+    preview_url = None
 
     #: URL to a small preview image of the video
-    small_image_url = str
+    small_image_url = None
     #: Width of the small preview image
-    small_image_width = int
+    small_image_width = None
     #: Height of the small preview image
-    small_image_height = int
+    small_image_height = None
 
     #: URL to a medium preview image of the video
-    medium_image_url = str
+    medium_image_url = None
     #: Width of the medium preview image
-    medium_image_width = int
+    medium_image_width = None
     #: Height of the medium preview image
-    medium_image_height = int
+    medium_image_height = None
 
     #: URL to a large preview image of the video
-    large_image_url = str
+    large_image_url = None
     #: Width of the large preview image
-    large_image_width = int
+    large_image_width = None
     #: Height of the large preview image
-    large_image_height = int
+    large_image_height = None
 
     def __init__(self, size=None, width=None, height=None, duration=None, preview_url=None, small_image=None, medium_image=None, large_image=None, **kwargs):
         """Represents a video that has been sent as a Facebook attachment"""
@@ -405,11 +418,11 @@ class VideoAttachment(Attachment):
 
 class Mention(object):
     #: The thread ID the mention is pointing at
-    thread_id = str
+    thread_id = None
     #: The character where the mention starts
-    offset = int
+    offset = None
     #: The length of the mention
-    length = int
+    length = None
 
     def __init__(self, thread_id, offset=0, length=10):
         """Represents a @mention"""
@@ -438,10 +451,10 @@ class ThreadType(Enum):
 
 class ThreadLocation(Enum):
     """Used to specify where a thread is located (inbox, pending, archived, other)."""
-    INBOX = 'inbox'
+    INBOX = 'INBOX'
-    PENDING = 'pending'
+    PENDING = 'PENDING'
-    ARCHIVED = 'action:archived'
+    ARCHIVED = 'ARCHIVED'
-    OTHER = 'other'
+    OTHER = 'OTHER'
 
 class TypingStatus(Enum):
     """Used to specify whether the user is typing or has stopped typing"""

fbchat/utils.py

@@ -9,6 +9,13 @@ import warnings
 import logging
 from .models import *
 
+try:
+    from urllib.parse import urlencode
+    basestring = (str, bytes)
+except ImportError:
+    from urllib import urlencode
+    basestring = basestring
+
 # Python 2's `input` executes the input, whereas `raw_input` just returns the input
 try:
     input = raw_input
@@ -74,13 +81,12 @@ GENDERS = {
     #'': 'female_singular_guess',
     #'': 'male_singular_guess',
     #'': 'mixed',
-    #'': 'neuter_singular',
+    'NEUTER': 'neuter_singular',
     #'': 'unknown_singular',
     #'': 'female_plural',
     #'': 'male_plural',
     #'': 'neuter_plural',
     #'': 'unknown_plural',
-    None: None
 }
 
 class ReqUrl(object):
@@ -88,7 +94,8 @@ class ReqUrl(object):
     SEARCH = "https://www.facebook.com/ajax/typeahead/search.php"
     LOGIN = "https://m.facebook.com/login.php?login_attempt=1"
     SEND = "https://www.facebook.com/messaging/send/"
-    THREAD_SYNC = "https://www.facebook.com/ajax/mercury/thread_sync.php"
+    UNREAD_THREADS = "https://www.facebook.com/ajax/mercury/unread_threads.php"
+    UNSEEN_THREADS = "https://www.facebook.com/mercury/unseen_thread_ids/"
     THREADS = "https://www.facebook.com/ajax/mercury/threadlist_info.php"
     MESSAGES = "https://www.facebook.com/ajax/mercury/thread_info.php"
     READ_STATUS = "https://www.facebook.com/ajax/mercury/change_read_status.php"

setup.py

@@ -54,10 +54,8 @@ setup(
     classifiers=[
         'Development Status :: 2 - Pre-Alpha',
         'Intended Audience :: Developers',
-        'Intended Audience :: Developers',
         'Intended Audience :: Information Technology',
         'License :: OSI Approved :: BSD License',
-        'License :: OSI Approved :: BSD License',
         'Operating System :: OS Independent',
         'Programming Language :: Python :: 2.6',
         'Programming Language :: Python :: 2.7',

tests.py

@@ -123,7 +123,8 @@ class TestFbchat(unittest.TestCase):
             self.assertTrue(client.sendLocalImage(image_local_url, Message(text='test_send_image_local_to__@you★', mentions=mentions)))
 
     def test_fetchThreadList(self):
-        client.fetchThreadList(offset=0, limit=20)
+        threads = client.fetchThreadList(limit=2)
+        self.assertEqual(len(threads), 2)
 
     def test_fetchThreadMessages(self):
         for thread in threads: