X-Git-Url: https://jfr.im/git/z_archive/twitter.git/blobdiff_plain/0d6c06464366d66e458910da81d62ce0eda811a0..4d4dd2cc1a8dde676618a50a58000f9f52e0b0c1:/twitter/api.py diff --git a/twitter/api.py b/twitter/api.py index f07b77d..8c7b08a 100644 --- a/twitter/api.py +++ b/twitter/api.py @@ -1,19 +1,29 @@ -import urllib2 - -from exceptions import Exception +try: + import urllib.request as urllib_request + import urllib.error as urllib_error +except ImportError: + import urllib2 as urllib_request + import urllib2 as urllib_error + +try: + from cStringIO import StringIO +except ImportError: + from io import BytesIO as StringIO from twitter.twitter_globals import POST_ACTIONS from twitter.auth import NoAuth -def _py26OrGreater(): - import sys - return sys.hexversion > 0x20600f0 +import re +import gzip -if _py26OrGreater(): +try: import json -else: +except ImportError: import simplejson as json +class _DEFAULT(object): + pass + class TwitterError(Exception): """ Base Exception thrown by the Twitter object when there is a @@ -27,17 +37,24 @@ class TwitterHTTPError(TwitterError): HTTP error interacting with twitter.com. """ def __init__(self, e, uri, format, uriparts): - self.e = e - self.uri = uri - self.format = format - self.uriparts = uriparts + self.e = e + self.uri = uri + self.format = format + self.uriparts = uriparts + if self.e.headers['Content-Encoding'] == 'gzip': + buf = StringIO(self.e.fp.read()) + f = gzip.GzipFile(fileobj=buf) + self.response_data = f.read() + else: + self.response_data = self.e.fp.read() def __str__(self): + fmt = ("." + self.format) if self.format else "" return ( - "Twitter sent status %i for URL: %s.%s using parameters: " + "Twitter sent status %i for URL: %s%s using parameters: " "(%s)\ndetails: %s" %( - self.e.code, self.uri, self.format, self.uriparts, - self.e.fp.read())) + self.e.code, self.uri, fmt, self.uriparts, + self.response_data)) class TwitterResponse(object): """ @@ -47,53 +64,56 @@ class TwitterResponse(object): `headers` gives you access to the response headers as an httplib.HTTPHeaders instance. You can do - `response.headers.getheader('h')` to retrieve a header. + `response.headers.get('h')` to retrieve a header. """ - def __init__(self, real_response, headers): - self._real_response = real_response + def __init__(self, headers): self.headers = headers - def __getattr__(self, k): - try: - return object.__getattr__(self, k) - except AttributeError: - return getattr(self._real_response, k) - @property def rate_limit_remaining(self): """ Remaining requests in the current rate-limit. """ - return int(self.headers.getheader('X-RateLimit-Remaining')) + return int(self.headers.get('X-RateLimit-Remaining', "0")) @property def rate_limit_reset(self): """ Time in UTC epoch seconds when the rate limit will reset. """ - return int(self.headers.getheader('X-RateLimit-Reset')) + return int(self.headers.get('X-RateLimit-Reset', "0")) + + +def wrap_response(response, headers): + response_typ = type(response) + if response_typ is bool: + # HURF DURF MY NAME IS PYTHON AND I CAN'T SUBCLASS bool. + response_typ = int + class WrappedTwitterResponse(response_typ, TwitterResponse): + __doc__ = TwitterResponse.__doc__ + + def __init__(self, response, headers): + response_typ.__init__(self, response) + TwitterResponse.__init__(self, headers) + def __new__(cls, response, headers): + return response_typ.__new__(cls, response) + + + return WrappedTwitterResponse(response, headers) -# Multiple inheritance makes my inner Java nerd cry. Why can't I just -# add arbitrary attributes to list or str objects?! Guido, we need to -# talk. -class TwitterJsonResponse(list, TwitterResponse): - __doc__ = """Twitter JSON Response - """ + TwitterResponse.__doc__ -class TwitterXmlResponse(str, TwitterResponse): - __doc__ = """Twitter XML Response - """ + TwitterResponse.__doc__ class TwitterCall(object): + def __init__( - self, auth, format, domain, uri="", agent=None, + self, auth, format, domain, callable_cls, uri="", uriparts=None, secure=True): self.auth = auth self.format = format self.domain = domain + self.callable_cls = callable_cls self.uri = uri - self.agent = agent self.uriparts = uriparts self.secure = secure @@ -101,10 +121,16 @@ class TwitterCall(object): try: return object.__getattr__(self, k) except AttributeError: - return TwitterCall( - auth=self.auth, format=self.format, domain=self.domain, - agent=self.agent, uriparts=self.uriparts + (k,), - secure=self.secure) + def extend_call(arg): + return self.callable_cls( + auth=self.auth, format=self.format, domain=self.domain, + callable_cls=self.callable_cls, uriparts=self.uriparts \ + + (arg,), + secure=self.secure) + if k == "_": + return extend_call + else: + return extend_call(k) def __call__(self, **kwargs): # Build the uri. @@ -112,14 +138,16 @@ class TwitterCall(object): for uripart in self.uriparts: # If this part matches a keyword argument, use the # supplied value otherwise, just use the part. - uriparts.append(kwargs.pop(uripart, uripart)) + uriparts.append(str(kwargs.pop(uripart, uripart))) uri = '/'.join(uriparts) - method = "GET" - for action in POST_ACTIONS: - if uri.endswith(action): - method = "POST" - break + method = kwargs.pop('_method', None) + if not method: + method = "GET" + for action in POST_ACTIONS: + if re.search("%s(/\d+)?$" % action, uri): + method = "POST" + break # If an id kwarg is present and there is no id to fill in in # the list of uriparts, assume the id goes at the end. @@ -136,7 +164,7 @@ class TwitterCall(object): uriBase = "http%s://%s/%s%s%s" %( secure_str, self.domain, uri, dot, self.format) - headers = {} + headers = {'Accept-Encoding': 'gzip'} if self.auth: headers.update(self.auth.generate_headers()) arg_data = self.auth.encode_params(uriBase, method, kwargs) @@ -144,17 +172,31 @@ class TwitterCall(object): uriBase += '?' + arg_data body = None else: - body = arg_data + body = arg_data.encode('utf8') - req = urllib2.Request(uriBase, body, headers) + req = urllib_request.Request(uriBase, body, headers) + return self._handle_response(req, uri, arg_data) + def _handle_response(self, req, uri, arg_data): try: - handle = urllib2.urlopen(req) + handle = urllib_request.urlopen(req) + if handle.headers['Content-Type'] in ['image/jpeg', 'image/png']: + return handle + elif handle.info().get('Content-Encoding') == 'gzip': + # Handle gzip decompression + buf = StringIO(handle.read()) + f = gzip.GzipFile(fileobj=buf) + data = f.read() + else: + data = handle.read() + if "json" == self.format: - return TwitterJsonResponse(json.loads(handle.read())) + res = json.loads(data.decode('utf8')) + return wrap_response(res, handle.headers) else: - return TwitterXmlResponse(handle.read()) - except urllib2.HTTPError, e: + return wrap_response( + data.decode('utf8'), handle.headers) + except urllib_error.HTTPError as e: if (e.code == 304): return [] else: @@ -167,43 +209,51 @@ class Twitter(TwitterCall): Get RESTful data by accessing members of this class. The result is decoded python objects (lists and dicts). - The Twitter API is documented here: + The Twitter API is documented at: http://dev.twitter.com/doc Examples:: - twitter = Twitter( - auth=OAuth(token, token_key, con_secret, con_secret_key))) + t = Twitter( + auth=OAuth(token, token_key, con_secret, con_secret_key))) + + # Get the public timeline + t.statuses.public_timeline() + + # Get a particular friend's timeline + t.statuses.friends_timeline(id="billybob") - # Get the public timeline - twitter.statuses.public_timeline() + # Also supported (but totally weird) + t.statuses.friends_timeline.billybob() - # Get a particular friend's timeline - twitter.statuses.friends_timeline(id="billybob") + # Update your status + t.statuses.update( + status="Using @sixohsix's sweet Python Twitter Tools.") - # Also supported (but totally weird) - twitter.statuses.friends_timeline.billybob() + # Send a direct message + t.direct_messages.new( + user="billybob", + text="I think yer swell!") - # Send a direct message - twitter.direct_messages.new( - user="billybob", - text="I think yer swell!") + # Get the members of tamtar's list "Things That Are Rad" + t._("tamtar")._("things-that-are-rad").members() - # Get the members of a particular list of a particular friend - twitter.user.listname.members(user="billybob", listname="billysbuds") + # Note how the magic `_` method can be used to insert data + # into the middle of a call. You can also use replacement: + t.user.list.members(user="tamtar", list="things-that-are-rad") Searching Twitter:: - twitter_search = Twitter(domain="search.twitter.com") + twitter_search = Twitter(domain="search.twitter.com") - # Find the latest search trends - twitter_search.trends() + # Find the latest search trends + twitter_search.trends() - # Search for the latest News on #gaza - twitter_search.search(q="#gaza") + # Search for the latest News on #gaza + twitter_search.search(q="#gaza") Using the data returned @@ -212,13 +262,13 @@ class Twitter(TwitterCall): Twitter API calls return decoded JSON. This is converted into a bunch of Python lists, dicts, ints, and strings. For example:: - x = twitter.statuses.public_timeline() + x = twitter.statuses.public_timeline() - # The first 'tweet' in the timeline - x[0] + # The first 'tweet' in the timeline + x[0] - # The screen name of the user who wrote the first 'tweet' - x[0]['user']['screen_name'] + # The screen name of the user who wrote the first 'tweet' + x[0]['user']['screen_name'] Getting raw XML data @@ -227,16 +277,16 @@ class Twitter(TwitterCall): If you prefer to get your Twitter data in XML format, pass format="xml" to the Twitter object when you instantiate it:: - twitter = Twitter(format="xml") + twitter = Twitter(format="xml") - The output will not be parsed in any way. It will be a raw string - of XML. + The output will not be parsed in any way. It will be a raw string + of XML. """ def __init__( self, format="json", - domain="twitter.com", secure=True, auth=None, - api_version=''): + domain="api.twitter.com", secure=True, auth=None, + api_version=_DEFAULT): """ Create a new twitter API connector. @@ -249,20 +299,14 @@ class Twitter(TwitterCall): `domain` lets you change the domain you are connecting. By - default it's twitter.com but `search.twitter.com` may be + default it's `api.twitter.com` but `search.twitter.com` may be useful too. If `secure` is False you will connect with HTTP instead of HTTPS. - The value of `agent` is sent in the `X-Twitter-Client` - header. This is deprecated. Instead Twitter determines the - application using the OAuth Client Key and Client Key Secret - parameters. - `api_version` is used to set the base uri. By default it's - nothing, but if you set it to '1' your URI will start with - '1/'. + '1'. If you are using "search.twitter.com" set this to None. """ if not auth: auth = NoAuth() @@ -270,14 +314,20 @@ class Twitter(TwitterCall): if (format not in ("json", "xml", "")): raise ValueError("Unknown data format '%s'" %(format)) + if api_version is _DEFAULT: + if domain == 'api.twitter.com': + api_version = '1.1' + else: + api_version = None + uriparts = () if api_version: uriparts += (str(api_version),) TwitterCall.__init__( self, auth=auth, format=format, domain=domain, + callable_cls=TwitterCall, secure=secure, uriparts=uriparts) -__all__ = ["Twitter", "TwitterError", "TwitterHTTPError", "TwitterJsonResponse", - "TwitterXmlResponse"] +__all__ = ["Twitter", "TwitterError", "TwitterHTTPError", "TwitterResponse"]