v0.1.0

Author: akirahrkw

.gitignore

@@ -0,0 +1,3 @@
+*.pyc
+.DS_Store
+*.swp

README.md

@@ -0,0 +1,65 @@
+python-500px
+======
+A Python client for the 500px API
+
+Installation
+----
+pip install python-500px
+
+Requires
+----
+  * httplib2
+  * simplejson
+
+Usage
+----
+	from fivehundredpx.client import FiveHundredPXAPI
+	from fivehundredpx.auth   import *
+	
+	unauthorized_api = FiveHundredPXAPI(handler)
+	
+	handler = OAuthHandler(CONSUMER_KEY,CONSUMER_SECRET)
+	handler.set_access_token(OAUTH_TOKEN,OAUTH_TOKEN_SECRET)
+	api = FiveHundredPXAPI(handler)
+	api.users()
+	
+Methods
+----
+  * api.photos()
+  * api.photos_search()
+  * api.photos_id()
+  * api.photos_post()
+  * api.photos_delete()
+  * api.photos_comments()
+  * api.photos_comments_post()
+  * api.photos_favorite_post()
+  * api.photos_favorite_delete()
+  * api.photos_tags_post()
+  * api.photos_tags_delete()
+  * api.photos_vote_post()
+  * api.upload_photo()
+  * api.photos_update()
+
+  * api.users()
+  * api.users_show()
+  * api.users_friends()
+  * api.users_followers()
+  * api.users_friends_post()
+  * api.users_friends_delete()
+
+  * api.blogs()
+  * api.blogs_id()
+  * api.blogs_comments()
+  * api.blogs_comments_post()
+  * api.blogs_post()
+  * api.blogs_delete()
+  * api.blogs_update()
+
+  * api.collections()
+  * api.collections_id()
+  * api.collections_post()
+  * api.collections_update()
+  * api.collections_delete()
+
+please check test.py
+

fivehundredpx/__init__.py

@@ -0,0 +1,10 @@
+from fivehundredpx.client import FiveHundredPXAPI
+from fivehundredpx.auth   import *
+from fivehundredpx.errors import *
+
+"""
+500px API library
+"""
+__version__ = '0.1.0'
+__author__  = 'Akira Hirakawa'
+__license__ = 'MIT'

fivehundredpx/auth.py

@@ -0,0 +1,90 @@
+from urllib2 import Request, urlopen
+
+from fivehundredpx import oauth
+from fivehundredpx.settings import *
+from fivehundredpx.errors 	import *
+
+class OAuthHandler(object):
+	
+    def __init__(self,consumer_key,consumer_secret,callback=None,secure=False):
+        self._consumer 	   = oauth.OAuthConsumer(consumer_key,consumer_secret)
+        self._sigmethod    = oauth.OAuthSignatureMethod_HMAC_SHA1()
+        self.request_token = None
+        self.access_token  = None
+        self.callback 	   = callback
+        self.username 	   = None
+        self.secure 	   = secure
+        self.host 		   = API_HOST
+        self.version 	   = API_VERSION
+        self.root 		   = OAUTH_ROOT
+
+    def _get_oauth_url(self,endpoint,secure=True):
+        prefix = 'https://' if (self.secure or secure) else 'http://'
+        return prefix + self.host + self.version + self.root + endpoint
+
+    def set_request_token(self, key, secret):
+        self.request_token = oauth.OAuthToken(key, secret)
+
+    def set_access_token(self, key, secret):
+        self.access_token = oauth.OAuthToken(key, secret)
+
+    def _get_request_token(self):
+        url = self._get_oauth_url('request_token')
+        request = oauth.OAuthRequest.from_consumer_and_token(self._consumer, http_url=url, callback=self.callback)
+        request.sign_request(self._sigmethod,self._consumer,None)
+        response = urlopen(Request(url,headers=request.to_header()))
+        return oauth.OAuthToken.from_string(response.read())
+
+    def apply_auth(self,url,method,headers,parameters):
+        request = oauth.OAuthRequest.from_consumer_and_token(
+            self._consumer,
+            http_url    = url,
+            http_method = method,
+            token		= self.access_token,
+            parameters	= parameters
+        )
+        request.sign_request(self._sigmethod,self._consumer,self.access_token)
+        headers.update(request.to_header())
+
+    def get_authorization_url(self):
+        try:
+            self.request_token = self._get_request_token()
+            request = oauth.OAuthRequest.from_token_and_callback(
+                token=self.request_token, http_url=self._get_oauth_url('authorize')
+            )
+            return request.to_url()
+        except Exception, e:
+            raise FiveHundredClientError(e)
+
+    def get_access_token(self,verifier=None):
+        try:
+            url = self._get_oauth_url('access_token')
+            request = oauth.OAuthRequest.from_consumer_and_token(
+		        self._consumer, token=self.request_token, http_url=url, verifier=str(verifier)
+            )
+            request.sign_request(self._sigmethod, self._consumer, self.request_token)
+            response = urlopen(Request(url,headers=request.to_header()))
+            self.access_token = oauth.OAuthToken.from_string(response.read())
+            return self.access_token
+        except Exception, e:
+            raise FiveHundredClientError(e)
+
+    def get_xauth_access_token(self,username,password):
+        try:
+            url = self._get_oauth_url('access_token',secure=True)
+            request = oauth.OAuthRequest.from_consumer_and_token(
+		        oauth_consumer=self._consumer,
+		        http_method='POST',
+		        http_url=url,
+		        parameters={
+		            'x_auth_mode': 'client_auth',
+		            'x_auth_username': username,
+		            'x_auth_password': password
+		        }
+		    )
+            request.sign_request(self._sigmethod,self._consumer,None)
+            response = urlopen(Request(url,data=request.to_postdata()))
+            self.access_token = oauth.OAuthToken.from_string(response.read())
+            return self.access_token
+        except Exception, e:
+            raise FiveHundredClientError(e)	

