Version up

[Feature] Quick replies

.travis.yml

@@ -1,90 +1,50 @@
 sudo: false
 language: python
-conditions: v1
+python: 3.6
 
-# There are two accounts made specifically for Travis, and the passwords are really only encrypted for obscurity
+cache: pip
-# The global env variables `client1_email`, `client1_password`, `client2_email`, `client2_password` and `group_id`
-# are set on the Travis Settings page
 
-# The tests are run with `Limit concurrent jobs = 1`, since the tests can't use the clients simultaneously
+before_install: pip install flit
-
+install: flit install --deps production --extras test
-install:
+script: pytest -m offline
-  - pip install -U -r requirements.txt
-  - pip install -U -r dev-requirements.txt
-
-cache:
-  pip: true
-  # Pytest caching is disabled, since TravisCI instances have different public IPs. Facebook  doesn't like that,
-  # and redirects you to the url `/checkpoint/block`, where you have to change the account's password
-  # directories:
-  #   - .pytest_cache
 
 jobs:
   include:
-    # The tests are split into online and offline versions.
+  - python: 2.7
-    # The online tests are only run against the master branch.
+    before_install:
-    # Because:
+    - sudo apt-get -y install python3-pip python3-setuptools
-    # Travis caching is per-branch and per-job, so even though we cache the Facebook sessions via. `.pytest_cache`
+    - sudo pip3 install flit
-    # and in `tests.utils.load_client`, we need 6 new sessions per branch. This is usually the point where Facebook
+    install: flit install --python python --deps production --extras test
-    # starts complaining, and we have to manually fix it
+  - python: 3.4
+  - python: 3.5
+  - python: 3.6
+  - python: 3.7
+    dist: xenial
+    sudo: required
+  - python: pypy3.5
 
