def read(self, args, c):
self.ore, c = utils.get_int(args, c)
self.gas, c = utils.get_int(args, c)
self.used_psi, c = utils.get_int(args, c)
self.total_psi, c = utils.get_int(args, c)
return c
def get(self, page_current=1):
db = self.db
d = load_info(db).copy()
page_size = utils.get_int(d.get('posts_pagesize', ''), 10)
page_current = utils.get_int(page_current, 1)
start_index = page_size * (page_current-1)
posts_count = d['posts_available']
page_count = utils.get_pagecount(posts_count, page_size)
if posts_count < 1:
self.finish("<p>No any posts</p>")
return
elif page_current > page_count or page_current < 1:
pass
else:
if posts_count > 0:
post_ids = db.query(Post.id).\
filter(Post.ispass == True).\
order_by(
Post.pubdate.desc()
)[start_index:start_index+page_size]
ids = (x[0] for x in post_ids)
d['posts'] = db.query(Post).\
filter(Post.id.in_(ids)).\
order_by(Post.pubdate.desc()).\
all()
d['page_count'] = page_count
d['page_current'] = page_current
return self.render('index.html', **d)
self.notfound()
def generate_payload(generator=None, verify_name=True, verify_size=True):
Filtering.information() # print filters xbmcaddon.Addon()
results = []
cont = 0
for name, info_hash, magnet, size, seeds, peers in generator:
size = clean_size(size)
magnet = clean_magnet(magnet, info_hash)
v_name = name if verify_name else Filtering.title
v_size = size if verify_size else None
logger.log.debug(
"name: %s \n info_hash: %s\n magnet: %s\n size: %s\n seeds: %s\n peers: %s"
% (name, info_hash, magnet, size, seeds, peers))
if Filtering.verify(v_name, v_size):
cont += 1
if Settings["read_magnet_link"] == "true":
magnet = get_links(magnet) # magnet
results.append({
"name": name,
"uri": magnet,
"info_hash": info_hash,
"size": size,
"seeds": get_int(seeds),
"peers": get_int(peers),
"language": Settings["language"],
"provider": Settings.name,
"icon": Settings.icon,
}) # return the torrent
if cont >= Settings["max_magnets"]: # limit magnets
break
else:
logger.log.debug(Filtering.reason)
logger.log.debug('>>>>>>' + str(cont) +
' torrents sent to Magnetic<<<<<<<')
return results
def load(self, identifier):
filename = file_utils.make_legal_filename(identifier, suffix='.json')
target = os.path.join(SAVE_PATH, filename)
try:
with open(target, mode='r') as target_file:
hashes = json.load(target_file)
except (IOError, OSError, TypeError, ValueError):
self.log('Could not load stored hashes from {0}'.format(target))
return False
if not hashes:
return False
self.version = hashes.get('version', self.version)
self.hash_size = hashes.get('hash_size', self.hash_size)
if 'data' in hashes:
hash_size = self.hash_size[0] * self.hash_size[1]
self.data = {
tuple([utils.get_int(i) for i in key[1:-1].split(', ')]): # pylint: disable=consider-using-generator
self.int_to_hash(hashes['data'][key], hash_size)
for key in hashes['data']
}
if 'timestamps' in hashes:
self.timestamps = {
utils.get_int(episode): hashes['timestamps'][episode]
for episode in hashes['timestamps']
}
self.log('Hashes loaded from {0}'.format(target))
return True
def do(self, db, d, post, page_current=1):
'''do'''
if post:
d['post'] = post
comment_pagesize = utils.get_int(
d.get('comments_pagesize', ''), 10)
page_current = utils.get_int(page_current, 1)
start_index = comment_pagesize * (page_current-1)
commentpass = post.commentpass
comments = None
if commentpass > 0:
comments = db.query(Comment).\
filter(Comment.post_id == post.id).\
filter(Comment.ispass==True).\
order_by(
Comment.id.desc()
)[start_index:start_index + comment_pagesize]
if comments:
page_count = utils.get_pagecount(commentpass,
comment_pagesize)
d['post_comments'] = comments
d['page_current'] = page_current
d['page_count'] = page_count
d['page_comment_count'] = commentpass
return self.render('details.html', **d)
self.notfound()
def get_edge_time(cur, outliers, alg='gcn', layer=2):
"""
获取edge-cal细分下的各算子的用时
:param cur: sqlite的cursor对象
:param alg: 算法
:return: ['collect', 'message', 'aggregate', 'update']对应的用时
"""
labels = ['collect', 'message', 'aggregate', 'update']
edge_times = []
for label in labels:
step = layer * 3 if alg == 'gaan' else layer
sql = "select start, end, text from nvtx_events where text == '{}'".format(
label)
res = cur.execute(sql).fetchall()[step:] # 过滤掉warm-up中forward阶段的结果
cost_time = 0
for i in range(50):
if i in outliers: continue
# epoch_time = forward time + backward time + eval time
# 1. 获取forward time和eval time
for j in range(step * 2):
time = get_real_time(res[step * 2 * i + j], cur)[0]
cost_time += time
# 2. 基于forward的标签对应的seq获取backward time
for j in range(step):
# 思路：首先得到label的时间段[st, ed]; 然后寻找该时间段中所有的seq, 然后找对应的backward中的seq
# 2.1 寻找该时间段中所有的seq
seq_sql = "select text from nvtx_events where start >= {} and end <= {} and text like '%seq%'"
seq_res = cur.execute(
seq_sql.format(res[step * 2 * i + j][0],
res[step * 2 * i + j][1])).fetchall()
if not seq_res: # ggnn, flickr; edge-cal, message=0
continue
# 2.2 获取seq的最值，seq为连续分布
min_seq, max_seq = get_int(seq_res[0][0]), get_int(
seq_res[-1][0])
seq_backward_sql = "select start, end, text from nvtx_events where text like '%Backward%seq = {0}' or text like '%ScatterMax%seq = {0}'"
end_time = cur.execute(
seq_backward_sql.format(min_seq)).fetchone()
# 2.3 为了将空格时间考虑进去，这里在左边时间进行延伸
start_time = cur.execute(
seq_backward_sql.format(max_seq + 1)).fetchone()
if start_time:
backward_time = get_real_time(
(start_time[1], end_time[1], label), cur)[0]
else:
start_time = cur.execute(
seq_backward_sql.format(max_seq)).fetchone()
backward_time = get_real_time(
(start_time[0], end_time[1], label), cur)[0]
cost_time += backward_time
cost_time /= 50 - len(outliers) # 基于epochs的平均
# print(label, cost_time)
edge_times.append(cost_time)
return edge_times
def main():
print("Enter x:", end=" ")
x = get_int()
print("Enter y:", end=" ")
y = get_int()
result = pow_(x, y)
print(f"{x} ^ {y} = {result}")
def cleanup_results(results_list):
""" Remove duplicate results, hash results without an info_hash, and sort by seeders
Args:
results_list (list): Results to clean-up
Returns:
list: De-duplicated, hashed and sorted results
"""
if len(results_list) == 0:
return []
hashes = []
filtered_list = []
allow_noseeds = get_setting('allow_noseeds', bool)
for result in results_list:
if not result['seeds'] and not allow_noseeds:
continue
provider_name = result['provider'][result['provider'].find(']')+1:result['provider'].find('[/')]
if not result['uri']:
if not result['name']:
continue
try:
log.warning('[%s] No URI for %s' % (provider_name, repr(result['name'])))
except Exception as e:
import traceback
log.warning("%s logging failed with: %s" % (provider_name, repr(e)))
map(log.debug, traceback.format_exc().split("\n"))
continue
hash_ = result['info_hash'].upper()
if not hash_:
if result['uri'] and result['uri'].startswith('magnet'):
hash_ = Magnet(result['uri']).info_hash.upper()
else:
hash_ = hashlib.md5(result['uri']).hexdigest()
try:
log.debug("[%s] Hash for %s: %s" % (provider_name, repr(result['name']), hash_))
except Exception as e:
import traceback
log.warning("%s logging failed with: %s" % (result['provider'], repr(e)))
map(log.debug, traceback.format_exc().split("\n"))
if not any(existing == hash_ for existing in hashes):
filtered_list.append(result)
hashes.append(hash_)
if (get_setting("sort_by_resolution", bool)):
log.debug("[EXPEREMENTAL] Start last sorting list by resolution of all result before send to Elementum")
filtered_list = sorted(filtered_list, key=lambda r: (get_int(r.pop('resolution'))), reverse=True)
else:
filtered_list = sorted(filtered_list, key=lambda r: (get_int(r['seeds'])), reverse=True)
return filtered_list
def get_calculations_time(cur, outliers, alg, layer=2):
labels = all_labels[alg]
vertex_time, edge_time = 0, 0
for label in labels:
sql = "select start, end, text from nvtx_events where text == '{}'".format(
label)
res = cur.execute(sql).fetchall()[layer:] # 不考虑warm up
cost_time = 0
for i in range(50):
if i in outliers: continue
# epoch_time = forward time + backward time + eval time
# 1. 获取forward time和eval time
for j in range(2 * layer):
time = get_real_time(res[2 * layer * i + j], cur)[0]
cost_time += time
# 2. 基于forward的标签对应的seq获取backward time
for j in range(layer):
# 思路：首先得到label的时间段[st, ed]; 然后寻找该时间段中所有的seq, 然后找对应的backward中的seq
# 2.1 寻找该时间段中所有的seq
seq_sql = "select text from nvtx_events where start >= {} and end <= {} and text like '%seq%'"
seq_res = cur.execute(
seq_sql.format(res[2 * layer * i + j][0],
res[2 * layer * i + j][1])).fetchall()
min_seq, max_seq = get_int(seq_res[0][0]), get_int(
seq_res[-1][0])
seq_backward_sql = "select start, end, text from nvtx_events where text like '%Backward%seq = {0}' or text like '%ScatterMax%seq = {0}'"
end_time = cur.execute(
seq_backward_sql.format(min_seq)).fetchone()
start_time = cur.execute(
seq_backward_sql.format(max_seq + 1)).fetchone()
if start_time:
backward_time = get_real_time(
(start_time[1], end_time[1], label), cur)[0]
else:
start_time = cur.execute(
seq_backward_sql.format(max_seq)).fetchone()
backward_time = get_real_time(
(start_time[0], end_time[1], label), cur)[0]
cost_time += backward_time
cost_time /= 50 - len(outliers) # 平均epochs
if 'vertex' in label:
vertex_time += cost_time
else:
edge_time += cost_time
return [vertex_time, edge_time]
def __getitem__(mcs, item):
# default values
if item is "max_magnets":
return get_int(mcs.value.get(item, "10"))
elif item is "separator":
return mcs.value.get(item, "%20")
elif item is "time_noti":
return get_int(mcs.value.get(item, "750"))
elif item.endswith("accept"):
temp = mcs.value.get(item, "{*}")
return "{*}" if temp is "" else temp
elif item.endswith("max_size"):
return get_float(mcs.value.get(item, "10"))
elif item.endswith("min_size"):
return get_float(mcs.value.get(item, "0"))
else:
return mcs.value.get(item, "")
def get_positive_int():
"""Get positive integer
Returns:
int: positive integer
"""
n = 0
while n < 1:
print("Enter positive integer: ", end="")
n = get_int()
return n
def _init_hashes(self):
# Limit captured data to 16 kB
self.capture_size, self.capture_ar = self._capture_resolution(
max_size=16)
self.hash_index = {
# Current hash index
'current': (0, 0),
# Previous hash index
'previous': None,
# Representative end credits hash index
'credits': (0, 0),
# Other episodes hash index
'episodes': None,
# Detected end credits timestamp from end of file
'detected_at': None
}
# Hash size as (width, height)
hash_size = [8 * self.capture_ar, 8]
# Round down width to multiple of 2
hash_size[0] = int(hash_size[0] - hash_size[0] % 2)
# Hashes for currently playing episode
self.hashes = UpNextHashStore(
version='0.1',
hash_size=hash_size,
seasonid=self.state.get_season_identifier(),
episode=utils.get_int(self.state.get_episode()),
# Representative hash of centred end credits text on a dark
# background stored as first hash
data={
self.hash_index['credits']:
self._generate_initial_hash(hash_size)
},
timestamps={})
# Calculated maximum allowable significant level
# self.significance_level = 0.90 * self.calc_significance(
# self.hashes.data[self.hash_index['credits']]
# )
self.significance_level = 25
# Hashes from previously played episodes
self.past_hashes = UpNextHashStore(hash_size=hash_size)
if self.hashes.is_valid():
self.past_hashes.load(self.hashes.seasonid)
# Number of consecutive frame matches required for a positive detection
self.match_number = 5
# Number of consecutive frame mismatches required to reset match count
# Set to 3 to account for bad frame capture
self.mismatch_number = 3
self._hash_match_reset()
def __reduct_power(self, _power_of, _first):
space = '' if _first == 0 else ' '
signe = '' if _first == 0 else '+ '
regex_power = r"(((\s+)?(\+|\-)(\s+)?)?((\d+\.)?\d+)((\s+)?\*(\s+)?)[X|x]\^{power}\b)".format(
power=_power_of)
core_power = re.search(regex_power, self.core_equation)
egal_power = re.search(regex_power, self.start_egal)
if core_power:
core_power = core_power.group()
self.core_equation = self.core_equation[len(core_power)::]
core_power_int = get_int(core_power)
self.__save_int_by_p(core_power_int, _power_of)
if egal_power:
egal_power = egal_power.group()
egal_power_int = get_int(egal_power)
reduct_int = core_power_int - egal_power_int
self.start_egal = re.sub(regex_power.format(power=_power_of),
"", self.start_egal, 1)
self.__save_int_by_p(reduct_int, _power_of)
if reduct_int < 0:
reduct_int = ft_abs(reduct_int)
signe = '- '
elif reduct_int == 0:
return
return f"{space}{signe}{reduct_int} * X^{_power_of}"
if _first == 0:
if core_power_int >= 0:
core_power = re.sub(r"(\s)?\+(\s)?", "", core_power)
else:
core_power = re.sub(r"(\s)?", "", core_power, count=1)
return core_power
elif not core_power and egal_power:
egal_power = egal_power.group()
egal_power_int = get_int(egal_power)
egal_power_int *= -1
self.__save_int_by_p(egal_power_int, _power_of)
if egal_power_int < 0:
egal_power_int = ft_abs(egal_power_int)
signe = '- '
return f"{space}{signe}{egal_power_int} * X^{_power_of}"
def generate_payload(provider, generator, filtering, verify_name=True, verify_size=True):
""" Payload formatter to format results the way Quasar expects them
Args:
provider (str): Provider ID
generator (function): Generator method, can be either ``extract_torrents`` or ``extract_from_api``
filtering (Filtering): Filtering class instance
verify_name (bool): Whether to double-check the results' names match the query or not
verify_size (bool): Whether to check the results' file sizes
Returns:
list: Formatted results
"""
filtering.information(provider)
results = []
definition = definitions[provider]
for name, info_hash, uri, size, seeds, peers in generator:
size = clean_size(size)
# uri, info_hash = clean_magnet(uri, info_hash)
v_name = name if verify_name else filtering.title
v_size = size if verify_size else None
if filtering.verify(provider, v_name, v_size):
results.append({"name": name,
"uri": uri,
"info_hash": info_hash,
"size": size,
"seeds": get_int(seeds),
"peers": get_int(peers),
"language": definition["language"] if 'language' in definition else 'en',
"provider": '[COLOR %s]%s[/COLOR]' % (definition['color'], definition['name']),
"icon": os.path.join(ADDON_PATH, 'burst', 'providers', 'icons', '%s.png' % provider),
})
else:
log.debug(filtering.reason.encode('utf-8'))
log.debug('>>>>>> %s would send %d torrents to Quasar <<<<<<<' % (provider, len(results)))
return results
def get(self, tag_name, page_current=1):
db = self.db
d = load_info(db).copy()
tag = db.query(Tag).\
filter(Tag.tag==tag_name).\
scalar()
if not tag:
self.notfound()
d['tag_item'] = tag
tag_posts_count = tag.nums
if tag_posts_count is None:
tag_posts_count = 0
tag_page_size = utils.get_int(d.get('posts_pagesize', ''), 10)
tag_page_current = utils.get_int(page_current, 1)
start_index = tag_page_size * (tag_page_current-1)
tag_page_count = utils.get_pagecount(tag_posts_count, tag_page_size)
if tag_page_current > tag_page_count or tag_page_current < 1:
pass
else:
if tag_posts_count > 0:
post_ids = db.query(post_tag.c.post_id).\
filter(post_tag.c.tag_id==tag.id).\
filter(Post.ispass==True).\
filter(Post.id==post_tag.c.post_id).\
order_by(
Post.pubdate.desc()
)[start_index:start_index+tag_page_size]
ids = [x[0] for x in post_ids]
d['post_list'] = db.query(Post).\
filter(Post.id.in_(ids)).\
order_by(Post.pubdate.desc()).\
all()
d['post_page_count'] = tag_page_count
d['post_page_current'] = tag_page_current
d['mode_type'] = 'tag'
return self.render('list.html', **d)
self.notfound()
def get(self, year, month, page_current=1):
db = self.db
d = load_info(db).copy()
year = utils.get_int(year)
month = utils.get_int(month)
first_day = None
if 13 > month > 0:
first_day = datetime.datetime(year, month, 1)
if first_day in d['archives_count']:
archive_posts_count = d['archives_count'][first_day]
if archive_posts_count is None:
archive_posts_count = 0
archive_page_size = utils.get_int(d.get('posts_pagesize', ''), 10)
page_current = utils.get_int(page_current, 1)
start_index = archive_page_size * (page_current-1)
archive_page_count = utils.get_pagecount(archive_posts_count,
archive_page_size)
if page_current > archive_page_count or page_current < 1:
pass
elif archive_posts_count > 0:
post_ids = db.query(Post.id).\
filter(Post.ispass==True).\
filter(Post.pubyear==year).\
filter(Post.pubmonth==month).\
order_by(
Post.id.desc()
)[start_index:start_index+archive_page_size]
ids = (x[0] for x in post_ids)
d['post_list'] = db.query(Post).\
filter(Post.id.in_(ids)).\
all()
d['post_page_count'] = archive_page_count
d['post_page_current'] = page_current
d['mode_type'] = 'archive'
d['first_day'] = first_day
return self.render('list.html', **d)
self.notfound()
def get(self):
self.set_header('Content-Type','text/xml')
db = self.db
d = load_info(db).copy()
site_url = d['site_url']
rss_size = utils.get_int(d.get('rss_size', ''), 10)
items = []
last_update = None
if rss_size > 0:
postIds = db.query(Post.id).\
filter(Post.ispass == True).\
order_by(
Post.id.desc()
)[0:rss_size]
postIds = (x[0] for x in postIds)
posts = db.query(Post).\
filter(Post.id.in_(postIds)).\
all()
for post in posts:
items.append({
'title':post.title,
'link': utils.urlwrite(site_url, post.url),
'pubDate': post.\
pubdate.strftime('%a, %d %b %Y %H:%M:%S GMT'),
'dc:creator': post.user.nickname,
'guid':{
'_text': utils.urlwrite(site_url, post.url),
'__isPermaLink': 'true'
},
'content:encoded': post.content
})
if posts and len(posts) > 0:
last_update = posts[0].\
pubdate.strftime('%a, %d %b %Y %H:%M:%S GMT')
xmldict = {'rss': {
'__version':'2.0',
'__xmlns:content': 'http://purl.org/rss/1.0/modules/content/',
'__xmlns:wfw': 'http://wellformedweb.org/CommentAPI/',
'__xmlns:dc': 'http://purl.org/dc/elements/1.1/',
'channel': {
'title': d['site_name'],
'link': d['site_url'],
'description': d['site_description'],
'pubDate': last_update,
'language': 'zh-CN',
'item': items# end item
}# end channel
}}
return self.finish(utils.dict_to_xml(xmldict))
def cleanup_results(results_list):
""" Remove duplicate results, hash results without an info_hash, and sort by seeders
Args:
results_list (list): Results to clean-up
Returns:
list: De-duplicated, hashed and sorted results
"""
if len(results_list) == 0:
return []
hashes = []
filtered_list = []
for result in results_list:
if not result['seeds']:
continue
if not result['uri']:
if not result['name']:
continue
try:
log.warning('[%s] No URI for %s' % (result['provider'][16:-8], repr(result['name'])))
except Exception as e:
import traceback
log.warning("%s logging failed with: %s" % (result['provider'], repr(e)))
map(log.debug, traceback.format_exc().split("\n"))
continue
hash_ = result['info_hash'].upper()
if not hash_:
if result['uri'] and result['uri'].startswith('magnet'):
hash_ = Magnet(result['uri']).info_hash.upper()
else:
hash_ = hashlib.md5(result['uri']).hexdigest()
try:
log.debug("[%s] Hash for %s: %s" % (result['provider'][16:-8], repr(result['name']), hash_))
except Exception as e:
import traceback
log.warning("%s logging failed with: %s" % (result['provider'], repr(e)))
map(log.debug, traceback.format_exc().split("\n"))
if not any(existing == hash_ for existing in hashes):
filtered_list.append(result)
hashes.append(hash_)
return sorted(filtered_list, key=lambda r: (get_int(r['seeds'])), reverse=True)
def post(self):
db = self.db
site_name = self.get_argument("site_name", "")
site_url = self.get_argument("site_url", "")
site_keywords = self.get_argument("site_keywords", "")
site_description = self.get_argument("site_description", "")
posts_pagesize = utils.get_int(
self.get_argument("posts_pagesize", ""), 10)
comments_pagesize = utils.get_int(
self.get_argument("comments_pagesize", ""), 10)
rss_size = utils.get_int(self.get_argument("rss_size", ""), 10)
domains.update_option(db, "site_name", site_name)
domains.update_option(db, "site_url", site_url)
domains.update_option(db, "site_keywords", site_keywords)
domains.update_option(db, "site_description", site_description)
domains.update_option(db, "posts_pagesize", posts_pagesize)
domains.update_option(db, "comments_pagesize", comments_pagesize)
domains.update_option(db, "rss_size", rss_size)
db.commit()
self.set_flash({'error': False, 'msg': u"更新成功"})
self.redirect(u"/admin/settings")
def load_info(db):
d = {}
#配置表
options = db.query(Option).all()
for x in options:
d[x.name] = x.value
posts_available = get_int(d.get('posts_available',''), -1)
posts_total = get_int(d.get('posts_total',''), -1)
if posts_available == -1:
posts_available = db.query(func.count(Post.id)).\
filter(Post.ispass == True).\
scalar()
if posts_total== -1:
posts_total= db.query(func.count(Post.id)).\
scalar()
d['posts_available'] = posts_available
d['posts_total'] = posts_total
# archive
archives_count = get_archives_count(db)
d['archives_count'] = archives_count
return d
def delete(args, timesheet):
if args['<date>']:
day = datetime.timetuple(parse(args['<date>']))
date_response = timesheet.get_day(day[7], day[0])
data = [date_response['day_entries']]
for sublist in data:
for k, entry in enumerate(sublist):
print str.format(
STATUS_TASK_FORMAT,
task = entry['task'],
client = entry['client'],
note = entry['notes'],
hours = entry['hours'],
date = entry['spent_at'],
indicator = k+1
)
if args['-a'] or args['--all']:
if raw_input("Confirm: Delete all entries for this date? ").lower() in 'yes':
for sublist in data:
for entry in sublist:
timesheet.delete(entry['id'])
else:
selection = get_int('Delete which entry? ') - 1
print str.format(
STATUS_TASK_FORMAT,
task = data[0][selection]['task'],
client = data[0][selection]['client'],
note = data[0][selection]['notes'],
hours = data[0][selection]['hours'],
date = data[0][selection]['spent_at'],
indicator = '-'
)
if raw_input("Confirm: Delete this entry? ").lower() in 'yes':
try:
timesheet.delete(data[0][selection]['id'])
except:
print 'Entry deleted.'
else:
print 'Deletion aborted.'
def get(self, page_current=1):
db = self.db
d = {}
d['user_name'] = self.get_current_user()
d['flash'] = self.get_flash()
page_size = 10
page_current = utils.get_int(page_current, 1)
start_index = page_size * (page_current-1)
total_count = db.query(func.count(Post.id)).\
scalar()
page_count = utils.get_pagecount(total_count, page_size)
items = db.query(Post).\
order_by(Post.id.desc())[start_index:start_index+page_size]
start_last = start_index + len(items)
d['start_index'] = start_index
d['start_last'] = start_last
d['total_count'] = total_count
d['page_count'] = page_count
d['page_current'] = page_current
d['posts'] = items
self.render('posts.html', **d)
def start(self, restart=False, reset=False):
"""Method to run actual detection test loop in a separate thread"""
if restart or self.running:
self.stop()
if reset:
self._hash_match_reset()
# Reset detector data if episode has changed
if not self.hashes.is_valid(self.state.get_season_identifier(),
utils.get_int(self.state.get_episode())):
self._init_hashes()
# If a previously detected timestamp exists then use it
stored_timestamp = self.past_hashes.timestamps.get(self.hashes.episode)
if stored_timestamp and not reset:
self.log('Stored credits timestamp found')
self.state.set_popup_time(detected_time=stored_timestamp)
# Otherwise run the detector in a new thread
else:
self.thread = utils.run_threaded(self._run)
def get(self, page_current=1):
db = self.db
d = {}
d['user_name'] = self.get_current_user()
d['flash'] = self.get_flash()
tag_page_size = 10
tag_page_current = utils.get_int(page_current, 1)
start_index = tag_page_size * (tag_page_current-1)
tag_count = db.query(func.count(Tag.id)).\
scalar()
tag_page_count = utils.get_pagecount(tag_count, tag_page_size)
tags = db.query(Tag).\
order_by(Tag.id.desc())[start_index:start_index+tag_page_size]
start_last = start_index + len(tags)
d['start_index'] = start_index
d['start_last'] = start_last
d['total_count'] = tag_count
d['page_count'] = tag_page_count
d['page_current'] = tag_page_current
d['tags'] = tags
self.render('tags.html', **d)
def get(self, page_current=1):
db = self.db
d = load_info(db).copy()
tag_page_size = 100
tag_page_current = utils.get_int(page_current, 1)
start_index = tag_page_size * (tag_page_current-1)
tag_count = db.query(func.count(Tag.id)).\
filter(Tag.nums>0).\
scalar()
tag_page_count = utils.get_pagecount(tag_count, tag_page_size)
tag_max_nums = 1
tag_maxs = db.query(Tag).\
order_by(Tag.nums.desc())[:1]
if tag_maxs and len(tag_maxs) == 1:
tag_max_nums = tag_maxs[0].nums
tags = db.query(Tag).\
filter(Tag.nums>0).\
order_by(Tag.id.desc())[start_index:start_index+tag_page_size]
d['tag_max_nums'] = tag_max_nums
d['tag_count'] = tag_count
d['tag_page_count'] = tag_page_count
d['tag_page_current'] = tag_page_current
d['tags'] = tags
return self.render('tags.html', **d)
def add(args, config, timesheet):
today = timesheet.today
if args['<alias>']:
try:
client_id = config.get(args['<alias>'], 'client')
client_name = config.get(args['<alias>'], 'clientname')
task_id = config.get(args['<alias>'], 'task')
task_name = config.get(args['<alias>'], 'taskname')
note = args['<note>']
hours = args['<hours>']
data = {"notes": args['<note>'], "project_id": client_id, "hours": args['<hours>'], "task_id": task_id}
except ConfigParser.NoSectionError:
print "No alias named " + args['<alias>'] + " found."
sys.exit()
if not args['<alias>']:
#Get the number of hours
if not args['<hours>']:
hours = get_int("How many hours to enter? ")
#User selects a client from the list
for key, value in enumerate(today['projects']):
print key + 1, value['name']
client_selection = get_int("Select a project: ")
client = today['projects'][client_selection-1]
client_name = client['name']
#User selects a task from the client task list
for key, task in enumerate(client['tasks']):
print key + 1, task['name']
task_selection = get_int("Select a task: ")
task = client['tasks'][task_selection-1]
task_name = task['name']
#User adds a note to the entry
if not args['<note>']:
note = raw_input("Leave a note (Skip with enter): ")
#Prompt the user to set an alias.
set_alias(client['name'], client['id'], task['name'], task['id'])
data = {"notes": note, "project_id":client['id'], "hours":hours, "task_id":task['id']}
if args['--date'] or args['-d']:
date = {'spent_at': parse(args['<date>'])}
data.update(date)
else:
date = datetime.today()
timesheet.add(data)
print "Your entry has been saved."
print str.format(
STATUS_TASK_FORMAT,
client = client_name,
task = task_name,
note = note,
hours = hours,
date = date,
indicator = '+'
)
#reprogram the previous assignment, but also prompt the user for the 'fill character'.
import utils
def grid2(n, fill):
for i in range(0, n):
print fill*n
n = utils.get_int("Enter an int ", "That's not int")
fill = raw_input("Enter any single character ")
grid2(n, fill)
def prompt():
a = utils.get_int("Enter a positive integer: ", "That's not int")
b = utils.get_int("Enter another positive integer: ", "That's not int")
print gcd(a, b)
# Prompt the user for two positive integers and print their greatest common # divisor (using Euclid's method). The GCD is the largest number which will # divide into both original numbers.
import utils
def prompt():
a = utils.get_int("Enter a positive integer: ", "That's not int")
b = utils.get_int("Enter another positive integer: ", "That's not int")
print gcd(a, b)
def gcd(i, j):
r = i % j
while r != 0:
i = j
j = r
r = i % j
return j
print gcd(utils.get_int("Enter a positive integer: ", "That's not int"), utils.get_int("Enter another positive integer: ", "That's not int"))
#works
import math
import utils
def find_e(nterm):
"""This finds the value of e to a specified number of terms."""
n = 0
x = 0
while n <= nterm:
a = float(1)/math.factorial(n)
x = x + a
n = n + 1
return x
print find_e(utils.get_int("How many terms to calculate? ", "Integer, please."))
#works
def get_meta(self):
info_labels = self.info_labels_init.copy()
if self.tmdb_api != '':
url = 'https://api.themoviedb.org/3/find/%s?external_source=imdb_id&api_key=%s' % (
self.imdb_id, self.tmdb_api)
Browser.open(url)
response = read_json(Browser.content)
if read_dict(response, 'movie_results', False) and self.type_video == 'MOVIE':
for item in response['movie_results']:
info_labels["tmdb_id"] = self.tmdb_id = read_dict(item, 'id')
info_labels["code"] = self.imdb_id
info_labels["type"] = "movie"
info_labels["fanart"] = self.base_url + read_dict(item, "backdrop_path")
info_labels['cover_url'] = self.base_url + read_dict(item, "poster_path")
info_labels["originaltitle"] = read_dict(item, "original_title")
info_labels["premiered"] = read_dict(item, "release_date")
info_labels["aired"] = read_dict(item, "release_date")
info_labels["year"] = read_dict(item, "release_date")[:4]
info_labels["title"] = read_dict(item, "title")
info_labels["sorttitle"] = read_dict(item, "title").replace(" ", "")
info_labels["plot"] = read_dict(item, "overview")
info_labels["votes"] = read_dict(item, "vote_count")
# Read Details
url = 'http://api.themoviedb.org/3/movie/%s?api_key=%s' % (self.tmdb_id, self.tmdb_api)
Browser.open(url)
details = read_json(Browser.content)
info_labels["status"] = read_dict(details, "status")
info_labels["duration"] = read_dict(details, "runtime", 0) * 60
info_labels["rating"] = read_dict(details, "popularity")
info_labels["tagline"] = read_dict(details, "tagline")
# Read genres
genres = read_dict(details, "genres", [])
for genre in genres:
info_labels["genre"] += genre["name"] + ", "
# Read studios
studios = read_dict(details, "production_companies", [])
for studio in studios:
info_labels["studio"] += studio["name"] + ", "
# Read cast
url = 'http://api.themoviedb.org/3/movie/%s/credits?api_key=%s' % (self.tmdb_id, self.tmdb_api)
Browser.open(url)
details = read_json(Browser.content)
cast_list = []
cast_and_role_list = []
for cast in read_dict(details, 'cast', []):
cast_list.append(cast["name"])
cast_and_role_list.append((cast["name"], cast["character"]))
info_labels["cast"] = cast_list
info_labels["castandrole"] = cast_and_role_list
# read crew
info_labels["director"] = ''
info_labels["credits"] = ''
for crew in read_dict(details, 'crew', []):
info_labels["credits"] += " %s - %s," % (crew["name"], crew["job"])
if crew["job"].lower() == "director":
info_labels["director"] = crew["name"]
if crew["job"].lower() == "writer":
info_labels["writer"] = crew["name"]
# read trailer
url = 'http://api.themoviedb.org/3/movie/%s/videos?api_key=%s' % (self.tmdb_id, self.tmdb_api)
Browser.open(url)
trailers = read_json(Browser.content)
for trailer in trailers.get("results", []):
info_labels["trailer"] = 'http://www.youtube.com/watch?v=%s' % trailer["key"]
break
# other information
info_labels["top250"] = 0
info_labels["tracknumber"] = 0
info_labels["playcount"] = 0
info_labels["overlay"] = 0
info_labels["mpaa"] = ''
info_labels["tvshowtitle"] = ''
info_labels["lastplayed"] = ''
info_labels["album"] = ''
info_labels["artist"] = ['']
info_labels["dateadded"] = ''
elif read_dict(response, 'tv_results', False):
for item in response['tv_results']:
info_labels["tmdb_id"] = self.tmdb_id = read_dict(item, 'id')
info_labels["code"] = self.imdb_id
info_labels["type"] = "series"
info_labels["fanart"] = self.base_url + read_dict(item, "backdrop_path")
info_labels['cover_url'] = self.base_url + read_dict(item, "poster_path")
info_labels["originaltitle"] = read_dict(item, "original_name")
info_labels["premiered"] = read_dict(item, "first_air_date")
info_labels["aired"] = read_dict(item, "first_air_date")
info_labels["year"] = read_dict(item, "first_air_date")[:4]
info_labels["title"] = read_dict(item, "name")
info_labels["sorttitle"] = read_dict(item, "name").replace(" ", "")
info_labels["plot"] = read_dict(item, "overview")
info_labels["votes"] = read_dict(item, "vote_count")
# Read Details
url = 'http://api.themoviedb.org/3/tv/%s?api_key=%s' % (self.tmdb_id, self.tmdb_api)
Browser.open(url)
details = read_json(Browser.content)
info_labels["status"] = read_dict(details, "status")
info_labels["duration"] = read_dict(details, "episode_run_time", [0])[0] * 60
info_labels["rating"] = read_dict(details, "popularity")
info_labels["tagline"] = ""
# Read genres
genres = read_dict(details, "genres", [])
for genre in genres:
info_labels["genre"] += genre["name"] + ", "
# Read studios
studios = read_dict(details, "production_companies", [])
for studio in studios:
info_labels["studio"] += studio["name"] + ", "
# Read cast
url = 'http://api.themoviedb.org/3/movie/%s/credits?api_key=%s' % (self.tmdb_id, self.tmdb_api)
Browser.open(url)
details = read_json(Browser.content)
cast_list = []
cast_and_role_list = []
for cast in read_dict(details, 'cast', []):
cast_list.append(cast["name"])
cast_and_role_list.append((cast["name"], cast["character"]))
info_labels["cast"] = cast_list
info_labels["castandrole"] = cast_and_role_list
# read crew
info_labels["director"] = ''
info_labels["credits"] = ''
for crew in read_dict(details, 'crew', []):
info_labels["credits"] += " %s - %s," % (crew["name"], crew["job"])
if crew["job"].lower() == "director":
info_labels["director"] = crew["name"]
if crew["job"].lower() == "writer":
info_labels["writer"] = crew["name"]
# read trailer
url = 'http://api.themoviedb.org/3/tv/%s/videos?api_key=%s' % (self.tmdb_id, self.tmdb_api)
Browser.open(url)
trailers = read_json(Browser.content)
for trailer in trailers.get("results", []):
info_labels["trailer"] = 'http://www.youtube.com/watch?v=%s' % trailer["key"]
break
# other information
info_labels["top250"] = 0
info_labels["tracknumber"] = 0
info_labels["playcount"] = 0
info_labels["overlay"] = 0
info_labels["mpaa"] = ''
info_labels["tvshowtitle"] = info_labels["title"]
info_labels["lastplayed"] = ''
info_labels["album"] = ''
info_labels["artist"] = ['']
info_labels["dateadded"] = ''
else:
# Search in http://www.omdbapi.com/
# Please visit the page and donate
url = 'http://www.omdbapi.com/?i=%s&plot=full&r=json' % self.imdb_id
Browser.open(url)
response = read_json(Browser.content)
info_labels["tmdb_id"] = ""
info_labels["code"] = read_dict(response, "imdbID")
info_labels["type"] = read_dict(response, "Type")
info_labels['fanart'] = read_dict(response, "Poster")
info_labels['cover_url'] = read_dict(response, "Poster")
info_labels["originaltitle"] = read_dict(response, "Title")
info_labels["premiered"] = read_dict(response, "Released")
info_labels["aired"] = read_dict(response, "Released")
info_labels["year"] = read_dict(response, "Year")
info_labels["title"] = read_dict(response, "Title")
if info_labels["type"] == "series":
info_labels["tvshowtitle"] = read_dict(response, "Title")
info_labels["sorttitle"] = read_dict(response, "Title").replace(" ", "")
info_labels["plot"] = read_dict(response, "Plot")
info_labels["votes"] = read_dict(response, "imdbVotes")
info_labels["status"] = "Released"
info_labels["duration"] = get_int(read_dict(response, "Runtime", "0")) * 60
info_labels["rating"] = read_dict(response, "imdbRating")
info_labels["tagline"] = read_dict(response, "Awards")
info_labels["genre"] = read_dict(response, "Genre")
info_labels["studios"] = ""
info_labels["cast"] = read_dict(response, "Actors")
info_labels["castandrole"] = ""
info_labels["director"] = read_dict(response, "Director")
info_labels["writer"] = read_dict(response, "Writer")
info_labels["credits"] = read_dict(response, "Writer")
info_labels["trailer"] = ""
# other information
info_labels["episode"] = 0
info_labels["season"] = 0
info_labels["top250"] = 0
info_labels["tracknumber"] = 0
info_labels["playcount"] = 0
info_labels["overlay"] = 0
info_labels["mpaa"] = read_dict(response, "Rated")
info_labels["tvshowtitle"] = ''
info_labels["lastplayed"] = ''
info_labels["album"] = ''
info_labels["artist"] = ['']
info_labels["dateadded"] = ''
# Common information
info_labels["episode"] = self.info_title.get("episode", 0)
info_labels["season"] = self.info_title.get("season", 0)
return info_labels
def main():
s = utils.get_int("Give us an int: ", "That's not int")
table(s)
def process_keywords(self, provider, text):
""" Processes the query payload from a provider's keyword definitions
Args:
provider (str): Provider ID
text (str): Keyword placeholders from definitions, ie. {title}
Returns:
str: Processed query keywords
"""
keywords = self.read_keywords(text)
for keyword in keywords:
keyword = keyword.lower()
if 'title' in keyword:
title = self.info["title"]
language = definitions[provider]['language']
use_language = None
if ':' in keyword:
use_language = keyword.split(':')[1]
if provider not in self.language_exceptions and \
(use_language or self.kodi_language) and \
'titles' in self.info and self.info['titles']:
try:
if self.kodi_language and self.kodi_language in self.info['titles']:
use_language = self.kodi_language
if use_language not in self.info['titles']:
use_language = language
if use_language in self.info['titles'] and self.info['titles'][use_language]:
title = self.info['titles'][use_language]
title = self.normalize_name(title)
log.info("[%s] Using translated '%s' title %s" % (provider, use_language,
repr(title)))
log.debug("[%s] Translated titles from Quasar: %s" % (provider,
repr(self.info['titles'])))
except Exception as e:
import traceback
log.error("%s failed with: %s" % (provider, repr(e)))
map(log.debug, traceback.format_exc().split("\n"))
text = text.replace('{%s}' % keyword, title)
if 'year' in keyword:
text = text.replace('{%s}' % keyword, str(self.info["year"]))
if 'season' in keyword:
if '+' in keyword:
keys = keyword.split('+')
if keys[1] == "t411season":
season = str(t411season(self.info['season']))
else:
season = str(self.info["season"] + get_int(keys[1]))
elif ':' in keyword:
keys = keyword.split(':')
season = ('%%.%sd' % keys[1]) % self.info["season"]
else:
season = '%s' % self.info["season"]
text = text.replace('{%s}' % keyword, season)
if 'episode' in keyword:
if '+' in keyword:
keys = keyword.split('+')
if keys[1] == "t411episode":
episode = str(t411episode(self.info['episode']))
else:
episode = str(self.info["episode"] + get_int(keys[1]))
elif ':' in keyword:
keys = keyword.split(':')
episode = ('%%.%sd' % keys[1]) % self.info["episode"]
else:
episode = '%s' % self.info["episode"]
text = text.replace('{%s}' % keyword, episode)
return text
def reddit_post_worker(idx, entry, q_out, delay=0):
import datetime
from utils import pretty_datediff, clean_str, get_int, format_description
from reddit import determine_if_video_media_from_reddit_json
from domains import sitesBase
if delay>0:
xbmc.Monitor().waitForAbort( float(delay)/1000 ) #xbmc.sleep(delay)
try:
credate = ""
is_a_video=False
title_line2=""
thumb_w=0; thumb_h=0
t_on = translation(32071) #"on"
#t_pts = u"\U0001F4AC" # translation(30072) #"cmnts" comment bubble symbol. doesn't work
t_pts = u"\U00002709" # translation(30072) envelope symbol
t_up = u"\U000025B4" #u"\U00009650"(up arrow) #upvote symbol
#on 3/21/2017 we're adding a new feature that lets users view their saved posts by entering /user/username/saved as their subreddit.
# in addition to saved posts, users can also save comments. we need to handle it by checking for "kind"
kind=entry.get('kind') #t1 for comments t3 for posts
data=entry.get('data')
if data:
if kind=='t3':
title = clean_str(data,['title'])
description=clean_str(data,['media','oembed','description'])
post_selftext=clean_str(data,['selftext'])
description=post_selftext+'\n'+description if post_selftext else description
domain=clean_str(data,['domain'])
else:
title=clean_str(data,['link_title'])
description=clean_str(data,['body'])
domain='Comment post'
description=format_description(description, hide_text_in_parens=False)
first_link_in_description=None
#title=strip_emoji(title) #an emoji in the title was causing a KeyError u'\ud83c'
title=format_description(title)
is_a_video = determine_if_video_media_from_reddit_json(entry)
log(" POS%s%cTITLE%.2d=%s d=%d" %( kind, ("v" if is_a_video else " "), idx, title,delay ))
#log("description%.2d=%s" %(idx,description))
post_id = entry['kind'] + '_' + data.get('id') #same as entry['data']['name']
#log(' %s %s ' % (post_id, entry['data']['name'] ))
commentsUrl = urlMain+clean_str(data,['permalink'])
#log("commentsUrl"+str(idx)+"="+commentsUrl)
try:
aaa = data.get('created_utc')
credate = datetime.datetime.utcfromtimestamp( aaa )
now_utc = datetime.datetime.utcnow()
pretty_date=pretty_datediff(now_utc, credate)
credate = str(credate)
except (AttributeError,TypeError,ValueError):
credate = ""
subreddit=clean_str(data,['subreddit'])
author=clean_str(data,['author'])
#log(" DOMAIN%.2d=%s" %(idx,domain))
#post_excluded_from() is a misnomer. it just returns true if subreddit is in csv-list
if (post_excluded_from( use_first_link_in_textpost_for_the_following_subreddits, subreddit) or
post_excluded_from( use_first_link_in_textpost_for_the_following_subreddits, 'all') and
domain.startswith('self.')):
first_link_in_description=sitesBase.get_first_url_from(description)
#override the domain so that bottom right of gui matches link
if first_link_in_description:
domain = '({uri.netloc})'.format( uri=urlparse.urlparse( first_link_in_description ) )
ups = data.get('score',0) #downs not used anymore
num_comments = data.get('num_comments',0)
d_url=clean_str(data,['url'])
link_url=clean_str(data,['link_url'])
media_oembed_url=clean_str(data,['media','oembed','url'])
# log(' kind ='+kind)
# log(' url ='+d_url)
# log(' link_url='+link_url)
# log(' permalink='+clean_str(data,['permalink']))
# log(' media_oembed_url='+media_oembed_url)
media_url=next((item for item in [first_link_in_description,d_url,link_url,media_oembed_url] if item ), '')
#log(" MEDIA%.2d=%s" %(idx,media_url))
thumb=clean_str(data,['thumbnail'])
#media_w=get_int(data,['media','oembed','width'])
#media_h=get_int(data,['media','oembed','height'])
#log(' media_w='+repr(media_w)+' h='+repr(media_h) )
#try:log(' media_w='+repr(data.get('media')['oembed']['width'] ) )
#except:pass
if not thumb.startswith('http'): #in ['nsfw','default','self']: #reddit has a "default" thumbnail (alien holding camera with "?")
thumb=""
if thumb=="":
thumb=clean_str(data,['media','oembed','thumbnail_url']).replace('&','&')
#a blank preview image will be replaced with poster_url from parse_reddit_link() for domains that support it
preview=clean_str(data,['preview','images',0,'source','url']).replace('&','&') #data.get('preview')['images'][0]['source']['url'].encode('utf-8').replace('&','&')
#log(' preview='+repr(preview))
#try:
thumb_h=get_int(data,['preview','images',0,'source','height'])#float( data.get('preview')['images'][0]['source']['height'] )
thumb_w=get_int(data,['preview','images',0,'source','width']) #float( data.get('preview')['images'][0]['source']['width'] )
#except (AttributeError,TypeError,ValueError):
#log(" thumb_w _h EXCEPTION:="+ str( sys.exc_info()[0]) + " " + str(e) )
# thumb_w=0; thumb_h=0
#preview images are 'keep' stretched to fit inside 1080x1080.
# if preview image is smaller than the box we have for thumbnail, we'll use that as thumbnail and not have a bigger stretched image
if thumb_w > 0 and thumb_w < 280:
#log('*******preview is small ')
thumb=preview
thumb_w=0; thumb_h=0; preview=""
over_18=data.get('over_18')
title_line2=""
title_line2 = "[I][COLOR dimgrey]%d%c %s %s [B][COLOR cadetblue]r/%s[/COLOR][/B] (%d) %s[/COLOR][/I]" %(ups,t_up,pretty_date,t_on, subreddit,num_comments, t_pts)
liz=addLink(title=title,
title_line2=title_line2,
iconimage=thumb,
previewimage=preview,
preview_w=thumb_w,
preview_h=thumb_h,
domain=domain,
description=description,
credate=credate,
reddit_says_is_video=is_a_video,
commentsUrl=commentsUrl,
subreddit=subreddit,
link_url=media_url,
over_18=over_18,
posted_by=author,
num_comments=num_comments,
post_id=post_id,
)
q_out.put( [idx, liz] ) #we put the idx back for easy sorting
except Exception as e:
log( ' #reddit_post_worker EXCEPTION:' + repr(sys.exc_info()) +'--'+ str(e) )
import utils
def pyramid2(n, x):
"""This draws a pyramid of a given size using asterisks."""
print "*"*x
x = x+1
if x <= n:
pyramid2(n, x)
pyramid2(utils.get_int("Please enter an int: ", "That's not int"), 1)
# Prompt the user for a number and a tolerance and calculate the number's
# square root to the tolerance (accuracy) specified, using the Newton-Raphson
# iteration method (not by importing math and using math.sqrt!).
import math
import utils
def root(n, delta):
xold = n/2.0
xnew = (n/xold+xold)/2.0
while math.fabs(xold-xnew) >= delta:
xold = xnew
xnew = (n/xold+xold)/2.0
return round(xnew, 3)
#works
print root(utils.get_int("Number to factor: ", "That's not int"), utils.get_float("Tolerance: ", "That's not float" ))
#utils.get_float("Tolerance: ", "That's not float"))
