def simulate_progressive_ogp(self, replay=False, shuffle=False): ogp = OGPlanner(self.num_functions) cost, path = ogp.plan(self.num_functions, self.func_sel, self.func_cost) functions = list(filter(lambda x: x.id in path, self.functions)) true = [0] false = [0] maybe = [0] cumu_cost = [0] items_batch = int(self.budget/cost) epoch = 1 if shuffle: np.random.shuffle(self.items) for i in range(0, self.num_items, items_batch): items = self.items[i:i+items_batch] function_map = {self.items[j].id:functions for j in range(i, min(i+items_batch, self.num_items))} epoch_plan = plan.Plan(items, function_map) exec = executor.DefaultExectuor(epoch_plan, self.budget) if not replay: epoch_cost, epoch_true, epoch_false, epoch_maybe = exec.run() else: epoch_cost, epoch_true, epoch_false, epoch_maybe = exec.replay() true.append(true[-1]+len(epoch_true)) false.append(false[-1]+len(epoch_false)) maybe.append(len(epoch_maybe)) cumu_cost.append(cumu_cost[-1]+epoch_cost) epoch += 1 print(true[-1], false[-1], maybe[-1], epoch, items_batch) return (true, false, maybe, cumu_cost)
def copyPlansWithMaxNumberActions(plan_file, path, maxActions): #funzione che sposta i piani con numero di azioni minore di maxActions try: piano = plan.Plan(plan_file) if len(piano.actions) <= maxActions: shutil.copy(plan_file, path) except IOError: a = 1
def _get_plan(self, part, part_size): if self._is_indirect: plan = _plan.Plan(part, *self._unwound_args, partition_size=part_size, matrix_coloring=True, staging=False, thread_coloring=False) else: # TODO: # Create the fake plan according to the number of cores available class FakePlan(object): def __init__(self, part, partition_size): self.nblocks = int( math.ceil(part.size / float(partition_size))) self.ncolors = 1 self.ncolblk = np.array([self.nblocks], dtype=np.int32) self.blkmap = np.arange(self.nblocks, dtype=np.int32) self.nelems = np.array([ min(partition_size, part.size - i * partition_size) for i in range(self.nblocks) ], dtype=np.int32) self.offset = np.arange(part.offset, part.offset + part.size, partition_size, dtype=np.int32) plan = FakePlan(part, part_size) return plan
def get_plans(folder): plan_list = [ plan.Plan(folder + "/" + file) for file in os.listdir(folder) if file.find("xml") >= 0 and ( file.endswith(".soln") or file.endswith(".SOL")) ] return plan_list
def simulate_progressive_dynamic_ogp(self, replay=False): dynamic_ogp = OGDyanmicPlanner(self.items, self.num_functions, self.func_cost) tuple_plans = sorted(dynamic_ogp.plan(), key=lambda x: x.cost) true = [0] false = [0] maybe = [0] cumu_cost = [0] epoch = 1 p_count = 0 start = 0 while p_count<len(self.items): cost = 0 start = p_count function_map ={} while p_count<len(self.items) and cost<self.budget: cost += tuple_plans[p_count].cost path = tuple_plans[p_count].path functions = list(filter(lambda x: x.id in path, self.functions)) function_map[self.items[p_count].id] = functions p_count += 1 items = self.items[start:p_count] epoch_plan = plan.Plan(items, function_map) exec = executor.DefaultExectuor(epoch_plan, self.budget) if not replay: epoch_cost, epoch_true, epoch_false, epoch_maybe = exec.run() else: epoch_cost, epoch_true, epoch_false, epoch_maybe = exec.replay() true.append(true[-1]+len(epoch_true)) false.append(false[-1]+len(epoch_false)) maybe.append(len(epoch_maybe)) cumu_cost.append(cumu_cost[-1]+epoch_cost) epoch += 1 print (true[-1], false[-1], maybe[-1], epoch) return (true, false, maybe, cumu_cost)
def start(profile=None, xml=True, dry_run=False, tree=None): # Load the profile if profile: # Read from a file with open(profile) as f: if xml: rtsp = rtsprofile.rts_profile.RtsProfile(xml_spec=f) else: rtsp = rtsprofile.rts_profile.RtsProfile(yaml_spec=f) else: # Read from standard input lines = sys.stdin.read() if xml: rtsp = rtsprofile.rts_profile.RtsProfile(xml_spec=lines) else: rtsp = rtsprofile.rts_profile.RtsProfile(yaml_spec=lines) # Build a list of actions to perform that will start the system checks, activates = activate_actions(rtsp) p = plan.Plan() p.make(rtsp, activates, rtsp.activation, rtctree.component.Component.ACTIVE) if dry_run: for a in checks: print a print p else: if not tree: # Load the RTC Tree, using the paths from the profile tree = rtctree.tree.RTCTree(paths=[ rtctree.path.parse_path('/' + c.path_uri)[0] for c in rtsp.components ]) try: for a in checks: a(tree) p.execute(tree) except rts_exceptions.RequiredActionFailedError: p.cancel() raise
def trans_girls_cron(): """Config for trans girls cron""" cron = plan.Plan('trans_girls_rule_the_world') environment = { 'TRANS_GIRLS_CONSUMER_KEY': os.environ['TRANS_GIRLS_CONSUMER_KEY'], 'TRANS_GIRLS_CONSUMER_SECRET': os.environ['TRANS_GIRLS_CONSUMER_SECRET'], 'TRANS_GIRLS_OAUTH_TOKEN': os.environ['TRANS_GIRLS_OAUTH_TOKEN'], 'TRANS_GIRLS_OAUTH_SECRET': os.environ['TRANS_GIRLS_OAUTH_SECRET'] } cron.command( 'curl http://localhost:5000/post_selfie', every='10.minutes', environment=environment ) #update cron if crontab exists, write new cron if crontab doesn't exist try: cron.run('update') except plan.PlanError: cron.run('write')
def witches_cron(): """Config for witches cron""" cron = plan.Plan('witches_rule_the_world') path = witches_rule_the_world.__path__[0] environment = { 'WITCHES_CONSUMER_KEY': os.environ['WITCHES_CONSUMER_KEY'], 'WITCHES_CONSUMER_SECRET': os.environ['WITCHES_CONSUMER_SECRET'], 'WITCHES_OAUTH_TOKEN': os.environ['WITCHES_OAUTH_TOKEN'], 'WITCHES_OAUTH_SECRET': os.environ['WITCHES_OAUTH_SECRET'] } cron.script( 'rule.py', every='10.minutes', path=path, environment=environment ) #update cron if crontab exists, write new cron if crontab doesn't exist try: cron.run('update') except plan.PlanError: cron.run('write')
def _makeInfoPageInfo(the_user, the_gig, the_band_key): gig_key = the_gig.key the_assocs = assoc.get_assocs_of_band_key(the_band_key, confirmed_only=True, keys_only=False) # get all the plans for this gig - might actually not be any yet. all_plans = plan.get_plans_for_gig_key(gig_key, keys_only=False) # now, for each associated member, find or make a plan the_plans = [] the_new_plans = [] # in case we need to make new ones the_plan_counts = {} for i in range(len(plan.plan_text)): the_plan_counts[i] = 0 need_empty_section = False for the_assoc in the_assocs: a_member_key = the_assoc.member new_plan = False for p in all_plans: if p.member == a_member_key: the_plan = p break else: # no plan? make a new one planval = 0 if (the_gig.default_to_attending): planval = 1 the_plan = plan.Plan(parent=gig_key, member=a_member_key, value=planval, comment="", section=None) the_new_plans.append(the_plan) new_plan = True if (not the_assoc.is_occasional) or \ (the_assoc.is_occasional and the_plan.value != 0) or \ (a_member_key == the_user.key) or \ the_user.is_superuser: if the_plan.section == None and the_assoc.default_section == None: need_empty_section = True info_block = {} info_block['the_gig_key'] = the_gig.key info_block['the_plan'] = the_plan info_block['the_member_key'] = a_member_key info_block['the_band_key'] = the_band_key info_block['the_assoc'] = the_assoc if the_plan.section is not None: info_block['the_section'] = the_plan.section else: info_block['the_section'] = the_assoc.default_section the_plans.append(info_block) the_plan_counts[the_plan.value] += 1 if the_new_plans: ndb.put_multi(the_new_plans) the_section_keys = band.get_section_keys_of_band_key(the_band_key) the_sections = ndb.get_multi(the_section_keys) if need_empty_section: the_sections.append(None) if len(the_section_keys) == 0: band_has_sections = False else: band_has_sections = True return the_plans, the_plan_counts, the_sections, band_has_sections
def get_plans(folder): plan_list = [ plan.Plan(folder + "/" + file) for file in os.listdir(folder) if file.endswith(".SOL") ] return plan_list
def _make_page(self, the_user): # find the gig we're interested in gig_key_str = self.request.get("gk", None) if gig_key_str is None: self.response.write('no gig key passed in!') return # todo figure out what to do if there's no ID passed in gig_key = ndb.Key(urlsafe=gig_key_str) the_gig = gig_key.get() if the_gig is None: template_args = {} self.render_template('no_gig_found.html', template_args) return # todo figure out what to do if we didn't find it the_comment_text = None if the_gig.comment_id: the_comment_text = gigcomment.get_comment(the_gig.comment_id) if not the_gig.is_archived: the_band_key = the_gig.key.parent() the_assocs = assoc.get_assocs_of_band_key(the_band_key, confirmed_only=True, keys_only=False) # get all the plans for this gig - might actually not be any yet. all_plans = plan.get_plans_for_gig_key(gig_key, keys_only=False) # now, for each associated member, find or make a plan the_plans = [] the_new_plans = [] # in case we need to make new ones the_plan_counts = {} for i in range(len(plan.plan_text)): the_plan_counts[i] = 0 need_empty_section = False for the_assoc in the_assocs: a_member_key = the_assoc.member new_plan = False for p in all_plans: if p.member == a_member_key: the_plan = p break else: the_plan = plan.Plan(parent=gig_key, member=a_member_key, value=0, comment="", section=None) the_new_plans.append(the_plan) new_plan = True if (not the_assoc.is_occasional) or \ (the_assoc.is_occasional and the_plan.value != 0) or \ (a_member_key == the_user.key) or \ the_user.is_superuser: if the_plan.section == None and the_assoc.default_section == None: need_empty_section = True info_block = {} info_block['the_gig_key'] = the_gig.key info_block['the_plan'] = the_plan info_block['the_member_key'] = a_member_key info_block['the_band_key'] = the_band_key info_block['the_assoc'] = the_assoc if the_plan.section is not None: info_block['the_section'] = the_plan.section else: info_block['the_section'] = the_assoc.default_section the_plans.append(info_block) the_plan_counts[the_plan.value] += 1 if the_new_plans: ndb.put_multi(the_new_plans) the_section_keys = band.get_section_keys_of_band_key(the_band_key) the_sections = ndb.get_multi(the_section_keys) if need_empty_section: the_sections.append(None) if len(the_section_keys) == 0: band_has_sections = False else: band_has_sections = True # is the current user a band admin? the_user_is_band_admin = assoc.get_admin_status_for_member_for_band_key( the_user, the_band_key) the_band = the_band_key.get() user_can_edit = can_edit_gig(the_user, the_gig, the_band) user_can_create = can_edit_gig(the_user, None, the_band) datestr = member.format_date_for_member(the_user, the_gig.date, format="long") if the_gig.enddate: enddatestr = u' - {0}'.format( member.format_date_for_member(the_user, the_gig.enddate, format="long")) else: enddatestr = '' template_args = { 'gig': the_gig, 'date_str': datestr, 'enddate_str': enddatestr, 'the_plans': the_plans, 'the_sections': the_sections, 'comment_text': the_comment_text, 'band_has_sections': band_has_sections, 'the_user_is_band_admin': the_user_is_band_admin, 'user_can_edit': user_can_edit, 'user_can_create': user_can_create, 'the_plan_counts': the_plan_counts } self.render_template('gig_info.html', template_args) else: # this is an archived gig the_archived_plans = gigarchive.get_archived_plans( the_gig.archive_id) template_args = { 'gig': the_gig, 'archived_plans': the_archived_plans, 'comment_text': the_comment_text } self.render_template('gig_archived_info.html', template_args)
# out_filename_phase3 = sys.argv[5] # out_filename_phase4 = sys.argv[6] # out_filename_phase5 = sys.argv[7] if debug_level > 1: print('args :', len(sys.argv)) indu_comp = 'comp' ic_name = 'all' if len(sys.argv) == 9: indu_comp = sys.argv[5] ic_name = sys.argv[6] ic_name = ic_name.capitalize() plan = plan.Plan() plan.set_debug_level(debug_level) if truncate_table: plan.plan_table_reload(truncate_table) plan.amfi_load_db() plan.plan_load_data(in_filename_phase[0]) plan.plan_dump_ticker(out_filename_phase[0]) plan.plan_dump_sorted_units(out_filename_phase[1]) plan.plan_dump_all(out_filename_phase[2]) plan.plan_dump_plus(out_filename_phase[3]) plan.plan_dump_zero(out_filename_phase[4])