Just spotted the following in the logs for a pair of my streamers:

Traceback (most recent call last):
  File "/home/keyz/tweets/tweetstream.py", line 20, in <module>
    stream.statuses.filter(locations=location)
  File "/usr/local/lib/python2.7/dist-packages/twython/streaming/types.py", line 65, in filter
    self.streamer._request(url, 'POST', params=params)
  File "/usr/local/lib/python2.7/dist-packages/twython/streaming/api.py", line 134, in _request
    for line in response.iter_lines(self.chunk_size):
  File "/usr/local/lib/python2.7/dist-packages/requests/models.py", line 602, in iter_lines
    decode_unicode=decode_unicode):
  File "/usr/local/lib/python2.7/dist-packages/requests/models.py", line 575, in generate
    raise ChunkedEncodingError(e)
requests.exceptions.ChunkedEncodingError: IncompleteRead(0 bytes read)

The line in question is

for line in response.iter_lines(self.chunk_size)

in https://github.com/ryanmcgrath/twython/blob/master/twython/streaming/api.py

Should there be some catch for this to pass it to on_error, rather than throwing an uncaught exception?

Looks like the exception is a fairly new one, see https://github.com/kennethreitz/requests/pull/1498.

I'd submit a patch, but I'm not sure of the best way to catch this. Putting a try block around the whole loop seems messy.

Hi, I'm testing the stream API sample code here https://github.com/ryanmcgrath/twython, but keep getting this error: line 560, in stream TwythonError: 'Response was not valid JSON, unable to decode.' Any help is appreciated.

I get the following error when using updateStatusWithMedia:

{"request":"/1/statuses/update_with_media.json","error":"Could not authenticate with OAuth."}

The updateStatus endpoint works fine, but updateStatusWithMedia generates an OAuth exception.

The majority of the unit tests for Twython test the Twitter API rather than Twython. Using a requests stub would allow the unit tests to focus on the code in Twython and work around the issues with failing tests due to Twitter hiccups and rate limits.

