def test_text_init(self):
"Test the Pocket object creation from text"
# 1. Create Pocket object from text
myobj = pocket.Pocket(text=aoc_17.from_text(EXAMPLE_TEXT))
# 2. Make sure it has the expected values
self.assertEqual(myobj.part2, False)
self.assertEqual(len(myobj.text), 3)
self.assertEqual(myobj.cycle, 0)
self.assertEqual(len(myobj.active), 5)
# 3. Check methods
self.assertEqual(myobj.count(), EXAMPLE_COUNT[0])
self.assertEqual(len([_ for _ in myobj.nearby((0, 0, 0))]), 26)
self.assertEqual(myobj.count_nearby((0, 0, 0)), 1)
self.assertEqual(myobj.count_nearby((0, 0, 1)), 1)
self.assertEqual(myobj.count_nearby((1, 1, 0)), 5)
self.assertEqual(myobj.count_nearby((1, 1, 1)), 5)
myobj.one_cycle()
self.assertEqual(myobj.count(), EXAMPLE_COUNT[1])
myobj.one_cycle()
self.assertEqual(myobj.count(), EXAMPLE_COUNT[2])
myobj.one_cycle()
self.assertEqual(myobj.count(), EXAMPLE_COUNT[3])
def main():
session = atabula.get_session()
frontpage = session.get("https://atabula.com")
access_token = os.getenv("POCKET_ACCESS_TOKEN")
p = pocket.Pocket(POCKET_CONSUMER_KEY, access_token)
already_in_pocket = p.get(domain=secrets.APP_DOMAIN, detailType="simple",
state="all")
if already_in_pocket[0]['list']:
articles_already_pushed = {
entry['given_url'].replace("https://", "").replace("http://", "")
for entry in already_in_pocket[0]['list'].values()
}
else:
articles_already_pushed = set()
for line in frontpage.text.split("\n"):
m = RE_ARTICLE_LINK.search(line)
if m:
link = "{}/{}/{}".format(
secrets.APP_DOMAIN, secrets.URL_PREFIX, m.group(1),
)
if link not in articles_already_pushed:
articles_already_pushed.add(link)
url = "https://" + link
p.add(url, tags=["Food"])
print("Adding {}".format(url))
def get_yo(poll):
print poll
username = request.args.get('username')
link = request.args.get('link')
print "Usernm"
print username
uid = accounts.get_uid(username)
if uid is None:
# create new account, send pocket info
uid = accounts.gen_uid(username)
print "uid generation"
print uid
send_link_yo(username, API_TOKEN, CLIENT_URL + "/connectPocket/" + uid)
else:
# check if we have pocket secret
secret = accounts.get_secret(uid)
if secret is None:
print "NO SECRET"
print "uid being sent"
print uid
send_link_yo(username, API_TOKEN,
CLIENT_URL + "/connectPocket/" + uid)
else:
if link is None:
send_read_link(username, uid, API_TOKEN)
else:
pocket_instance = pocket.Pocket(CONSUMER_KEY, secret)
pocket_instance.add(link)
print "received a link on an already existing account"
return 'OK'
def tags(self, *args):
at = getSessionItemOrEmpty('access_token')
if at == '':
return '{"error":true}'
try:
pocket_instance = pocket.Pocket(rar_config['consumer_key'], at)
resp = pocket_instance.get(state='unread', detailType='complete')
except Exception as e:
return '<h1 style="color: red">' + str(e)
articles = resp[0]['list']
ai = iter(articles.items())
tags = set()
for k, a in ai:
try:
for t in list(a['tags'].items()):
tags.add(t[0])
except:
pass
txt = '{"error":false, "tags": [ '
for t in tags:
if t == 'norar':
continue
txt += '"' + t + '", '
txt += '"_untagged_" ]}'
return txt
async def main():
"""Main function"""
ui = None
app = None
logging.info(f'Config file: {CONFIG_FILE_PATH}')
with open(CONFIG_FILE_PATH, mode='r+') as file:
config = json.load(file)
try:
app = pocket.Pocket(config.get('POCKET', {}).get('consumer_key'),
access_token=config.get(
'POCKET', {}).get('access_token'))
await app.authorize()
use_tui = config.get('APP', {}).get('use_tui', True)
ui = tui_init if CURSES_AVAILABLE and use_tui else cli
except pocket.PocketException as pocket_exception:
logging.error(
f'Error authenticating with pocket: {pocket_exception}')
print(f'Error authenticating with pocket: {pocket_exception}')
sys.exit(1)
except Exception as exception:
logging.error(f'An unknown error occured: {exception}')
print(f'An unknown error occured: {exception}')
sys.exit(1)
config['POCKET']['access_token'] = app.access_token
# Seek to the beginning to overwrite the existing config
# Otherwise json.dump would just append,
# because we have read at the beginning and moved the stream position
file.seek(0)
json.dump(config, file, indent=4)
await ui(app)
def articles(self, *args):
at = getSessionItemOrEmpty('access_token')
pocket_instance = pocket.Pocket(rar_config['consumer_key'], at)
articles = pocket_instance.get(state='unread',
detailType='complete')[0]['list'].items(
) #this is dict of dicts ;__;
articles_simplified = []
for k, v in articles:
ttr = v.get('time_to_read')
if ttr is None:
ttr = 0
articles_simplified.append(
(k, ttr, v.get('resolved_title'), v.get('resolved_url')))
articles_sorted = sorted(articles_simplified, key=lambda tup: tup[1])
alist = ""
count = len(articles)
total_ttr = 0
for v in articles_sorted:
aid = v[0] #.get('resolved_id')
ttr = v[1] #.get('time_to_read')
total_ttr += ttr
title = html.escape(v[2]) #.get('resolved_title'))
url = v[3] #.get('resolved_url')
if title is None or title == '':
title = "[%s]" % (url)
alist += (
'<tr><td align=right>%d mins</td><td><a href="https://app.getpocket.com/read/%s">%s</a></td><td><a href=%s>real url</a></td></tr>'
% (ttr, aid, title, url))
ttr_ftm = "%d hrs %d mins" % (total_ttr / 60, total_ttr % 60)
return '<meta charset="utf-8" /><style>td{padding: 5px;</style><h1>Count: %s<br />Time to read: %s</h1>'% (count, ttr_ftm)+\
'<table border=1><tr><td>time</td><td>title</td><td>real url</td></tr>%s' % (alist)
def random(self):
at = getSessionItemOrEmpty('access_token')
if at == '':
return writeJSRedir('/login')
try:
tags = json.loads(urllib.parse.unquote(
request.cookies.get('tags')))
except:
tags = ['_untagged_']
if len(tags) == 0:
tags = ['_untagged_']
try:
pocket_instance = pocket.Pocket(rar_config['consumer_key'], at)
articles = dict()
#for tag in tags: #tag=tag,
resp = pocket_instance.get(state='unread',
contentType='article',
detailType='complete')
articles.update(resp[0]['list'])
except Exception as e:
return '<h1 style="color: red">' + str(e)
articlesToConsider = dict()
for key, article in articles.items():
try:
articleTags = article['tags']
except:
articleTags = ['_untagged_']
if 'norar' in articleTags:
continue
for articleTag in articleTags:
for tag in tags:
if tag == articleTag:
articlesToConsider[key] = article
break
cnt = len(articlesToConsider)
if cnt == 0:
return '<p style="font-size: 120px">No articles :(</p>'+\
'<script>setTimeout(function(){'+\
' window.location.replace("/")'+\
'}, 1500);</script>'
f = open("/tmp/rar_last.json", "w")
f.write(json.dumps(articlesToConsider))
f.close()
trgt = random.randint(0, cnt - 1)
targetArticle = articlesToConsider[list(
articlesToConsider.keys())[trgt]]
return '<script>'+\
'localStorage.setItem("last_cnt","'+str(cnt)+'");'+\
'localStorage.setItem("last_id","'+targetArticle['item_id']+'");'+\
'localStorage.setItem("last_title","'+targetArticle['resolved_title']+'");'+\
'</script>'+\
writeJSRedir('https://app.getpocket.com/read/'+targetArticle['item_id'])
def test_pocket_init(self):
pocket_instance = pocket.Pocket(
self.consumer_key,
self.access_token,
)
self.assertEqual(self.consumer_key, pocket_instance.consumer_key)
self.assertEqual(self.access_token, pocket_instance.access_token)
def test_part_one(self):
"Test part one example of Pocket object"
# 1. Create Pocket object from text
myobj = pocket.Pocket(text=aoc_17.from_text(PART_ONE_TEXT))
# 2. Check the part one result
self.assertEqual(myobj.part_one(verbose=False), PART_ONE_RESULT)
def test_part_two(self):
"Test part two example of Pocket object"
# 1. Create Pocket object from text
myobj = pocket.Pocket(part2=True, text=aoc_17.from_text(PART_TWO_TEXT))
# 2. Check the part two result
self.assertEqual(myobj.part_two(verbose=False), PART_TWO_RESULT)
def _initPocket(self):
access_token = u'3d50b538-8bfc-d571-1488-fabf77'
consumer_key = self.config.get("AuthPocket", "consumer_key", None)
if access_token is None:
redirect_uri = self.config.get("AuthPocket", "redirect_uri", None)
access_token = Pocket.auth(consumer_key=consumer_key,
redirect_uri=redirect_uri)
self._pocket_instance = pocket.Pocket(consumer_key, access_token)
def get_pocket_instance():
"""
Connect to Pocket API
"""
consumer_key = settings.consumer_key
access_token = settings.access_token
pocket_instance = pocket.Pocket(consumer_key, access_token)
return pocket_instance
def test_pocket_init_payload(self):
pocket_instance = pocket.Pocket(
self.consumer_key,
self.access_token,
)
expected_payload = {
'consumer_key': self.consumer_key,
'access_token': self.access_token,
}
self.assertEqual(expected_payload, pocket_instance._payload)
def method(args):
access_token = utils.get_access_token(args.consumer_key, auth_file=args.auth_file)
pocket_instance = pocket.Pocket(args.consumer_key, access_token)
# perfoms all these actions in one request
# NOTE: Each individual method returns the instance itself. The response
# dictionary is not returned till commit is called on the instance.
response, headers = pocket_instance.get(
state=args.state, favorite=args.favorite, tag=args.tag,
contentType=args.content_type, sort=args.sort,
detailType=args.detail_type, search=args.search,
domain=args.domain, since=args.since,
count=args.count, offset=args.offset
)
if args.header_output is not None:
header_file = args.header_output
if os.path.splitext(header_file)[1] == '':
header_file = header_file + "." + args.header_format
with open(args.header_file, 'w+') as fp:
if args.header_format == "yaml":
fp.write(yaml.dump(headers))
elif args.header_format == "json":
fp.write(json.dumps([headers]))
else:
raise ArgumentError
headers_dict = {}
for key in headers:
headers_dict[key] = headers[key]
response["headers"] = headers_dict
args_dict = {}
for arg in vars(args):
if type(getattr(args, arg)) in [str, int]:
args_dict[arg] = getattr(args, arg)
response["args"] = args_dict
if args.response_format == "yaml":
response_output = yaml.dump(response)
elif args.response_format == "json":
response_output = json.dumps([response])
else:
raise ArgumentError
if args.response_output is None:
print(response_output)
else:
response_file = args.response_output
if os.path.splitext(response_file)[1] == '':
response_file = response_file + "." + args.response_format
with open(response_file, 'w+') as fp:
fp.write(response_output)
def articles(self):
at = getSessionItemOrEmpty('access_token')
pocket_instance = pocket.Pocket(_app_cfg['consumer_key'], at)
articles_data = pocket_instance.get(
state='unread', detail=True)[0]['list']
username = getSessionItemOrEmpty('username')
time, words, count = processStatistics(articles_data)
storeStatsToInfluxDB(username, time, words, count)
return articles_data
def counters(self, *args):
at = getSessionItemOrEmpty('access_token')
pocket_instance = pocket.Pocket(rar_config['consumer_key'], at)
articles = pocket_instance.get(
state='unread', detailType='complete')[0]['list'].items()
count = len(articles)
total_ttr = 0
for k, v in articles:
ttr = v.get('time_to_read')
if not ttr is None:
total_ttr += ttr
return '{"ok":true,"count":%d,"ttr":%d}' % (count, total_ttr)
def check(self, *args):
at = getSessionItemOrEmpty('access_token')
if at == '':
return '{"ok":false}'
try:
pocket_instance = pocket.Pocket(rar_config['consumer_key'], at)
articles = dict()
resp = pocket_instance.get(tag='TagThatDoesNotExist')
return '{"ok":true,"confirmation":' + str(len(
resp[0]['list'])) + '}'
except:
return '{"ok":false}'
def post_readLink():
uid = request.headers.get('Authorization')
content = request.get_json()
item_id = content["item_id"]
# archive the link!
access_token = accounts.get_secret(uid)
print "a t"
print access_token
pocket_instance = pocket.Pocket(CONSUMER_KEY, access_token)
pocket_instance.archive(item_id, wait=False)
return "OK"
def verify(self):
status = {'authenticated': False}
at = getSessionItemOrEmpty('access_token')
if at != '':
try:
pocket_instance = pocket.Pocket(_app_cfg['consumer_key'], at)
resp = pocket_instance.get(state='unread', count=1)
except pocket.AuthException:
status = {'authenticated': False}
else:
status = {'authenticated': True}
return status
def part_two(args, input_lines):
"Process part two of the puzzle"
# 1. Create the puzzle solver
solver = pocket.Pocket(part2=True, text=input_lines)
# 2. Determine the solution for part two
solution = solver.part_two(verbose=args.verbose, limit=args.limit)
if solution is None:
print("There is no solution")
else:
print("The solution for part two is %s" % (solution))
# 3. Return result
return solution is not None
def send_read_link(username, uid, api_token):
# api call
print "sending read link!"
access_token = accounts.get_secret(uid)
pocket_instance = pocket.Pocket(CONSUMER_KEY, access_token)
response = pocket_instance.get()[0]
unread = response['list'].keys()
random_pick = unread[random.randrange(len(unread))]
url = response['list'][random_pick]['given_url']
r = {}
r['item_id'] = random_pick
r['aid'] = uid
r['url'] = url
kek = urllib.urlencode(r)
send_link_yo(username, API_TOKEN, CLIENT_URL + "/reader?" + kek)
def test_empty_init(self):
"Test the default Pocket creation"
# 1. Create default Pocket object
myobj = pocket.Pocket()
# 2. Make sure it has the default values
self.assertEqual(myobj.part2, False)
self.assertEqual(myobj.text, None)
self.assertEqual(myobj.cycle, 0)
self.assertEqual(myobj.active, set())
# 3. Check methods
self.assertEqual(myobj.count(), 0)
self.assertEqual(len([_ for _ in myobj.nearby((0, 0, 0))]), 26)
self.assertEqual(myobj.count_nearby((0, 0, 0)), 0)
def test_pocket_init(self):
pocket_instance = pocket.Pocket(
self.consumer_key,
self.access_token,
self.username,
)
self.assertEqual(self.consumer_key, pocket_instance.consumer_key)
self.assertEqual(self.access_token, pocket_instance.access_token)
self.assertEqual(self.username, pocket_instance.username)
expected_payload = {
'consumer_key': self.consumer_key,
'access_token': self.access_token,
}
self.assertEqual(expected_payload, pocket_instance._payload)
def from_pocket(consumer_key: str, access_token: str) -> Set[Recipe]:
# http://getpocket.com/developer/docs/v3/retrieve
client = pocket.Pocket(consumer_key, access_token)
resp = client.get(state="all", tag="recipe", detailType="simple")
items = resp[0]["list"]
keys = list(items.keys())
recipes: Set[Recipe] = set()
while len(recipes) < 10:
item = items[random.choice(keys)]
if not item["resolved_title"]:
continue
recipes.add(
Recipe(
url=item["resolved_url"],
title=item["resolved_title"],
img=item.get("top_image_url"),
))
return recipes
def main():
session = requests.Session()
session.post("https://lwn.net/Login/",
data={
"Username": os.getenv("LWNNET_USERNAME"),
"Password": os.getenv("LWNNET_PASSWORD")
}).cookies
bigpage = session.get("https://lwn.net/current/bigpage")
access_token = os.getenv("POCKET_ACCESS_TOKEN")
p = pocket.Pocket(POCKET_CONSUMER_KEY, access_token)
already_in_pocket = p.get(domain="lwn.net",
detailType="simple",
state="all")
articles_already_pushed = set()
if already_in_pocket[0]['list']:
for entry_id, entry in already_in_pocket[0]['list'].items():
m = RE_SUBSCRIBER_LINK.match(entry['given_url'])
if m:
articles_already_pushed.add(m.group(1))
for line in bigpage.text.split("\n"):
m = RE_SUBSCRIBER_LINK_FORM.search(line)
if m:
articleid = m.group(1)
if articleid in articles_already_pushed:
continue
link = session.post("https://lwn.net/SubscriberLink/MakeLink",
data={"articleid": articleid})
RE_SUBLINK = re.compile(
"<a href=\"(https://lwn.net/SubscriberLink/%s/.+)\">" %
articleid)
for line in link.text.split("\n"):
m = RE_SUBLINK.search(line)
if m:
p.add(m.group(1))
break
def save_data(self, token, trigger_id, **data):
"""
let's save the data
:param trigger_id: trigger ID from which to save data
:param **data: the data to check to be used and save
:type trigger_id: int
:type **data: dict
:return: the status of the save statement
:rtype: boolean
"""
from th_pocket.models import Pocket as PocketModel
pocket_instance = ''
status = False
if token and 'link' in data and data['link'] is not None and len(data['link']) > 0:
# get the pocket data of this trigger
trigger = PocketModel.objects.get(trigger_id=trigger_id)
pocket_instance = pocket.Pocket(
settings.TH_POCKET['consumer_key'], token)
title = ''
title = (data['title'] if 'title' in data else '')
try:
pocket_instance.add(
url=data['link'], title=title, tags=(trigger.tag.lower()))
sentence = str('pocket {} created').format(data['link'])
logger.debug(sentence)
status = True
except Exception as e:
logger.critical(e)
status = False
else:
logger.critical("no token provided for trigger ID %s ", trigger_id)
return status
def main():
try:
# Retrieve the current Pocket library.
p = pocket.Pocket(consumer_key, access_token)
response = p.get()
# Randomly select an article.
library = getLibrary(response)
article = random.choice(list(library.values()))
# Retrieve the article's:
resolved_title = article["resolved_title"]
resolved_url = article["resolved_url"]
# String to send:
body_message = "\n \"{}\" \n {}".format(resolved_title, resolved_url)
except pocket.PocketException as error:
# (i.e. if the access_token is old, catch the
# error and text me the error that was sent.)
print error
body_message = error
print body_message
# Uncomment when you actually want to use the API --- note that it will
# draw from your Twilio balance.
account_sid = '{}'.format(os.environ['TWILIO_ACCOUNT_SID'])
auth_token = '{}'.format(os.environ['TWILIO_AUTH_TOKEN'])
client = Client(account_sid, auth_token)
message = client.messages \
.create(
body=body_message,
from_=os.environ['TWILIO_NUMBER'],
to=os.environ['PERSONAL_NUM']
)
i.write(p)
i.seek(0)
return i
last = '1970-01-01'
db = dbm.open('%s/.simple-kindle-sender-database' % os.environ['HOME'], 'c')
cookies = get_w3m_cookies()
if 'last' in db:
# Saved timestamp.
last = db['last']
p = pocket.Pocket(consumer_key=consumerkey, access_token=token)
current = p.get(since=last)
l = current[0]['list']
i = 0
for q in l:
i = i + 1
if (not q in db):
obj = l[q]
if 'resolved_url' not in obj:
continue
#!/usr/bin/env python
# Removes Pocket entries that don't actually contain a URL.
import pocket
import re
import secrets
import sys
import urllib2
for login, serviceData in secrets.access_keys.items():
if 'pocket' in serviceData:
p = pocket.Pocket(secrets.app_keys['pocket']['consumer_key'],
serviceData['pocket']['access_token'])
to_delete = []
offset = 0
favs = p.get(sort='newest', favorite=0, offset=0, count=100)
while len(favs[0]['list']) > 0:
for k in favs[0]['list'].keys():
fav = favs[0]['list'][k]
if u'resolved_title' in fav and fav[
u'resolved_title'] == u'Missing Link':
#print "deleting " + str(fav)
to_delete.append(fav['item_id'])
offset = offset + 1000
favs = p.get(sort='newest', favorite=0, offset=offset, count=10)
for iid in to_delete:
p.delete(iid)
tumblr = pytumblr.TumblrRestClient(
secrets.app_keys['tumblr']['consumer_key'],
secrets.app_keys['tumblr']['consumer_secret'],
secrets.access_keys['jonathankoren']['tumblr']['access_token'],
secrets.access_keys['jonathankoren']['tumblr']['access_secret'])
tapi = twitter.Api(
consumer_key=secrets.app_keys['twitter']['consumer_key'],
consumer_secret=secrets.app_keys['twitter']['consumer_secret'],
access_token_key=secrets.access_keys['jonathankoren']['twitter']
['access_token'],
access_token_secret=secrets.access_keys['jonathankoren']['twitter']
['access_secret'])
p = pocket.Pocket(
secrets.app_keys['pocket']['consumer_key'],
secrets.access_keys['jonathankoren']['pocket']['access_token'])
favs = p.get(sort='newest', offset=0, count=1000)
for k in favs[0]['list'].keys():
fav = favs[0]['list'][k]
if ('resolved_url' in fav) and ('twitter.com/' in fav['resolved_url']):
toks = fav['resolved_url'].split('/')
for i in xrange(len(toks)):
if toks[i] == 'status':
try:
tweet = tapi.GetStatus(toks[i + 1])
if tweet.media is not None:
for m in tweet.media:
url = m.media_url_https + ':large'
print 'tumblr ' + str(
