Merge branch 'master' into polls

Author: MarcoBuster

.travis.yml

@@ -1,7 +1,14 @@
 language: python
+
+# In order to run Python 3.7 or higher, we need xenial
+# https://docs.travis-ci.com/user/languages/python/#python-37-and-higher
+dist: xenial
+
 python:
 - "3.4"
 - "3.5"
+- "3.6"
+- "3.7"
 
 sudo: false
 cache: pip

botogram/objects/messages.py

@@ -335,6 +335,8 @@ def from_(self):
         "forward_from": User,
         "forward_from_chat": Chat,
         "forward_from_message_id": int,
+        "forward_sender_name": str,
+        "forward_signature": str,
         "forward_date": int,
         "reply_to_message": _itself,
         "text": str,
@@ -371,6 +373,7 @@ def from_(self):
         # Those are provided dynamically by self.forward_from
         "forward_from": "_forward_from",
         "forward_from_chat": "_forward_from_chat",
+        "forward_sender_name": "_forward_sender_name",
     }
     _check_equality_ = "message_id"
 
@@ -392,12 +395,24 @@ def forward_from(self):
         """Get from where the message was forwarded"""
         # Provide either _forward_from or _forward_from_chat
         # _forward_from_chat is checked earlier because it's more correct
+        # _forward_sender_name is returned if the original sender
+        # has opted to hide his account
+
         if self._forward_from_chat is not None:
             return self._forward_from_chat
 
         if self._forward_from is not None:
             return self._forward_from
 
+        if self._forward_sender_name is not None:
+            return self._forward_sender_name
+
+    @property
+    def forward_hidden(self):
+        """Check if the original sender is hidden or not"""
+
+        return isinstance(self.forward_from, str)
+
     @property
     def channel_post_author(self):
         """Get the author of the channel post"""

botogram/objects/mixins.py

@@ -77,6 +77,24 @@ def _get_call_args(self, reply_to, extra, attach, notify):
 
         return args
 
+    @staticmethod
+    def _get_file_args(path, file_id, url):
+        args = None
+        if path is not None and file_id is None and url is None:
+            file = open(path, "rb")
+        elif file_id is not None and path is None and url is None:
+            args = file_id
+            file = None
+        elif url is not None and file_id is None and path is None:
+            args = url
+            file = None
+        elif path is None and file_id is None and url is None:
+            raise TypeError("path or file_id or URL is missing")
+        else:
+            raise TypeError("Only one among path, file_id and URL must be" +
+                            "passed")
+        return args, file
+
     @_require_api
     def send(self, message, preview=True, reply_to=None, syntax=None,
              extra=None, attach=None, notify=True):
