"get_content" needs content-type header value. so, i changed interface. And modify kitchensink(use tempfile).

Author: be-hase

README.md

@@ -114,17 +114,17 @@ print(profile.picture_url)
 print(profile.status_message)
 ```
 
-#### get_content_stream(self, message_id, chunk_size=1024, timeout=None)
+#### get_content(self, message_id, timeout=None)
 
 Retrieve image, video, and audio data sent by users.
 
 https://devdocs.line.me/en/#get-content
 
 ```python
-stream = line_bot_api.get_content_stream(message_id)
+message_content = line_bot_api.get_content(message_id)
 
 with open(file_path, 'wb') as fd:
-    for chunk in stream:
+    for chunk in message_content.iter_content():
         fd.write(chunk)
 ```
 

examples/flask-kitchensink/app.py

@@ -17,6 +17,7 @@
 import errno
 import os
 import sys
+import tempfile
 from argparse import ArgumentParser
 
 from flask import Flask, request, abort
@@ -190,23 +191,29 @@ def handle_sticker_message(event):
 @handler.add(MessageEvent, message=(ImageMessage, VideoMessage, AudioMessage))
 def handle_content_message(event):
     if isinstance(event.message, ImageMessage):
-        ext = '.jpg'
+        ext = 'jpg'
     elif isinstance(event.message, VideoMessage):
-        ext = '.mp4'
+        ext = 'mp4'
     elif isinstance(event.message, AudioMessage):
-        ext = '.m4a'
+        ext = 'm4a'
     else:
         return
 
-    stream = line_bot_api.get_content_stream(event.message.id)
-    file_path = os.path.join(static_tmp_path, event.message.id + ext)
-    with open(file_path, 'wb') as f:
-        for chunk in stream:
-            f.write(chunk)
+    message_content = line_bot_api.get_content(event.message.id)
+    with tempfile.NamedTemporaryFile(dir=static_tmp_path, prefix=ext + '-', delete=False) as tf:
+        for chunk in message_content.iter_content():
+            tf.write(chunk)
+        tempfile_path = tf.name
+
+    dist_path = tempfile_path + '.' + ext
+    dist_name = os.path.basename(dist_path)
+    os.rename(tempfile_path, dist_path)
 
     line_bot_api.reply_message(
-        event.reply_token,
-        TextSendMessage(text='Save content at ' + file_path))
+        event.reply_token, [
+            TextSendMessage(text='Save content.'),
+            TextSendMessage(text=request.host_url + os.path.join('static', 'tmp', dist_name))
+        ])
 
 
 @handler.add(FollowEvent)

linebot/api.py

@@ -22,7 +22,7 @@
 from .exceptions import LineBotApiError
 from .http_client import HttpClient, RequestsHttpClient
 from .models.error import Error
-from .models.responses import Profile
+from .models.responses import Profile, MessageContent
 
 
 class LineBotApi(object):
@@ -83,6 +83,7 @@ def reply_message(self, reply_token, messages, timeout=None):
             'replyToken': reply_token,
             'messages': [message.as_json_dict() for message in messages]
         }
+
         self._post(
             '/v2/bot/message/reply', data=json.dumps(data), timeout=timeout
         )
@@ -109,6 +110,7 @@ def push_message(self, to, messages, timeout=None):
             'to': to,
             'messages': [message.as_json_dict() for message in messages]
         }
+
         self._post(
             '/v2/bot/message/push', data=json.dumps(data), timeout=timeout
         )
@@ -129,36 +131,35 @@ def get_profile(self, user_id, timeout=None):
         :return:
 
         """
-        body = self._get(
+        response = self._get(
             '/v2/bot/profile/{user_id}'.format(user_id=user_id),
             timeout=timeout
         )
-        return Profile.new_from_json_dict(json.loads(body))
 
-    def get_content_stream(self, message_id, chunk_size=1024, timeout=None):
+        return Profile.new_from_json_dict(response.json)
+
+    def get_content(self, message_id, timeout=None):
         """Call get content API.
 
         https://devdocs.line.me/en/#get-content
 
         Retrieve image, video, and audio data sent by users.
 
         :param message_id: Message ID
-        :param int chunk_size: Chunk size
         :param float|tuple(float, float) timeout: (optional) How long to wait for the server
             to send data before giving up, as a float,
             or a (connect timeout, readtimeout) float tuple.
             Default is self.http_client.timeout
-        :rtype: iterator
+        :rtype: linebot.models.MessageContent
         :return:
 
         """
-        body_stream = self._get_stream(
-            '/v2/bot/message/{message_id}/content'.format(
-                message_id=message_id),
-            chunk_size=chunk_size, timeout=timeout
+        response = self._get(
+            '/v2/bot/message/{message_id}/content'.format(message_id=message_id),
+            stream=True, timeout=timeout
         )
 
-        return body_stream
+        return MessageContent(response)
 
     def leave_group(self, group_id, timeout=None):
         """Call leave group API.
@@ -196,26 +197,15 @@ def leave_room(self, room_id, timeout=None):
             timeout=timeout
         )
 
-    def _get(self, path, timeout=None):
+    def _get(self, path, stream=False, timeout=None):
         url = self.endpoint + path
 
         response = self.http_client.get(
-            url, headers=self.headers, timeout=timeout
-        )
-
-        self.__check_error(response)
-        return response.body
-
-    def _get_stream(self, path, chunk_size=1024, decode_unicode=False, timeout=None):
-        url = self.endpoint + path
-
-        response = self.http_client.get_stream(
-            url, headers=self.headers, timeout=timeout,
-            chunk_size=chunk_size, decode_unicode=decode_unicode
+            url, headers=self.headers, stream=stream, timeout=timeout
         )
 
         self.__check_error(response)
-        return response.body_stream
+        return response
 
     def _post(self, path, data=None, timeout=None):
         url = self.endpoint + path
@@ -227,12 +217,12 @@ def _post(self, path, data=None, timeout=None):
         )
 
         self.__check_error(response)
-        return response.body
+        return response
 
     @staticmethod
     def __check_error(response):
         if 200 <= response.status_code < 300:
             pass
         else:
-            error = Error.new_from_json_dict(json.loads(response.body))
+            error = Error.new_from_json_dict(response.json)
             raise LineBotApiError(response.status_code, error)

linebot/http_client.py

@@ -16,7 +16,7 @@
 
 from __future__ import unicode_literals
 
-from abc import ABCMeta, abstractmethod
+from abc import ABCMeta, abstractmethod, abstractproperty
 
 import requests
 from future.utils import with_metaclass
@@ -38,36 +38,20 @@ def __init__(self, timeout=DEFAULT_TIMEOUT):
         self.timeout = timeout
 
     @abstractmethod
-    def get(self, url, headers=None, params=None, timeout=None):
+    def get(self, url, headers=None, params=None, stream=False, timeout=None):
         """GET request.
 
         :param str url: Request url
         :param dict headers: (optional) Request headers
         :param dict params: (optional) Request query parameter
+        :param bool stream: (optional) get content as stream
         :param float|tuple(float, float) timeout: (optional), How long to wait for the server
             to send data before giving up, as a float,
             or a (connect timeout, readtimeout) float tuple.
             Default is DEFAULT_TIMEOUT
         """
         raise NotImplementedError
 
-    @abstractmethod
-    def get_stream(self, url, headers=None, params=None, timeout=None,
-                   chunk_size=1024, decode_unicode=False):
-        """GET request. Response is chunk content.
-
-        :param str url: Request url
-        :param dict headers: (optional) Request headers
-        :param dict params: (optional) Request query parameter
-        :param float|tuple(float, float) timeout: (optional), How long to wait for the server
-            to send data before giving up, as a float,
-            or a (connect timeout, readtimeout) float tuple.
-            Default is DEFAULT_TIMEOUT
-        :param int chunk_size: (optional) Chunk size
-        :param boole decode_unicode: (optional) Decode unicode
-        """
-        raise NotImplementedError
-
     @abstractmethod
     def post(self, url, headers=None, data=None, timeout=None):
         """POST request.
@@ -96,12 +80,13 @@ def __init__(self, timeout=HttpClient.DEFAULT_TIMEOUT):
         """
         super(RequestsHttpClient, self).__init__(timeout)
 
-    def get(self, url, headers=None, params=None, timeout=None):
+    def get(self, url, headers=None, params=None, stream=False, timeout=None):
         """GET request.
 
         :param str url: Request url
         :param dict headers: (optional) Request headers
         :param dict params: (optional) Request query parameter
+        :param bool stream: (optional) get content as stream
         :param float|tuple(float, float) timeout: (optional), How long to wait for the server
             to send data before giving up, as a float,
             or a (connect timeout, readtimeout) float tuple.
@@ -113,48 +98,10 @@ def get(self, url, headers=None, params=None, timeout=None):
             timeout = self.timeout
 
         response = requests.get(
-            url, headers=headers, params=params, timeout=timeout
-        )
-
-        return HttpResponse(
-            status_code=response.status_code, headers=response.headers,
-            body=response.text)
-
-    def get_stream(self, url, headers=None, params=None, timeout=None,
-                   chunk_size=1024, decode_unicode=False):
-        """GET request. Response is chunk content.
-
-        :param str url: Request url
-        :param dict headers: (optional) Request headers
-        :param dict params: (optional) Request query parameter
-        :param float|tuple(float, float) timeout: (optional), How long to wait for the server
-            to send data before giving up, as a float,
-            or a (connect timeout, readtimeout) float tuple.
-            Default is DEFAULT_TIMEOUT
-        :param int chunk_size: (optional) Chunk size
-        :param boole decode_unicode: (optional) Decode unicode
-        :rtype: HttpResponse
-        :return:
-        """
-        if timeout is None:
-            timeout = self.timeout
-
-        response = requests.get(
-            url, headers=headers, params=params, timeout=timeout,
-            stream=True
+            url, headers=headers, params=params, stream=stream, timeout=timeout
         )
 
-        if 200 <= response.status_code < 300:
-            return HttpResponse(
-                status_code=response.status_code, headers=response.headers,
-                body_stream=response.iter_content(
-                    chunk_size=chunk_size, decode_unicode=decode_unicode
-                )
-            )
-        else:
-            return HttpResponse(
-                status_code=response.status_code, headers=response.headers,
-                body=response.text)
+        return RequestsHttpResponse(response)
 
     def post(self, url, headers=None, data=None, timeout=None):
         """POST request.
@@ -176,23 +123,82 @@ def post(self, url, headers=None, data=None, timeout=None):
             url, headers=headers, data=data, timeout=timeout
         )
 
-        return HttpResponse(
-            status_code=response.status_code, headers=response.headers,
-            body=response.text)
+        return RequestsHttpResponse(response)
+
+
+class HttpResponse(with_metaclass(ABCMeta)):
+    """HttpResponse."""
 
+    @abstractproperty
+    def status_code(self):
+        """Get status code."""
+        raise NotImplementedError
 
-class HttpResponse(object):
-    """HttpResponse container."""
+    @abstractproperty
+    def headers(self):
+        """Get headers."""
+        raise NotImplementedError
 
-    def __init__(self, status_code=None, body=None, headers=None, body_stream=None):
+    @abstractproperty
+    def text(self):
+        """Get request body as text-decoded."""
+        raise NotImplementedError
+
+    @abstractproperty
+    def content(self):
+        """Get request body as binary."""
+        raise NotImplementedError
+
+    @abstractproperty
+    def json(self):
+        """Get request body as json-decoded."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def iter_content(self, chunk_size=1024, decode_unicode=False):
+        """Get request body as iterator content (stream)."""
+        raise NotImplementedError
+
+
+class RequestsHttpResponse(HttpResponse):
+    """HttpResponse implemented by requests lib's response."""
+
+    def __init__(self, response):
         """__init__ method.
 
-        :param str status_code: Status code
-        :param str body: Response body as text
-        :param dict headers: Response headers
-        :param iterator body_stream:
+        :param response: requests lib's response
+        """
+        self.response = response
+
+    @property
+    def status_code(self):
+        """Get status code."""
+        return self.response.status_code
+
+    @property
+    def headers(self):
+        """Get headers."""
+        return self.response.headers
+
+    @property
+    def text(self):
+        """Get request body as text-decoded."""
+        return self.response.text
+
+    @property
+    def content(self):
+        """Get request body as binary."""
+        return self.response.content
+
+    @property
+    def json(self):
+        """Get request body as json-decoded."""
+        return self.response.json()
+
+    def iter_content(self, chunk_size=1024, decode_unicode=False):
+        """Get request body as iterator content (stream).
+
+        :param chunk_size:
+        :param decode_unicode:
         """
-        self.status_code = status_code
-        self.headers = headers
-        self.body = body
-        self.body_stream = body_stream
+        return self.response.iter_content(chunk_size=chunk_size, decode_unicode=decode_unicode)