fivehundredpx/bind.py

@@ -0,0 +1,109 @@
+from fivehundredpx.utils   import encode_string
+from fivehundredpx.errors  import *
+import urllib, re, httplib, time, simplejson
+
+re_path_template = re.compile('{\w+}')
+
+def bind_api(**config):
+    
+    class APIMethod(object):
+        '''common parameters for a api action'''
+        path   		   = config['path']
+        method 		   = config.get('method','GET')
+        allowed_params = config.get('allowed_params',[])
+        model_class    = config.get('model_class',None)
+        response_type  = config.get('response_type','list')
+        require_auth   = config.get('require_auth',False)
+
+        def __init__(self,api,*args,**kwargs):
+            '''parameters for every request'''
+            if self.require_auth and not api.auth_handler: raise FiveHundredClientError('auth handler is required')
+			
+            self.api 		  = api
+            self.parameters   = {}
+            self.as_generator = kwargs.pop("as_generator", False)
+            self.max_pages 	  = kwargs.pop("max_pages", 3)
+            self.headers      = kwargs.pop('headers', {})
+            self.body         = kwargs.pop('http_body', None)
+            self.protocol     = 'https://' if self.api.secure else 'http://'
+            if 'method'       in kwargs: self.method = kwargs.pop('method')
+            if 'require_auth' in kwargs: self.require_auth = kwargs.pop('require_auth')
+            self._build_parameters(args, kwargs)
+            self._build_path()
+	
+        def _build_parameters(self,args,kwargs):
+            for index,value in enumerate(args):
+                if value is None: continue
+                try:
+                    self.parameters[self.allowed_params[index]] = encode_string(value)
+                except IndexError:
+                    raise FiveHundredsClientError("Too many arguments supplied")
+
+            for key,value in kwargs.iteritems():
+                if value is None: continue
+                self.parameters[key] = encode_string(value)
+		
+        def _build_path(self):
+            for variable in re_path_template.findall(self.path):
+                name = variable.strip('{}')			
+                try:
+                    value = urllib.quote(self.parameters[name])
+                    del self.parameters[name]
+                    self.path = self.path.replace(variable,value)
+                except KeyError:
+                    raise FiveHundredsClientError('No parameter value found for path variable: %s' % name)
+
+        def _execute(self):
+
+            url    = "%s%s%s%s" % (self.protocol,self.api.host,self.api.version,self.path)
+            params = urllib.urlencode(self.parameters) if len(self.parameters) != 0 else ''
+
+    	    if self.require_auth and self.api.auth_handler:
+                self.api.auth_handler.apply_auth(url, self.method, self.headers, self.parameters)
+
+            if not params == '': url = "%s?%s" % (url,params)
+            
+            for count in xrange(self.api.retry_count):
+                conn = httplib.HTTPSConnection(self.api.host) if self.api.secure else httplib.HTTPConnection(self.api.host)
+                try:
+                    conn.request(self.method, url, body=self.body, headers=self.headers)
+                    response = conn.getresponse()
+                except Exception, e:
+                    conn.close()
+                    raise FiveHundredClientError('Failed to send request: %s' % e)
+
+                if self.api.retry_errors:
+                    if response.status not in self.api.retry_errors: break
+                else:
+                    if response.status == 200: break
+                conn.close()
+                time.sleep(self.api.retry_delay)
+
+            if response.status > 199 and response.status < 300:
+                result = response.read()
+                conn.close()
+                return simplejson.loads(result)
+            else:
+                try:
+                    error_msg = self.api.parser.parse_error(response.read())
+                except Exception:
+                    error_msg = "500PX error response: status code = %s" % response.status
+                finally:
+                    conn.close()
+                raise FiveHundredClientError(error_msg,status=response.status)
+
+        def _generator(self):
+            base = self.parameters['page'] if 'page' in self.parameters else 1    
+            for count in xrange(self.max_pages):
+                self.parameters['page'] = base + count
+                yield self._execute()
+            return
+
+        def execute(self):
+            return self._generator() if self.as_generator else self._execute()
+
+    def _call(api, *args, **kwargs):
+        method = APIMethod(api, *args, **kwargs)
+        return method.execute()
+
+    return _call