Here is an example using HTTMock (https://github.com/patrys/httmock):

class TwythonAPITestCase(unittest.TestCase):
    def setUp(self):
        [snip]

    def _make_url_checker(self, path):
        def check_url(url, request):
            self.assertEqual(path, url.path)
            return "empty response"
        return check_url

    def test_get(self):
        """Test Twython generic GET request works"""
        with httmock.HTTMock(self._make_url_checker("/1.1/account/verify_credentials.json")):
            self.api.get('account/verify_credentials')

In the example, I use a closure to create a url checker, but it could be expanded to check the request method and parameters.

This shows how the unit tests can now focus on making sure the request (url, params, header) is correct and skip hitting the Twitter API entirely. For those functions that process the response, the mock can return a hard coded response.

To run just this unit test: nosetests tests.test_core:TwythonAPITestCase.test_get

What do you think?

Hello, I know that recently a very similar issue was close, but I think it is different.

What happens is that when I try to work with TwythonStreamer - exactly like tutorial, I'm receiving the error 401.

The credentials are ok, since it works nicely with basic usage tutorial.

I'm with:

python=2.7.3 requests=1.2.0 requests_oauthlib=0.3.2 oauthlib=0.4.2

ps: I've found a question at Stackoverflow with the same question http://stackoverflow.com/questions/17438943/twython-oauth1-issues-401-error-using-example-code

Just started getting these today. I am guessing Twitter made some kind of change that is breaking it. I tried creating a new app with new credentials and it still fails.

Here's an example:

t = twython.Twython('XXXX','XXXX');
t.search(q='dogs');

/Users/joeldrotleff/code/connectr/connectr_server/ENV/lib/python2.7/site-packages/twython/twython.pyc in _request(self, url, method, params, api_call)
    192             raise ExceptionType(error_message,
    193                                 error_code=response.status_code,
--> 194                                 retry_after=response.headers.get('retry-after'))
    195 
    196         # if we have a json error here, then it's not an official Twitter API error

TwythonAuthError: Twitter API returned a 400 (Bad Request), Bad Authentication data

Sorry it's not more specific, I don't really know the ins and outs of twitter authentication.

3.0.0

• Changed twython/twython.py to twython/api.py in attempt to make structure look a little neater
• Removed all camelCase function access (anything like getHomeTimeline is now get_home_timeline)
• Removed shorten_url. With the requests library, shortening a URL on your own is simple enough
• twitter_token, twitter_secret and callback_url are no longer passed to Twython.__init__
  • twitter_token and twitter_secret have been replaced with app_key and app_secret respectively
  • callback_url is now passed through Twython.get_authentication_tokens
• Update test_twython.py docstrings per http://www.python.org/dev/peps/pep-0257/
• Removed get_list_memberships, method is Twitter API 1.0 deprecated
• Developers can now pass an array as a parameter to Twitter API methods and they will be automatically joined by a comma and converted to a string
• endpoints.py now contains EndpointsMixin (rather than the previous api_table dict) for Twython, which enables Twython to use functions declared in the Mixin.
• Added OAuth 2 authentication (Application Only) for when you want to make read-only calls to Twitter without having to go through the whole user authentication ritual (see docs for usage)
• Added obtain_access_token to obtain an OAuth 2 Application Only read-only access token
• construct_api_url now accepts keyword arguments like other Twython methods (e.g. instead of passing {'q': 'twitter', 'result_type': 'recent'}, pass q='twitter', result_type='recent')
• Pass client_args to the Twython __init__ to manipulate request variables. client_args accepts a dictionary of keywords and values that accepted by requests (http://docs.python-requests.org/en/latest/api/#sessionapi) [ex. headers, proxies, verify(SSL verification)] and the "request" section directly below it.
• Added get_application_rate_limit_status API method for returning the current rate limits for the specified source
• Added invalidate_token API method which allows registed apps to revoke an access token presenting its client credentials
• get_lastfunction_header now accepts a default_return_value parameter. This means that if you pass a second value (ex. Twython.get_lastfunction_header('x-rate-limit-remaining', 0)) and the value is not found, it returns your default value

To-do

• [x] Add file encoding to all files # -*- coding: utf-8 -*-
• [x] Add file description to all Twython api files
• [x] Remove deprecated variables fixes #185
• [x] Remove support for camelCase functions fixes #199
• [x] Substitute api_table for actual functions (EndpointsMixin) fixes #211
• [x] Better way to pass requests config fixes #213

please help, update status with normal message is fine but with media, i get this error :(

from twython import Twython

twitter = Twython( twitter_token = '52IKIxxxx', twitter_secret = 'SvwK4xmxxxx', oauth_token = '5164xxxxxxx', oauth_token_secret = 'kVkrHxxxxxx' )

twitter.updateStatus(status='hello tweet from raspberry pi 1.47am') twitter.updateStatusWithMedia("/home/pi/teddy.jpg", status='hello!')

image of error http://i.stack.imgur.com/5W1Bq.png

Good Morning I am trying to stream tweets that are aimed at a user, so the line looks like stream.statuses.filter(track="@RexFuzzle") However I see that in order for it to update and print the output I need to tweet to the account twice and on the second tweet is prints the first one, on the third tweet is prints the second one... etc. Is this standard for streaming?

Back in 2.7, I could make the following call:

t._media_update(settings.TWITTER_SHARE_URL,
    {'media[]': image_data}, status=message)

But the internal _media_update function has since been removed, so I can't upgrade Twython. Any chance it could come back or some other solution for posting in-memory image data could be added?

Or perhaps I'm missing something and there's a way to do this with the latest Twython?

Thanks!

Since Twitter now enforces OAuth 1.0a the oauth_verifier attached to the callback_url has to be passed to final authentication via GET. Added a new arg for this.

There are small typos in:

• docs/usage/advanced_usage.rst
• docs/usage/basic_usage.rst
• docs/usage/special_functions.rst
• docs/usage/starting_out.rst
• tests/test_endpoints.py
• twython/endpoints.py
• twython/streaming/api.py

Fixes:

• Should read received rather than recieved.
• Should read paginated rather than pagintated.
• Should read multiple rather than mutiple.
• Should read membership rather than memberhips.
• Should read manipulate rather than maninpulate.
• Should read explicitly rather than explicity.
• Should read destroy rather than destory.
• Should read authentication rather than autentication.
• Should read actual rather than acutal.

Semi-automated pull request generated by https://github.com/timgates42/meticulous/blob/master/docs/NOTE.md

As of 2021-11-15, new users can only use the v2 version of the API unless they are granted elevated access:

Twitter API returned a 403 (Forbidden), You currently have Essential access which includes access to Twitter API v2 endpoints only. If you need access to this endpoint, you’ll need to apply for Elevated access via the Developer Portal. You can learn more here: https://developer.twitter.com/en/docs/twitter-api/getting-started/about-twitter-api#v2-access-leve

Unfortunately, twython appears to be hard-coded to v1, or at least I did not find out how to use the v2 endpoints. It would be great if support or docs for this could be added!

This pull request added headers to the on_error call: https://github.com/ryanmcgrath/twython/pull/504

The issue is that all other the examples and documentation show on_error as taking two parameters, so they are all broken. I copied the code from here: https://twython.readthedocs.io/en/latest/usage/streaming_api.html

Looking at the codebase, here are the places that need to be updated: https://github.com/ryanmcgrath/twython/blob/master/docs/usage/streaming_api.rst https://github.com/ryanmcgrath/twython/blob/master/examples/stream.py https://github.com/ryanmcgrath/twython/blob/master/tests/test_streaming.py

I can try submitting a PR requests, though updating those seems fairly trivial.

python 3.8.2 twython 3.8.2

ImportError: cannot import name 'Twython' from partially initialized module 'twython' (most likely due to a circular import)

import sys import string from twython import Twython

twitter = Twython('Insert Consumer Key Here', 'Insert Consumer Secret Key',oauth_version=2) Access_token = twitter.obtain_access_token() t = Twython('Insert Consumer Key', access_token=Access_token)

user_timeline = t.search(q='@puremichigan', count=20, include_rts=1)

for tweets in user_timeline['statuses']: print(tweets['text'] +"\n")

I'm trying to send DM with this it's returning 404 sorry page not exist.

here's what I tried api.send_direct_message(type='message_create', recipient_id="id", message_data="test message"))

Hello Team,

Thanks for the fantastic job, I am loving Twython!! However, I ran into a small issue, I hope you'd have seen it already, and might have a solution for me. "include_email" parameter isn't working for me, I am not able to get user email. Yes, I've enabled "Request email address" in "Advanced Permissions". I've tried the following variations:

1. include_email=1
2. include_email="1"
3. include_email = True
4. include_email = "true"
5. include_email= "True"

I don't see what else can I try. Can you please help?