thib8956/wallabag-api-client
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

API for Wallabag v2 ready

Browse Source
This commit is contained in:
Olivier Demah
2016-04-16 15:42:37 +02:00
parent ccb961a3c7
commit 31b6ba0d73
1 changed files with 92 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

167
wallabag_api/wallabag.py
View File

@@ -17,24 +17,33 @@ class Wallabag(object):
"""
host = ''
api_key = ''
token = ''
client_id = ''
client_secret = ''
user_agent = ''
format = ''
def __init__(self,
host='http://v2.wallabag.org',
api_key='',
host='',
token='',
client_id='',
client_secret='',
extension='json',
user_agent="WallabagPython/1.0 +https://github.com/foxmask/wallabag-api"):
user_agent="WallabagPython/1.0 "
"+https://github.com/foxmask/wallabag-api"):
"""
init variable
:param host: string url to the official API Wallabag
:param api_key: string of the key provided by Wallabag
:param token: string of the key provided by Wallabag
:param client_id client id
:param client_secret client secret
:param extension: json/xml/html
:param user_agent
"""
self.host = host
self.api_key = api_key
self.client_id = client_id
self.client_secret = client_secret
self.token = token
self.format = extension
self.user_agent = user_agent
@@ -50,23 +59,30 @@ class Wallabag(object):
Do a query to the System API
:param path: url to the API
:param method: the kind of query to do
:param params: a dict with all the necessary things to query the API
:param params: a dict with all the
necessary things to query the API
:return json data
"""
# params = params
params['key'] = self.api_key
r = requests.get(self.get_host() + path, params=params)
if method in ('get', 'post', 'patch', 'delete', 'put', 'get_token'):
if method == 'get':
r = requests.get(self.get_host() + path, params=params)
elif method == 'post':
r = requests.post(self.get_host() + path, data=params)
elif method == 'patch':
r = requests.patch(self.get_host() + path, data=params)
elif method == 'delete':
r = requests.delete(self.get_host() + path, headers=params)
elif method == 'put':
r = requests.put(self.get_host() + path, params=params)
elif method == 'get_token':
r = requests.post(self.get_host() + path, data=params)
# todo : handle case of self.ext is xml or html
return self.handle_json_response(r)
else:
raise ValueError('method expected : get, post, patch, delete or put')
if method == 'post':
r = requests.post(self.get_host() + path, params=params)
elif method == 'patch':
r = requests.patch(self.get_host() + path, params=params)
elif method == 'delete':
r = requests.delete(self.get_host() + path, params=params)
# todo : handle case of self.ext is xml or html
return self.handle_json_response(r)
def handle_json_response(self, responses):
@staticmethod
def handle_json_response(responses):
"""
get the json data response
:param responses: the json response
@@ -83,14 +99,13 @@ class Wallabag(object):
logging.error("Wallabag: {error}".format(error=error_json))
return json_data
def get_entries(self, token, **kwargs):
def get_entries(self, **kwargs):
"""
GET /api/entries.{_format}
Retrieve all entries. It could be filtered by many options.
:param token: the token that identified the user to access the API
:param kwargs: can contain one of the following filters
archive: '0' or '1', default '0' filter by archived status.
star: '0' or '1', default '0' filter by starred status.
@@ -99,11 +114,12 @@ class Wallabag(object):
order: 'asc' or 'desc', default 'desc'
page: int default 1 what page you want
perPage: int default 30 result per page
tags: list of tags url encoded. Will returns entries that matches ALL tags
tags: list of tags url encoded.
Will returns entries that matches ALL tags
:return data related to the ext
"""
# default values
params = {'token': token,
params = {'access_token': self.token,
'archive': 0,
'star': 0,
'delete': 0,
@@ -132,59 +148,60 @@ class Wallabag(object):
return self.query(path, "get", **params)
def post_entries(self, token, url, title='', tags=''):
def post_entries(self, url, title='', tags='', starred=0, archive=0):
"""
POST /api/entries.{_format}
Create an entry
:param token: the token that identified the user to access the API
:param url: the url of the note to store
:param title: Optional, we'll get the title from the page.
:param tags: tag1,tag2,tag3 a comma-separated list of tags.
:param starred entry already starred
:param archive entry already archived
:return result
"""
params = {'token': token, 'url': url, 'title': title, 'tags': []}
params = {'access_token': self.token, 'url': url, 'title': title,
'tags': tags, 'starred': starred, 'archive': archive}
if len(tags) > 0 and isinstance(tags, list):
params['tags'] = tags
params['tags'] = ', '.join(tags)
path = '/api/entries.{ext}'.format(ext=self.format)
return self.query(path, "post", **params)
def get_entry(self, token, entry):
def get_entry(self, entry):
"""
GET /api/entries/{entry}.{_format}
Retrieve a single entry
:param token: the token that identified the user to access the API
:param entry: \w+ an integer The Entry ID
:return data related to the ext
"""
params = {'token': token}
params = {'access_token': self.token}
url = '/api/entries/{entry}.{ext}'.format(entry=entry, ext=self.format)
return self.query(url, "get", **params)
def patch_entries(self, token, entry, **kwargs):
def patch_entries(self, entry, **kwargs):
"""
PATCH /api/entries/{entry}.{_format}
Change several properties of an entry
:param token: the token that identified the user to access the API
:param entry: the entry to 'patch' / update
:param kwargs: can contain one of the following
title: string
tags: a list of tags tag1,tag2,tag3
archive: '0' or '1', default '0' archived the entry.
star: '0' or '1', default '0' starred the entry
delete: '0' or '1', default '0' flag as deleted. In case that you don't want to *really* remove it..
delete: '0' or '1', default '0' flag as deleted.
In case that you don't want to *really* remove it..
:return data related to the ext
"""
# default values
params = {'token': token,
params = {'access_token': self.token,
'title': '',
'archive': 0,
'tags': [],
@@ -193,121 +210,121 @@ class Wallabag(object):
if 'title' in kwargs:
params['title'] = kwargs['title']
if 'tags' in kwargs and isinstance(kwargs['tags'], list):
params['tags'] = kwargs['tags']
params['tags'] = ', '.join(kwargs['tags'])
if 'archive' in kwargs and int(kwargs['archive']) in (0, 1):
params['archive'] = int(kwargs['archive'])
if 'star' in kwargs and int(kwargs['star']) in (0, 1):
params['star'] = int(kwargs['star'])
if 'delete' in kwargs and int(kwargs['delete']) in (0, 1):
params['delete'] = int(kwargs['delete'])
path = '/api/entries/{entry}.{ext}'.format(entry=entry, ext=self.format)
path = '/api/entries/{entry}.{ext}'.format(
entry=entry, ext=self.format)
return self.query(path, "patch", **params)
def delete_entries(self, token, entry):
def delete_entries(self, entry):
"""
DELETE /api/entries/{entry}.{_format}
Delete permanently an entry
:param token: the token that identified the user to access the API
:param entry: \w+ an integer The Entry ID
:return result
"""
params = {'token': token}
path = '/api/entries/{entry}.{ext}'.format(entry=entry, ext=self.format)
params = {'Authorization': 'Bearer {}'.format(self.token)}
path = '/api/entries/{entry}.{ext}'.format(
entry=entry, ext=self.format)
return self.query(path, "delete", **params)
def get_entry_tags(self, token, entry):
def get_entry_tags(self, entry):
"""
GET /api/entries/{entry}/tags.{_format}
Retrieve all tags for an entry
:param token: the token that identified the user to access the API
:param entry: \w+ an integer The Entry ID
:return data related to the ext
"""
params = {'token': token}
url = '/api/entries/{entry}/tags.{ext}'.format(entry=entry, ext=self.format)
params = {'access_token': self.token}
url = '/api/entries/{entry}/tags.{ext}'.format(
entry=entry, ext=self.format)
return self.query(url, "get", **params)
def post_entry_tags(self, token, entry, tags):
def post_entry_tags(self, entry, tags):
"""
POST /api/entries/{entry}/tags.{_format}
Add one or more tags to an entry
:param token: the token that identified the user to access the API
:param entry: \w+ an integer The Entry ID
:param tags: string
:return result
"""
params = {'token': token, 'tags': []}
params = {'access_token': self.token, 'tags': []}
if isinstance(tags, list):
params['tags'] = tags
path = '/api/entries/{entry}/tags.{ext}'.format(entry=entry, ext=self.format)
path = '/api/entries/{entry}/tags.{ext}'.format(
entry=entry, ext=self.format)
return self.query(path, "post", **params)
def delete_entry_tag(self, token, entry, tag):
def delete_entry_tag(self, entry, tag):
"""
DELETE /api/entries/{entry}/tags/{tag}.{_format}
Permanently remove one tag for an entry
:param token: the token that identified the user to access the API
:param entry: \w+ an integer The Entry ID
:param tag: string The Tag
:return data related to the ext
"""
params = {'token': token}
url = '/api/entries/{entry}/tags/{tag}.{ext}'.format(entry=entry, tag=tag, ext=self.format)
params = {'access_token': self.token}
url = '/api/entries/{entry}/tags/{tag}.{ext}'.format(
entry=entry, tag=tag, ext=self.format)
return self.query(url, "delete", **params)
def get_tags(self, token):
def get_tags(self):
"""
GET /api/tags.{_format}
Retrieve all tags
:param token: the token that identified the user to access the API
:return data related to the ext
"""
params = {'token': token}
params = {'access_token': self.token}
path = '/api/tags.{ext}'.format(ext=self.format)
return self.query(path, "get", **params)
def get_tag(self, token, tag):
"""
GET /api/tags/{tag}.{_format}
Retrieve a single tag
:param token: the token that identified the user to access the API
:param tag: string The Tag
:return data related to the ext
"""
path = '/api/tags/{tag}.{ext}'.format(tag=tag, ext=self.format)
params = {'token': token}
return self.query(path, "get", **params)
def delete_tag(self, token, tag):
def delete_tag(self, tag):
"""
DELETE /api/tags/{tag}.{_format}
Permanently remove one tag from every entry
:param token: the token that identified the user to access the API
:param tag: string The Tag
:return data related to the ext
"""
path = '/api/tags/{tag}.{ext}'.format(tag=tag, ext=self.format)
params = {'token': token}
params = {'access_token': self.token}
return self.query(path, "delete", **params)
def get_token(self, params):
"""
:param params: will contain :
params = {"grant_type": "password",
"client_id": "a string",
"client_secret": "a string",
"username": "a login",
"password": "a password"}
:return: access token
"""
path = "/oauth/v2/token"
return self.query(path, "get_token", **params)['access_token']