X-Git-Url: https://jfr.im/git/z_archive/twitter.git/blobdiff_plain/1be4ce71813a9b52f00f19bc68cc13e0f99d4403..098660ce6ca34597e97f074b3af48f64dcf3ea03:/twitter/api.py diff --git a/twitter/api.py b/twitter/api.py index c6aa9a1..52c800e 100644 --- a/twitter/api.py +++ b/twitter/api.py @@ -1,17 +1,16 @@ -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 from twitter.twitter_globals import POST_ACTIONS -from twitter.auth import UserPassAuth, NoAuth - -def _py26OrGreater(): - import sys - return sys.hexversion > 0x20600f0 +from twitter.auth import NoAuth -if _py26OrGreater(): +try: import json -else: +except ImportError: import simplejson as json class TwitterError(Exception): @@ -27,10 +26,10 @@ 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 def __str__(self): return ( @@ -39,15 +38,60 @@ class TwitterHTTPError(TwitterError): self.e.code, self.uri, self.format, self.uriparts, self.e.fp.read())) +class TwitterResponse(object): + """ + Response from a twitter request. Behaves like a list or a string + (depending on requested format) but it has a few other interesting + attributes. + + `headers` gives you access to the response headers as an + httplib.HTTPHeaders instance. You can do + `response.headers.getheader('h')` to retrieve a header. + """ + def __init__(self, headers): + self.headers = headers + + @property + def rate_limit_remaining(self): + """ + Remaining requests in the current rate-limit. + """ + return int(self.headers.getheader('X-RateLimit-Remaining')) + + @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')) + + +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): + if response_typ is not int: + response_typ.__init__(self, response) + TwitterResponse.__init__(self, headers) + + return WrappedTwitterResponse(response) + + + class TwitterCall(object): def __init__( - self, auth, format, domain, uri="", agent=None, + self, auth, format, domain, uri="", uriparts=None, secure=True): self.auth = auth self.format = format self.domain = domain self.uri = uri - self.agent = agent self.uriparts = uriparts self.secure = secure @@ -57,30 +101,26 @@ class TwitterCall(object): except AttributeError: return TwitterCall( auth=self.auth, format=self.format, domain=self.domain, - agent=self.agent, uriparts=self.uriparts + (k,), + uriparts=self.uriparts + (k,), secure=self.secure) def __call__(self, **kwargs): - #build the uri + # Build the uri. uriparts = [] 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)) + # If this part matches a keyword argument, use the + # supplied value otherwise, just use the part. + uriparts.append(str(kwargs.pop(uripart, uripart))) uri = '/'.join(uriparts) method = "GET" for action in POST_ACTIONS: if uri.endswith(action): method = "POST" - if (self.agent): - kwargs["source"] = self.agent break - """This handles a special case. It isn't really needed anymore because now - we can insert an id value (or any other value) at the end of the - uri (or anywhere else). - However we can leave it for backward compatibility.""" + # 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. id = kwargs.pop('id', None) if id: uri += "/%s" %(id) @@ -95,8 +135,6 @@ class TwitterCall(object): secure_str, self.domain, uri, dot, self.format) headers = {} - if (self.agent): - headers["X-Twitter-Client"] = self.agent if self.auth: headers.update(self.auth.generate_headers()) arg_data = self.auth.encode_params(uriBase, method, kwargs) @@ -104,21 +142,23 @@ 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) try: - handle = urllib2.urlopen(req) + handle = urllib_request.urlopen(req) if "json" == self.format: - return json.loads(handle.read()) + res = json.loads(handle.read().decode('utf8')) + return wrap_response(res, handle.headers) else: - return handle.read() - except urllib2.HTTPError, e: + return wrap_response( + handle.read().decode('utf8'), handle.headers) + except urllib_error.HTTPError as e: if (e.code == 304): return [] else: - raise TwitterHTTPError(e, uriBase, self.format, self.uriparts) + raise TwitterHTTPError(e, uri, self.format, arg_data) class Twitter(TwitterCall): """ @@ -129,8 +169,8 @@ class Twitter(TwitterCall): The Twitter API is documented here: - http://apiwiki.twitter.com/ - http://groups.google.com/group/twitter-development-talk/web/api-documentation + http://dev.twitter.com/doc + Examples:: @@ -194,9 +234,9 @@ class Twitter(TwitterCall): """ def __init__( - self, email=None, password=None, format="json", - domain="twitter.com", agent=None, secure=True, auth=None, - api_version=''): + self, format="json", + domain="api.twitter.com", secure=True, auth=None, + api_version='1'): """ Create a new twitter API connector. @@ -208,36 +248,16 @@ class Twitter(TwitterCall): token, token_secret, consumer_key, consumer_secret)) - Alternately you can pass `email` and `password` parameters but - this authentication mode will be deactive by Twitter very soon - and is not recommended:: - - twitter = Twitter(email="blah@blah.com", password="foobar") - - `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 email is not None or password is not None: - if auth: - raise ValueError( - "Can't specify 'email'/'password' and 'auth' params" - " simultaneously.") - auth = UserPassAuth(email, password) - if not auth: auth = NoAuth() @@ -249,8 +269,8 @@ class Twitter(TwitterCall): uriparts += (str(api_version),) TwitterCall.__init__( - self, auth=auth, format=format, domain=domain, agent=agent, + self, auth=auth, format=format, domain=domain, secure=secure, uriparts=uriparts) -__all__ = ["Twitter", "TwitterError", "TwitterHTTPError"] +__all__ = ["Twitter", "TwitterError", "TwitterHTTPError", "TwitterResponse"]