make inversion optional

[z_archive/twitter.git] / twitter / api.py

diff --git a/twitter/api.py b/twitter/api.py
index 52c800edd612b561edb373dee799d3bc308497a0..2a9f93556cd0bf60c87597752d5fb74547854b04 100644 (file)
--- a/twitter/api.py
+++ b/twitter/api.py
@@ -8,11 +8,16 @@ except ImportError:
 from twitter.twitter_globals import POST_ACTIONS
 from twitter.auth import NoAuth
 
+import re
+
 try:
     import json
 except ImportError:
     import simplejson as json
 
+class _DEFAULT(object):
+    pass
+
 class TwitterError(Exception):
     """
     Base Exception thrown by the Twitter object when there is a
@@ -30,13 +35,15 @@ class TwitterHTTPError(TwitterError):
         self.uri = uri
         self.format = format
         self.uriparts = uriparts
+        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):
     """
@@ -75,22 +82,26 @@ def wrap_response(response, headers):
     class WrappedTwitterResponse(response_typ, TwitterResponse):
         __doc__ = TwitterResponse.__doc__
 
-        def __init__(self, response):
-            if response_typ is not int:
-                response_typ.__init__(self, response)
+        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)
+    return WrappedTwitterResponse(response, headers)
 
 
 
 class TwitterCall(object):
+
     def __init__(
-        self, auth, format, domain, uri="",
+        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.uriparts = uriparts
         self.secure = secure
@@ -99,10 +110,16 @@ class TwitterCall(object):
         try:
             return object.__getattr__(self, k)
         except AttributeError:
-            return TwitterCall(
-                auth=self.auth, format=self.format, domain=self.domain,
-                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.
@@ -113,11 +130,13 @@ class TwitterCall(object):
             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.
@@ -145,7 +164,9 @@ class TwitterCall(object):
                 body = arg_data.encode('utf8')
 
         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 = urllib_request.urlopen(req)
             if "json" == self.format:
@@ -236,7 +257,7 @@ class Twitter(TwitterCall):
     def __init__(
         self, format="json",
         domain="api.twitter.com", secure=True, auth=None,
-        api_version='1'):
+        api_version=_DEFAULT):
         """
         Create a new twitter API connector.
 
@@ -256,7 +277,7 @@ class Twitter(TwitterCall):
         HTTPS.
 
         `api_version` is used to set the base uri. By default it's
-        '1'.
+        '1'. If you are using "search.twitter.com" set this to None.
         """
         if not auth:
             auth = NoAuth()
@@ -264,12 +285,19 @@ 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'
+            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)