@@ -102,26 +120,19 @@ def send_photo(self, path=None, file_id=None, url=None, caption=None,
             if syntax is not None:
                 syntax = syntaxes.guess_syntax(caption, syntax)
                 args["parse_mode"] = syntax
-        if path is not None and file_id is None and url is None:
-            files = {"photo": open(path, "rb")}
-        elif file_id is not None and path is None and url is None:
-            args["photo"] = file_id
-            files = None
-        elif url is not None and file_id is None and path is None:
-            args["photo"] = url
-            files = None
-        elif path is None and file_id is None and url is None:
-            raise TypeError("path or file_id or URL is missing")
-        else:
-            raise TypeError("Only one among path, file_id and URL must be" +
-                            "passed")
+        files = dict()
+        args["photo"], files["photo"] = self._get_file_args(path,
+                                                            file_id,
+                                                            url)
+        if files["photo"] is None:
+            del files["photo"]
 
         return self._api.call("sendPhoto", args, files,
                               expect=_objects().Message)
 
     @_require_api
     def send_audio(self, path=None, file_id=None, url=None, duration=None,
-                   performer=None, title=None, reply_to=None,
+                   thumb=None, performer=None, title=None, reply_to=None,
                    extra=None, attach=None, notify=True, caption=None, *,
                    syntax=None):
         """Send an audio track"""
@@ -138,19 +149,14 @@ def send_audio(self, path=None, file_id=None, url=None, duration=None,
         if title is not None:
             args["title"] = title
 
-        if path is not None and file_id is None and url is None:
-            files = {"audio": open(path, "rb")}
-        elif file_id is not None and path is None and url is None:
-            files = None
-            args["audio"] = file_id
-        elif url is not None and file_id is None and path is None:
-            args["audio"] = url
-            files = None
-        elif path is None and file_id is None and url is None:
-            raise TypeError("path or file_id or URL is missing")
-        else:
-            raise TypeError("Only one among path, file_id and URL must be" +
-                            "passed")
+        files = dict()
+        args["audio"], files["audio"] = self._get_file_args(path,
+                                                            file_id,
+                                                            url)
+        if files["audio"] is None:
+            del files["audio"]
+        if thumb is not None:
+            files["thumb"] = thumb
 
         return self._api.call("sendAudio", args, files,
                               expect=_objects().Message)
@@ -168,30 +174,25 @@ def send_voice(self, path=None, file_id=None, url=None, duration=None,
                 args["parse_mode"] = syntax
         if duration is not None:
             args["duration"] = duration
+        if title is not None:
+            args["title"] = title
         syntax = syntaxes.guess_syntax(caption, syntax)
         if syntax is not None:
             args["parse_mode"] = syntax
 
-        if path is not None and file_id is None and url is None:
-            files = {"voice": open(path, "rb")}
-        elif file_id is not None and path is None and url is None:
-            files = None
-            args["voice"] = file_id
-        elif url is not None and file_id is None and path is None:
-            args["voice"] = url
-            files = None
-        elif path is None and file_id is None and url is None:
-            raise TypeError("path or file_id or URL is missing")
-        else:
-            raise TypeError("Only one among path, file_id and URL must be" +
-                            "passed")
+        files = dict()
+        args["voice"], files["voice"] = self._get_file_args(path,
+                                                            file_id,
+                                                            url)
+        if files["voice"] is None:
+            del files["voice"]
 
         return self._api.call("sendVoice", args, files,
                               expect=_objects().Message)
 
     @_require_api
     def send_video(self, path=None, file_id=None, url=None,
-                   duration=None, caption=None, streaming=True,
+                   duration=None, caption=None, streaming=True, thumb=None,
                    reply_to=None, extra=None, attach=None,
                    notify=True, *, syntax=None):
         """Send a video"""
@@ -204,83 +205,81 @@ def send_video(self, path=None, file_id=None, url=None,
             if syntax is not None:
                 syntax = syntaxes.guess_syntax(caption, syntax)
                 args["parse_mode"] = syntax
-        if path is not None and file_id is None and url is None:
-            files = {"video": open(path, "rb")}
-        elif file_id is not None and path is None and url is None:
-            files = None
-            args["video"] = file_id
-        elif url is not None and file_id is None and path is None:
-            args["video"] = url
-            files = None
-        elif path is None and file_id is None and url is None:
-            raise TypeError("path or file_id or URL is missing")
-        else:
-            raise TypeError("Only one among path, file_id and URL must be" +
-                            "passed")
+
+        files = dict()
+        args["video"], files["video"] = self._get_file_args(path,
+                                                            file_id,
+                                                            url)
+        if files["video"] is None:
+            del files["video"]
+        if thumb is not None:
+            files["thumb"] = thumb
 
         return self._api.call("sendVideo", args, files,
                               expect=_objects().Message)
 
     @_require_api
     def send_video_note(self, path=None, file_id=None, duration=None,
-                        diameter=None, reply_to=None, extra=None,
+                        diameter=None, thumb=None, reply_to=None, extra=None,
                         attach=None, notify=True):
         """Send a video note"""
         args = self._get_call_args(reply_to, extra, attach, notify)
         if duration is not None:
             args["duration"] = duration
         if diameter is not None:
             args["length"] = diameter
-        if path is not None and file_id is None:
-            files = {"video_note": open(path, "rb")}
-        elif file_id is not None and path is None:
-            files = None
-            args["video_note"] = file_id
-        elif path is None and file_id is None:
-            raise TypeError("Path or file_id or URL is missing")
-        else:
-            raise TypeError("Only one among path and file_id must be" +
-                            "passed")
+
+        files = dict()
+        args["video_note"], files["video_note"] = self._get_file_args(path,
+                                                                      file_id,
+                                                                      None)
+        if files["video_note"] is None:
+            del files["video_note"]
+        if thumb is not None:
+            files["thumb"] = thumb
 
         return self._api.call("sendVideoNote", args, files,
                               expect=_objects().Message)
 
     @_require_api
-    def send_file(self, path=None, file_id=None, url=None, reply_to=None,
-                  extra=None, attach=None, notify=True, caption=None, *,
-                  syntax=None):
+    def send_file(self, path=None, file_id=None, url=None, thumb=None,
+                  reply_to=None, extra=None, attach=None,
+                  notify=True, caption=None, *, syntax=None):
         """Send a generic file"""
         args = self._get_call_args(reply_to, extra, attach, notify)
         if caption is not None:
             args["caption"] = caption
             if syntax is not None:
                 syntax = syntaxes.guess_syntax(caption, syntax)
                 args["parse_mode"] = syntax
-        if path is not None and file_id is None and url is None:
-            files = {"document": open(path, "rb")}
-        elif file_id is not None and path is None and url is None:
-            files = None
-            args["document"] = file_id
-        elif url is not None and file_id is None and path is None:
-            args["document"] = url
-            files = None
-        elif path is None and file_id is None and url is None:
-            raise TypeError("path or file_id or URL is missing")
-        else:
-            raise TypeError("Only one among path, file_id and URL must be" +
-                            "passed")
+
+        files = dict()
+        args["document"], files["document"] = self._get_file_args(path,
+                                                                  file_id,
+                                                                  url)
+        if files["document"] is None:
+            del files["document"]
+        if thumb is not None:
+            files["thumb"] = thumb
 
         return self._api.call("sendDocument", args, files,
                               expect=_objects().Message)
 
     @_require_api
-    def send_location(self, latitude, longitude, reply_to=None, extra=None,
-                      attach=None, notify=True):
-        """Send a geographic location"""
+    def send_location(self, latitude, longitude, live_period=None,
+                      reply_to=None, extra=None, attach=None, notify=True):
+        """Send a geographic location, set live_period to a number between 60
+        and 86400 if it's a live location"""
         args = self._get_call_args(reply_to, extra, attach, notify)
         args["latitude"] = latitude
         args["longitude"] = longitude
 
+        if live_period:
+            if live_period < 60 or live_period > 86400:
+                raise ValueError(
+                    "live_period must be a number between 60 and 86400")
+            args["live_period"] = live_period
+
         return self._api.call("sendLocation", args,
                               expect=_objects().Message)
 
@@ -313,19 +312,13 @@ def send_sticker(self, sticker=None, reply_to=None, extra=None,
             )
 
         args = self._get_call_args(reply_to, extra, attach, notify)
-        if path is not None and file_id is None and url is None:
-            files = {"sticker": open(path, "rb")}
-        elif file_id is not None and path is None and url is None:
-            files = None
-            args["sticker"] = file_id
-        elif url is not None and file_id is None and path is None:
-            args["sticker"] = url
-            files = None
-        elif path is None and file_id is None and url is None:
-            raise TypeError("path or file_id or URL is missing")
-        else:
-            raise TypeError("Only one among path, file_id and URL must be " +
-                            "passed")
+
+        files = dict()
+        args["sticker"], files["sticker"] = self._get_file_args(path,
+                                                                file_id,
+                                                                url)
+        if files["sticker"] is None:
+            del files["sticker"]
 
         return self._api.call("sendSticker", args, files,
                               expect=_objects().Message)
@@ -451,10 +444,55 @@ def edit_caption(self, caption, extra=None, attach=None, *, syntax=None):
     def edit_attach(self, attach):
         """Edit this message's attachment"""
         args = {"message_id": self.id, "chat_id": self.chat.id}
-        args["reply_markup"] = attach
+        if not hasattr(attach, "_serialize_attachment"):
+            raise ValueError("%s is not an attachment" % attach)
+        args["reply_markup"] = json.dumps(attach._serialize_attachment(
+            self.chat
+        ))
 
         self._api.call("editMessageReplyMarkup", args)
 
+    @_require_api
+    def edit_live_location(self, latitude, longitude, extra=None, attach=None):
+        """Edit this message's live location position"""
+        args = {"message_id": self.id, "chat_id": self.chat.id}
+        args["latitude"] = latitude
+        args["longitude"] = longitude
+
+        if extra is not None:
+            _deprecated_message(
+                "The extra parameter", "1.0", "use the attach parameter", -3
+            )
+            args["reply_markup"] = json.dumps(extra.serialize())
+
+        if attach is not None:
+            if not hasattr(attach, "_serialize_attachment"):
+                raise ValueError("%s is not an attachment" % attach)
+            args["reply_markup"] = json.dumps(attach._serialize_attachment(
+                self.chat
+            ))
+
+        self._api.call("editMessageLiveLocation", args)
+
+    @_require_api
+    def stop_live_location(self, extra=None, attach=None):
+        """Stop this message's live location"""
+        args = {"message_id": self.id, "chat_id": self.chat.id}
+
+        if extra is not None:
+            _deprecated_message(
+                "The extra parameter", "1.0", "use the attach parameter", -3
+            )
+            args["reply_markup"] = json.dumps(extra.serialize())
+
+        if attach is not None:
+            if not hasattr(attach, "_serialize_attachment"):
+                raise ValueError("%s is not an attachment" % attach)
+            args["reply_markup"] = json.dumps(attach._serialize_attachment(
+                self.chat
+            ))
+        self._api.call("stopMessageLiveLocation", args)
+
     @_require_api
     def reply(self, *args, **kwargs):
         """Reply to the current message"""