repos/twython
1
Fork 0
Code Issues 23 Pull requests 4 Projects Releases 5 Packages Wiki Activity Actions

Merged "api_ads.py" and "api.py" into the same file, as @michaelhelmick suggested.

Browse source
This commit is contained in:
Marko Novak 2015-11-19 12:16:13 +01:00 • committed by markonovak
parent bf160cd870
commit 7d87822688
7 changed files with 100 additions and 543 deletions
Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored
View file

@ -41,3 +41,4 @@ docs/_build
test.py test.py
.venv .venv
.idea

23
tests/test_core_ads.py
View file

@ -1,23 +0,0 @@
from .config import (
test_tweet_object, test_tweet_html, unittest
)
import responses
import requests
from twython.api_ads import TwythonAds
from twython.compat import is_py2
if is_py2:
from StringIO import StringIO
else:
from io import StringIO
try:
import unittest.mock as mock
except ImportError:
import mock
class TwythonAPITestCase(unittest.TestCase):
def setUp(self):
self.api = TwythonAds('', '', '', '')

40
tests/test_endpoints_ads.py
View file

@ -1,13 +1,11 @@
import base64 import base64
import datetime import datetime
import urllib import urllib
from twython import Twython, TwythonError from twython import Twython, TwythonError
from .config import ( from .config import (
app_key, app_secret, oauth_token, oauth_token_secret, app_key, app_secret, oauth_token, oauth_token_secret,
access_token, test_account_id, test_funding_instrument_id, test_campaign_id, unittest access_token, test_account_id, test_funding_instrument_id, test_campaign_id, unittest
) )
from twython.api_ads import TwythonAds
class TwythonEndpointsTestCase(unittest.TestCase): class TwythonEndpointsTestCase(unittest.TestCase):
@ -42,36 +40,36 @@ class TwythonEndpointsTestCase(unittest.TestCase):
'headers': {} 'headers': {}
} }
self.api = TwythonAds(app_key, app_secret, self.api = Twython(app_key, app_secret,
oauth_token, oauth_token_secret, oauth_token, oauth_token_secret,
client_args=client_args) client_args=client_args)
self.oauth2_api = Twython(app_key, access_token=access_token, self.oauth2_api = Twython(app_key, access_token=access_token,
client_args=oauth2_client_args) client_args=oauth2_client_args)
@unittest.skip('skipping non-updated test') # @unittest.skip('skipping non-updated test')
def test_get_accounts(self): def test_get_accounts(self):
accounts = self.api.get_accounts() accounts = self.api.get_accounts()
self.assertTrue(len(accounts) >= 0) self.assertTrue(len(accounts) >= 0)
@unittest.skip('skipping non-updated test') # @unittest.skip('skipping non-updated test')
def test_get_account(self): def test_get_account(self):
account = self.api.get_account(test_account_id) account = self.api.get_account(test_account_id)
self.assertEqual(account['id'], test_account_id) self.assertEqual(account['id'], test_account_id)
with self.assertRaises(TwythonError): with self.assertRaises(TwythonError):
self.api.get_account('1234') self.api.get_account('1234')
@unittest.skip('skipping non-updated test') # @unittest.skip('skipping non-updated test')
def test_get_account_features(self): def test_get_account_features(self):
account_features = self.api.get_account_features(test_account_id) account_features = self.api.get_account_features(test_account_id)
self.assertTrue(len(account_features) >= 0) self.assertTrue(len(account_features) >= 0)
@unittest.skip('skipping non-updated test') # @unittest.skip('skipping non-updated test')
def test_get_funding_instruments(self): def test_get_funding_instruments(self):
funding_instruments = self.api.get_funding_instruments(test_account_id) funding_instruments = self.api.get_funding_instruments(test_account_id)
self.assertTrue(len(funding_instruments) >= 0) self.assertTrue(len(funding_instruments) >= 0)
@unittest.skip('skipping non-updated test') # @unittest.skip('skipping non-updated test')
def test_get_funding_instrument(self): def test_get_funding_instrument(self):
funding_instrument = self.api.get_funding_instrument(test_account_id, test_funding_instrument_id) funding_instrument = self.api.get_funding_instrument(test_account_id, test_funding_instrument_id)
self.assertEqual(funding_instrument['id'], test_funding_instrument_id) self.assertEqual(funding_instrument['id'], test_funding_instrument_id)
@ -79,17 +77,17 @@ class TwythonEndpointsTestCase(unittest.TestCase):
with self.assertRaises(TwythonError): with self.assertRaises(TwythonError):
self.api.get_funding_instrument('1234', '1234') self.api.get_funding_instrument('1234', '1234')
@unittest.skip('skipping non-updated test') # @unittest.skip('skipping non-updated test')
def test_get_iab_categories(self): def test_get_iab_categories(self):
iab_categories = self.api.get_iab_categories() iab_categories = self.api.get_iab_categories()
self.assertTrue(len(iab_categories) >= 0) self.assertTrue(len(iab_categories) >= 0)
@unittest.skip('skipping non-updated test') # @unittest.skip('skipping non-updated test')
def test_get_available_platforms(self): def test_get_available_platforms(self):
available_platforms = self.api.get_available_platforms() available_platforms = self.api.get_available_platforms()
self.assertTrue(len(available_platforms) >= 0) self.assertTrue(len(available_platforms) >= 0)
@unittest.skip('skipping non-updated test') # @unittest.skip('skipping non-updated test')
def test_get_available_locations(self): def test_get_available_locations(self):
params = { params = {
'location_type': 'CITY', 'location_type': 'CITY',
@ -98,12 +96,12 @@ class TwythonEndpointsTestCase(unittest.TestCase):
available_locations = self.api.get_available_locations(**params) available_locations = self.api.get_available_locations(**params)
self.assertTrue(len(available_locations) > 0) self.assertTrue(len(available_locations) > 0)
@unittest.skip('skipping non-updated test') # @unittest.skip('skipping non-updated test')
def test_get_campaigns(self): def test_get_campaigns(self):
campaigns = self.api.get_campaigns(test_account_id) campaigns = self.api.get_campaigns(test_account_id)
self.assertTrue(len(campaigns) >= 0) self.assertTrue(len(campaigns) >= 0)
@unittest.skip('skipping non-updated test') # @unittest.skip('skipping non-updated test')
def test_create_and_delete_campaign(self): def test_create_and_delete_campaign(self):
campaign_id = self._create_test_campaign() campaign_id = self._create_test_campaign()
campaign_check = self.api.get_campaign(test_account_id, campaign_id) campaign_check = self.api.get_campaign(test_account_id, campaign_id)
@ -121,7 +119,7 @@ class TwythonEndpointsTestCase(unittest.TestCase):
is_deleted = self.api.delete_campaign(test_account_id, campaign_id) is_deleted = self.api.delete_campaign(test_account_id, campaign_id)
self.assertTrue(is_deleted) self.assertTrue(is_deleted)
@unittest.skip('skipping non-updated test') # @unittest.skip('skipping non-updated test')
def test_create_and_delete_line_item(self): def test_create_and_delete_line_item(self):
campaign_id = self._create_test_campaign() campaign_id = self._create_test_campaign()
line_item_id = self._create_test_line_item(campaign_id) line_item_id = self._create_test_line_item(campaign_id)
@ -142,7 +140,7 @@ class TwythonEndpointsTestCase(unittest.TestCase):
is_deleted = self.api.delete_line_item(test_account_id, line_item_id) is_deleted = self.api.delete_line_item(test_account_id, line_item_id)
self.assertTrue(is_deleted) self.assertTrue(is_deleted)
@unittest.skip('skipping non-updated test') # @unittest.skip('skipping non-updated test')
def test_upload_image(self): def test_upload_image(self):
response = self._upload_test_image() response = self._upload_test_image()
self.assertIsNotNone(response['media_id']) self.assertIsNotNone(response['media_id'])
@ -158,12 +156,12 @@ class TwythonEndpointsTestCase(unittest.TestCase):
response = self.api.upload_image(**upload_data) response = self.api.upload_image(**upload_data)
return response return response
@unittest.skip('skipping non-updated test') # @unittest.skip('skipping non-updated test')
def test_get_website_cards(self): def test_get_website_cards(self):
response = self.api.get_website_cards(test_account_id) response = self.api.get_website_cards(test_account_id)
self.assertTrue(len(response) >= 0) self.assertTrue(len(response) >= 0)
@unittest.skip('skipping non-updated test') # @unittest.skip('skipping non-updated test')
def test_create_and_delete_website_card(self): def test_create_and_delete_website_card(self):
card_id = self._create_test_website_card() card_id = self._create_test_website_card()
card = self.api.get_website_card(test_account_id, card_id) card = self.api.get_website_card(test_account_id, card_id)
@ -189,7 +187,7 @@ class TwythonEndpointsTestCase(unittest.TestCase):
response_delete = self.api.delete_website_card(test_account_id, card_id) response_delete = self.api.delete_website_card(test_account_id, card_id)
self.assertEqual(response_delete['id'], card_id) self.assertEqual(response_delete['id'], card_id)
@unittest.skip('skipping non-updated test') # @unittest.skip('skipping non-updated test')
def test_create_promoted_only_tweet(self): def test_create_promoted_only_tweet(self):
card_id, tweet_id = self._create_test_promoted_only_tweet() card_id, tweet_id = self._create_test_promoted_only_tweet()
self._delete_test_website_card(card_id) self._delete_test_website_card(card_id)
@ -206,7 +204,7 @@ class TwythonEndpointsTestCase(unittest.TestCase):
self.assertIsNotNone(tweet_id) self.assertIsNotNone(tweet_id)
return card_id, tweet_id return card_id, tweet_id
@unittest.skip('skipping non-updated test') # @unittest.skip('skipping non-updated test')
def test_promote_and_unpromote_tweet(self): def test_promote_and_unpromote_tweet(self):
campaign_id = self._create_test_campaign() campaign_id = self._create_test_campaign()
line_item_id = self._create_test_line_item(campaign_id) line_item_id = self._create_test_line_item(campaign_id)
@ -228,7 +226,7 @@ class TwythonEndpointsTestCase(unittest.TestCase):
self._delete_test_campaign(campaign_id) self._delete_test_campaign(campaign_id)
self._delete_test_website_card(card_id) self._delete_test_website_card(card_id)
@unittest.skip('skipping non-updated test') # @unittest.skip('skipping non-updated test')
def test_add_targeting_criteria(self): def test_add_targeting_criteria(self):
campaign_id = self._create_test_campaign() campaign_id = self._create_test_campaign()
line_item_id = self._create_test_line_item(campaign_id) line_item_id = self._create_test_line_item(campaign_id)
@ -254,7 +252,7 @@ class TwythonEndpointsTestCase(unittest.TestCase):
self.assertEquals(response_add['line_item_id'], line_item_id) self.assertEquals(response_add['line_item_id'], line_item_id)
return response_add['id'] return response_add['id']
@unittest.skip('skipping non-updated test') # @unittest.skip('skipping non-updated test')
def test_get_stats_promoted_tweets(self): def test_get_stats_promoted_tweets(self):
line_items = self.api.get_line_items(test_account_id, test_campaign_id) line_items = self.api.get_line_items(test_account_id, test_campaign_id)
promoted_tweets = self.api.get_promoted_tweets(test_account_id, line_items[0]['id']) promoted_tweets = self.api.get_promoted_tweets(test_account_id, line_items[0]['id'])

30
twython/api.py
View file

@ -5,8 +5,8 @@ twython.api
~~~~~~~~~~~ ~~~~~~~~~~~
This module contains functionality for access to core Twitter API calls, This module contains functionality for access to core Twitter API calls,
Twitter Authentication, and miscellaneous methods that are useful when Twitter Ads API calls, Twitter Authentication, and miscellaneous methods
dealing with the Twitter API that are useful when dealing with the Twitter API
""" """
import warnings import warnings
@ -20,17 +20,19 @@ from . import __version__
from .advisory import TwythonDeprecationWarning from .advisory import TwythonDeprecationWarning
from .compat import json, urlencode, parse_qsl, quote_plus, str, is_py2 from .compat import json, urlencode, parse_qsl, quote_plus, str, is_py2
from .endpoints import EndpointsMixin from .endpoints import EndpointsMixin
from .endpoints_ads import EndpointsAdsMixin
from .exceptions import TwythonError, TwythonAuthError, TwythonRateLimitError from .exceptions import TwythonError, TwythonAuthError, TwythonRateLimitError
from .helpers import _transparent_params from .helpers import _transparent_params
from .api_type import API_TYPE_TWITTER, API_TYPE_TWITTER_ADS
warnings.simplefilter('always', TwythonDeprecationWarning) # For Python 2.7 > warnings.simplefilter('always', TwythonDeprecationWarning) # For Python 2.7 >
class Twython(EndpointsMixin, object): class Twython(EndpointsMixin, EndpointsAdsMixin, object):
def __init__(self, app_key=None, app_secret=None, oauth_token=None, def __init__(self, app_key=None, app_secret=None, oauth_token=None,
oauth_token_secret=None, access_token=None, oauth_token_secret=None, access_token=None,
token_type='bearer', oauth_version=1, api_version='1.1', token_type='bearer', oauth_version=1, api_version='1.1',
client_args=None, auth_endpoint='authenticate'): api_ads_version='0', client_args=None, auth_endpoint='authenticate'):
"""Instantiates an instance of Twython. Takes optional parameters for """Instantiates an instance of Twython. Takes optional parameters for
authentication and such (see below). authentication and such (see below).
@ -48,6 +50,8 @@ class Twython(EndpointsMixin, object):
Default: 1 Default: 1
:param api_version: (optional) Choose which Twitter API version to :param api_version: (optional) Choose which Twitter API version to
use. Default: 1.1 use. Default: 1.1
:param api_ads_version: (optional) Choose which Twitter Ads API version to
use. Default: 0
:param client_args: (optional) Accepts some requests Session parameters :param client_args: (optional) Accepts some requests Session parameters
and some requests Request parameters. and some requests Request parameters.
@ -64,7 +68,9 @@ class Twython(EndpointsMixin, object):
# API urls, OAuth urls and API version; needed for hitting that there # API urls, OAuth urls and API version; needed for hitting that there
# API. # API.
self.api_version = api_version self.api_version = api_version
self.api_ads_version = api_ads_version
self.api_url = 'https://api.twitter.com/%s' self.api_url = 'https://api.twitter.com/%s'
self.api_ads_url = 'https://ads-api.twitter.com/%s'
self.app_key = app_key self.app_key = app_key
self.app_secret = app_secret self.app_secret = app_secret
@ -224,7 +230,7 @@ class Twython(EndpointsMixin, object):
return error_message return error_message
def request(self, endpoint, method='GET', params=None, version='1.1'): def request(self, endpoint, api_type=API_TYPE_TWITTER, method='GET', params=None, version='1.1'):
"""Return dict of response received from Twitter's API """Return dict of response received from Twitter's API
:param endpoint: (required) Full url or Twitter API endpoint :param endpoint: (required) Full url or Twitter API endpoint
@ -251,6 +257,8 @@ class Twython(EndpointsMixin, object):
# i.e. https://api.twitter.com/1.1/search/tweets.json # i.e. https://api.twitter.com/1.1/search/tweets.json
if endpoint.startswith('https://'): if endpoint.startswith('https://'):
url = endpoint url = endpoint
elif api_type == API_TYPE_TWITTER_ADS:
url = '%s/%s' % (self.api_ads_url % version, endpoint)
else: else:
url = '%s/%s.json' % (self.api_url % version, endpoint) url = '%s/%s.json' % (self.api_url % version, endpoint)
@ -259,13 +267,17 @@ class Twython(EndpointsMixin, object):
return content return content
def get(self, endpoint, params=None, version='1.1'): def get(self, endpoint, api_type=API_TYPE_TWITTER, params=None, version='1.1'):
"""Shortcut for GET requests via :class:`request`""" """Shortcut for GET requests via :class:`request`"""
return self.request(endpoint, params=params, version=version) return self.request(endpoint, api_type=api_type, params=params, version=version)
def post(self, endpoint, params=None, version='1.1'): def post(self, endpoint, api_type=API_TYPE_TWITTER, params=None, version='1.1'):
"""Shortcut for POST requests via :class:`request`""" """Shortcut for POST requests via :class:`request`"""
return self.request(endpoint, 'POST', params=params, version=version) return self.request(endpoint, api_type=api_type, method='POST', params=params, version=version)
def delete(self, endpoint, api_type=API_TYPE_TWITTER, params=None, version='1.1'):
"""Shortcut for DELETE requests via :class:`request`"""
return self.request(endpoint, api_type=api_type, method='DELETE', params=params, version=version)
def get_lastfunction_header(self, header, default_return_value=None): def get_lastfunction_header(self, header, default_return_value=None):
"""Returns a specific header from the last API call """Returns a specific header from the last API call

461
twython/api_ads.py
View file

@ -1,461 +0,0 @@
# -*- coding: utf-8 -*-
"""
twython.api_ads
~~~~~~~~~~~
This module contains functionality for access to core Twitter Ads API calls,
Twitter Authentication, and miscellaneous methods that are useful when
dealing with the Twitter Ads API
"""
import warnings
import re
import requests
from requests.auth import HTTPBasicAuth
from requests_oauthlib import OAuth1, OAuth2
from . import __version__
from .advisory import TwythonDeprecationWarning
from .compat import json, urlencode, parse_qsl, quote_plus, str, is_py2
from .exceptions import TwythonError, TwythonAuthError, TwythonRateLimitError
from .helpers import _transparent_params
from twython.endpoints_ads import EndpointsAdsMixin
warnings.simplefilter('always', TwythonDeprecationWarning) # For Python 2.7 >
class TwythonAds(EndpointsAdsMixin, object):
def __init__(self, app_key=None, app_secret=None, oauth_token=None,
oauth_token_secret=None, access_token=None,
token_type='bearer', oauth_version=1, api_version='0',
client_args=None, auth_endpoint='authenticate'):
"""Instantiates an instance of TwythonAds. Takes optional parameters for
authentication and such (see below).
:param app_key: (optional) Your applications key
:param app_secret: (optional) Your applications secret key
:param oauth_token: (optional) When using **OAuth 1**, combined with
oauth_token_secret to make authenticated calls
:param oauth_token_secret: (optional) When using **OAuth 1** combined
with oauth_token to make authenticated calls
:param access_token: (optional) When using **OAuth 2**, provide a
valid access token if you have one
:param token_type: (optional) When using **OAuth 2**, provide your
token type. Default: bearer
:param oauth_version: (optional) Choose which OAuth version to use.
Default: 1
:param api_version: (optional) Choose which Twitter API version to
use. Default: 0
:param client_args: (optional) Accepts some requests Session parameters
and some requests Request parameters.
See http://docs.python-requests.org/en/latest/api/#sessionapi
and requests section below it for details.
[ex. headers, proxies, verify(SSL verification)]
:param auth_endpoint: (optional) Lets you select which authentication
endpoint will use your application.
This will allow the application to have DM access
if the endpoint is 'authorize'.
Default: authenticate.
"""
# API urls, OAuth urls and API version; needed for hitting that there
# API.
self.api_version = api_version
self.api_url = 'https://ads-api.twitter.com/%s'
self.app_key = app_key
self.app_secret = app_secret
self.oauth_token = oauth_token
self.oauth_token_secret = oauth_token_secret
self.access_token = access_token
# OAuth 1
self.request_token_url = self.api_url % 'oauth/request_token'
self.access_token_url = self.api_url % 'oauth/access_token'
self.authenticate_url = self.api_url % ('oauth/%s' % auth_endpoint)
if self.access_token: # If they pass an access token, force OAuth 2
oauth_version = 2
self.oauth_version = oauth_version
# OAuth 2
if oauth_version == 2:
self.request_token_url = self.api_url % 'oauth2/token'
self.client_args = client_args or {}
default_headers = {'User-Agent': 'Twython v' + __version__}
if 'headers' not in self.client_args:
# If they didn't set any headers, set our defaults for them
self.client_args['headers'] = default_headers
elif 'User-Agent' not in self.client_args['headers']:
# If they set headers, but didn't include User-Agent.. set
# it for them
self.client_args['headers'].update(default_headers)
# Generate OAuth authentication object for the request
# If no keys/tokens are passed to __init__, auth=None allows for
# unauthenticated requests, although I think all v1.1 requests
# need auth
auth = None
if oauth_version == 1:
# User Authentication is through OAuth 1
if self.app_key is not None and self.app_secret is not None:
auth = OAuth1(self.app_key, self.app_secret,
self.oauth_token, self.oauth_token_secret)
elif oauth_version == 2 and self.access_token:
# Application Authentication is through OAuth 2
token = {'token_type': token_type,
'access_token': self.access_token}
auth = OAuth2(self.app_key, token=token)
self.client = requests.Session()
self.client.auth = auth
# Make a copy of the client args and iterate over them
# Pop out all the acceptable args at this point because they will
# Never be used again.
client_args_copy = self.client_args.copy()
for k, v in client_args_copy.items():
if k in ('cert', 'hooks', 'max_redirects', 'proxies'):
setattr(self.client, k, v)
self.client_args.pop(k) # Pop, pop!
# Headers are always present, so we unconditionally pop them and merge
# them into the session headers.
self.client.headers.update(self.client_args.pop('headers'))
self._last_call = None
def __repr__(self):
return '<Twython: %s>' % (self.app_key)
def _request(self, url, method='GET', params=None, api_call=None):
"""Internal request method"""
method = method.lower()
params = params or {}
func = getattr(self.client, method)
params, files = _transparent_params(params)
requests_args = {}
for k, v in self.client_args.items():
# Maybe this should be set as a class variable and only done once?
if k in ('timeout', 'allow_redirects', 'stream', 'verify'):
requests_args[k] = v
if method == 'get':
requests_args['params'] = params
else:
requests_args.update({
'data': params,
'files': files,
})
try:
response = func(url, **requests_args)
except requests.RequestException as e:
raise TwythonError(str(e))
# create stash for last function intel
self._last_call = {
'api_call': api_call,
'api_error': None,
'cookies': response.cookies,
'headers': response.headers,
'status_code': response.status_code,
'url': response.url,
'content': response.text,
}
# greater than 304 (not modified) is an error
if response.status_code > 304:
error_message = self._get_error_message(response)
self._last_call['api_error'] = error_message
ExceptionType = TwythonError
if response.status_code == 429:
# Twitter API 1.1, always return 429 when
# rate limit is exceeded
ExceptionType = TwythonRateLimitError
elif response.status_code == 401 or 'Bad Authentication data' \
in error_message:
# Twitter API 1.1, returns a 401 Unauthorized or
# a 400 "Bad Authentication data" for invalid/expired
# app keys/user tokens
ExceptionType = TwythonAuthError
raise ExceptionType(
error_message,
error_code=response.status_code,
retry_after=response.headers.get('X-Rate-Limit-Reset'))
try:
if response.status_code == 204:
content = response.content
else:
content = response.json()
except ValueError:
raise TwythonError('Response was not valid JSON. \
Unable to decode.')
return content
def _get_error_message(self, response):
"""Parse and return the first error message"""
error_message = 'An error occurred processing your request.'
try:
content = response.json()
# {"errors":[{"code":34,"message":"Sorry,
# that page does not exist"}]}
error_message = content['errors'][0]['message']
except TypeError:
error_message = content['errors']
except ValueError:
# bad json data from Twitter for an error
pass
except (KeyError, IndexError):
# missing data so fallback to default message
pass
return error_message
def request(self, endpoint, method='GET', params=None, version='0'):
"""Return dict of response received from Twitter's API
:param endpoint: (required) Full url or Twitter API endpoint
(e.g. search/tweets)
:type endpoint: string
:param method: (optional) Method of accessing data, either
GET or POST. (default GET)
:type method: string
:param params: (optional) Dict of parameters (if any) accepted
the by Twitter API endpoint you are trying to
access (default None)
:type params: dict or None
:param version: (optional) Twitter API version to access
(default 0)
:type version: string
:rtype: dict
"""
if endpoint.startswith('http://'):
raise TwythonError('ads-api.twitter.com is restricted to SSL/TLS traffic.')
# In case they want to pass a full Twitter URL
# i.e. https://api.twitter.com/1.1/search/tweets.json
if endpoint.startswith('https://'):
url = endpoint
else:
url = '%s/%s' % (self.api_url % version, endpoint)
content = self._request(url, method=method, params=params,
api_call=url)
return content
def get(self, endpoint, params=None, version='0'):
"""Shortcut for GET requests via :class:`request`"""
return self.request(endpoint, params=params, version=version)
def post(self, endpoint, params=None, version='0'):
"""Shortcut for POST requests via :class:`request`"""
return self.request(endpoint, 'POST', params=params, version=version)
def delete(self, endpoint, params=None, version='0'):
"""Shortcut for DELETE requests via :class:`request`"""
return self.request(endpoint, 'DELETE', params=params, version=version)
def get_lastfunction_header(self, header, default_return_value=None):
"""Returns a specific header from the last API call
This will return None if the header is not present
:param header: (required) The name of the header you want to get
the value of
Most useful for the following header information:
x-rate-limit-limit,
x-rate-limit-remaining,
x-rate-limit-class,
x-rate-limit-reset
"""
if self._last_call is None:
raise TwythonError('This function must be called after an API call. \
It delivers header information.')
return self._last_call['headers'].get(header, default_return_value)
def get_authentication_tokens(self, callback_url=None, force_login=False,
screen_name=''):
"""Returns a dict including an authorization URL, ``auth_url``, to
direct a user to
:param callback_url: (optional) Url the user is returned to after
they authorize your app (web clients only)
:param force_login: (optional) Forces the user to enter their
credentials to ensure the correct users
account is authorized.
:param screen_name: (optional) If forced_login is set OR user is
not currently logged in, Prefills the username
input box of the OAuth login screen with the
given value
:rtype: dict
"""
if self.oauth_version != 1:
raise TwythonError('This method can only be called when your \
OAuth version is 1.0.')
request_args = {}
if callback_url:
request_args['oauth_callback'] = callback_url
response = self.client.get(self.request_token_url, params=request_args)
if response.status_code == 401:
raise TwythonAuthError(response.content,
error_code=response.status_code)
elif response.status_code != 200:
raise TwythonError(response.content,
error_code=response.status_code)
request_tokens = dict(parse_qsl(response.content.decode('utf-8')))
if not request_tokens:
raise TwythonError('Unable to decode request tokens.')
oauth_callback_confirmed = request_tokens.get('oauth_callback_confirmed') \
== 'true'
auth_url_params = {
'oauth_token': request_tokens['oauth_token'],
}
if force_login:
auth_url_params.update({
'force_login': force_login,
'screen_name': screen_name
})
# Use old-style callback argument if server didn't accept new-style
if callback_url and not oauth_callback_confirmed:
auth_url_params['oauth_callback'] = self.callback_url
request_tokens['auth_url'] = self.authenticate_url + \
'?' + urlencode(auth_url_params)
return request_tokens
def get_authorized_tokens(self, oauth_verifier):
"""Returns a dict of authorized tokens after they go through the
:class:`get_authentication_tokens` phase.
:param oauth_verifier: (required) The oauth_verifier (or a.k.a PIN
for non web apps) retrieved from the callback url querystring
:rtype: dict
"""
if self.oauth_version != 1:
raise TwythonError('This method can only be called when your \
OAuth version is 1.0.')
response = self.client.get(self.access_token_url,
params={'oauth_verifier': oauth_verifier},
headers={'Content-Type': 'application/\
json'})
if response.status_code == 401:
try:
try:
# try to get json
content = response.json()
except AttributeError: # pragma: no cover
# if unicode detected
content = json.loads(response.content)
except ValueError:
content = {}
raise TwythonError(content.get('error', 'Invalid / expired To \
ken'), error_code=response.status_code)
authorized_tokens = dict(parse_qsl(response.content.decode('utf-8')))
if not authorized_tokens:
raise TwythonError('Unable to decode authorized tokens.')
return authorized_tokens # pragma: no cover
def obtain_access_token(self):
"""Returns an OAuth 2 access token to make OAuth 2 authenticated
read-only calls.
:rtype: string
"""
if self.oauth_version != 2:
raise TwythonError('This method can only be called when your \
OAuth version is 2.0.')
data = {'grant_type': 'client_credentials'}
basic_auth = HTTPBasicAuth(self.app_key, self.app_secret)
try:
response = self.client.post(self.request_token_url,
data=data, auth=basic_auth)
content = response.content.decode('utf-8')
try:
content = content.json()
except AttributeError:
content = json.loads(content)
access_token = content['access_token']
except (KeyError, ValueError, requests.exceptions.RequestException):
raise TwythonAuthError('Unable to obtain OAuth 2 access token.')
else:
return access_token
@staticmethod
def construct_api_url(api_url, **params):
"""Construct a Twitter API url, encoded, with parameters
:param api_url: URL of the Twitter API endpoint you are attempting
to construct
:param \*\*params: Parameters that are accepted by Twitter for the
endpoint you're requesting
:rtype: string
Usage::
>>> from twython import Twython
>>> twitter = Twython()
>>> api_url = 'https://api.twitter.com/1.1/search/tweets.json'
>>> constructed_url = twitter.construct_api_url(api_url, q='python',
result_type='popular')
>>> print constructed_url
https://api.twitter.com/1.1/search/tweets.json?q=python&result_type=popular
"""
querystring = []
params, _ = _transparent_params(params or {})
params = requests.utils.to_key_val_list(params)
for (k, v) in params:
querystring.append(
'%s=%s' % (TwythonAds.encode(k), quote_plus(TwythonAds.encode(v)))
)
return '%s?%s' % (api_url, '&'.join(querystring))
@staticmethod
def unicode2utf8(text):
try:
if is_py2 and isinstance(text, str):
text = text.encode('utf-8')
except:
pass
return text
@staticmethod
def encode(text):
if is_py2 and isinstance(text, (str)):
return TwythonAds.unicode2utf8(text)
return str(text)

2
twython/api_type.py Normal file
View file

@ -0,0 +1,2 @@
API_TYPE_TWITTER='api'
API_TYPE_TWITTER_ADS='api_ads'

82
twython/endpoints_ads.py
View file

@ -15,6 +15,8 @@ The API functions that are implemented in this module are documented at:
https://dev.twitter.com/ads/overview https://dev.twitter.com/ads/overview
""" """
from .api_type import API_TYPE_TWITTER_ADS
try: try:
from StringIO import StringIO from StringIO import StringIO
except ImportError: except ImportError:
@ -23,118 +25,143 @@ except ImportError:
class EndpointsAdsMixin(object): class EndpointsAdsMixin(object):
def get_accounts(self, **params): def get_accounts(self, **params):
response = self.get('accounts', params=params) response = self.get('accounts', params=params, api_type=API_TYPE_TWITTER_ADS, version=self.api_ads_version)
return response['data'] return response['data']
def get_account(self, account_id, **params): def get_account(self, account_id, **params):
response = self.get('accounts/%s' % account_id, params=params) response = self.get('accounts/%s' % account_id, params=params, api_type=API_TYPE_TWITTER_ADS,
version=self.api_ads_version)
return response['data'] return response['data']
def get_account_features(self, account_id, **params): def get_account_features(self, account_id, **params):
response = self.get('accounts/%s/features' % account_id, params=params) response = self.get('accounts/%s/features' % account_id, params=params, api_type=API_TYPE_TWITTER_ADS,
version=self.api_ads_version)
return response['data'] return response['data']
def get_funding_instruments(self, account_id, **params): def get_funding_instruments(self, account_id, **params):
response = self.get('accounts/%s/funding_instruments' % account_id, params=params) response = self.get('accounts/%s/funding_instruments' % account_id, params=params,
api_type=API_TYPE_TWITTER_ADS, version=self.api_ads_version)
return response['data'] return response['data']
def get_funding_instrument(self, account_id, funding_instrument_id, **params): def get_funding_instrument(self, account_id, funding_instrument_id, **params):
response = self.get('accounts/%s/funding_instruments/%s' % (account_id, funding_instrument_id), params=params) response = self.get('accounts/%s/funding_instruments/%s' % (account_id, funding_instrument_id), params=params,
api_type=API_TYPE_TWITTER_ADS, version=self.api_ads_version)
return response['data'] return response['data']
def get_iab_categories(self, **params): def get_iab_categories(self, **params):
response = self.get('iab_categories', params=params) response = self.get('iab_categories', params=params, api_type=API_TYPE_TWITTER_ADS,
version=self.api_ads_version)
return response['data'] return response['data']
def get_available_platforms(self, **params): def get_available_platforms(self, **params):
response = self.get('targeting_criteria/platforms', params=params) response = self.get('targeting_criteria/platforms', params=params, api_type=API_TYPE_TWITTER_ADS,
version=self.api_ads_version)
return response['data'] return response['data']
def get_available_locations(self, **params): def get_available_locations(self, **params):
response = self.get('targeting_criteria/locations', params=params) response = self.get('targeting_criteria/locations', params=params, api_type=API_TYPE_TWITTER_ADS,
version=self.api_ads_version)
return response['data'] return response['data']
def get_campaigns(self, account_id, **params): def get_campaigns(self, account_id, **params):
response = self.get('accounts/%s/campaigns' % account_id, params=params) response = self.get('accounts/%s/campaigns' % account_id, params=params, api_type=API_TYPE_TWITTER_ADS,
version=self.api_ads_version)
return response['data'] return response['data']
def get_campaign(self, account_id, campaign_id, **params): def get_campaign(self, account_id, campaign_id, **params):
response = self.get('accounts/%s/campaigns/%s' % (account_id, campaign_id), params=params) response = self.get('accounts/%s/campaigns/%s' % (account_id, campaign_id), params=params,
api_type=API_TYPE_TWITTER_ADS, version=self.api_ads_version)
return response['data'] return response['data']
def create_campaign(self, account_id, **params): def create_campaign(self, account_id, **params):
response = self.post('accounts/%s/campaigns' % account_id, params=params) response = self.post('accounts/%s/campaigns' % account_id, params=params, api_type=API_TYPE_TWITTER_ADS,
version=self.api_ads_version)
return response['data'] return response['data']
def delete_campaign(self, account_id, campaign_id): def delete_campaign(self, account_id, campaign_id):
response = self.delete('accounts/%s/campaigns/%s' % (account_id, campaign_id)) response = self.delete('accounts/%s/campaigns/%s' % (account_id, campaign_id), api_type=API_TYPE_TWITTER_ADS,
version=self.api_ads_version)
return response['data']['deleted'] return response['data']['deleted']
def create_line_item(self, account_id, campaign_id, **params): def create_line_item(self, account_id, campaign_id, **params):
params_extended = params.copy() params_extended = params.copy()
params_extended['campaign_id'] = campaign_id params_extended['campaign_id'] = campaign_id
response = self.post('accounts/%s/line_items' % account_id, params=params_extended) response = self.post('accounts/%s/line_items' % account_id, params=params_extended,
api_type=API_TYPE_TWITTER_ADS, version=self.api_ads_version)
return response['data'] return response['data']
def delete_line_item(self, account_id, line_item_id): def delete_line_item(self, account_id, line_item_id):
response = self.delete('accounts/%s/line_items/%s' % (account_id, line_item_id)) response = self.delete('accounts/%s/line_items/%s' % (account_id, line_item_id), api_type=API_TYPE_TWITTER_ADS,
version=self.api_ads_version)
return response['data']['deleted'] return response['data']['deleted']
def get_line_items(self, account_id, campaign_id=None, **params): def get_line_items(self, account_id, campaign_id=None, **params):
params_extended = params.copy() params_extended = params.copy()
if campaign_id is not None: if campaign_id is not None:
params_extended['campaign_ids'] = campaign_id params_extended['campaign_ids'] = campaign_id
response = self.get('accounts/%s/line_items' % account_id, params=params_extended) response = self.get('accounts/%s/line_items' % account_id, params=params_extended,
api_type=API_TYPE_TWITTER_ADS, version=self.api_ads_version)
return response['data'] return response['data']
def get_website_cards(self, account_id, **params): def get_website_cards(self, account_id, **params):
response = self.get('accounts/%s/cards/website' % account_id, params=params) response = self.get('accounts/%s/cards/website' % account_id, params=params, api_type=API_TYPE_TWITTER_ADS,
version=self.api_ads_version)
return response['data'] return response['data']
def get_website_card(self, account_id, card_id, **params): def get_website_card(self, account_id, card_id, **params):
response = self.get('accounts/%s/cards/website/%s' % (account_id, card_id), params=params) response = self.get('accounts/%s/cards/website/%s' % (account_id, card_id), params=params,
api_type=API_TYPE_TWITTER_ADS, version=self.api_ads_version)
return response['data'] return response['data']
def create_website_card(self, account_id, **params): def create_website_card(self, account_id, **params):
# TODO: handle the case where name, website_title, website_url are too long! # TODO: handle the case where name, website_title, website_url are too long!
response = self.post('accounts/%s/cards/website' % account_id, params=params) response = self.post('accounts/%s/cards/website' % account_id, params=params, api_type=API_TYPE_TWITTER_ADS,
version=self.api_ads_version)
return response['data'] return response['data']
def delete_website_card(self, account_id, card_id, **params): def delete_website_card(self, account_id, card_id, **params):
response = self.delete('accounts/%s/cards/website/%s' % (account_id, card_id), params=params) response = self.delete('accounts/%s/cards/website/%s' % (account_id, card_id), params=params,
api_type=API_TYPE_TWITTER_ADS, version=self.api_ads_version)
return response['data'] return response['data']
def upload_image(self, **params): def upload_image(self, **params):
response = self.post('https://upload.twitter.com/1.1/media/upload.json', params=params) response = self.post('https://upload.twitter.com/1.1/media/upload.json', params=params,
api_type=API_TYPE_TWITTER_ADS, version=self.api_ads_version)
return response return response
def create_promoted_only_tweet(self, account_id, **params): def create_promoted_only_tweet(self, account_id, **params):
response = self.post('accounts/%s/tweet' % account_id, params=params) response = self.post('accounts/%s/tweet' % account_id, params=params, api_type=API_TYPE_TWITTER_ADS,
version=self.api_ads_version)
return response['data'] return response['data']
def promote_tweet(self, account_id, **params): def promote_tweet(self, account_id, **params):
response = self.post('accounts/%s/promoted_tweets' % account_id, params=params) response = self.post('accounts/%s/promoted_tweets' % account_id, params=params, api_type=API_TYPE_TWITTER_ADS,
version=self.api_ads_version)
return response['data'] return response['data']
def unpromote_tweet(self, account_id, promotion_id): def unpromote_tweet(self, account_id, promotion_id):
response = self.delete('accounts/%s/promoted_tweets/%s' % (account_id, promotion_id)) response = self.delete('accounts/%s/promoted_tweets/%s' % (account_id, promotion_id),
api_type=API_TYPE_TWITTER_ADS, version=self.api_ads_version)
return response['data'] return response['data']
def get_promoted_tweets(self, account_id, line_item_id=None, **params): def get_promoted_tweets(self, account_id, line_item_id=None, **params):
params_extended = params.copy() params_extended = params.copy()
if line_item_id is not None: if line_item_id is not None:
params_extended['line_item_id'] = line_item_id params_extended['line_item_id'] = line_item_id
response = self.get('accounts/%s/promoted_tweets' % account_id, params=params_extended) response = self.get('accounts/%s/promoted_tweets' % account_id, params=params_extended,
api_type=API_TYPE_TWITTER_ADS, version=self.api_ads_version)
return response['data'] return response['data']
def add_targeting_criteria(self, account_id, line_item_id, **params): def add_targeting_criteria(self, account_id, line_item_id, **params):
params_extended = params.copy() params_extended = params.copy()
params_extended['line_item_id'] = line_item_id params_extended['line_item_id'] = line_item_id
response = self.post('accounts/%s/targeting_criteria' % account_id, params=params_extended) response = self.post('accounts/%s/targeting_criteria' % account_id, params=params_extended,
api_type=API_TYPE_TWITTER_ADS, version=self.api_ads_version)
return response['data'] return response['data']
def remove_targeting_criteria(self, account_id, criteria_id): def remove_targeting_criteria(self, account_id, criteria_id):
response = self.delete('accounts/%s/targeting_criteria/%s' % (account_id, criteria_id)) response = self.delete('accounts/%s/targeting_criteria/%s' % (account_id, criteria_id),
api_type=API_TYPE_TWITTER_ADS, version=self.api_ads_version)
return response['data'] return response['data']
def get_stats_promoted_tweets(self, account_id, promoted_tweet_ids, **params): def get_stats_promoted_tweets(self, account_id, promoted_tweet_ids, **params):
@ -146,6 +173,7 @@ class EndpointsAdsMixin(object):
chunk = promoted_tweet_ids[i:i + max_chunk_size] chunk = promoted_tweet_ids[i:i + max_chunk_size]
params_extended = params.copy() params_extended = params.copy()
params_extended['promoted_tweet_ids'] = ",".join(chunk) params_extended['promoted_tweet_ids'] = ",".join(chunk)
response = self.get('stats/accounts/%s/promoted_tweets' % account_id, params=params_extended) response = self.get('stats/accounts/%s/promoted_tweets' % account_id, params=params_extended,
api_type=API_TYPE_TWITTER_ADS, version=self.api_ads_version)
stats.extend(response['data']) stats.extend(response['data'])
return stats return stats