summarylogtreecommitdiffstats
diff options
context:
space:
mode:
authorKonstantin Stepanov2015-06-19 10:59:51 +0300
committerKonstantin Stepanov2015-06-19 10:59:51 +0300
commit63b6b2e594024412515799c9eb0f17e1b59bb06b (patch)
tree2ba1c4abfe690bc420d771bc340b05089720c408
downloadaur-63b6b2e594024412515799c9eb0f17e1b59bb06b.tar.gz
import package from old aur
-rw-r--r--.SRCINFO20
-rw-r--r--PKGBUILD27
-rwxr-xr-xpb147
-rw-r--r--pushybullet.py1373
-rwxr-xr-xsetup.py25
5 files changed, 1592 insertions, 0 deletions
diff --git a/.SRCINFO b/.SRCINFO
new file mode 100644
index 00000000000..a75693438f9
--- /dev/null
+++ b/.SRCINFO
@@ -0,0 +1,20 @@
+pkgbase = python2-pushybullet
+ pkgdesc = PushBullet APIv2 python bindings
+ pkgver = 1.5.4
+ pkgrel = 1
+ url = http://github.com/kstep/pushybullet
+ arch = any
+ license = GPL
+ depends = python2
+ optdepends = python2-websocket-client: read pushes stream in real-time
+ optdepends = python2-dateutil: parse datetime in string format
+ optdepends = python2-magic: file type autodetection
+ source = pushybullet.py
+ source = pb
+ source = setup.py
+ md5sums = 9596e1f55ea766bdd0e110b85bc6767a
+ md5sums = 654983199a909516b9d643c3c1714190
+ md5sums = ddf1a4bf540c4c21044fe8ec50b76ef3
+
+pkgname = python2-pushybullet
+
diff --git a/PKGBUILD b/PKGBUILD
new file mode 100644
index 00000000000..d7bd4c67308
--- /dev/null
+++ b/PKGBUILD
@@ -0,0 +1,27 @@
+# Maintainer: Konstantin Stepanov <me@kstep.me>
+pkgname="python2-pushybullet"
+pkgver="1.5.4"
+pkgrel=1
+pkgdesc="PushBullet APIv2 python bindings"
+arch=('any')
+url="http://github.com/kstep/pushybullet"
+license=('GPL')
+depends=('python2')
+optdepends=('python2-websocket-client: read pushes stream in real-time'
+ 'python2-dateutil: parse datetime in string format'
+ 'python2-magic: file type autodetection')
+source=(pushybullet.py pb setup.py)
+
+build() {
+ cd "$srcdir"
+ python2 ./setup.py build
+}
+
+package() {
+ cd "$srcdir"
+ python2 ./setup.py install --root="$pkgdir" --skip-build --optimize=1
+}
+
+md5sums=('9596e1f55ea766bdd0e110b85bc6767a'
+ '654983199a909516b9d643c3c1714190'
+ 'ddf1a4bf540c4c21044fe8ec50b76ef3')
diff --git a/pb b/pb
new file mode 100755
index 00000000000..ddc6d15f7aa
--- /dev/null
+++ b/pb
@@ -0,0 +1,147 @@
+#!/usr/bin/env python2
+# encoding: utf-8
+
+from __future__ import print_function
+
+import argparse
+import pushybullet
+import time
+import sys
+import os
+
+def get_parser():
+ apikey = pushybullet.get_apikey_from_config()
+ parser = argparse.ArgumentParser(description='PushBullet command line client')
+ parser.add_argument('--apikey', help='API key (get from https://www.pushbullet.com/account)', type=str,
+ default=apikey, required=not apikey)
+ parser.add_argument('--target', help='target device identifiers', default=[], action='append')
+ subparsers = parser.add_subparsers(help='message type', dest='type')
+
+ note_group = subparsers.add_parser('note')
+ note_group.add_argument('body', help='note body', type=str, default='', nargs='?')
+ note_group.add_argument('--title', help='note title', default='', type=str)
+
+ link_group = subparsers.add_parser('link')
+ link_group.add_argument('url', help='link URL', type=str)
+ link_group.add_argument('--title', help='link title', default='', type=str)
+ link_group.add_argument('--body', help='link messsage', default='', type=str)
+
+ list_group = subparsers.add_parser('list')
+ list_group.add_argument('items', help='list item', action='append', nargs='+', metavar='item')
+ list_group.add_argument('--title', help='list title', default='', type=str)
+
+ file_group = subparsers.add_parser('file')
+ file_group.add_argument('file', help='file name to push', type=argparse.FileType('rb'), default=sys.stdin, nargs='?')
+ file_group.add_argument('--name', help='user visible file name', type=str, default='', dest='file_name')
+ file_group.add_argument('--mime', help='file mime type', type=str, default='', dest='file_type')
+ file_group.add_argument('--body', help='file message', default='', type=str)
+
+ address_group = subparsers.add_parser('address')
+ address_group.add_argument('address', help='address', type=str)
+ address_group.add_argument('--name', help='address name', default='', type=str)
+
+ devices_group = subparsers.add_parser('devices', help='list all devices')
+
+ contacts_group = subparsers.add_parser('contacts', help='list all contacts')
+
+ clients_group = subparsers.add_parser('clients', help='list all clients')
+
+ channels_group = subparsers.add_parser('channels', help='list all channels')
+
+ subscriptions_group = subparsers.add_parser('subscriptions', help='list all subscriptions')
+
+ pushes_group = subparsers.add_parser('pushes', help='list all pushes')
+ pushes_group.add_argument('--since', help='show pushes since this timestamp', type=str, default='')
+ pushes_group.add_argument('--with-empty', help='include empty pushes', action='store_false', dest='skip_empty', default=True)
+
+ watch_group = subparsers.add_parser('watch', help='watch for events')
+ watch_group.add_argument('--with-nop', help='include "nop" events', action='store_false', dest='skip_nop', default=True)
+ watch_group.add_argument('--with-pushes', help='output arrived pushes', action='store_true', dest='with_pushes', default=False)
+ watch_group.add_argument('--with-empty', help='include empty pushes', action='store_false', dest='skip_empty', default=True)
+
+ return parser
+
+def command_devices(api, args):
+ devices = api.devices()
+ for device in devices:
+ print(device.iden, str(device))
+
+def command_pushes(api, args):
+ pushes = api.pushes(since=args['since'], skip_empty=args['skip_empty'])
+ for push in pushes:
+ print_push(push)
+
+def command_contacts(api, args):
+ contacts = api.contacts()
+ for contact in contacts:
+ print(contact.iden, '%s <%s>' % (contact.name, contact.email))
+
+def command_watch(api, args):
+ print('Watching for push events (press <Ctrl-C> to interrupt)...')
+
+ try:
+ for event in api.stream(skip_nop=args['skip_nop']):
+ print_event(event)
+
+ if args['with_pushes']:
+ for push in event.pushes(skip_empty=args['skip_empty']):
+ print_push(push)
+
+ except KeyboardInterrupt:
+ print('Watching stopped')
+
+def command_push(api, args):
+ devices = args.pop('target') or [api]
+ print('... preparing push ...')
+ push = api.make_push(args)
+ for device in devices:
+ print('... pushing to %s ...' % device)
+ push.send(device)
+
+ print('... all done!')
+
+def command_clients(api, args):
+ clients = api.clients()
+ for client in clients:
+ print(client.iden, str(client))
+
+def command_channels(api, args):
+ channels = api.channels()
+ for channel in channels:
+ print(channel.iden, str(channel))
+
+def command_subscriptions(api, args):
+ subscriptions = api.subscriptions()
+ for subscription in subscriptions:
+ print(subscription.__dict__)
+ print(subscription.iden, str(subscription))
+
+def print_push(push):
+ print('%(created)s %(type)s %(iden)s [%(flags)s] %(sender_iden)s <%(sender_email)s> -> %(receiver_iden)s <%(receiver_email)s> %(target_device_iden)s %(push)s' % dict(
+ created=time.strftime('%b %d %Y %H:%M:%S', time.localtime(getattr(push, 'created', 0))),
+ type=push.type, iden=push.iden, push=unicode(push),
+ target_device_iden=getattr(push, 'target_device_iden', '-'),
+ sender_iden=getattr(push, 'sender_iden', 'N/A'), sender_email=getattr(push, 'sender_email', 'N/A'),
+ receiver_iden=getattr(push, 'receiver_iden', 'N/A'), receiver_email=getattr(push, 'receiver_email', 'N/A'),
+ flags=('A' if push.active else '') + ('D' if getattr(push, 'dismissed', False) else '')))
+
+def print_event(event):
+ print('%(time)s %(type)s %(data)s' % dict(
+ time=time.strftime('%b %d %Y %H:%M:%S', time.localtime(event.time)),
+ type='tickle' if isinstance(event, pushybullet.TickleEvent) else
+ 'push' if isinstance(event, pushybullet.PushEvent) else
+ 'nop' if isinstance(event, pushybullet.NopEvent) else
+ 'unknown',
+ data=event.subtype if isinstance(event, pushybullet.TickleEvent) else
+ event.push.type if isinstance(event, pushybullet.PushEvent) else
+ ''))
+
+def main():
+ parser = get_parser()
+ args = vars(parser.parse_args())
+ api = pushybullet.PushBullet(args.pop('apikey'))
+ command = globals().get('command_%s' % args['type'], command_push)
+ command(api, args)
+
+if __name__ == '__main__':
+ main()
diff --git a/pushybullet.py b/pushybullet.py
new file mode 100644
index 00000000000..5ee976950a0
--- /dev/null
+++ b/pushybullet.py
@@ -0,0 +1,1373 @@
+# -*- encoding: utf-8 -*-
+
+from StringIO import StringIO
+import os
+import datetime
+import time
+import base64
+import binascii
+
+import urllib
+import urlparse
+import httplib
+import random
+
+try:
+ import simplejson as json
+except ImportError:
+ import json
+
+class FilelikeGenerator(object):
+ def __init__(self, gen):
+ self.__gen = gen
+ self.__buf = ''
+ self.__eof = False
+
+ def __popbuf(self, buflen):
+ self.__buf, res = self.__buf[buflen+1:], self.__buf[0:buflen]
+ return res
+
+ def read(self, buflen=0):
+ if buflen > 0:
+ if len(self.__buf) >= buflen:
+ return self.__popbuf(buflen)
+
+ if self.__eof:
+ return None
+
+ while len(self.__buf) < buflen:
+ try:
+ self.__buf += self.__gen.next()
+ except StopIteration:
+ self.__eof = True
+ break
+
+ return self.__popbuf(buflen)
+
+ else:
+ for part in self.__gen:
+ self.__buf += part
+
+ self.__eof = True
+ res, self.__buf = self.__buf, ''
+ return res or None
+
+ def next(self):
+ value = self.read(8192)
+ if value is None:
+ raise StopIteration
+ return value
+
+ def isatty(self):
+ return False
+
+ @property
+ def closed(self):
+ return False
+
+ def close(self):
+ pass
+
+ def seek(self, pos, whence=0):
+ raise NotImplementedError
+
+def filelike_generator(func):
+ def wrapper(*args, **kwargs):
+ return FilelikeGenerator(func(*args, **kwargs))
+ return wrapper
+
+class Session(object):
+ auth = ()
+ headers = {}
+
+ def get(self, url, params=None, auth=None, headers=None):
+ return self._request('GET', url, params=params, auth=auth, headers=headers)
+
+ def post(self, url, params=None, data=None, files=None, auth=None, headers=None):
+ return self._request('POST', url, params=params, data=data, files=files, auth=auth, headers=headers)
+
+ def delete(self, url, params=None, auth=None, headers=None):
+ return self._request('DELETE', url, params=params, auth=auth, headers=headers)
+
+ def _encode_form_data(self, pairs):
+ boundary = ''.join(chr(random.choice(xrange(ord('a'), ord('z')))) for _ in xrange(0, 30))
+
+ body = []
+ for name, value in pairs:
+ if hasattr(value, 'read'):
+ _body = value.read()
+ body.append(
+ 'Content-Type: application/octet-stream\r\n'
+ 'Content-Disposition: form-data; name="%s"; filename="%s"\r\n'
+ 'Content-Length: %s\r\n'
+ '\r\n'
+ '%s' % (
+ urllib.quote(name),
+ urllib.quote(getattr(value, 'name', None) or "file.txt"),
+ len(_body),
+ _body))
+ else:
+ body.append(
+ 'Content-Type: text/plain\r\n'
+ 'Content-Disposition: form-data; name="%s"\r\n'
+ 'Content-Length: %s\r\n'
+ '\r\n'
+ '%s' % (
+ urllib.quote(name),
+ len(value),
+ value))
+
+ return 'multipart/form-data; boundary="%s"' % boundary, ('--%s\r\n' % boundary) + ('\r\n--%s\r\n' % boundary).join(body) + ('\r\n--%s--\r\n' % boundary)
+
+ class Response(object):
+ def __init__(self, resp):
+ self.__resp = resp
+
+ def json(self):
+ return json.load(self.__resp)
+
+ def raise_for_status(self):
+ status = self.__resp.status
+ kind = status // 100
+
+ if kind in (1, 2, 3):
+ return
+
+ raise RuntimeError('%s %s' % (status, self.__resp.reason))
+
+ def _request(self, method, url, params=None, data=None, files=None, auth=None, headers=None):
+ _url = urlparse.urlparse(url)
+
+ conn = {'http': httplib.HTTPConnection,
+ 'https': httplib.HTTPSConnection}[_url.scheme](_url.hostname, _url.port)
+
+ if params:
+ _params = params.copy()
+ for k in _params.keys():
+ if _params[k] is None:
+ del _params[k]
+
+ _query = urllib.urlencode(_params)
+
+ else:
+ _query = _url.query
+
+ _headers = self.headers.copy()
+ _headers['Host'] = _url.hostname
+
+ if files:
+ content_type, _data = self._encode_form_data(p for n in (data, files) for p in n.iteritems())
+
+ elif data:
+ content_type, _data = ('application/x-www-form-urlencoded',
+ urllib.urlencode(data) if isinstance(data, dict) else str(data))
+
+ else:
+ content_type, _data = None, None
+
+ if _data:
+ _headers['Content-Type'] = content_type
+ #_headers['Content-Length'] = str(len(_data))
+
+ if headers:
+ _headers.update(headers)
+
+ _auth = auth if auth is not None else (
+ (_url.username or '', _url.password or '')
+ if (_url.username is not None or _url.password is not None) else
+ self.auth)
+ if _auth:
+ _headers['Authorization'] = 'Basic %s' % base64.encodestring(':'.join(_auth)).strip()
+
+ conn.request(method, '?'.join((_url.path, _query)), _data, _headers)
+
+ response = conn.getresponse()
+ return self.Response(response)
+
+def get_apikey_from_config():
+ try:
+ from ConfigParser import SafeConfigParser as ConfigParser
+ except ImportError:
+ from configparser import SafeConfigParser as ConfigParser
+
+ try:
+ config = ConfigParser()
+ config.read(os.path.expanduser('~/.config/pushbullet/config.ini'))
+ return config.get('pushbullet', 'apikey')
+ except:
+ return None
+
+def utf8(s):
+ return s if isinstance(s, unicode) else unicode(s, 'utf-8') if isinstance(s, str) else unicode(s)
+
+def parse_since(since):
+ if not since:
+ return 0
+
+ if isinstance(since, (long, int)):
+ return since + time.time() if since < 0 else since
+
+ if isinstance(since, datetime.date):
+ return since.strftime('%s')
+
+ if isinstance(since, datetime.timedelta):
+ return (datetime.datetime.now() - since).strftime('%s')
+
+ try:
+ since = int(since)
+ return since + time.time() if since < 0 else since
+
+ except ValueError:
+ from dateutil.parser import parse
+ return parse(since).strftime('%s')
+
+
+# Events {{{
+class Event(object):
+ '''
+ Abstract Pushbullet event
+ '''
+ __slots__ = ['api', 'time']
+ def __init__(self, api):
+ self.time = time.time()
+ self.api = api
+
+ def __repr__(self):
+ return '<%s @%s>' % (self.__class__.__name__, self.time)
+
+ def pushes(self, skip_empty=False, limit=None):
+ return xrange(0) # empty generator
+
+ def latest_push_time(self):
+ try:
+ push = self.pushes(limit=1).next()
+ return push.get('modified') or push.get('created')
+ except (StopIteration, AttributeError):
+ return None
+
+class NopEvent(Event):
+ '''
+ Nop event (keep-alive ticks)
+ '''
+ __slots__ = ['api', 'time']
+
+class TickleEvent(Event):
+ '''
+ Tickle event (user pushes)
+ '''
+ __slots__ = ['api', 'time', 'since', 'subtype']
+ def __init__(self, api, subtype, since):
+ Event.__init__(self, api)
+ self.subtype = subtype
+ self.since = since
+
+ def pushes(self, skip_empty=False, limit=None):
+ return self.api.pushes(since=self.since, skip_empty=skip_empty, limit=limit)
+
+ def __repr__(self):
+ return '<%s[%s] @%s>' % (self.__class__.__name__, self.subtype, self.time)
+
+class PushEvent(Event):
+ '''
+ Push event (device notification mirroring)
+ '''
+ __slots__ = ['api', 'time', 'push']
+ def __init__(self, api, push):
+ Event.__init__(self, api)
+ self.push = push
+
+ def __repr__(self):
+ return (u'<%s[%r] @%s>' % (self.__class__.__name__, self.push, self.time)).encode('utf-8')
+
+ def pushes(self, skip_empty=False, limit=None):
+ yield self.push
+
+# }}}
+
+class PushBulletError(Exception):
+ pass
+
+class PushBulletObject(object):
+ '''
+ Abstract Pushbullet object for given REST endpoint
+ '''
+
+ collection_name = None
+
+ def __init__(self, **data):
+ self.__dict__.update(data)
+
+ @property
+ def uri(self):
+ '''
+ Relative REST-object URI
+ '''
+ raise NotImplementedError
+
+ def delete(self):
+ '''
+ Delete object
+ '''
+ self.api.delete(self.uri)
+
+ def bind(self, api):
+ '''
+ Bind object to given API object
+
+ :param PushBullet api: API object to bind to
+ :returns: self
+ '''
+ assert(isinstance(api, PushBullet))
+ self.api = api
+ return self
+
+ @property
+ def bound(self):
+ '''
+ True if an object is bound to an API object
+ '''
+ return bool(getattr(self, 'api', None))
+
+ def reload(self):
+ self.__dict__.update(self.api.get(self.uri))
+ return self
+
+ @classmethod
+ def iterate(cls, api, skip_inactive=True, since=0, limit=None):
+ it = api.paged(cls.collection_name,
+ modified_after=parse_since(since),
+ limit=limit)
+
+ print(cls)
+ if skip_inactive:
+ return (cls(api, **o) for o in it if o.get('active', False))
+ else:
+ return (cls(api, **o) for o in it)
+
+ def get(self, name, default=None):
+ return getattr(self, name, default)
+
+ def json(self):
+ return dict(self.__dict__)
+
+ def __contains__(self, name):
+ return hasattr(self, name)
+
+ def __str__(self):
+ return unicode(self).encode('utf8')
+
+class ObjectWithIden(object):
+ @classmethod
+ def load(cls, api, iden):
+ self = cls()
+ self.bind(api)
+ self.iden = iden
+ self.reload()
+ return self
+
+ def __init__(self, api, iden=None, **data):
+ self.iden = iden
+ self.__dict__.update(data)
+ self.bind(api)
+
+ @property
+ def uri(self):
+ return '%s/%s' % (self.collection_name, self.iden)
+
+class Grant(ObjectWithIden, PushBulletObject):
+ collection_name = 'grants'
+
+ def __repr__(self):
+ return (u'<Grant[%s]: %s>' % (self.iden, self.client['name'])).encode('utf-8')
+
+ def __unicode__(self):
+ return u'grant for %s' % (self.client['name'])
+
+class Subscription(ObjectWithIden, PushBulletObject):
+ collection_name = 'subscriptions'
+
+ def __repr__(self):
+ return (u'<Subscription[%s] %s>' % (self.iden, getattr(self, 'channel', {}).get('tag', 'untagged'))).encode('utf-8')
+
+ def __unicode__(self):
+ channel = getattr(self, 'channel', {})
+ return u'%s (%s)' % (
+ channel.get('name', 'Unnamed'),
+ channel.get('tag', 'untagged'))
+
+ def channel(self):
+ return ChannelInfo(self.api, **getattr(self, 'channel', {}))
+
+ def create(self, channel_tag):
+ if self.iden:
+ raise PushBulletError('subscription already exists')
+
+ if isinstance(channel_tag, (ChannelInfo, Channel)):
+ channel_tag = channel_tag.tag
+
+ self.__dict__.update(self.api.post('subscriptions', channel_tag=str(channel_tag)))
+
+ return self
+
+class ChannelInfo(ObjectWithIden, PushBulletObject):
+ collection_name = 'channel-info'
+
+ @classmethod
+ def load_by_tag(cls, api, tag):
+ return cls(api, **api.get('/channel-info', tag=utf8(tag)))
+
+ def __repr__(self):
+ return (u'<ChannelInfo[%s]: %s (%s)>' % (self.iden,
+ getattr(self, 'name', 'Unnamed'),
+ getattr(self, 'tag', 'untagged'))).encode('utf-8')
+
+ def __unicode__(self):
+ return u'%s (%s)' % (
+ getattr(self, 'name', 'Unnamed'),
+ getattr(self, 'tag', 'untagged'))
+
+ def subscribe(self):
+ return Subscription(self.api, None).create(self.tag)
+
+# Push targets {{{
+
+class PushTarget(PushBulletObject):
+ '''
+ Abstract push target object
+ '''
+ @property
+ def ident(self):
+ '''
+ Interface property with parameters to identify given push target
+ :rtype: dict
+ '''
+ raise NotImplementedError
+
+ def push(self, push=None, **pushargs):
+ '''
+ Push a message to the push target
+
+ Either `push` or `pushargs` must be given.
+ If both are present, `pushargs` are ignored.
+
+ :param Push push: a push object
+ :param dict pushargs: parameters to construct push object
+ '''
+ if not isinstance(push, Push):
+ push = self.api.make_push(pushargs, push)
+
+ push.send(self)
+ return push
+
+class Channel(PushTarget, ObjectWithIden):
+ '''
+ Channel to push to
+ '''
+ collection_name = 'channels'
+
+ def __repr__(self):
+ return (u'<Channel[%s]: %s (%s)>' % (self.iden,
+ getattr(self, 'name', 'Unnamed'),
+ getattr(self, 'tag', 'untagged'))).encode('utf-8')
+
+ def __unicode__(self):
+ return u'%s (%s)' % (
+ getattr(self, 'name', 'Unnamed'),
+ getattr(self, 'tag', 'untagged'))
+
+ @property
+ def ident(self):
+ return {'channel_tag': self.tag}
+
+ def create(self):
+ if self.iden:
+ raise PushBulletError('channel already exists')
+
+ self.__dict__.update(self.api.post('clients',
+ tag=self.tag,
+ name=getattr(self, 'name', None),
+ description=getattr(self, 'description', None),
+ feed_url=getattr(self, 'feed_url', None),
+ feed_filters=getattr(self, 'feed_filters', None)))
+
+ return self
+
+ def update(self):
+ if not self.iden:
+ raise PushBulletError('channel does not exist yet')
+
+ self.__dict__.update(self.api.post(self.uri,
+ name=getattr(self, 'name', None),
+ description=getattr(self, 'description', None),
+ feed_url=getattr(self, 'feed_url', None),
+ feed_filters=getattr(self, 'feed_filters', None)))
+
+ return self
+
+ def subscribe(self):
+ return Subscription(self.api, None).create(self.tag)
+
+class Client(PushTarget, ObjectWithIden):
+ '''
+ Current user's OAuth client
+
+ By pushing to it you push to all users, who granted access to the client.
+ '''
+ collection_name = 'clients'
+
+ def __repr__(self):
+ return (u'<Client[%s]: %s>' % (self.iden, getattr(self, 'name', 'Unnamed'))).encode('utf-8')
+
+ def __unicode__(self):
+ return getattr(self, 'name', 'Unnamed')
+
+ @property
+ def ident(self):
+ return {'client_iden': self.iden}
+
+class Contact(ObjectWithIden, PushTarget):
+ '''
+ Contact to push to
+ '''
+ collection_name = 'contacts'
+
+ def __repr__(self):
+ return (u'<Contact[%s]: %s <%s>>' % (self.iden,
+ getattr(self, 'name', 'Unnamed'),
+ getattr(self, 'email', None) or getattr(self, 'email_normalized'))).encode('utf-8')
+
+ def __unicode__(self):
+ return u'%s <%s>' % (self.name, self.email)
+
+ @property
+ def ident(self):
+ return {'email': self.email_normalized}
+
+ def create(self):
+ if self.iden:
+ raise PushBulletError('contact already exists')
+
+ self.__dict__.update(self.api.post('contacts', name=self.name, email=self.email))
+ return self
+
+ def update(self):
+ if not self.iden:
+ raise PushBulletError('contact does not exist yet')
+
+ self.__dict__.update(self.api.post(self.uri, name=self.name))
+ return self
+
+ def rename(self, newname):
+ self.name = newname
+ return self.update()
+
+class Device(ObjectWithIden, PushTarget):
+ '''
+ Device to push to
+ '''
+ collection_name = 'devices'
+
+ def __repr__(self):
+ return (u'<Device[%s]: %s>' % (self.iden,
+ getattr(self, 'nickname', None) or
+ getattr(self, 'model', None) or
+ 'Unnamed')).encode('utf-8')
+
+ def __unicode__(self):
+ return (getattr(self, 'nickname', None) or
+ getattr(self, 'model', None) or
+ self.iden)
+
+ @property
+ def ident(self):
+ return {'device_iden': self.iden}
+
+ def create(self):
+ if self.iden:
+ raise PushBulletError('device already exists')
+
+ self.__dict__.update(self.api.post('devices', nickname=self.nickname, type=getattr(self, 'type', 'stream')))
+ return self
+
+ def update(self):
+ if not self.iden:
+ raise PushBulletError('device does not exist yet')
+
+ self.__dict__.update(self.api.post(self.uri, nickname=self.nickname))
+ return self
+
+ def rename(self, newname):
+ self.nickname = newname
+ return self.update()
+
+class PhoneNumber(PushTarget):
+ '''
+ Phone number to push SMS to
+ '''
+ device = None
+ number = None
+
+ def __init__(self, device, number):
+ assert isinstance(device, Device)
+ self.device = device
+ self.number = str(number)
+
+ @property
+ def ident(self):
+ return {
+ 'type': 'messaging_extension_reply',
+ 'package_name': 'com.pushbullet.android',
+ 'conversation_iden': self.number,
+ 'target_device_iden': self.device.iden,
+ 'source_user_iden': self.api.me.iden
+ }
+
+ def push(self, push=None, **pushargs):
+ api = self.device.api
+ if not isinstance(push, Push):
+ push = api.make_push(pushargs, push)
+
+ data = self.ident
+ data['message'] = push.body
+ api.post("ephemerals", type="push", push=data)
+ return push
+
+ def __repr__(self):
+ return (u'<PhoneNumber[%s] device=%s>' % (self.number, self.device)).encode('utf-8')
+
+ def __unicode__(self):
+ return self.number
+
+class User(PushTarget):
+ '''
+ User profile
+ '''
+ def __init__(self, api, **data):
+ self.__dict__.update(data)
+ self.bind(api)
+
+ @classmethod
+ def load(cls, api):
+ return cls(api, **api.get('users/me'))
+
+ def __repr__(self):
+ return (u'<User[%s]: %s <%s>>' % (self.iden,
+ getattr(self, 'name', 'Unnamed'),
+ getattr(self, 'email', None) or getattr(self, 'email_normalized'))).encode('utf-8')
+
+ @property
+ def ident(self):
+ return {}
+
+ @property
+ def uri(self):
+ return 'users/me'
+
+ def update(self):
+ self.__dict__.update(self.api.post(self.uri, preferences=getattr(self, 'preferences', {})))
+ return self
+
+ def set_prefs(self, **prefs):
+ try:
+ self.preferences.update(prefs)
+ except AttributeError:
+ self.prefereces = prefs
+
+ return self.update()
+
+# }}}
+
+# Pushes {{{
+
+class Push(PushBulletObject):
+ '''
+ Abstract push object
+ '''
+ type = None
+ collection_name = 'pushes'
+
+ @property
+ def uri(self):
+ return "pushes/%s" % self.iden
+
+ def decode(self):
+ try:
+ self.modified = datetime.datetime.fromtimestamp(self.modified)
+ except AttributeError:
+ pass
+
+ try:
+ self.created = datetime.datetime.fromtimestamp(self.created)
+ except AttributeError:
+ pass
+
+ def send(self, target=None):
+ '''
+ Send the push to some target
+
+ If target is None (or omitted) or a string, the push must be bound to some API.
+ By default the push will be sent to API object (i.e. all user devices).
+
+ If target is a string, it must be a device iden to push to.
+
+ If you use anything except for Device, Contact or PushBullet object as a target
+ (i.e. a PushTarget object), you must make sure a push is bound to PushBullet
+ object before by calling `push.bind(api)` method.
+ Push is already bound if you fetched it with `api.pushes()` call
+ or sent it before.
+
+ :param target: push target
+ :type target: PushTarget|str|None
+ '''
+ if not isinstance(target, PushTarget):
+ target = self.api.make_target(target)
+
+ self.bind(target.api)
+
+ data = self.data
+ data.update(target.ident)
+ data['type'] = self.type
+
+ result = self.api.post('pushes', **data)
+ self.__dict__.update(result)
+
+ def resend(self):
+ '''
+ Try to send the push to the same target again (e.g. as a part of error handling logic)
+ '''
+ if not hasattr(self, 'target_device_iden'):
+ raise PushBulletError('push was not sent yet')
+
+ self.send(self.target_device_iden)
+
+ def update(self):
+ self.__dict__.update(self.api.post(self.uri, dissmissed=getattr(self, 'dismissed', False)))
+ return self
+
+ def dismiss(self):
+ '''
+ Dismiss a push
+ '''
+ if getattr(self, 'dismissed', False):
+ return # don't dismiss twice
+
+ self.dismissed = True
+ return self.update()
+
+ @property
+ def data(self):
+ '''
+ Push data necessary to send push to a target
+
+ :rtype: dict
+ '''
+ raise NotImplementedError
+
+ @property
+ def target_device(self):
+ '''
+ Get target device object
+ '''
+ iden = self.get('target_device_iden')
+ return Device(self.api, iden) if iden else None
+
+ @property
+ def source_device(self):
+ '''
+ Get source device object
+ '''
+ iden = self.get('source_device_iden')
+ return Device(self.api, iden) if iden else None
+
+ def __eq__(self, other):
+ return isinstance(other, Push) and self.iden == other.iden
+
+ def __repr__(self):
+ return (u'<%s[%s]: %s>' % (self.__class__.__name__, getattr(self, 'iden', None), unicode(self))).encode('utf-8')
+
+ def __unicode__(self):
+ return u'%s push' % getattr(self, 'type', 'general')
+
+
+class NotePush(Push):
+ '''
+ Note push
+ '''
+ type = 'note'
+ def __init__(self, body='', title='', **data):
+ '''
+ A note push constructor
+
+ Notes has both body and title parameters optional, but at least one of them
+ must be defined for the push to be useful. The `title` argument defaults to "Note"
+ by PushBullet service, so I choose to require at least `body` argument.
+ If you really don't need body (you should define `title` then, or you will end up
+ with empty note, which usually has no sense), set it to empty string `''`.
+
+ :type body: str
+ :type title: str
+ '''
+ self.title, self.body = utf8(title), utf8(body)
+ Push.__init__(self, **data)
+
+ @property
+ def data(self):
+ return {'title': self.title, 'body': self.body}
+
+ def __unicode__(self):
+ return self.title
+
+class LinkPush(Push):
+ '''
+ Link push
+ '''
+ type = 'link'
+ def __init__(self, url, title='', body='', **data):
+ '''
+ A link push constructor
+
+ URL is the only required argument, otherwise the push is actually useless.
+ You can of cause set it to empty string (`''`), but what is the use of it?
+
+ :type url: str
+ :type title: str
+ :type body: str
+ '''
+ self.title, self.url, self.body = utf8(title), utf8(url), utf8(body)
+ Push.__init__(self, **data)
+
+ @property
+ def data(self):
+ return {'title': self.title, 'url': self.url, 'body': self.body}
+
+ def __unicode__(self):
+ return self.url
+
+class AddressPush(Push):
+ '''
+ Address push
+ '''
+ type = 'address'
+ def __init__(self, address, name='', **data):
+ '''
+ An address push constructor
+
+ Address argument is the only required argument here.
+ The push actually has no sense without it, doesn't it?
+
+ :type address: str
+ :type name: str
+ '''
+ self.name, self.address = utf8(name), utf8(address)
+ Push.__init__(self, **data)
+
+ @property
+ def data(self):
+ return {'name': self.name, 'address': self.address}
+
+ def __unicode__(self):
+ return u'%s (%s)' % (self.name, self.address)
+
+class ListPush(Push):
+ '''
+ List push
+ '''
+ type = 'list'
+ def __init__(self, items, title='', **data):
+ '''
+ A list push constructor
+
+ Items argument is the only required one, and it should be a list
+ of strings. Of cause you can send empty list (`[]`), but what is the use of it?
+
+ :type items: list of str
+ :type title: str
+ '''
+ self.title, self.items = utf8(title), map(utf8, items)
+ Push.__init__(self, **data)
+
+ @property
+ def data(self):
+ return {'title': self.title, 'items': self.items}
+
+ def __unicode__(self):
+ return u'%s (%d)' % (self.title, len(self.items))
+
+class FilePush(Push):
+ '''
+ File push
+ '''
+ type = 'file'
+ def __init__(self, file=None, file_name=None, file_type=None, body='', **data):
+ '''
+ A file push constructor
+
+ You must specify at least `file` argument in order to be able to push some new file
+
+ The `file` argument is optional only for internal usage, like if a file push fetched
+ by `api.pushes()` method call, in which case file to push is undefined, but `file_url`
+ is present to download the file. If you then resend such push, file designated by `file_url`
+ will be sent, not any new file set by you. You can use this knowledge to try and
+ set `file_url` directly on `FilePush` object without setting `file` argument on your
+ own risk, but bear in mind it's an internal implementation detail, so please make sure you
+ a) understand what you are doing, b) don't abuse the feature.
+
+ If you specify `file` only, it must be either a file-like object, a file-handler opened for read,
+ a buffer (for in-memory files), an openable object (the one with `open([mode])` method)
+ or a string with absolute file path.
+ You will see basename of the file (the part of path after final slash).
+
+ If you specify both `file` and `file_name`, a push receiver will see `file_name` value
+ as a file name, not the actual file name. You can use it for example to send some
+ system stream without user-friendly name, like `sys.stdin`.
+
+ The `file_type` argument is optional and must be a string in MIME-type format (e.g. `text/plain`).
+ If you omit it, file type will be deteremined by magic library by file's content, and if
+ autodetection will fail, file type will default to `application/octet-stream`.
+ The autodetection reads first 1024 bytes of file content and then resets file's seek cursor
+ to the beginning, so it won't work for non-seekable streams, so if you are about to push
+ something like `sys.stdin`, make sure you set `file_type` manually.
+
+ :param file: file to push
+ :type file: str, file, buffer, int, Path or any file-like or openable object
+ :param str file_name: file name to push (will be visible to reciever)
+ :param str file_type: file's MIME type (will be determined by file's content if omitted)
+ :param str body: optional message to accompany file
+ '''
+ assert(file or file_name)
+ self.file, self.file_name, self.file_type = file, utf8(file_name), utf8(file_type)
+ if not self.file:
+ self.file = self.file_name
+
+ self.file_url = None
+ self.body = utf8(body)
+ Push.__init__(self, **data)
+
+ def send(self, target=None):
+ if not isinstance(target, PushTarget):
+ target = self.api.make_target(target)
+
+ if not self.file_url: # file not uploaded yet
+ fh = (self.file if hasattr(self.file, 'read') else # file-like object
+ self.file.open('rb') if hasattr(self.file, 'open') else # openable object
+ os.fdopen(self.file, 'rb') if isinstance(self.file, int) else # file descriptor
+ StringIO(self.file) if isinstance(self.file, buffer) else # in-memory file
+ open(self.file, 'rb')) # file name
+
+ try:
+ file_name = utf8(self.file_name) if self.file_name else os.path.basename(fh.name)
+ file_type = utf8(self.file_type) if self.file_type else self.guess_type(fh)
+ req = target.api.get('upload-request', file_name=file_name, file_type=file_type)
+ target.api.upload(req['upload_url'], data=req['data'], file=fh)
+ self.file_name, self.file_type, self.file_url = req['file_name'], req['file_type'], req['file_url']
+
+ finally:
+ fh.close()
+
+ Push.send(self, target)
+
+ def guess_type(self, file):
+ try:
+ import magic
+ guesser = magic.open(magic.MIME_TYPE)
+ guesser.load()
+ mime_type = guesser.buffer(file.read(1024))
+ file.seek(0)
+ return mime_type or 'application/octet-stream'
+
+ except:
+ return 'application/octet-stream'
+
+ @property
+ def data(self):
+ return {'file_name': self.file_name, 'file_type': self.file_type, 'file_url': self.file_url, 'body': self.body}
+
+ def __unicode__(self):
+ return self.file_name
+
+class MirrorPush(Push):
+ '''
+ Mirror push (internal usage only)
+ '''
+ type = 'mirror'
+
+ def decode(self):
+ super(MirrorPush, self).decode()
+
+ try:
+ self.icon = base64.decodestring(self.icon)
+ except (AttributeError, binascii.Error):
+ pass
+
+ def send(self, target):
+ raise NotImplementedError
+
+class DismissalPush(Push):
+ '''
+ Dismissal push (internal usage only)
+ '''
+ type = 'dismissal'
+
+ def send(self, target):
+ raise NotImplementedError
+
+# }}}
+
+# Main API class {{{
+
+def cached_list_method(cls):
+ cache_key = '_%s' % cls.collection_name
+ def wrapper(self, reset_cache=False):
+ if reset_cache or getattr(self, cache_key, None) is None:
+ setattr(self, cache_key, list(cls.iterate(self)))
+ return getattr(self, cache_key)
+ return wrapper
+
+def iterator_method(cls):
+ def iterator(self, skip_inactive=False, since=0, limit=None):
+ return cls.iterate(self, skip_inactive, since, limit)
+ return iterator
+
+class PushBullet(PushTarget):
+ '''
+ Main API class for PushBullet
+ '''
+
+ API_URL = 'https://api.pushbullet.com/v2/%s'
+
+ def __init__(self, apikey):
+ '''
+ Initialize API object (get API key from https://www.pushbullet.com/account)
+
+ :param str apikey: API key (get at https://www.pushbullet.com/account)
+ '''
+ self.apikey = apikey
+ self.sess = Session()
+ self.sess.auth = (apikey, '')
+
+ def get_type_by_args(self, args, arg=None):
+ return args.get('type') or ('url' if 'url' in args else
+ 'list' if 'items' in args else
+ 'address' if 'address' in args else
+ 'file' if 'file' in args or 'file_name' in args else
+ self.get_type_by_class(arg) if arg else
+ 'note')
+
+ def get_type_by_class(self, arg):
+ if isinstance(arg, (file, buffer)):
+ return 'file'
+
+ # any iteratable (except for strings) is a list push
+ if hasattr(arg, '__iter__') and not isinstance(arg, (str, unicode)):
+ return 'list'
+
+ # special case: looks like url, therefore it is an link push
+ if utf8(arg).startswith(('http://', 'https://', 'ftp://', 'ftps://', 'mailto:')):
+ return 'link'
+
+ # default is a note push
+ return 'note'
+
+ def make_push(self, pushargs, pusharg=None):
+ '''
+ Factory to create a push object out of raw data in dictionary
+
+ The `pushargs` dict should contain `type` element to determine
+ push type. If you omit it, push type will be autodefined by presence of
+ other elements, defaulting to `note`.
+
+ Other `pushargs` elements depend on push type:
+
+ * for `note`: `title` and `body`,
+ * for `list`: `title` and `items`,
+ * for `file`: `file`, `file_name`, `file_type` and `body`,
+ * for `link`: `title` and `url`,
+ * for `address`: `name` and `address`.
+
+ See correspondent push classes docs for details of these arguments.
+
+ :param dict pushargs: a dict of parameters to compose a push object
+ '''
+ # a set of arguments in a dictionary
+ pushcls = {
+ 'note': NotePush,
+ 'list': ListPush,
+ 'link': LinkPush,
+ 'file': FilePush,
+ 'address': AddressPush,
+ 'mirror': MirrorPush,
+ 'dismissal': DismissalPush,
+ }.get(self.get_type_by_args(pushargs, pusharg), Push)
+ push = pushcls(pusharg, **pushargs) if pusharg else pushcls(**pushargs)
+
+ return push.bind(self)
+
+ def delete(self, _uri):
+ '''
+ Helper method for DELETE requests to API
+ '''
+ self.sess.delete(self.API_URL % _uri).raise_for_status()
+
+ def post(self, _uri, **data):
+ '''
+ Helper method for POST requests to API
+ '''
+ response = self.sess.post(self.API_URL % _uri, data=json.dumps(data),
+ headers={'Content-Type': 'application/json'})
+ response.raise_for_status()
+
+ result = response.json()
+
+ if 'error' in result:
+ raise PushBulletError(result['message'])
+
+ return result
+
+ def get(self, _uri, **params):
+ '''
+ Helper method for GET requests to API
+ '''
+ response = self.sess.get(self.API_URL % _uri, params=params)
+ response.raise_for_status()
+
+ result = response.json()
+
+ if 'error' in result:
+ raise PushBulletError(result['message'])
+
+ return result
+
+ def upload(self, _uri, data, **files):
+ '''
+ Helper method to upload a file to given URL
+ '''
+ response = self.sess.post(_uri, data=data, files=files, auth=()).raise_for_status()
+
+ def paged(self, _uri, **params):
+ page = self.get(_uri, **params)
+
+ while True:
+ for item in page[_uri]:
+ yield item
+
+ if not page.get('cursor'):
+ break
+
+ page = self.get(_uri, cursor=page['cursor'])
+
+ def subscribe(self, channel_tag):
+ return Subscription(self, None).create(channel_tag)
+
+ def create_device(self, nickname, type='stream'):
+ '''
+ Create new (a stream) device with given nickname
+
+ :param str nickname: device's name
+ :param str type: device's type
+ :rtype: Device
+ '''
+ return Device(self, None, nickname=nickname, type=type).create()
+
+ def create_contact(self, name, email):
+ '''
+ Create a new contact with given name and email
+
+ :param str name: contact's name
+ :param str email: contact's email
+ :rtype: Contact
+ '''
+ return Contact(self, None, name=name, email=email).create()
+
+ iter_contacts = iterator_method(Contact)
+ iter_devices = iterator_method(Device)
+ iter_grants = iterator_method(Grant)
+ iter_clients = iterator_method(Client)
+ iter_channels = iterator_method(Channel)
+ iter_subscriptions = iterator_method(Subscription)
+
+ contacts = cached_list_method(Contact)
+ devices = cached_list_method(Device)
+ grants = cached_list_method(Grant)
+ clients = cached_list_method(Client)
+ channels = cached_list_method(Channel)
+ subscriptions = cached_list_method(Subscription)
+
+ def pushes(self, since=0, skip_empty=True, limit=None):
+ '''
+ Generator fetches and yields all pushes since given timestamp
+
+ The `since` argument, which defines time limit in the past to get
+ pushes from, accepts almost any sensible date/time object.
+
+ If it is an integer (int or long) and positive, it is expected
+ to be correct unix timestamp (number of seconds since 1/1/1970 00:00:00 UTC).
+ If it is an integer and negative, it is a number of seconds in the past
+ (e.g. use `-86400` to fetch pushes for the last day).
+ If it is a date or datetime object, it is, well, a date/time =).
+ If it is a timedelta object, it is a time-span in the past
+ (so `timedelta(days=7)` means "pushes for the last week").
+ If it is a string, it is parsed with dateutil.parser.parse() for datetime object.
+
+ :param since: minimal time for pushes to fetch
+ :type since: int|long|date|datetime|timedelta
+ :param bool skip_empty: skip empty (inactive, removed) pushes, default is True
+ :param int limit: limit number of items per page
+ :rtype: generator
+ '''
+ it = self.paged(Push.collection_name,
+ modified_after=parse_since(since),
+ limit=limit)
+
+ if skip_empty:
+ return (self.make_push(o) for o in it if bool(o.get('type', None)))
+ else:
+ return (self.make_push(o) for o in it)
+
+ def __getitem__(self, device_iden):
+ '''
+ Find and return device object by device iden or device name
+
+ At first search is done by device iden field, and if it's not found,
+ search is repeated by device name. A device name is either device nickname,
+ model or iden, whichever is defined for any given device object.
+
+ So you can get your Chrome device object with `api["Chrome"]` call.
+
+ Throws `KeyError` if no device is found.
+
+ :param str device_iden: a device iden
+ '''
+ try:
+ return next(d for d in self.devices() if d.iden == device_iden)
+ except StopIteration:
+ try:
+ return next(d for d in self.devices() if utf8(d) == device_iden)
+ except StopIteration:
+ raise KeyError(device_iden)
+
+ _me = None
+ def me(self, reset_cache=False):
+ '''
+ Get current user information
+ '''
+ if not reset_cache and self._me:
+ return self._me
+
+ self._me = User.load(self)
+ return self._me
+
+ def make_target(self, target):
+ if target is None:
+ return self
+
+ if isinstance(target, PushTarget):
+ return target
+
+ target = utf8(target)
+ return (Device(self, target) if '@' not in target else
+ Contact(self, None, email_normalized=target))
+
+ def push(self, push=None, target=None, **pushargs):
+ '''
+ Send push to a target (to all devices by default)
+
+ If you omit `target` argument, the push will be sent to all user devices.
+ If `target` is anything but `PushTarget` object, it will be cast to string
+ and will be taken as a device iden to push to.
+
+ Only one of `push` or `pushargs` arguments must be given at a time.
+ If `push` is omitted, new push will be constructed from `pushargs` arguments,
+ if both `push` and `pushargs` are given, `pushargs` is ignored.
+
+ :param Push push: a push object ot push
+ :param target: a push target to push to
+ :type target: str|PushTarget|None
+ :param dict pushargs: push arguments
+ :rtype: Push
+ :returns: push just sent
+ '''
+ if not isinstance(push, Push):
+ push = self.make_push(pushargs, push)
+
+ push.bind(self).send(target)
+ return push
+
+ def bind(self, obj):
+ '''
+ Bind given object to the API
+
+ :type obj: PushBulletObject
+ :returns: obj
+ '''
+ assert(isinstance(obj, PushBulletObject))
+ return obj.bind(self)
+
+ @property
+ def ident(self):
+ '''
+ For `PushTarget` interface compliance
+ '''
+ return {}
+
+ @property
+ def api(self):
+ '''
+ For `PushTarget` interface compliance only
+ '''
+ return self
+
+ def stream(self, skip_nop=True, use_server_time=False, throttle=1):
+ '''
+ Generator to listen for events on websocket and yield them
+
+ The method requires `websocket` library. It will run an infinite event loop, which
+ fetches events from websocket and provides them as an Event objects, e.g.::
+
+ for ev in api.stream():
+ print(ev)
+
+ To be able to run any other code at the same time, consider running the loop
+ in some other (background) thread.
+
+ :param bool skip_nop: skip "nop" events (used as keep-alive heartbeats only), default is True
+ :param bool use_server_time: use server time to track last push to fetch (requires additional request on event), default is False
+ :rtype: generator
+ '''
+ from websocket import create_connection
+ conn = create_connection('wss://stream.pushbullet.com/websocket/%s' % self.apikey)
+ last_ts = ((self.latest_push_time() or time.time()) if use_server_time else time.time()) + throttle
+
+ while True:
+ event = json.loads(conn.recv())
+ evtype = event['type']
+ if skip_nop and evtype == 'nop':
+ continue
+
+ event = (NopEvent(self) if evtype == 'nop' else
+ TickleEvent(self, event['subtype'], since=last_ts) if evtype == 'tickle' else
+ PushEvent(self, self.make_push(event['push'])) if evtype == 'push' else
+ None)
+
+ last_ts = ((event.latest_push_time() or time.time()) if use_server_time else time.time()) + throttle
+
+ if event:
+ yield event
+
+ def latest_push_time(self):
+ try:
+ push = self.pushes(limit=1).next()
+ return push.get('modified') or push.get('created')
+ except StopIteration:
+ return None
+
+ def __unicode__(self):
+ return u'<PushBullet>'
+
+# }}}
+
+#import yaml
+#with open('/usr/local/etc/pushbullet.yml', 'rb') as f:
+# config = yaml.safe_load(f)
+#
+#pb = PushBullet(config['apikey'])
+
diff --git a/setup.py b/setup.py
new file mode 100755
index 00000000000..ebe1b90a685
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,25 @@
+#!/usr/bin/env python2
+
+from distutils.core import setup
+
+setup(name='PushyBullet',
+ version='1.5.4',
+ description='PushBullet APIv2 python bindings',
+ author='Konstantin Stepanov',
+ author_email='me@kstep.me',
+ url='http://github.com/kstep/pushybullet/',
+ py_modules=['pushybullet'],
+ install_requires=[
+ #'requests>=2.3.0',
+ #'websocket-client>=0.12.0',
+ #'dateutil>=2.2',
+ #'magic>=5.18',
+ ],
+ scripts=['pb'],
+ classifiers=[
+ 'Topic :: Software Development :: Libraries',
+ 'Topic :: Utilities',
+ 'Topic :: Internet',
+ 'Development Status :: 4 - Beta',
+ 'Environment :: Console',
+ ])