-    - &test-online
+  - stage: deploy
-      if: (branch = master OR tag IS present) AND type != pull_request
+    name: Github Releases
-      stage: online tests
+    if: tag IS present
-      script: scripts/travis-online
+    install: skip
+    script: flit build
+    deploy:
+      provider: releases
+      api_key: $GITHUB_OAUTH_TOKEN
+      file_glob: true
+      file: dist/*
+      skip_cleanup: true
+      draft: true
+      on:
+        tags: true
 
-    # Run online tests in all the supported python versions
+  - stage: deploy
-      python: 2.7
+    name: PyPI
-    - <<: *test-online
+    if: tag IS present
-      python: 3.4
+    install: skip
-    - <<: *test-online
+    script: skip
-      python: 3.5
+    deploy:
-    - <<: *test-online
+      provider: script
-      python: 3.6
+      script: flit publish
-    - <<: *test-online
+      on:
-      python: pypy
+        tags: true
-
-    # Run the expensive tests, with the python version most likely to break, aka. 2
-    - <<: *test-online
-      # Only run if the commit message includes [ci all] or [all ci]
-      if: commit_message =~ /\[ci\s+all\]|\[all\s+ci\]/
-      python: 2.7
-      env: PYTEST_ADDOPTS='-m expensive'
-
-    - &test-offline
-      # Ideally, it'd be nice to run the offline tests in every build, but since we can't run jobs concurrently (yet),
-      # we'll disable them when they're not needed, and include them inside the online tests instead
-      if: not ((branch = master OR tag IS present) AND type != pull_request)
-      stage: offline tests
-      script: scripts/travis-offline
-
-    # Run offline tests in all the supported python versions
-      python: 2.7
-    - <<: *test-offline
-      python: 3.4
-    - <<: *test-offline
-      python: 3.5
-    - <<: *test-offline
-      python: 3.6
-    - <<: *test-offline
-      python: 3.6
-    - <<: *test-offline
-      python: pypy
-
-    # Deploy to PyPI
-    - &deploy
-      stage: deploy
-      if: branch = master AND tag IS present
-      install: skip
-      deploy:
-        provider: pypi
-        user: madsmtm
-        password:
-          secure: "VA0MLSrwIW/T2KjMwjLZCzrLHw8pJT6tAvb48t7qpBdm8x192hax61pz1TaBZoJvlzyBPFKvluftuclTc7yEFwzXe7Gjqgd/ODKZl/wXDr36hQ7BBOLPZujdwmWLvTzMh3eJZlvkgcLCzrvK3j2oW8cM/+FZeVi/5/FhVuJ4ofs="
-        distributions: sdist bdist_wheel
-        skip_existing: true
-
-    # We need the bdist_wheels from both Python 2 and 3
-      python: 3.6
-    - <<: *deploy
-      python: 2.7

MANIFEST.in

@@ -1,3 +0,0 @@
-include LICENSE
-include CONTRIBUTING.rst
-include README.rst

README.rst

@@ -5,9 +5,9 @@ fbchat: Facebook Chat (Messenger) for Python
     :target: https://github.com/carpedm20/fbchat/tree/master/LICENSE
     :alt: License: BSD 3-Clause
 
-.. image:: https://img.shields.io/badge/python-2.7%2C%203.4%2C%203.5%2C%203.6%20pypy-blue.svg
+.. image:: https://img.shields.io/badge/python-2.7%2C%203.4%2C%203.5%2C%203.6%203.7%20pypy-blue.svg
     :target: https://pypi.python.org/pypi/fbchat
-    :alt: Supported python versions: 2.7, 3.4, 3.5, 3.6 and pypy
+    :alt: Supported python versions: 2.7, 3.4, 3.5, 3.6, 3.7 and pypy
 
 .. image:: https://readthedocs.org/projects/fbchat/badge/?version=master
     :target: https://fbchat.readthedocs.io
@@ -27,17 +27,18 @@ or jump right into the code by viewing the `examples <https://github.com/carpedm
 
 Installation:
 
-.. code-block:: console
+.. code-block::
 
     $ pip install fbchat
 
-You can also install from source, by using `setuptools` (You need at least version 30.3.0):
+You can also install from source, by using `flit`:
 
-.. code-block:: console
+.. code-block::
 
+    $ pip install flit
     $ git clone https://github.com/carpedm20/fbchat.git
     $ cd fbchat
-    $ python setup.py install
+    $ flit install
 
 
 Maintainer

dev-requirements.txt

@@ -1,2 +0,0 @@
-pytest
-six

fbchat/__init__.py

@@ -1,13 +1,8 @@
 # -*- coding: UTF-8 -*-
+"""Facebook Chat (Messenger) for Python
 
-"""
+:copyright: (c) 2015 - 2019 by Taehoon Kim
-    fbchat
+:license: BSD 3-Clause, see LICENSE for more details.
-    ~~~~~~
-
-    Facebook Chat (Messenger) for Python
-
-    :copyright: (c) 2015 - 2018 by Taehoon Kim
-    :license: BSD 3-Clause, see LICENSE for more details.
 """
 
 from __future__ import unicode_literals
@@ -15,10 +10,10 @@ from __future__ import unicode_literals
 from .client import *
 
 __title__ = 'fbchat'
-__version__ = '1.5.0'
+__version__ = '1.6.1'
 __description__ = 'Facebook Chat (Messenger) for Python'
 
-__copyright__ = 'Copyright 2015 - 2018 by Taehoon Kim'
+__copyright__ = 'Copyright 2015 - 2019 by Taehoon Kim'
 __license__ = 'BSD 3-Clause'
 
 __author__ = 'Taehoon Kim; Moreels Pieter-Jan; Mads Marquart'

fbchat/client.py

@@ -62,6 +62,8 @@ class Client(object):
         self.default_thread_id = None
         self.default_thread_type = None
         self.req_url = ReqUrl()
+        self._markAlive = True
+        self._buddylist = dict()
 
         if not user_agent:
             user_agent = choice(USER_AGENTS)
@@ -474,6 +476,82 @@ class Client(object):
         }))
         return j
 
+    def fetchThreads(self, thread_location, before=None, after=None, limit=None):
+        """
+        Get all threads in thread_location.
+        Threads will be sorted from newest to oldest.
+
+        :param thread_location: models.ThreadLocation: INBOX, PENDING, ARCHIVED or OTHER
+        :param before: Fetch only thread before this epoch (in ms) (default all threads)
+        :param after: Fetch only thread after this epoch (in ms) (default all threads)
+        :param limit: The max. amount of threads to fetch (default all threads)
+        :return: :class:`models.Thread` objects
+        :rtype: list
+        :raises: FBchatException if request failed
+        """
+        threads = []
+
+        last_thread_timestamp = None
+        while True:
+            # break if limit is exceeded
+            if limit and len(threads) >= limit:
+                break
+
+            # fetchThreadList returns at max 20 threads before last_thread_timestamp (included)
+            candidates = self.fetchThreadList(before=last_thread_timestamp,
+                                              thread_location=thread_location
+                                              )
+
+            if len(candidates) > 1:
+                threads += candidates[1:]
+            else:  # End of threads
+                break
+
+            last_thread_timestamp = threads[-1].last_message_timestamp
+
+            # FB returns a sorted list of threads
+            if (before is not None and int(last_thread_timestamp) > before) or \
+                (after is not None and int(last_thread_timestamp) < after):
+                break
+
+        # Return only threads between before and after (if set)
+        if before is not None or after is not None:
+            for t in threads:
+                last_message_timestamp = int(t.last_message_timestamp)
+                if (before is not None and last_message_timestamp > before) or \
+                    (after is not None and last_message_timestamp < after):
+                    threads.remove(t)
+
+        if limit and len(threads) > limit:
+            return threads[:limit]
+
+        return threads
+
+    def fetchAllUsersFromThreads(self, threads):
+        """
+        Get all users involved in threads.
+
+        :param threads: models.Thread: List of threads to check for users
+        :return: :class:`models.User` objects
+        :rtype: list
+        :raises: FBchatException if request failed
+        """
+        users = []
+        users_to_fetch = []  # It's more efficient to fetch all users in one request
+        for thread in threads:
+            if thread.type == ThreadType.USER:
+                if thread.uid not in [user.uid for user in users]:
+                    users.append(thread)
+            elif thread.type == ThreadType.GROUP:
+                for user_id in thread.participants:
+                    if user_id not in [user.uid for user in users] and user_id not in users_to_fetch:
+                        users_to_fetch.append(user_id)
+            else:
+                pass
+        for user_id, user in self.fetchUserInfo(*users_to_fetch).items():
+            users.append(user)
+        return users
+
     def fetchAllUsers(self):
         """
         Gets all users the client is currently chatting with
@@ -984,6 +1062,44 @@ class Client(object):
         plan = graphql_to_plan(j["payload"])
         return plan
 
+    def _getPrivateData(self):
+        j = self.graphql_request(GraphQL(doc_id='1868889766468115'))
+        return j['viewer']
+
+    def getPhoneNumbers(self):
+        """
+        Fetches a list of user phone numbers.
+
+        :return: List of phone numbers
+        :rtype: list
+        """
+        data = self._getPrivateData()
+        return [j['phone_number']['universal_number'] for j in data['user']['all_phones']]
+
+    def getEmails(self):
+        """
+        Fetches a list of user emails.
+
+        :return: List of emails
+        :rtype: list
+        """
+        data = self._getPrivateData()
+        return [j['display_email'] for j in data['all_emails']]
+
+    def getUserActiveStatus(self, user_id):
+        """
+        Gets friend active status as an :class:`models.ActiveStatus` object.
+        Returns `None` if status isn't known.
+
+        .. warning::
+            Only works when listening.
+
+        :param user_id: ID of the user
+        :return: Given user active status
+        :rtype: models.ActiveStatus
+        """
+        return self._buddylist.get(str(user_id))
+
     """
     END FETCH METHODS
     """
@@ -1040,6 +1156,25 @@ class Client(object):
         if message.sticker:
             data['sticker_id'] = message.sticker.uid
 
+        if message.quick_replies:
+            xmd = {"quick_replies": []}
+            for quick_reply in message.quick_replies:
+                q = dict()
+                q["content_type"] = quick_reply._type
+                q["payload"] = quick_reply.payload
+                q["external_payload"] = quick_reply.external_payload
+                q["data"] = quick_reply.data
+                if quick_reply.is_response:
+                    q["ignore_for_webhook"] = False
+                if isinstance(quick_reply, QuickReplyText):
+                    q["title"] = quick_reply.title
+                if not isinstance(quick_reply, QuickReplyLocation):
+                    q["image_url"] = quick_reply.image_url
+                xmd["quick_replies"].append(q)
+            if len(message.quick_replies) == 1 and message.quick_replies[0].is_response:
+                xmd["quick_replies"] = xmd["quick_replies"][0]
+            data['platform_xmd'] = json.dumps(xmd)
+
         return data
 
     def _doSendRequest(self, data, get_thread_id=False):
@@ -1111,6 +1246,36 @@ class Client(object):
             data['specific_to_list[0]'] = "fbid:{}".format(thread_id)
         return self._doSendRequest(data)
 
+    def quickReply(self, quick_reply, payload=None, thread_id=None, thread_type=None):
+        """
+        Replies to a chosen quick reply
+
+        :param quick_reply: Quick reply to reply to
+        :param payload: Optional answer to the quick reply
+        :param thread_id: User/Group ID to send to. See :ref:`intro_threads`
+        :param thread_type: See :ref:`intro_threads`
+        :type quick_reply: models.QuickReply
+        :type thread_type: models.ThreadType
+        :return: :ref:`Message ID <intro_message_ids>` of the sent message
+        :raises: FBchatException if request failed
+        """
+        quick_reply.is_response = True
+        if isinstance(quick_reply, QuickReplyText):
+            return self.send(Message(text=quick_reply.title, quick_replies=[quick_reply]))
+        elif isinstance(quick_reply, QuickReplyLocation):
+            if not isinstance(payload, LocationAttachment): raise ValueError("Payload must be an instance of `fbchat.models.LocationAttachment`")
+            return self.sendLocation(payload, thread_id=thread_id, thread_type=thread_type)
+        elif isinstance(quick_reply, QuickReplyEmail):
+            if not payload: payload = self.getEmails()[0]
+            quick_reply.external_payload = quick_reply.payload
+            quick_reply.payload = payload
+            return self.send(Message(text=payload, quick_replies=[quick_reply]))
+        elif isinstance(quick_reply, QuickReplyPhoneNumber):
+            if not payload: payload = self.getPhoneNumbers()[0]
+            quick_reply.external_payload = quick_reply.payload
+            quick_reply.payload = payload
+            return self.send(Message(text=payload, quick_replies=[quick_reply]))
+
     def unsend(self, mid):
         """
         Unsends a message (removes for everyone)
@@ -1828,7 +1993,7 @@ class Client(object):
         .. todo::
             Documenting this
         """
-        r = self._post(self.req_url.MARK_SEEN, {"seen_timestamp": 0})
+        r = self._post(self.req_url.MARK_SEEN, {"seen_timestamp": now()})
         return r.ok
 
     def friendConnect(self, friend_id):
@@ -2056,7 +2221,7 @@ class Client(object):
         }
         self._get(self.req_url.PING, data, fix_request=True, as_json=False)
 
-    def _pullMessage(self, markAlive=True):
+    def _pullMessage(self):
         """Call pull api with seq value to get message data."""
 
         data = {
@@ -2064,7 +2229,7 @@ class Client(object):
             "sticky_token": self.sticky,
             "sticky_pool": self.pool,
             "clientid": self.client_id,
-            'state': 'active' if markAlive else 'offline',
+            'state': 'active' if self._markAlive else 'offline',
         }
 
         j = self._get(self.req_url.STICKY, data, fix_request=True, as_json=True)
@@ -2164,7 +2329,7 @@ class Client(object):
                                 image_metadata = fetch_data.get("image_with_metadata")
                                 image_id = int(image_metadata["legacy_attachment_id"]) if image_metadata else None
                                 self.onImageChange(mid=mid, author_id=author_id, new_image=image_id, thread_id=thread_id,
-                                                   thread_type=ThreadType.GROUP, ts=ts)
+                                                   thread_type=ThreadType.GROUP, ts=ts, msg=m)
 
                     # Nickname change
                     elif delta_type == "change_thread_nickname":
@@ -2472,12 +2637,48 @@ class Client(object):
 
                 # Chat timestamp
                 elif mtype == "chatproxy-presence":
-                    buddylist = {}
+                    buddylist = dict()
                     for _id in m.get('buddyList', {}):
                         payload = m['buddyList'][_id]
-                        buddylist[_id] = payload.get('lat')
+
+                        last_active = payload.get('lat')
+                        active = payload.get('p') in [2, 3]
+                        in_game = int(_id) in m.get('gamers', {})
+
+                        buddylist[_id] = last_active
+
+                        if self._buddylist.get(_id):
+                            self._buddylist[_id].last_active = last_active
+                            self._buddylist[_id].active = active
+                            self._buddylist[_id].in_game = in_game
+                        else:
+                            self._buddylist[_id] = ActiveStatus(active=active, last_active=last_active, in_game=in_game)
+
                     self.onChatTimestamp(buddylist=buddylist, msg=m)
 
+                # Buddylist overlay
+                elif mtype == "buddylist_overlay":
+                    statuses = dict()
+                    for _id in m.get('overlay', {}):
+                        payload = m['overlay'][_id]
+
+                        last_active = payload.get('la')
+                        active = payload.get('a') in [2, 3]
+                        in_game = self._buddylist[_id].in_game if self._buddylist.get(_id) else False
+
+                        status = ActiveStatus(active=active, last_active=last_active, in_game=in_game)
+
+                        if self._buddylist.get(_id):
+                            self._buddylist[_id].last_active = last_active
+                            self._buddylist[_id].active = active
+                            self._buddylist[_id].in_game = in_game
+                        else:
+                            self._buddylist[_id] = status
+
+                        statuses[_id] = status
+
+                    self.onBuddylistOverlay(statuses=statuses, msg=m)
+
                 # Unknown message type
                 else:
                     self.onUnknownMesssageType(msg=m)
@@ -2493,20 +2694,24 @@ class Client(object):
         """
         self.listening = True
 
-    def doOneListen(self, markAlive=True):
+    def doOneListen(self, markAlive=None):
         """
         Does one cycle of the listening loop.
         This method is useful if you want to control fbchat from an external event loop
 
-        :param markAlive: Whether this should ping the Facebook server before running
+        .. warning::
-        :type markAlive: bool
+            `markAlive` parameter is deprecated now, use :func:`fbchat.Client.setActiveStatus`
+            or `markAlive` parameter in :func:`fbchat.Client.listen` instead.
+
         :return: Whether the loop should keep running
         :rtype: bool
         """
+        if markAlive is not None:
+            self._markAlive = markAlive
         try:
-            if markAlive:
+            if self._markAlive:
                 self._ping()
-            content = self._pullMessage(markAlive)
+            content = self._pullMessage()
             if content:
                 self._parseMessage(content)
         except KeyboardInterrupt:
@@ -2533,21 +2738,33 @@ class Client(object):
         self.listening = False
         self.sticky, self.pool = (None, None)
 
-    def listen(self, markAlive=True):
+    def listen(self, markAlive=None):
         """
         Initializes and runs the listening loop continually
 
         :param markAlive: Whether this should ping the Facebook server each time the loop runs
         :type markAlive: bool
         """
+        if markAlive is not None:
+            self.setActiveStatus(markAlive)
+
         self.startListening()
         self.onListening()
 
-        while self.listening and self.doOneListen(markAlive):
+        while self.listening and self.doOneListen():
             pass
 
         self.stopListening()
 
+    def setActiveStatus(self, markAlive):
+        """
+        Changes client active status while listening
+
+        :param markAlive: Whether to show if client is active
+        :type markAlive: bool
+        """
+        self._markAlive = markAlive
+
     """
     END LISTEN METHODS
     """
@@ -2659,15 +2876,18 @@ class Client(object):
         log.info("Title change from {} in {} ({}): {}".format(author_id, thread_id, thread_type.name, new_title))
 
 
-    def onImageChange(self, mid=None, author_id=None, new_image=None, thread_id=None, thread_type=ThreadType.GROUP, ts=None):
+    def onImageChange(self, mid=None, author_id=None, new_image=None, thread_id=None, thread_type=ThreadType.GROUP, ts=None, msg=None):
         """
         Called when the client is listening, and somebody changes the image of a thread
 
         :param mid: The action ID
-        :param new_image: The ID of the new image
         :param author_id: The ID of the person who changed the image
+        :param new_image: The ID of the new image
         :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 ts: A timestamp of the action
+        :param msg: A full set of the data recieved
+        :type thread_type: models.ThreadType
         """
         log.info("{} changed thread image in {}".format(author_id, thread_id))
 
@@ -2945,41 +3165,6 @@ class Client(object):
         """
         log.info("{} sent live location info in {} ({}) with latitude {} and longitude {}".format(author_id, thread_id, thread_type, location.latitude, location.longitude))
 
-    def onQprimer(self, ts=None, msg=None):
-        """
-        Called when the client just started listening
-
-        :param ts: A timestamp of the action
-        :param msg: A full set of the data recieved
-        """
-        pass
-
-    def onChatTimestamp(self, buddylist=None, msg=None):
-        """
-        Called when the client receives chat online presence update
-
-        :param buddylist: A list of dicts with friend id and last seen timestamp
-        :param msg: A full set of the data recieved
-        """
-        log.debug('Chat Timestamps received: {}'.format(buddylist))
-
-    def onUnknownMesssageType(self, msg=None):
-        """
-        Called when the client is listening, and some unknown data was recieved
-
-        :param msg: A full set of the data recieved
-        """
-        log.debug('Unknown message received: {}'.format(msg))
-
-    def onMessageError(self, exception=None, msg=None):
-        """
-        Called when an error was encountered while parsing recieved data
-
-        :param exception: The exception that was encountered
-        :param msg: A full set of the data recieved
-        """
-        log.exception('Exception in parsing of {}'.format(msg))
-
     def onCallStarted(self, mid=None, caller_id=None, is_video_call=None, thread_id=None, thread_type=None, ts=None, metadata=None, msg=None):
         """
         .. todo::
@@ -3158,6 +3343,51 @@ class Client(object):
         else:
             log.info("{} won't take part in {} in {} ({})".format(author_id, plan, thread_id, thread_type.name))
 
+    def onQprimer(self, ts=None, msg=None):
+        """
+        Called when the client just started listening
+
+        :param ts: A timestamp of the action
+        :param msg: A full set of the data recieved
+        """
+        pass
+
+    def onChatTimestamp(self, buddylist=None, msg=None):
+        """
+        Called when the client receives chat online presence update
+
+        :param buddylist: A list of dicts with friend id and last seen timestamp
+        :param msg: A full set of the data recieved
+        """
+        log.debug('Chat Timestamps received: {}'.format(buddylist))
+
+    def onBuddylistOverlay(self, statuses=None, msg=None):
+        """
+        Called when the client is listening and client receives information about friend active status
+
+        :param statuses: Dictionary with user IDs as keys and :class:`models.ActiveStatus` as values
+        :param msg: A full set of the data recieved
+        :type statuses: dict
+        """
+        log.debug('Buddylist overlay received: {}'.format(statuses))
+
+    def onUnknownMesssageType(self, msg=None):
+        """
+        Called when the client is listening, and some unknown data was recieved
+
+        :param msg: A full set of the data recieved
+        """
+        log.debug('Unknown message received: {}'.format(msg))
+
+    def onMessageError(self, exception=None, msg=None):
+        """
+        Called when an error was encountered while parsing recieved data
+
+        :param exception: The exception that was encountered
+        :param msg: A full set of the data recieved
+        """
+        log.exception('Exception in parsing of {}'.format(msg))
+
     """
     END EVENTS
     """

fbchat/graphql.py

@@ -168,7 +168,7 @@ def graphql_to_extensible_attachment(a):
                     url=story['url'],
                     original_url=get_url_parameter(story['url'], 'u') if "/l.php?u=" in story['url'] else story['url'],
                     title=story['title_with_entities'].get('text'),
-                    description=story['description'].get('text'),
+                    description=story['description'].get('text') if story.get('description') else None,
                     source=story['source']['text'],
                     image_url=story['media']['image']['uri'] if story.get('media') else None,
                     original_image_url=(get_url_parameter(story['media']['image']['uri'], 'url') if "/safe_image.php" in story['media']['image']['uri'] else story['media']['image']['uri']) if story.get('media') else None,
@@ -267,6 +267,24 @@ def graphql_to_plan(a):
     rtn.invited = [m.get('node').get('id') for m in guests if m.get('guest_list_state') == "INVITED"]
     return rtn
 
+def graphql_to_quick_reply(q, is_response=False):
+    data = dict()
+    _type = q.get('content_type').lower()
+    if q.get('payload'): data["payload"] = q["payload"]
+    if q.get('data'): data["data"] = q["data"]
+    if q.get('image_url') and _type is not QuickReplyLocation._type: data["image_url"] = q["image_url"]
+    data["is_response"] = is_response
+    if _type == QuickReplyText._type:
+        if q.get('title') is not None: data["title"] = q["title"]
+        rtn = QuickReplyText(**data)
+    elif _type == QuickReplyLocation._type:
+        rtn = QuickReplyLocation(**data)
+    elif _type == QuickReplyPhoneNumber._type:
+        rtn = QuickReplyPhoneNumber(**data)
+    elif _type == QuickReplyEmail._type:
+        rtn = QuickReplyEmail(**data)
+    return rtn
+
 def graphql_to_message(message):
     if message.get('message_sender') is None:
         message['message_sender'] = {}
@@ -290,6 +308,12 @@ def graphql_to_message(message):
     }
     if message.get('blob_attachments') is not None:
         rtn.attachments = [graphql_to_attachment(attachment) for attachment in message['blob_attachments']]
+    if message.get('platform_xmd_encoded'):
+        quick_replies = json.loads(message['platform_xmd_encoded']).get('quick_replies')
+        if isinstance(quick_replies, list):
+            rtn.quick_replies = [graphql_to_quick_reply(q) for q in quick_replies]
+        elif isinstance(quick_replies, dict):
+            rtn.quick_replies = [graphql_to_quick_reply(quick_replies, is_response=True)]
     if message.get('extensible_attachment') is not None:
         attachment = graphql_to_extensible_attachment(message['extensible_attachment'])
         if isinstance(attachment, UnsentMessage):

fbchat/models.py

@@ -2,6 +2,7 @@
 
 from __future__ import unicode_literals
 import aenum
+from string import Formatter
 
 
 class FBchatException(Exception):
@@ -190,10 +191,12 @@ class Message(object):
     sticker = None
     #: A list of attachments
     attachments = None
+    #: A list of :class:`QuickReply`
+    quick_replies = None
     #: Whether the message is unsent (deleted for everyone)
     unsent = None
 
-    def __init__(self, text=None, mentions=None, emoji_size=None, sticker=None, attachments=None):
+    def __init__(self, text=None, mentions=None, emoji_size=None, sticker=None, attachments=None, quick_replies=None):
         """Represents a Facebook message"""
         self.text = text
         if mentions is None:
@@ -204,6 +207,9 @@ class Message(object):
         if attachments is None:
             attachments = []
         self.attachments = attachments
+        if quick_replies is None:
+            quick_replies = []
+        self.quick_replies = quick_replies
         self.reactions = {}
         self.read_by = []
         self.deleted = False
@@ -214,6 +220,52 @@ class Message(object):
     def __unicode__(self):
         return '<Message ({}): {}, mentions={} emoji_size={} attachments={}>'.format(self.uid, repr(self.text), self.mentions, self.emoji_size, self.attachments)
 
+    @classmethod
+    def formatMentions(cls, text, *args, **kwargs):
+        """Like `str.format`, but takes tuples with a thread id and text instead.
+
+        Returns a `Message` object, with the formatted string and relevant mentions.
+
+        ```
+        >>> Message.formatMentions("Hey {!r}! My name is {}", ("1234", "Peter"), ("4321", "Michael"))
+        <Message (None): "Hey 'Peter'! My name is Michael", mentions=[<Mention 1234: offset=4 length=7>, <Mention 4321: offset=24 length=7>] emoji_size=None attachments=[]>
+
+        >>> Message.formatMentions("Hey {p}! My name is {}", ("1234", "Michael"), p=("4321", "Peter"))
+        <Message (None): 'Hey Peter! My name is Michael', mentions=[<Mention 4321: offset=4 length=5>, <Mention 1234: offset=22 length=7>] emoji_size=None attachments=[]>
+        ```
+        """
+        result = ""
+        mentions = list()
+        offset = 0
+        f = Formatter()
+        field_names = [field_name[1] for field_name in f.parse(text)]
+        automatic = '' in field_names
+        i = 0
+
+        for (literal_text, field_name, format_spec, conversion) in f.parse(text):
+            offset += len(literal_text)
+            result += literal_text
+
+            if field_name is None: continue
+
+            if field_name == '':
+                field_name = str(i)
+                i += 1
+            elif automatic and field_name.isdigit():
+                raise ValueError("cannot switch from automatic field numbering to manual field specification")
+
+            thread_id, name = f.get_field(field_name, args, kwargs)[0]
+
+            if format_spec: name = f.format_field(name, format_spec)
+            if conversion: name = f.convert_field(name, conversion)
+
+            result += name
+            mentions.append(Mention(thread_id=thread_id, offset=offset, length=len(name)))
+            offset += len(name)
+
+        message = cls(text=result, mentions=mentions)
+        return message
+
 class Attachment(object):
     #: The attachment ID
     uid = None
@@ -521,6 +573,73 @@ class Mention(object):
     def __unicode__(self):
         return '<Mention {}: offset={} length={}>'.format(self.thread_id, self.offset, self.length)
 
+class QuickReply(object):
+    #: Payload of the quick reply
+    payload = None
+    #: External payload for responses
+    external_payload = None
+    #: Additional data
+    data = None
+    #: Whether it's a response for a quick reply
+    is_response = None
+
+    def __init__(self, payload=None, data=None, is_response=False):
+        """Represents a quick reply"""
+        self.payload = payload
+        self.data = data
+        self.is_response = is_response
+
+    def __repr__(self):
+        return self.__unicode__()
+
+    def __unicode__(self):
+        return '<{}: payload={!r}>'.format(self.__class__.__name__, self.payload)
+
+class QuickReplyText(QuickReply):
+    #: Title of the quick reply
+    title = None
+    #: URL of the quick reply image (optional)
+    image_url = None
+    #: Type of the quick reply
+    _type = "text"
+
+    def __init__(self, title=None, image_url=None, **kwargs):
+        """Represents a text quick reply"""
+        super(QuickReplyText, self).__init__(**kwargs)
+        self.title = title
+        self.image_url = image_url
+
+class QuickReplyLocation(QuickReply):
+    #: Type of the quick reply
+    _type = "location"
+
+    def __init__(self, **kwargs):
+        """Represents a location quick reply (Doesn't work on mobile)"""
+        super(QuickReplyLocation, self).__init__(**kwargs)
+        self.is_response = False
+
+class QuickReplyPhoneNumber(QuickReply):
+    #: URL of the quick reply image (optional)
+    image_url = None
+    #: Type of the quick reply
+    _type = "user_phone_number"
+
+    def __init__(self, image_url=None, **kwargs):
+        """Represents a phone number quick reply (Doesn't work on mobile)"""
+        super(QuickReplyPhoneNumber, self).__init__(**kwargs)
+        self.image_url = image_url
+
+class QuickReplyEmail(QuickReply):
+    #: URL of the quick reply image (optional)
+    image_url = None
+    #: Type of the quick reply
+    _type = "user_email"
+
+    def __init__(self, image_url=None, **kwargs):
+        """Represents an email quick reply (Doesn't work on mobile)"""
+        super(QuickReplyEmail, self).__init__(**kwargs)
+        self.image_url = image_url
+
 class Poll(object):
     #: ID of the poll
     uid = None
@@ -602,6 +721,25 @@ class Plan(object):
     def __unicode__(self):
         return '<Plan ({}): {} time={}, location={}, location_id={}>'.format(self.uid, repr(self.title), self.time, repr(self.location), repr(self.location_id))
 
+class ActiveStatus(object):
+    #: Whether the user is active now
+    active = None
+    #: Timestamp when the user was last active
+    last_active = None
+    #: Whether the user is playing Messenger game now
+    in_game = None
+
+    def __init__(self, active=None, last_active=None, in_game=None):
+        self.active = active
+        self.last_active = last_active
+        self.in_game = in_game
+
+    def __repr__(self):
+        return self.__unicode__()
+
+    def __unicode__(self):
+        return '<ActiveStatus: active={} last_active={} in_game={}>'.format(self.active, self.last_active, self.in_game)
+
 class Enum(aenum.Enum):
     """Used internally by fbchat to support enumerations"""
     def __repr__(self):

pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["flit"]
+build-backend = "flit.buildapi"
+
+[tool.flit.metadata]
+module = "fbchat"
+author = "Taehoon Kim"
+author-email = "carpedm20@gmail.com"
+maintainer = "Mads Marquart"
+maintainer-email = "madsmtm@gmail.com"
+home-page = "https://github.com/carpedm20/fbchat/"
+requires = [
+    "aenum",
+    "requests",
+    "beautifulsoup4",
+]
+description-file = "README.rst"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Information Technology",
+    "License :: OSI Approved :: BSD License",
+    "Operating System :: OS Independent",
+    "Natural Language :: English",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 2.7",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.4",
+    "Programming Language :: Python :: 3.5",
+    "Programming Language :: Python :: 3.6",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: Implementation :: PyPy",
+    "Topic :: Communications :: Chat",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+requires-python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, <4.0"
+keywords = "Facebook FB Messenger Library Chat Api Bot"
+license = "BSD 3-Clause"
+
+[tool.flit.metadata.urls]
+Documentation = "https://fbchat.readthedocs.io/"
+Repository = "https://github.com/carpedm20/fbchat/"
+
+[tool.flit.metadata.requires-extra]
+test = [
+    "pytest~=4.0",
+    "six",
+]

requirements.txt

@@ -1,3 +0,0 @@
-requests
-beautifulsoup4
-aenum

scripts/travis-offline

@@ -1,5 +0,0 @@
-#!/bin/bash
-
-set -ex
-
-python -m pytest -m offline --color=yes

scripts/travis-online

@@ -1,18 +0,0 @@
-#!/bin/bash
-
-set -ex
-
-if ! python -m pytest --color=yes; then
-    echo << EOF
------------------------------------------------------------------
------------------------------------------------------------------
------------------------------------------------------------------
-
-Some tests failed! Rerunning them, since they can be kinda flaky.
-
------------------------------------------------------------------
------------------------------------------------------------------
------------------------------------------------------------------
-EOF
-    python -m pytest --last-failed --color=yes
-fi

setup.cfg

@@ -1,48 +0,0 @@
-[metadata]
-name = fbchat
-version = attr: fbchat.__version__
-license = BSD 3-Clause
-license_file = LICENSE
-
-author = Taehoon Kim
-author_email = carpedm20@gmail.com
-maintainer = Mads Marquart
-maintainer_email = madsmtm@gmail.com
-
-description = Facebook Chat (Messenger) for Python
-long_description = file: README.rst
-long_description_content_type = text/x-rst
-
-keywords = Facebook FB Messenger Chat Api Bot
-classifiers =
-    Development Status :: 3 - Alpha
-    Intended Audience :: Developers
-    Intended Audience :: Information Technology
-    License :: OSI Approved :: BSD License
-    Operating System :: OS Independent
-    Natural Language :: English
-    Programming Language :: Python
-    Programming Language :: Python :: 2.7
-    Programming Language :: Python :: 3.4
-    Programming Language :: Python :: 3.5
-    Programming Language :: Python :: 3.6
-    Programming Language :: Python :: Implementation :: CPython
-    Programming Language :: Python :: Implementation :: PyPy
-    Topic :: Communications :: Chat
-    Topic :: Internet :: WWW/HTTP :: Dynamic Content
-    Topic :: Software Development :: Libraries :: Python Modules
-
-url = https://github.com/carpedm20/fbchat/
-project_urls =
-    Documentation = https://fbchat.readthedocs.io/
-    Repository = https://github.com/carpedm20/fbchat/
-
-[options]
-zip_safe = True
-include_package_data = True
-packages = find:
-python_requires = >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, <4.0
-install_requires =
-    aenum
-    requests
-    beautifulsoup4

setup.py

@@ -1,8 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: UTF-8 -*-
-
-from __future__ import unicode_literals
-
-from setuptools import setup
-
-setup()

tests/test_fetch.py

@@ -19,6 +19,11 @@ def test_fetch_thread_list(client1):
     assert len(threads) == 2
 
 
+def test_fetch_threads(client1):
+    threads = client1.fetchThreads(limit=2)
+    assert len(threads) == 2
+
+
 @pytest.mark.parametrize("emoji, emoji_size", EMOJI_LIST)
 def test_fetch_message_emoji(client, emoji, emoji_size):
     mid = client.sendEmoji(emoji, emoji_size)