fivehundredpx/client.py

@@ -0,0 +1,75 @@
+from fivehundredpx       import settings
+from fivehundredpx.auth  import *
+from fivehundredpx.bind  import bind_api
+from fivehundredpx.utils import *
+
+class FiveHundredPXAPI(object):
+
+    def __init__(self,auth_handler=None,host=None,secure=True,version=None,retry_count=None,retry_delay=None,retry_errors=None):
+        self.format		  = 'json'
+        self.auth_handler = auth_handler
+        self.secure 	  = secure
+        self.host 		  = host 		or settings.API_HOST
+        self.version      = version 	or settings.API_VERSION
+        self.retry_count  = retry_count or settings.RETRY_COUNT
+        self.retry_delay  = retry_delay or settings.RETRY_DELAY
+        self.retry_errors = retry_errors
+
+    photos 		           = bind_api(path='/photos')
+    photos_search          = bind_api(path='/photos/search')
+    photos_id 	           = bind_api(path='/photos/{id}', allowed_params=['id'])
+    photos_post            = bind_api(path='/photos', method='POST', require_auth=True)
+    photos_delete          = bind_api(path='/photos/{id}', method='DELETE', allowed_params=['id'],require_auth=True)
+    photos_comments        = bind_api(path='/photos/{id}/comments', allowed_params=['id'])
+    photos_comments_post   = bind_api(path='/photos/{id}/comments', method='POST', allowed_params=['id'], require_auth=True)
+    photos_favorite_post   = bind_api(path='/photos/{id}/favorite', method='POST', allowed_params=['id'], require_auth=True)
+    photos_favorite_delete = bind_api(path='/photos/{id}/favorite', method='DELETE', allowed_params=['id'], require_auth=True)
+    photos_tags_post       = bind_api(path='/photos/{id}/tags', method='POST', allowed_params=['id'], require_auth=True)
+    photos_tags_delete     = bind_api(path='/photos/{id}/tags', method='DELETE', allowed_params=['id'], require_auth=True)
+    photos_vote_post       = bind_api(path='/photos/{id}/vote', method='POST', allowed_params=['id'], require_auth=True)
+
+    def upload_photo(self, filename=None,fp=None,file_type=None, **kwargs):
+        headers,body = create_body_by_filepath(filename,'file',kwargs) if fp==None else create_body_by_fp(fp, 'file', file_type, kwargs) 
+        return bind_api(
+            path = '/upload',
+            method = 'POST',
+            require_auth = True
+        )(self,http_body=body, headers=headers)
+
+    def photos_update(self, id, **kwargs):
+        headers,body = create_body(kwargs)
+        return bind_api(
+            path='/photos/{id}',
+            method = 'PUT',
+            allowed_params=['id'],
+            require_auth = True
+        )(self,id=id, http_body=body, headers=headers)
+
+    users                = bind_api(path='/users', require_auth=True)
+    users_show           = bind_api(path='/users/show')
+    users_friends        = bind_api(path='/users/{id}/friends', allowed_params=['id'])
+    users_followers      = bind_api(path='/users/{id}/followers', allowed_params=['id'])
+    users_friends_post   = bind_api(path='/users/{id}/friends', method='POST', allowed_params=['id'])
+    users_friends_delete = bind_api(path='/users/{id}/friends', method='DELETE', allowed_params=['id'])
+
+    blogs               = bind_api(path='/blogs')
+    blogs_id            = bind_api(path='/blogs/{id}', allowed_params=['id'])
+    blogs_comments      = bind_api(path='/blogs/{id}/comments', allowed_params=['id'])
+    blogs_comments_post = bind_api(path='/blogs/{id}/comments', require_auth=True, allowed_params=['id'], method='POST')
+    blogs_post          = bind_api(path='/blogs', require_auth=True, method='POST')
+    blogs_delete        = bind_api(path='/blogs/{id}', require_auth=True, allowed_params=['id'], method='DELETE')
+
+    def blogs_update(self, id, **kwargs):
+        headers,body = create_body(kwargs)
+        return bind_api(
+            path='/blogs/{id}',
+            method = 'PUT',
+            allowed_params=['id'],
+            require_auth = True
+        )(self,id=id, http_body=body, headers=headers)
+
+    collections        = bind_api(path='/collections')
+    collections_id     = bind_api(path='/collections/{id}', allowed_params=['id'])
+    collections_post   = bind_api(path='/collections', require_auth=True, method='POST')
+    collections_update = bind_api(path='/collections/{id}', require_auth=True, method='POST', allowed_params=['id'])
+    collections_delete = bind_api(path='/collections/{id}', require_auth=True, method='DELETE', allowed_params=['id'])

fivehundredpx/errors.py

@@ -0,0 +1,8 @@
+class FiveHundredClientError(Exception):
+
+    def __init__(self,error_message,status=None):
+        self.error_message = error_message	
+        self.status = status	
+
+    def __str__(self):
+        return self.error_message