def init_algo_params(self): '''Initialize other algorithm parameters''' algorithm_spec = self.agent.spec['algorithm'] net_spec = self.agent.spec['net'] self.set_action_fn() util.set_attr(self, _.pick(algorithm_spec, [ 'gamma', 'num_epis_to_collect', 'add_entropy', 'entropy_weight', 'continuous_action_clip', 'lamda', 'num_step_returns', 'training_frequency', 'training_iters_per_batch', 'use_GAE', 'policy_loss_weight', 'val_loss_weight', ])) util.set_attr(self, _.pick(net_spec, [ 'decay_lr', 'decay_lr_frequency', 'decay_lr_min_timestep', ])) '''Select appropriate function for calculating state-action-value estimate (target)''' self.get_target = self.get_nstep_target if self.use_GAE: self.get_target = self.get_gae_target self.set_memory_flag() '''To save on a forward pass keep the log probs and entropy from each action''' self.saved_log_probs = [] self.entropy = [] self.to_train = 0
def init_algo_params(self): '''Initialize other algorithm parameters''' algorithm_spec = self.agent.spec['algorithm'] net_spec = self.agent.spec['net'] # Automatically selects appropriate discrete or continuous action policy if setting is default action_fn = algorithm_spec['action_policy'] if action_fn == 'default': if self.is_discrete: self.action_policy = act_fns['softmax'] else: self.action_policy = act_fns['gaussian'] else: self.action_policy = act_fns[action_fn] util.set_attr( self, _.pick(algorithm_spec, [ 'gamma', 'num_epis_to_collect', 'add_entropy', 'entropy_weight', 'continuous_action_clip' ])) util.set_attr( self, _.pick(net_spec, [ 'decay_lr', 'decay_lr_frequency', 'decay_lr_min_timestep', 'gpu' ])) if not hasattr(self, 'gpu'): self.gpu = False logger.info(f'Training on gpu: {self.gpu}') # To save on a forward pass keep the log probs from each action self.saved_log_probs = [] self.entropy = [] self.to_train = 0
def plot_session(session, session_data): '''Plot the session graph, 2 panes: reward, loss & explore_var. Each aeb_df gets its own color''' aeb_count = len(session_data) if aeb_count <= 8: palette = cl.scales[str(max(3, aeb_count))]['qual']['Set2'] else: palette = util.interp(cl.scales['8']['qual']['Set2'], aeb_count) fig = viz.tools.make_subplots(rows=3, cols=1, shared_xaxes=True) for idx, (a, e, b) in enumerate(session_data): aeb_str = f'{a}{e}{b}' aeb_df = session_data[(a, e, b)] fig_1 = viz.plot_line(aeb_df, 'reward', 'epi', legend_name=aeb_str, draw=False, trace_kwargs={ 'legendgroup': aeb_str, 'line': { 'color': palette[idx] } }) fig.append_trace(fig_1.data[0], 1, 1) fig_2 = viz.plot_line(aeb_df, ['loss'], 'epi', y2_col=['explore_var'], trace_kwargs={ 'legendgroup': aeb_str, 'showlegend': False, 'line': { 'color': palette[idx] } }, draw=False) fig.append_trace(fig_2.data[0], 2, 1) fig.append_trace(fig_2.data[1], 3, 1) fig.layout['xaxis1'].update(title='epi', zerolinewidth=1) fig.layout['yaxis1'].update(fig_1.layout['yaxis']) fig.layout['yaxis1'].update(domain=[0.55, 1]) fig.layout['yaxis2'].update(fig_2.layout['yaxis']) fig.layout['yaxis2'].update(showgrid=False, domain=[0, 0.45]) fig.layout['yaxis3'].update(fig_2.layout['yaxis2']) fig.layout['yaxis3'].update(overlaying='y2', anchor='x2') fig.layout.update(_.pick(fig_1.layout, ['legend'])) fig.layout.update(_.pick(fig_2.layout, ['legend'])) fig.layout.update(title=session.spec['name'], width=500, height=600) viz.plot(fig) return fig
def save(self, commit=True): user = super().save(commit) cd = self.cleaned_data user.save() if user.is_participant(): for field, value in py_.pick(cd, *self.PROFILE_FIELDS).items(): setattr(user.participant_profile, field, value) else: user.participant_profile = Participant(**py_.pick(cd, *self.PROFILE_FIELDS)) user.participant_profile.save() return user
def test_query_index_by(db, model_class, data, callback, expected): """Test Query.index_by.""" db.save([model_class(item) for item in data]) results = db.query(model_class).index_by(callback) for key, value in results.items(): assert pyd.pick(dict(value), pyd.keys(expected[key])) == expected[key]
def task_reports(name, _id, endpoint, method="GET", source='report', args={}, chain=[]): msg = "Task Report - %s" % _id normalize = from_pairs(map_(args, lambda i: [i['key'], i['value']])) query = json.dumps({ '_id': normalize.get('report_id'), 'owner._id': normalize.get('owner_user'), 'active': True }) resource = ExternalMaestroScheduler(_id) \ .post_request(path="reports", body={'query': query}) if resource.get_status() >= 400: msg = resource.get_error() task_deplete.delay(msg, _id) if resource.get_status() < 400: result = resource.get_results() msg = "Report success - %s" % _id if result.get('found', 0) == 1: objs = pick(result.get('items')[0], ['filters', 'component']) transformParams(args, objs) task_webhook.delay(name, _id, endpoint, source, method, args, chain) return {'msg': msg, 'status_code': resource.get_status()}
def populate(self, **kwargs): """Extended ndb.Model populate method, so it can ignore properties, which are not defined in model class without throwing error """ kwargs = _.omit(kwargs, Base.PUBLIC_PROPERTIES + ['key', 'id']) # We don't want to populate those properties kwargs = _.pick(kwargs, _.keys(self._properties)) # We want to populate only real model properties super(Base, self).populate(**kwargs)
def init_algo_params(self): '''Initialize other algorithm parameters''' algorithm_spec = self.agent.spec['algorithm'] net_spec = self.agent.spec['net'] self.action_policy = act_fns[algorithm_spec['action_policy']] self.action_policy_update = act_update_fns[ algorithm_spec['action_policy_update']] util.set_attr( self, _.pick( algorithm_spec, [ # explore_var is epsilon, tau or etc. depending on the action policy # these control the trade off between exploration and exploitaton 'explore_var_start', 'explore_var_end', 'explore_anneal_epi', 'gamma', # the discount factor 'training_epoch', # how many batches to train each time 'training_frequency', # how often to train (once a few timesteps) 'training_iters_per_batch', # how many times to train each batch 'training_min_timestep', # how long before starting training ])) self.nanflat_explore_var_a = [self.explore_var_start ] * self.agent.body_num
def init_nets(self): '''Initialize the neural network used to learn the Q function from the spec''' body = self.agent.nanflat_body_a[0] # single-body algo state_dim = body.state_dim # dimension of the environment state, e.g. 4 action_dim = body.action_dim # dimension of the environment actions, e.g. 2 net_spec = self.agent.spec['net'] net_kwargs = util.compact_dict( dict( hid_layers_activation=_.get(net_spec, 'hid_layers_activation'), optim_param=_.get(net_spec, 'optim'), loss_param=_.get(net_spec, 'loss'), clamp_grad=_.get(net_spec, 'clamp_grad'), clamp_grad_val=_.get(net_spec, 'clamp_grad_val'), )) self.net = getattr(net, net_spec['type'])(state_dim, net_spec['hid_layers'], action_dim, **net_kwargs) util.set_attr( self, _.pick( net_spec, [ # how many examples to learn per training iteration 'batch_size', 'decay_lr', 'decay_lr_frequency', 'decay_lr_min_timestep', ]))
def load(self, train_df): '''Load clock from the last row of body.train_df''' last_row = train_df.iloc[-1] last_clock_vals = ps.pick(last_row, *['epi', 't', 'wall_t', 'opt_step', 'frame']) util.set_attr(self, last_clock_vals) self.start_wall_t -= self.wall_t # offset elapsed wall_t
def save(self, commit=True): user = super().save(commit) cd = self.cleaned_data current_grade = Grade.objects.get_current() user.is_active = False user.save() user.participant_profile = Participant( **py_.pick( cd, "phone", "street", "city", "zip_code", "country", "school", "school_year", "school_alt_name", "schole_alt_street", "school_alt_city", "school_alt_zip_code", ) ) user.participant_profile.save() if current_grade: user.participant_profile.applications.add(current_grade) return user
def parse_form_args_for_model(model, extra_args=None, json=None, validator=True): # get all editable properties editable_props = model.EDITABLE_PROPS + (extra_args or []) return _.pick(json or request.form, editable_props)
def transform(device, with_description=False): item = pick( device, 'id', 'code', 'name', 'model', 'brand', 'tag_code', 'status', 'manufacturer_id', 'manufacturer_date', 'department_id', ) if with_description: item['description'] = device.description manufacturer = Manufacturer.query.filter_by( id=device.manufacturer_id, record_status=const.RECORD_NORMAL).first() item['manufacturer_name'] = manufacturer.name department = Department.query.filter_by( id=device.department_id, record_status=const.RECORD_NORMAL).first() item['department_code'] = department.code item['department_name'] = department.name return item
def init_nets(self): '''Initialize nets with multi-task dimensions, and set net params''' # NOTE: Separate init from MultitaskDQN despite similarities so that this implementation can support arbitrary sized state and action heads (e.g. multiple layers) net_spec = self.agent.spec['net'] if len(net_spec['hid_layers']) > 0: state_head_out_d = int(net_spec['hid_layers'][0] / 4) else: state_head_out_d = 16 self.state_dims = [ [body.state_dim, state_head_out_d] for body in self.agent.nanflat_body_a] self.action_dims = [ [body.action_dim] for body in self.agent.nanflat_body_a] self.total_state_dim = sum([s[0] for s in self.state_dims]) self.total_action_dim = sum([a[0] for a in self.action_dims]) logger.debug( f'State dims: {self.state_dims}, total: {self.total_state_dim}') logger.debug( f'Action dims: {self.action_dims}, total: {self.total_action_dim}') net_kwargs = util.compact_dict(dict( hid_layers_activation=_.get(net_spec, 'hid_layers_activation'), optim_param=_.get(net_spec, 'optim'), loss_param=_.get(net_spec, 'loss'), clamp_grad=_.get(net_spec, 'clamp_grad'), clamp_grad_val=_.get(net_spec, 'clamp_grad_val'), )) self.net = getattr(net, net_spec['type'])( self.state_dims, net_spec['hid_layers'], self.action_dims, **net_kwargs) self.target_net = getattr(net, net_spec['type'])( self.state_dims, net_spec['hid_layers'], self.action_dims, **net_kwargs) self.online_net = self.target_net self.eval_net = self.target_net util.set_attr(self, _.pick(net_spec, [ 'batch_size', 'update_type', 'update_frequency', 'polyak_weight', ]))
def set_attr(obj, attr_dict, keys=None): '''Set attribute of an object from a dict''' if keys is not None: attr_dict = ps.pick(attr_dict, keys) for attr, val in attr_dict.items(): setattr(obj, attr, val) return obj
def init_nets(self): '''Initialize nets with multi-task dimensions, and set net params''' self.state_dims = [ body.state_dim for body in self.agent.nanflat_body_a] self.action_dims = [ body.action_dim for body in self.agent.nanflat_body_a] self.total_state_dim = sum(self.state_dims) self.total_action_dim = sum(self.action_dims) net_spec = self.agent.spec['net'] net_kwargs = util.compact_dict(dict( hid_layers_activation=_.get(net_spec, 'hid_layers_activation'), optim_param=_.get(net_spec, 'optim'), loss_param=_.get(net_spec, 'loss'), clamp_grad=_.get(net_spec, 'clamp_grad'), clamp_grad_val=_.get(net_spec, 'clamp_grad_val'), )) self.net = getattr(net, net_spec['type'])( self.total_state_dim, net_spec['hid_layers'], self.total_action_dim, **net_kwargs) self.target_net = getattr(net, net_spec['type'])( self.total_state_dim, net_spec['hid_layers'], self.total_action_dim, **net_kwargs) self.online_net = self.target_net self.eval_net = self.target_net util.set_attr(self, _.pick(net_spec, [ 'batch_size', 'update_type', 'update_frequency', 'polyak_weight', ]))
def plot_session(session_spec, info_space, session_data): '''Plot the session graph, 2 panes: reward, loss & explore_var. Each aeb_df gets its own color''' graph_x = session_spec['meta'].get('graph_x', 'epi') aeb_count = len(session_data) palette = viz.get_palette(aeb_count) fig = viz.tools.make_subplots(rows=3, cols=1, shared_xaxes=True) for idx, (a, e, b) in enumerate(session_data): aeb_str = f'{a}{e}{b}' aeb_df = session_data[(a, e, b)] aeb_df.fillna(0, inplace=True) # for saving plot, cant have nan fig_1 = viz.plot_line(aeb_df, 'reward', graph_x, legend_name=aeb_str, draw=False, trace_kwargs={'legendgroup': aeb_str, 'line': {'color': palette[idx]}}) fig.append_trace(fig_1.data[0], 1, 1) fig_2 = viz.plot_line(aeb_df, ['loss'], graph_x, y2_col=['explore_var'], trace_kwargs={'legendgroup': aeb_str, 'showlegend': False, 'line': {'color': palette[idx]}}, draw=False) fig.append_trace(fig_2.data[0], 2, 1) fig.append_trace(fig_2.data[1], 3, 1) fig.layout['xaxis1'].update(title=graph_x, zerolinewidth=1) fig.layout['yaxis1'].update(fig_1.layout['yaxis']) fig.layout['yaxis1'].update(domain=[0.55, 1]) fig.layout['yaxis2'].update(fig_2.layout['yaxis']) fig.layout['yaxis2'].update(showgrid=False, domain=[0, 0.45]) fig.layout['yaxis3'].update(fig_2.layout['yaxis2']) fig.layout['yaxis3'].update(overlaying='y2', anchor='x2') fig.layout.update(ps.pick(fig_1.layout, ['legend'])) fig.layout.update(title=f'session graph: {session_spec["name"]} t{info_space.get("trial")} s{info_space.get("session")}', width=500, height=600) viz.plot(fig) return fig
def init_nets(self): '''Initialize networks''' body = self.agent.nanflat_body_a[0] # single-body algo state_dim = body.state_dim action_dim = body.action_dim net_spec = self.agent.spec['net'] net_kwargs = util.compact_dict(dict( hid_layers_activation=_.get(net_spec, 'hid_layers_activation'), optim_param=_.get(net_spec, 'optim'), loss_param=_.get(net_spec, 'loss'), clamp_grad=_.get(net_spec, 'clamp_grad'), clamp_grad_val=_.get(net_spec, 'clamp_grad_val'), )) self.net = getattr(net, net_spec['type'])( state_dim, net_spec['hid_layers'], action_dim, **net_kwargs) self.target_net = getattr(net, net_spec['type'])( state_dim, net_spec['hid_layers'], action_dim, **net_kwargs) self.online_net = self.target_net self.eval_net = self.target_net util.set_attr(self, _.pick(net_spec, [ 'batch_size', ])) # Default network update params for base self.update_type = 'replace' self.update_frequency = 1 self.polyak_weight = 0.0
def plot_session(session_spec, info_space, session_data): '''Plot the session graph, 2 panes: reward, loss & explore_var. Each aeb_df gets its own color''' aeb_count = len(session_data) palette = get_palette(aeb_count) fig = viz.tools.make_subplots(rows=3, cols=1, shared_xaxes=True) for idx, (a, e, b) in enumerate(session_data): aeb_str = f'{a}{e}{b}' aeb_df = session_data[(a, e, b)] aeb_df.fillna(0, inplace=True) # for saving plot, cant have nan fig_1 = viz.plot_line(aeb_df, 'reward', 'epi', legend_name=aeb_str, draw=False, trace_kwargs={'legendgroup': aeb_str, 'line': {'color': palette[idx]}}) fig.append_trace(fig_1.data[0], 1, 1) fig_2 = viz.plot_line(aeb_df, ['loss'], 'epi', y2_col=['explore_var'], trace_kwargs={'legendgroup': aeb_str, 'showlegend': False, 'line': {'color': palette[idx]}}, draw=False) fig.append_trace(fig_2.data[0], 2, 1) fig.append_trace(fig_2.data[1], 3, 1) fig.layout['xaxis1'].update(title='epi', zerolinewidth=1) fig.layout['yaxis1'].update(fig_1.layout['yaxis']) fig.layout['yaxis1'].update(domain=[0.55, 1]) fig.layout['yaxis2'].update(fig_2.layout['yaxis']) fig.layout['yaxis2'].update(showgrid=False, domain=[0, 0.45]) fig.layout['yaxis3'].update(fig_2.layout['yaxis2']) fig.layout['yaxis3'].update(overlaying='y2', anchor='x2') fig.layout.update(ps.pick(fig_1.layout, ['legend'])) fig.layout.update(title=f'session graph: {session_spec["name"]} t{info_space.get("trial")} s{info_space.get("session")}', width=500, height=600) viz.plot(fig) return fig
def test_query_key_by(db, model_class, data, iteratee, expected): """Test SQLQuery.key_by.""" db.save([model_class(item) for item in data]) results = db.query(model_class).key_by(iteratee) for key, value in results.items(): assert pyd.pick(dict(value), pyd.keys(expected[key])) == expected[key]
def transform(device_rent): item = pick(device_rent, 'id', 'device_code', 'status', 'borrower_member_code', 'borrower_department_id', 'borrow_date', 'borrow_remark', 'returner_member_code', 'return_remark', 'expect_return_date', 'real_return_date', ) device = Device.query.filter_by( code=device_rent.device_code, record_status=const.RECORD_NORMAL ).first() item['device_id'] = device.id item['device_name'] = device.name item['model'] = device.model item['brand'] = device.brand item['tag_code'] = device.tag_code item['description'] = device.description item['manufacturer_date'] = device.manufacturer_date item['department_id'] = device.department_id manufacturer = Manufacturer.query.filter_by( id=device.manufacturer_id, record_status=const.RECORD_NORMAL ).first() item['manufacturer'] = manufacturer.name device_department = Department.query.filter_by( id=device.department_id, record_status=const.RECORD_NORMAL ).first() item['department_code'] = device_department.code item['department_name'] = device_department.name borrower = Member.query.filter_by( code=device_rent.borrower_member_code, record_status=const.RECORD_NORMAL ).first() item['borrower_id'] = borrower.id item['borrower_name'] = borrower.name borrower_department = Department.query.filter_by( id=borrower.department_id, record_status=const.RECORD_NORMAL ).first() item['borrower_department_code'] = borrower_department.code item['borrower_department_name'] = borrower_department.name returner = Member.query.filter_by( code=device_rent.returner_member_code, record_status=const.RECORD_NORMAL ).first() item['returner_id'] = returner.id item['returner_name'] = returner.name return item
async def upsert(self, body): request = self._httpclient.request() req_body = pydash.pick(body, [ 'status', 'name', 'type_specific', 'release_version', 'type', 'uuid' ]) req_json_body = json.dumps(req_body) #req_json_body = req_body url = self._httpclient.scheduler_url('/workers/') try: headers = {'Content-type': 'application/json'} async with request.put(url, data=req_json_body) as r: #TODO error json_data = await r.json() #await request.close() print(r) print(json_data) print('upset done') return json_data except Exception as exc: print(exc) pass
def run_around_tests(): query = pick(sample_config, 'tenant', 'integration_type') collection.delete_one(query) yield # Run the test collection.delete_one(query)
def _map(item): values = [ v for i, v in enumerate(pick(attr.asdict(item), fields).values()) ] return DataRecord(formulation=item.formulation, fields=fields, values=values)
def init_nets(self): super(DQN, self).init_nets() # Network update params net_spec = self.agent.spec['net'] util.set_attr(self, _.pick(net_spec, [ 'update_type', 'update_frequency', 'polyak_weight', ]))
def test_get_config(): query = pick(sample_config, 'tenant', 'integration_type') collection.update_one(query, {'$set': sample_config}, upsert=True) uri = '/config?tenant=acme&integration_type=flight-information-system' _, response = app.test_client.get(uri) assert response.status == 200 assert response.json == sample_config
def transform(field): sportsfield_data = pick(field, 'id', 'court_name', 'description', 'court_type', 'court_count', 'court_fee', 'period_class_id', 'order_days') period_class_id = sportsfield_data['period_class_id'] period_class_name = PeriodClass.query.filter_by(id=period_class_id).first() sportsfield_data['period_class_name'] = period_class_name.period_class_name return sportsfield_data
def test_query_stack_by(db, model_class, data, iteratee, expected): """Test SQLQuery.stack_by.""" db.save([model_class(item) for item in data]) results = db.query(model_class).stack_by(iteratee) for key, items in results.items(): items = [pyd.pick(dict(item), pyd.keys(expected[key][0])) for item in items] assert items == expected[key]
def plot_go( df, y_col=None, x_col='index', y2_col=None, title=None, y_title=None, x_title=None, x_type=None, legend_name=None, width=500, height=350, draw=True, save=False, filename=None, trace_class='Scatter', trace_kwargs=None, layout_kwargs=None): ''' Quickly plot from df using trace_class, e.g. go.Scatter 1. create_label() to auto-resolve labels 2. create_layout() with go.Layout() and update(layout_kwargs) 3. spread and create go.<trace_class>() and update(trace_kwargs) 4. Create the figure and plot accordingly @returns figure ''' df = df.copy() if x_col == 'index': df['index'] = df.index.tolist() label = create_label(y_col, x_col, title, y_title, x_title, legend_name) layout = create_layout( x_type=x_type, width=width, height=height, layout_kwargs=layout_kwargs, **ps.pick(label, ['title', 'y_title', 'x_title'])) y_col_list, x_col_list = label['y_col_list'], label['x_col_list'] if y2_col is not None: label2 = create_label(y2_col, x_col, title, y_title, x_title, legend_name) layout.update(dict(yaxis2=dict( rangemode='tozero', title=label2['y_title'], side='right', overlaying='y1', anchor='x1', ))) y2_col_list, x_col_list = label2['y_col_list'], label2['x_col_list'] label2_legend_name_list = label2['legend_name_list'] else: y2_col_list = [] label2_legend_name_list = [] combo_y_col_list = y_col_list + y2_col_list combo_legend_name_list = label['legend_name_list'] + label2_legend_name_list y_col_num, x_col_num = len(combo_y_col_list), len(x_col_list) trace_num = max(y_col_num, x_col_num) data = [] for idx in range(trace_num): y_c = ps.get(combo_y_col_list, idx % y_col_num) x_c = ps.get(x_col_list, idx % x_col_num) df_y, df_x = ps.get(df, y_c), ps.get(df, x_c) trace = ps.get(go, trace_class)(y=df_y, x=df_x, name=combo_legend_name_list[idx]) trace.update(trace_kwargs) if idx >= len(y_col_list): trace.update(dict(yaxis='y2', xaxis='x1')) data.append(trace) figure = go.Figure(data=data, layout=layout) if draw: plot(figure) if save: save_image(figure, filename=filename) return figure
def set_net_attributes(self): '''Initializes additional parameters from the net spec. Called by init_nets''' net_spec = self.agent.spec['net'] util.set_attr(self, _.pick(net_spec, [ 'decay_lr', 'decay_lr_frequency', 'decay_lr_min_timestep', 'gpu' ])) if not hasattr(self, 'gpu'): self.gpu = False logger.info(f'Training on gpu: {self.gpu}')
def plot_go( df, y_col=None, x_col='index', y2_col=None, title=None, y_title=None, x_title=None, x_type=None, legend_name=None, width=500, height=350, draw=True, save=False, filename=None, trace_class='Scatter', trace_kwargs=None, layout_kwargs=None): ''' Quickly plot from df using trace_class, e.g. go.Scatter 1. create_label() to auto-resolve labels 2. create_layout() with go.Layout() and update(layout_kwargs) 3. spread and create go.<trace_class>() and update(trace_kwargs) 4. Create the figure and plot accordingly @returns figure ''' df = df.copy() if x_col == 'index': df['index'] = df.index.tolist() label = create_label(y_col, x_col, title, y_title, x_title, legend_name) layout = create_layout( x_type=x_type, width=width, height=height, layout_kwargs=layout_kwargs, **ps.pick(label, ['title', 'y_title', 'x_title'])) y_col_list, x_col_list = label['y_col_list'], label['x_col_list'] if y2_col is not None: label2 = create_label(y2_col, x_col, title, y_title, x_title, legend_name) layout.update(dict(yaxis2=dict( rangemode='tozero', title=label2['y_title'], side='right', overlaying='y1', anchor='x1', ))) y2_col_list, x_col_list = label2['y_col_list'], label2['x_col_list'] label2_legend_name_list = label2['legend_name_list'] else: y2_col_list = [] label2_legend_name_list = [] combo_y_col_list = y_col_list + y2_col_list combo_legend_name_list = label['legend_name_list'] + label2_legend_name_list y_col_num, x_col_num = len(combo_y_col_list), len(x_col_list) trace_num = max(y_col_num, x_col_num) data = [] for idx in range(trace_num): y_c = ps.get(combo_y_col_list, idx % y_col_num) x_c = ps.get(x_col_list, idx % x_col_num) df_y, df_x = ps.get(df, y_c), ps.get(df, x_c) trace = ps.get(go, trace_class)(y=df_y, x=df_x, name=combo_legend_name_list[idx]) trace.update(trace_kwargs) if idx >= len(y_col_list): trace.update(dict(yaxis='y2', xaxis='x1')) data.append(trace) figure = go.Figure(data=data, layout=layout) if draw: plot(figure) if save: save_image(figure, filename=filename) return figure
def appInfo(): root_path = os.path.join(app.root_path, '..') file = open(root_path + '/package.json') json_data = file.read() data = json.loads(json_data) file.close() return pick(data, ['name', 'provider', 'description', 'version', 'license'])
def extract(s, i): d = _.pick( s['item'], ['id', 'mallProductId', 'productTitle', 'imageUrl', 'rank']) is_ad = isinstance(d['rank'], str) d['isAd'] = is_ad d['displayRank'] = i + 1 if is_ad: d['rank'] = int(d['rank']) return d
def get_auth_module(cls): if cls.json_auth in request.json: args = _.pick(request.json.get(cls.json_auth), [cls.json_email, cls.json_password, cls.json_refresh_token, cls.json_google_token]) if cls.json_password in args and cls.json_email in args: # authType is password return EmailAuth(args.get(cls.json_email), args.get(cls.json_password)) elif cls.json_refresh_token in args: # refresh token time return RefreshTokenAuth(args.get(cls.json_refresh_token)) elif cls.json_google_token in args: return GoogleAuth(args.get(cls.json_google_token)) return None
def post(self): # lists all the products args = _.pick(request.json, TransactionModel.PUBLIC_PROPERTIES + ['merchant_id', 'product_id']) merchant_db = product_db = None if args.get('merchant_id'): # do a look up url = "https://www.delivery.com/api/merchant/%s?client_id=brewhacks2016" % args.get('merchant_id') result = urlfetch.fetch(url) if result.status_code == 200: data = json.loads(result.content) merchant_db = scraper.parse_merchant(data.get('merchant')) args['merchant_key'] = merchant_db._key else: args['merchant_key'] = ndb.Key(urlsafe=args.get('merchant_key')) merchant_db = args.get('merchant_key').get() if not merchant_db: # look it up errors.create(404, message="merchant not found") # do products if args.get('product_id'): # do a look up url = "https://www.delivery.com/api/data/product/%(product)s?merchant_id=%(merchant)s" \ "&client_id=brewhacks2016" % dict(product=args.get('product_id'), merchant=args.get('merchant_id')) result = urlfetch.fetch(url) if result.status_code == 200: data = json.loads(result.content) product_db = scraper.parse_product(data.get('item')[0], data.get('item')[0].get('id')) args['product_key'] = product_db._key else: args['product_key'] = ndb.Key(urlsafe=args.get('product_key')) product_db = args.get('product_key').get() if not product_db: # look it up errors.create(404, message="product not found") args['merchant'] = merchant_db args['product'] = product_db transaction_db = TransactionModel(**args) transaction_db.put() return transaction_db.to_dict(include=TransactionModel.get_public_properties())
def __on_battle_player_added(self, player): database.insert_battle_player(**_.pick(player, 'id', 'name')) database.insert_vehicle(id=player['vehicle_id'], player_id=player['id'], is_alive=player['is_alive'])
def test_pick(case, expected): assert _.pick(*case) == expected