def affinities_by_school(school_id):
"""return affinities got from that school"""
school_ = api.data.schools.get(school_id)
if not school_:
return []
ret_ = []
ranks_ = query(api.character.rankadv.get_all()).where(
lambda x: x.school == school_id and len(x.affinities) > 0).to_list()
for r in ranks_:
ret_ += r.affinities
# special affinities
if school_id == 'scorpion_yogo_wardmaster_school':
ret_.append('wards')
is_phoenix_embrace_the_elements = query(school_.techs).where(
lambda x: x.id == 'phoenix_embrace_the_elements').count() > 0
if is_phoenix_embrace_the_elements:
affinity_, deficiencies_ = phoenix_embrace_the_elements()
ret_.append(affinity_)
is_mantis_favor_of_the_sun = query(school_.techs).where(
lambda x: x.id == 'mantis_favor_of_the_sun').count() > 0
if is_mantis_favor_of_the_sun:
ret_.append('fire')
return ret_
def get_tech_by_rank(rank):
"""returns the technique learned at the given insight rank, or None"""
# get the school rank at that insight rank
rank_ = query(api.character.rankadv.get_all()).where(
lambda x: x.rank == rank).first_or_default(None)
if not rank_:
log.api.error(u"get_tech_by_rank. rank advancement not found: %d",
rank)
return None
school_id = rank_.school
school_rank = query(api.character.rankadv.get_all()).where(
lambda x: (x.school == school_id or x.replaced == school_id
) and x.rank <= rank).count()
school_ = api.data.schools.get(school_id)
if not school_:
return None
# for path use the school rank as a tech index
if api.data.schools.is_path(school_.id):
try:
return school_.techs[school_rank - 1].id
except:
return None
return query(school_.techs).where(lambda x: x.rank == school_rank).select(
a_('id')).first_or_default(None)
def search(self, term=None):
if (term is None):
template = Template(filename=TEMPLATE_BASE + "search.html")
return template.render(model=None, title="Enter a Hostname, Location or Channel")
else:
print("Searching for {0}".format(term))
repo = Repository()
allchannels = repo.GetAllChannels()
servers = query(allchannels).where(lambda x: x['Hostname'] == term).to_list()
locations = query(allchannels).where(lambda x: x['Location'] == term).to_list()
channels = query(allchannels).where(lambda x: x['Channel'] == term).to_list()
template = Template(filename=TEMPLATE_BASE + "search.html")
if (len(servers) > 0):
to_return = servers
title = "Found Server(s)"
elif (len(locations) > 0):
to_return = locations
title = "Found Location(s)"
elif (len(channels) > 0):
to_return = channels
title = "Found Channel(s)"
else:
to_return = []
title = "Did not find any matches"
if (to_return is not None):
for row in to_return:
row.setdefault('URL', "/server?{0}".format(urlencode({'name':row['IPAddress']})))
return template.render(model=to_return, title=title)
def put(self, plan_id, item_id, **kwargs):
user = kwargs['user']
json = request.json
new_item = Item.from_json(json)
if new_item.id != item_id:
on_error(error_message="Could not update item, ids do not match")
plan = query(self.plan_repository.get(user_id=user.id, id=plan_id)).single_or_default(
default=None)
if not plan:
abort(404, message="This plan does not exist")
old_item = query(plan.items).where(lambda i: i.id ==
item_id).single_or_default(default=None)
if not old_item:
abort(404, message="This item does not exist")
result = self.item_repository.add_or_update(new_item)
if not result.success():
on_error(error_message="Could not update item", result=result)
self.item_repository.save_changes()
return new_item
def get_school_rank(sid):
"""return the school rank"""
if api.data.schools.is_path(sid):
return query(api.data.schools.get(sid).techs).select(a_('rank')).first_or_default(1)
return query(api.character.rankadv.get_all()).where(
lambda x: x.school == sid or x.replaced == sid).count()
def get_paths_with_rank(rank):
"""returns alternate schools list with rank equal to `rank`"""
return query(__api.ds.schools) \
.where(lambda x: 'alternate' in x.tags) \
.where(lambda x: query(x.techs).select(a_('rank')).first_or_default(0) == rank) \
.to_list()
def get_tech_by_rank(rank):
"""returns the technique learned at the given insight rank, or None"""
# get the school rank at that insight rank
rank_ = query(api.character.rankadv.get_all()).where(
lambda x: x.rank == rank).to_list()
if not rank_:
#log.api.error(u"get_tech_by_rank. rank advancement not found: %d", rank)
return None
school_id = rank_[0].school
if len(rank_) > 1:
# find a replacement
replacement_ = query(rank_).where(
lambda x: x.replaced == school_id).first_or_default(None)
if replacement_:
school_id = replacement_.school
school_ = api.data.schools.get(school_id)
if not school_:
return None
return query(school_.techs).where(lambda x: x.rank == rank).select(
a_('id')).first_or_default(None)
def auto_lib(self,
base_dir='.',
include_root=False,
filter_func=None,
**kwargs):
srcs, headers = opa_waf.get_files(os.path.join(self.path, base_dir),
include_root)
if filter_func:
srcs = query(srcs).where(filter_func).to_list()
headers = query(srcs).where(filter_func).to_list()
ipath = ['./include-internal']
eipath = ['./inc', './include']
ipath = [os.path.join(base_dir, x) for x in ipath]
eipath = [os.path.join(base_dir, x) for x in eipath]
if include_root:
eipath.append(base_dir)
ipath.append(base_dir)
num_inc_dir = query(eipath).where(lambda x: self.has_child(x)).count()
found = False
if len(srcs) + len(headers) == 0 and num_inc_dir == 0:
return
return self.create_conf(BuilderType.LIB,
**kwargs).update(includes=ipath + eipath,
exports=eipath,
sources=srcs,
headers=headers)
def affinities_by_school(school_id):
"""return affinities got from that school"""
school_ = api.data.schools.get(school_id)
if not school_:
return []
ret_ = []
ranks_ = query(api.character.rankadv.get_all()).where(
lambda x: x.school == school_id and len(x.affinities) > 0).to_list()
for r in ranks_:
ret_ += r.affinities
# special affinities
if school_id == 'scorpion_yogo_wardmaster_school':
ret_.append('wards')
is_phoenix_embrace_the_elements = query(school_.techs).where(
lambda x: x.id == 'phoenix_embrace_the_elements').count() > 0
if is_phoenix_embrace_the_elements:
affinity_, deficiencies_ = phoenix_embrace_the_elements()
ret_.append(affinity_)
is_mantis_favor_of_the_sun = query(school_.techs).where(lambda x: x.id == 'mantis_favor_of_the_sun').count() > 0
if is_mantis_favor_of_the_sun:
ret_.append('fire')
return ret_
def get_paths_with_rank(rank):
"""returns alternate schools list with rank equal to `rank`"""
return query(__api.ds.schools) \
.where(lambda x: 'alternate' in x.tags) \
.where(lambda x: query(x.techs).select(a_('rank')).first_or_default(0) == rank) \
.to_list()
def post(self, plan_id, **kwargs):
plan = query(self.plan_repository.get(user_id=kwargs['user'].id, id=plan_id)).single_or_default(
default=None)
if not plan:
abort(404, message="This plan does not exist")
post_body = request.json
if type(post_body) is not list:
on_error(error_message="Invalid post body")
result = ChangeResult()
try:
shares = query(post_body)
for shared_user in plan.shared_users:
if not shares.contains(shared_user, lambda lhs, rhs: rhs['user_id'] == lhs.id):
result.add_child_result(
self.plan_repository.unshare(plan, shared_user.id))
for share in post_body:
user_id = share['user_id']
permission = share['permission']
result.add_child_result(
self.plan_repository.share(plan, user_id, permission))
except KeyError as ke:
on_error(error_message="Invalid post body")
if not result.success():
on_error(error_message="Could not share plan", result=result)
self.plan_repository.save_changes()
return plan
def get_yelp_item(coordinate, category, strategy=DistanceStrategy()):
extra_yelp_params = {}
yelp_item_repository = YelpItemRepository()
# for these strategies, use YelpAPI
# then reset strategy_name so that we can still call strategy module below
extra_yelp_params['radius_filters'] = 7500
if strategy.type == StrategyType.popularity:
extra_yelp_params['sort'] = 2
strategy = FirstStrategy()
elif strategy.type == StrategyType.distance:
extra_yelp_params['sort'] = 1
strategy = FirstRandomStrategy()
try:
search_results = query(yelpapi.search(coordinate.latitude,
coordinate.longitude,
category.search_term,
query(category.search_filters).select(lambda f: f.filter).to_list(),
**extra_yelp_params)).where(
lambda r: ['Food Trucks', 'foodtrucks'] not in r['categories'])
yelp_items = [YelpItem.create_from_dict(result) for result in search_results]
yelp_item = strategy.run_strategy(yelp_items)
yelp_item = yelp_item_repository.get_or_insert(yelp_item)
yelp_item_repository.save_changes()
return yelp_item
except:
return None
def get_school_rank(sid):
"""return the school rank"""
if api.data.schools.is_path(sid):
return query(api.data.schools.get(sid).techs).select(a_('rank')).first_or_default(1)
return query(api.character.rankadv.get_all()).where(
lambda x: x.school == sid or x.replaced == sid).count()
def get_tech_by_rank(rank):
"""returns the technique learned at the given insight rank, or None"""
# get the school rank at that insight rank
rank_ = query(api.character.rankadv.get_all()).where(
lambda x: x.rank == rank).to_list()
if not rank_:
#log.api.error(u"get_tech_by_rank. rank advancement not found: %d", rank)
return None
school_id = rank_[0].school
if len(rank_) > 1:
# find a replacement
replacement_ = query(rank_).where(lambda x: x.replaced == school_id).first_or_default(None)
if replacement_:
school_id = replacement_.school
school_ = api.data.schools.get(school_id)
if not school_:
return None
return query(school_.techs).where(lambda x: x.rank == rank).select(a_('id')).first_or_default(None)
def get_spells(ring, mastery, maho=True):
"""returns all the maho spells for the given ring and mastery, if maho include maho spells"""
including_maho = query(
all()).where(lambda x: x.element == ring and x.mastery == mastery)
if not maho:
return query(including_maho).where(
lambda x: 'maho' not in tags(x.id)).to_list()
return including_maho.to_list()
def getThemeInstances(theme, pages):
print "instanceOf::Theme:" + theme
instances = query(pages).where(lambda p: ("instanceOf" in p)).to_list()
insts = (
query(instances).where(lambda p: any(filter(lambda i: "n" in i and i["n"] == theme, p["instanceOf"]))).to_list()
)
print insts
return insts
def get_locations_from_site_map(site_map):
site_map_elements = site_map.getroot().getchildren()
return (
query(site_map_elements)
.select(lambda e: query(e.getchildren()).single(lambda e: e.tag == 'loc'))
.select(lambda e: e.text)
.to_list()
)
def realtime_volume_ratio(Coin):
Transaction_history = pybithumb.transaction_history(Coin)
Realtime_bid = query(Transaction_history['data']).where(lambda item: item[
'type'] == 'bid').select(lambda item: item['units_traded']).to_list()
Realtime_ask = query(Transaction_history['data']).where(lambda item: item[
'type'] == 'ask').select(lambda item: item['units_traded']).to_list()
Realtime_bid = sum(list(map(float, Realtime_bid)))
Realtime_ask = sum(list(map(float, Realtime_ask)))
Realtime_Volume_Ratio = Realtime_bid / Realtime_ask
return Realtime_Volume_Ratio
def get(self, plan_id, item_id, **kwargs):
user = kwargs['user']
plan = query(self.plan_repository.get(user_id=user.id, id=plan_id)).single_or_default(
default=None)
if not plan:
abort(404, message="This plan does not exist")
item = query(plan.items).where(lambda i: i.id ==
item_id).single_or_default(default=None)
if not item:
abort(404, message="This item does not exist")
return item
def generate_ratio_chart(results, report_dir):
data = query(results) \
.where(lambda x: x['compare']) \
.where(lambda x: x['ratio']) \
.order_by(lambda x: x['info'].label()) \
.select(lambda x: new(label=x['info'].label(), value=x['ratio'])) \
.to_list()
labels = query(data).select(lambda x: x.label).to_list()
values = query(data).select(lambda x: x.value).to_list()
if len(labels):
filename = report_dir / 'ratios.png'
ratio_plot(filename, labels, values, 'Throughput compared to golden')
return Image(filename)
return None
def generate_efficiency_chart(results, report_dir):
data = query(results) \
.where(lambda x: x['compare']) \
.where(lambda x: x['efficiency']) \
.order_by(lambda x: x['info'].label()) \
.select(lambda x: new(label=x['info'].label(), value=x['efficiency'])) \
.to_list()
labels = query(data).select(lambda x: x.label).to_list()
values = query(data).select(lambda x: x.value).to_list()
if len(values):
filename = report_dir / 'efficiency.png'
ratio_plot(filename, labels, values, 'Efficiency relative to TF/GP100')
return Image(filename)
return None
def load_families(self, clanid=None):
self.cb_family.blockSignals(True)
self.cb_family.clear()
if clanid:
family_list = query(api.data.families.get_all()).where(lambda x: x.clanid == clanid).order_by(a_('name'))
else:
family_list = query(api.data.families.get_all()).order_by(a_('name'))
for f in family_list:
self.cb_family.addItem(f.name, f.id)
self.cb_family.blockSignals(False)
# select first family
self.on_family_changed(0)
def load_families(self, clanid=None):
self.cb_family.blockSignals(True)
self.cb_family.clear()
if clanid:
family_list = query(api.data.families.get_all()).where(lambda x: x.clanid == clanid).order_by(a_('name'))
else:
family_list = query(api.data.families.get_all()).order_by(a_('name'))
for f in family_list:
self.cb_family.addItem(f.name, f.id)
self.cb_family.blockSignals(False)
# select first family
self.on_family_changed(0)
def get_school_by_rank(rank):
"""returns the school joined at the given insight rank, considering alternate paths"""
rank_ = query(api.character.rankadv.get_all()).where(lambda x: x.rank == rank).first_or_default(None)
if not rank_:
log.api.error(u"get_school_by_rank. rank advancement not found: %d", rank)
return None
return rank_.school
def realtime_volume(Coin):
Transaction_history = pybithumb.transaction_history(Coin)
Realtime_Volume = query(Transaction_history['data']).where(
lambda item: item['type'] == 'bid').select(
lambda item: item['units_traded']).to_list()
Realtime_Volume = sum(list(map(float, Realtime_Volume)))
return Realtime_Volume
def get_rank(mid, rank):
"""returns a merit rank"""
merit_ = get(mid)
if not merit_:
return None
return query(
merit_.ranks).where(lambda x: x.id == rank).first_or_default(None)
def get_longpoll_collision(self):
def common(l1, l2):
return list(set(l1).intersection(l2))
# glc str is laik '
# {"ts":1814582040,"pts":1707239,"updates":[[61,275403018,1],[8,-262426908,4],[61,275403018,1]]};
# {"ts":1801587829,"pts":1333083,"updates":[[9,-7837569,1]]};
# {"ts":1654083789,"pts":284006,"updates":[[8,-229675882,4]]};
# {"ts":1654083793,"pts":284006,"updates":[[8,-15683318,7]]};
# {"ts":1814582464,"pts":1707465,"updates":[[8,-180240104,4]]}'
with open(ARGS.glc) as f:
updates_input = f.read()
updates = query(updates_input.splitlines()) \
.select(lambda x: json.loads(x)) \
.select_many(lambda x: x['updates']) \
.where(lambda x: x[0] == 9 or x[0] == 8) \
.select(lambda x: abs(x[1])) \
.to_list()
possible_user = self.api.friends.get(user_id=updates[0])
updates = updates[1:]
for id in updates:
friends = self.api.friends.get(user_id=id)
new_possible_user = common(possible_user, friends)
print('checked: ' + str(id))
if len(new_possible_user) != 0:
possible_user = new_possible_user
# if len(new_possible_user) == 1:
# break
print(possible_user)
def get_rank(fid, rank):
"""returns a flaw rank"""
flaw_ = get(fid)
if not flaw_:
return None
return query(
flaw_.ranks).where(lambda x: x.id == rank).first_or_default(None)
def createTable(resource, contribs, classification, classname):
classificationBase = root + "/" + classification + '/'
logging.info(classificationBase)
classBase = classificationBase + classname.replace('_',' ')
if not os.path.exists(classificationBase):
os.makedirs(classificationBase)
if not os.path.exists(classBase):
os.makedirs(classBase)
if not os.path.exists(classBase + "/" + resource):
os.makedirs(classBase + "/" + resource)
level0Links = {}
level1Links = {}
for contribName in sorted(contribs.keys()):
logging.info('Checking' + contribName + '...')
clevel0Links = contribs[contribName]
level0Links[contribName] = clevel0Links
clevel1Links = []
logging.info('' + str(len(clevel0Links)) + 'level 0 links found.')
logging.info(' Finding level 1 links...')
for rawlink in clevel0Links:
split = rawlink.split('::')[-1].replace('_',' ').split(':')
n = split[-1]
p = split[0].title() if len(split) > 1 else ''
ls = query(pages).where(lambda page: handlePrefix(page['p']).lower() == p.lower() and page['n'].lower() == n.lower() and 'internal_links' in page).select(lambda page: map(lambda l: l.split('::')[-1].lower(),page['internal_links'])).to_list()
clevel1Links.extend(filter(lambda l: l not in clevel0Links, ls[0]) if ls else [])
level1Links[contribName] = clevel1Links
logging.info(''+ str(len(clevel1Links))+ 'level 1 links found.')
flipped = {}
for contribName in sorted(level0Links.keys()):
logging.info(contribName)
for term in level0Links[contribName]:
term = term.encode('utf-8')
logging.info(term)
if term in flipped:
flipped[term].append(contribName)
else:
flipped[term] = [contribName]
uniqueLevel0 = {}
lowerMappedTerms = set(map(lambda r: r.lower(), mappedTerms))
for term in flipped:
for contribName in sorted(contribs.keys()):
if not contribName in uniqueLevel0:
uniqueLevel0[contribName] = []
if contribName in flipped[term] and len(flipped[term]) == 1:
if contribName in uniqueLevel0:
if term in lowerMappedTerms:
logging.info(contribName + "-> " + term)
uniqueLevel0[contribName].append(term)
mytemplate = Template(filename='templates/coverageTemplate.txt')
table = mytemplate.render(mappedTerms=mappedTerms, contribs=contribs.keys(), level0Links = level0Links, level1Links=level1Links, uniqueLevel0=uniqueLevel0)
logging.info( "Creating " + classBase + "/" + resource + '/coverage.html')
with open(classBase + "/" + resource + '/coverage.html', 'write') as tablef:
tablef.write(table)
coverage = {}
for term in mappedTerms:
coverage[term] = {}
coverage[term]['level0'] = filter(lambda c: term.lower() in map(lambda t: t.lower(), level0Links[c]), contribs)
coverage[term]['level1'] = filter(lambda c: term.lower() in map(lambda t: t.lower(), level1Links[c]) and not c in coverage[term]['level0'], contribs)
with open(classBase + "/" + resource + '/coverage.json', 'write') as tablefjson:
json.dump(coverage, tablefjson,indent=4 )
def list_files_rec(base, *paths):
lst = []
for path_entry in paths:
for root, dirs, files in os.walk(os.path.join(base, path_entry)):
for f in files:
lst.append(os.path.join(root, f))
return query(lst)
def find_indexed_element_for_first_maximum(histogram):
return query(histogram) \
.copy_padded_triples() \
.select_with_index() \
.where(lambda item: is_maxima(*item.element)) \
.select(a_('index')) \
.first_or_default(0)
def get(self, plan_id, **kwargs):
user = kwargs['user']
plan = query(self.plan_repository.get(user_id=user.id, id=plan_id)).single_or_default(
default=None)
if not plan:
abort(404, message="This plan does not exist")
return plan.items
def get_bought():
"""return all merits that comes from advancements"""
if not __api.pc:
return []
return query(
__api.pc.advans).where(lambda x: x.type == 'perk' and
(x.cost > 0 or x.tag == 'merit')).to_list()
def calc_section(section_spec, metrics, section_baseline=None):
display.vv("calculate section {}".format(section_spec['name']))
display.vvv("spec: {}".format(section_spec))
display.vvv("metrics: {}".format(metrics))
display.vvv("baseline: {}".format(section_baseline))
metric_results = []
section_score = 0
if section_baseline:
for m in section_spec['metrics']:
m_baseline = query(section_baseline['metrics']).first(
lambda metric: metric['name'] == m['name'])
metric_results.append(
calc_metric(m, metrics[m['name']], m_baseline))
section_score = mean([r['score'] for r in metric_results])
else:
for m in section_spec['metrics']:
metric_results.append(calc_metric(m, metrics[m['name']]))
# TODO(yujunz): use formula in spec
return {
'score': section_score,
'name': section_spec['name'],
'description': section_spec.get('description', 'section'),
'metrics': metric_results
}
def get_requirements(sid):
"""returns the requirements to join the given school"""
school_ = get(sid)
if not school_:
log.api.error(u"school not found: %s", sid)
return []
requirements_by_data_ = school_.require
# fixme. since i can't rewrite all alternate path
# I decided to patch these requirement by code
import l5r.api.character.schools
from l5rdal.requirements import Requirement
coded_requirements_ = []
if is_path(sid):
# An alternate path can only be joined
# on the same school rank that its technique replaces
path_rank_ = query(school_.techs).select(a_('rank')).first_or_default(0)
if path_rank_ > 0:
r = Requirement()
r.field = api.character.schools.get_current()
r.type = 'school'
r.min = path_rank_ - 1
r.max = path_rank_ - 1
r.trg = None
r.text = __api.tr("Replaces School Rank: {0}").format(path_rank_)
coded_requirements_.append(r)
return requirements_by_data_ + coded_requirements_
def get_learned():
"""return all the learned ( not starting ) skills"""
if not __api.pc:
return []
return query(__api.pc.advans).where(
lambda x: x.type == 'skill').select(
lambda x: x.skill).distinct().to_list()
def delete(self, plan_id, item_id, **kwargs):
user = kwargs['user']
plan = query(self.plan_repository.get(user_id=user.id, id=plan_id)).single_or_default(
default=None)
if not plan:
abort(404, message="This plan does not exist")
item = query(plan.items).where(lambda i: i.id ==
item_id).single_or_default(default=None)
if not item:
abort(404, message="This item does not exist")
plan.remove_item(item)
self.item_repository.delete(id)
self.item_repository.save_changes()
return {"message": "Deleted item"}
def get_skill_rank(skill_id):
"""return the character skill rank"""
if not __api.pc:
return 0
sk_rank_ = 0
for r in api.character.rankadv.get_all():
sk_rank_ += query(r.skills).where(lambda x: x == skill_id).count()
sk_rank_ += query(__api.pc.advans).where(
lambda x: x.type == 'skill' and x.skill == skill_id).count()
if skill_id in get_acquired():
sk_rank_ += 1
return sk_rank_
def get_skill_rank(skill_id):
"""return the character skill rank"""
if not __api.pc:
return 0
sk_rank_ = 0
for r in api.character.rankadv.get_all():
sk_rank_ += query(r.skills).where(lambda x: x == skill_id).count()
sk_rank_ += query(__api.pc.advans).where(
lambda x: x.type == 'skill' and x.skill == skill_id).count()
if skill_id in get_acquired():
sk_rank_ += 1
return sk_rank_
def get_all():
"""return all character skills"""
if not __api.pc:
return []
return query(get_starting() + get_learned() +
get_acquired()).distinct().to_list()
def add_step(self,
name,
data,
log_debug=True,
print_step=True,
overwrite=False):
if not overwrite:
self._steps.append(
ImageTrace(step=self._step, name=name, data=data))
else:
step = next(
iter(query(self._steps).where(lambda s: s.name == name)), None)
if step is not None:
step.data = data
else:
self._steps.append(
ImageTrace(step=self._step, name=name, data=data))
if log_debug:
log.debug(name + (': ' + data) if data is not None else '')
if print_step:
printer.printf(name, data if data is not None else '')
self._step += 1
def get_mastery_ability(skill_id, rank):
"""returns the mastery ability for a given rank"""
skill_ = get(skill_id)
if not skill_:
return None
return query(skill_.mastery_abilities).where(
lambda x: x.rank == rank).first_or_default(None)
def mandelbrot():
MaxIterations = 200
SampleWidth = 3.2
SampleHeight = 2.5
OffsetX = -2.1
OffsetY = -1.25
ImageWidth = 480
ImageHeight = int(SampleHeight * ImageWidth / SampleWidth)
query = integers(0, ImageHeight).select(lambda y: (y * SampleHeight) / ImageHeight + OffsetY) \
.select_many_with_correspondence(
lambda y: integers(0, ImageWidth).select(lambda x: (x * SampleWidth) / ImageWidth + OffsetX),
lambda y, x: (x, y)) \
.select(lambda real_imag: complex(*real_imag)) \
.select(lambda c: query(generate(c, lambda x: x * x + c))
.take_while(lambda x: x.real ** 2 + x.imag ** 2 < 4)
.take(MaxIterations)
.count()) \
.select(lambda c: ((c * 7) % 255, (c * 5) % 255, (c * 11) % 255) if c != MaxIterations else (0, 0, 0))
data = q.to_list()
image = Image.new("RGB", (ImageWidth, ImageHeight))
image.putdata(data)
image.show()
def get_references():
"""return a list of data-packs that are referenced by the character"""
refs_ = []
# get references from families
family_ = api.data.families.get(api.character.get_family())
if family_:
refs_.append(family_.pack)
# get references from schools
for s in [
api.data.schools.get(x) for x in api.character.schools.get_all()
if api.data.schools.get(x) is not None
]:
refs_.append(s.pack)
# get references from skills
for s in [
api.data.skills.get(x) for x in api.character.skills.get_all()
if api.data.skills.get(x) is not None
]:
refs_.append(s.pack)
# get references from spells
for s in [
api.data.spells.get(x) for x in api.character.spells.get_all()
if api.data.spells.get(x) is not None
]:
refs_.append(s.pack)
return query(refs_).where(lambda y: y is not None).distinct(
a_('id')).to_list()
def make_html_suites(results):
return query(results) \
.group_by(
lambda x: x['info'].suite_name,
result_selector=lambda k, g: new(name=k, results=make_html_results(g))) \
.order_by(lambda x: x.name) \
.to_list()
def make_html_summary(results):
counts = query(results) \
.group_by(lambda x: x['status']) \
.to_dictionary(lambda x: x.key, len)
errors = counts.get('ERROR', 0)
failures = counts.get('FAIL', 0)
skipped = counts.get('SKIP', 0)
passed = counts.get('PASS', 0)
total = errors + failures + skipped + passed
if errors:
status = 'ERROR'
elif failures:
status = 'FAIL'
else:
status = 'PASS'
return new(
status=status,
css=CSS_MAP.get(status),
errors_count=errors,
failures_count=failures,
skipped_count=skipped,
passed_count=passed,
total_count=total,
)
def _register(self, rid, name):
if not query(self.report_registry).any(lambda r: r['id'] == rid):
self.report_registry.append({
'id': rid,
'name': name,
'path': 'reporter/%s.html' % rid
})
def get_report_name(self, report_id):
report = query(self.report_registry).first_or_default(
None, lambda r: r['id'] == report_id)
if report is not None:
return report['name']
else:
return None
def get_techs_by_school(sid):
"""returns all the techniques learned in the given school"""
school_ = api.data.schools.get(sid)
if not school_:
return []
return query(school_.techs).where(lambda x: api.character.has_rule(x.id)).select(a_('id')).to_list()
def get_filtered_clan_list(self):
schools = self.get_filtered_school_list()
clanids = query(schools) \
.distinct(a_('clanid')) \
.select(a_('clanid')) \
.to_list()
return [api.data.clans.get(x) for x in clanids]
def get_emphasis_to_choose(sid):
"""returns player choose emphasis"""
school = get(sid)
if not school:
return []
return query(school.skills) \
.where(lambda x: x.emph and x.emph.startswith('*')) \
.to_list()
def get_starting():
"""get character starting skills"""
# get first rank advancement
rank_ = api.character.rankadv.get(1)
if not rank_:
return []
return query(rank_.skills).distinct().to_list()
def get_shared_user_permission(self, plan_id, user_id):
shared_user = query(
PlanShares.query.filter_by(plan_id=plan_id, user_id=user_id).all()).single_or_default(
default=None
)
if not shared_user:
return None
return shared_user.permission
def getPermutations(listOfLists): numEntries = len(listOfLists) listOfLists = query(listOfLists).select(lambda x:filter(None,x)).to_list() if not len(listOfLists): return [] listLengths = query(list(listOfLists)).select(lambda x:len(x)).to_list() totalPermutations = query(listLengths).aggregate(lambda cur,sum: sum*cur) retList=[] for p in range(0,totalPermutations): scalePerm = totalPermutations+0 oneList=[] for l in range(0,numEntries): scalePerm = scalePerm/listLengths[l] pos= p/scalePerm p=p-(scalePerm*pos) oneList.append(listOfLists[l][pos]) retList.append(oneList) return retList
def getFeatures(pages):
techs = (
query(pages)
.where(lambda p: any(filter(lambda i: i.startswith("implements::Feature:"), p.get("internal_links", []))))
.select(lambda p: filter(lambda i: i.startswith("implements::Feature:"), p["internal_links"]))
.to_list()
)
s = reduce(lambda a, b: a + b, techs) if techs else []
return map(lambda n: n.replace("implements::Feature:", ""), s)
def getConcepts(pages):
cs = (
query(pages)
.where(lambda p: any(filter(lambda i: re.match(r"^[a-zA-Z0-9 ]+$", i), p.get("internal_links", []))))
.select(lambda p: filter(lambda i: re.match(r"^[a-zA-Z0-9 ]+$", i), p["internal_links"]))
.to_list()
)
s = reduce(lambda a, b: a + b, cs) if cs else []
return s
def getLangs(pages):
langs = (
query(pages)
.where(lambda p: any(filter(lambda i: i.startswith("uses::Language"), p.get("internal_links", []))))
.select(lambda p: filter(lambda i: i.startswith("uses::Language"), p["internal_links"]))
.to_list()
)
s = reduce(lambda a, b: a + b, langs) if langs else []
return map(lambda n: n.replace("uses::Language:", ""), s)
def load_clans(self):
self.cb_clan.blockSignals(True)
self.cb_clan.clear()
self.cb_clan.addItem(self.tr("No Clan"), None)
for c in query(api.data.clans.all()).order_by(a_('name')):
self.cb_clan.addItem(c.name, c.id)
self.cb_clan.blockSignals(False)
# select first clan
self.on_clan_changed(0)
