def test_verbose(self): qs = TradeLog.objects.all() df = read_frame(qs, verbose=True) self.assertListEqual( list(qs.values_list('trader__name', flat=True)), df.trader.tolist() ) df1 = read_frame(qs, verbose=False) self.assertListEqual( list(qs.values_list('trader__pk', flat=True)), df1.trader.tolist() ) # Testing verbose with annotated column: if django.VERSION >= (1, 10): from django.db.models import F, FloatField from django.db.models.functions import Cast qs1 = TradeLog.objects.all().annotate( total_sum=Cast(F('price') * F('volume'), FloatField()), ) df2 = read_frame( qs1, fieldnames=['trader', 'total_sum']) self.assertListEqual( list(qs1.values_list('total_sum', flat=True)), df2.total_sum.tolist() ) self.assertListEqual( list(qs1.values_list('trader__name', flat=True)), df2.trader.tolist() )
def test_basic(self): qs = MyModel.objects.all() df = read_frame(qs) n, c = df.shape self.assertEqual(n, qs.count()) fields = MyModel._meta.get_all_field_names() self.assertEqual(c, len(fields)) df1 = read_frame(qs, ['col1', 'col2']) self.assertEqual(df1.shape, (qs.count(), 2))
def test_verbose(self): qs = TradeLog.objects.all() df = read_frame(qs, verbose=True) self.assertListEqual( list(qs.values_list('trader__name', flat=True)), df.trader.tolist() ) df1 = read_frame(qs, verbose=False) self.assertListEqual( list(qs.values_list('trader__pk', flat=True)), df1.trader.tolist() )
def test_basic(self): qs = MyModel.objects.all() df = read_frame(qs) n, c = df.shape self.assertEqual(n, qs.count()) if django.VERSION < (1, 10): fields = MyModel._meta.get_all_field_names() else: fields = [f.name for f in MyModel._meta.get_fields()] self.assertEqual(c, len(fields)) df1 = read_frame(qs, ['col1', 'col2']) self.assertEqual(df1.shape, (qs.count(), 2))
def test_index(self): qs = MyModel.objects.all() df = read_frame(qs, ['col1', 'col2', 'col3', 'col4'], index_col='index_col') self.assertEqual(df.shape, (qs.count(), 4)) self.assertEqual(set(df.index.tolist()), set(qs.values_list('index_col', flat=True)))
def export_to_xls_users(self, request, queryset): df = pd.DataFrame() for el in queryset: users = el.get_filtered_user_queryset() users = users.annotate(userlogins=Count('usersession')) users = users.annotate(usertime=Sum('usersession__duration')) df = pd.concat([df, read_frame(users, index_col='user__id', verbose=True, fieldnames=( 'user__id', 'user__username', 'user__first_name', 'user__last_name', 'patronimyc', 'user__email', 'user__last_login', 'userlogins', 'usertime', 'date_of_birth', 'age', 'gender', 'city__name', 'area__name', 'score', 'total_score', 'total_exchange', 'speciality__name', 'work__name', 'curing_form', 'position__name', 'category', 'bed_quantity', 'patient_quantity', 'main_phone', 'secondary_phone', 'work_phone', 'district', 'house', 'flat', 'index',))]) df = translate_column_names(df) return export_to_xls(df, translit(el.name) + '.xls', engine='openpyxl')
def get_openings_df(from_date, to_date, freq='H'): query = {} if from_date is not None: query['time__gte'] = from_date if to_date is not None: query['time__lt'] = to_date # Grab openings in a pandas dataframe df = read_frame(SpaceStatus.objects.filter(**query)) start = pd.to_datetime(from_date).tz_localize('Europe/Brussels') end = pd.to_datetime(to_date).tz_localize('Europe/Brussels') # No records found, just return a fake df, always closed if len(df) == 0: df = pd.DataFrame([ {'time': start, 'is_open': 0}, {'time': end, 'is_open': 0} ]) # Drop duplicate time index df = df.groupby(df.time).last() start = start.replace(minute=0, second=0, microsecond=0) end = end.replace(minute=0, second=0, microsecond=0) # Reindex on a monotonic time index index = pd.date_range(start=start, end=end, freq=freq) df = df.reindex(index, method='ffill') nans = np.isnan(df.is_open.astype(np.float64)) df[nans] = not df[~nans].is_open[0] return df
def test_basic(self): qs = MyModel.objects.all() df = read_frame(qs) n, c = df.shape self.assertEqual(n, qs.count()) from itertools import chain if django.VERSION < (1, 10): fields = MyModel._meta.get_all_field_names() else: fields = list(set(chain.from_iterable((field.name, field.attname) if hasattr(field, 'attname') else (field.name,) for field in MyModel._meta.get_fields() if not (field.many_to_one and field.related_model is None) ))) self.assertEqual(c, len(fields)) df1 = read_frame(qs, ['col1', 'col2']) self.assertEqual(df1.shape, (qs.count(), 2))
def test_verbose_duplicates_fieldnames(self): qs = TradeLog.objects.all() df = read_frame(qs, fieldnames=['trader', 'trader', 'price']) self.assertListEqual( list(qs.values_list('price', flat=True)), df.price.tolist() )
def export_to_xls_user_poll(self, request, queryset): uf = queryset[0] users = uf.get_filtered_user_queryset() if not uf.polls: uf.polls = Poll.objects.all() polls = UsersPoll.objects.filter(user__pk__in=users.values_list('pk'), poll__pk__in=uf.polls.values_list('pk'), ) if uf.date_from: polls = polls.filter(date_passed__lte=uf.date_from) if uf.date_to: polls = polls.filter(date_passed__gte=uf.date_to) polls = Poll.objects.filter(pk__in=polls.values_list('poll')) answers = UserAnswer.objects.filter(user__pk__in=users.values_list('pk'), question__poll__pk__in=polls.values_list('pk')) answers = answers.order_by(uf.order, set(ORDERS - set(uf.order)).pop(), 'question__id', 'answer__id') df = read_frame(answers, verbose=True, fieldnames=( 'user__user__id', 'user__user__username', 'question__poll__id', 'question__poll__name', 'question__id', 'question__question_text', 'answer__id', 'answer__answer_text', 'other_answer', )) df = translate_column_names(df) return export_to_xls(df, translit(uf.group.name) + '.xls', engine='openpyxl')
def poll_to_xls(request, queryset): qs = None for poll in queryset: if qs: qs |= Answer.objects.filter(question__poll=poll.id) else: qs = Answer.objects.filter(question__poll=poll.id) qs = qs.annotate(useranswers=Count('useranswer')) qs = qs.order_by('-question__poll__id', 'question__id', 'id') df = read_frame(qs, verbose=True, fieldnames=('question__poll__id', 'question__poll__name', 'question__id', 'question__question_text', 'id', 'answer_text', 'useranswers' )) for i, row in df.iterrows(): question = df.loc[i, 'question__id'] answers = df.loc[i, 'useranswers'] total_counts = sum(df[df['question__id'] == question]['useranswers']) if total_counts: percent = answers / total_counts * 100 else: percent = 0 df.ix[i, 'percent'] = str(percent) + '%' i = dt.datetime.now() path = 'oprosy' + "_%s_%s_%s" % (i.day, i.month, i.year) + '.xls' df = translate_column_names(df) return export_to_xls(df, path)
def to_dataframe(self, fieldnames=(), verbose=True, index=None, coerce_float=False): """ Returns a DataFrame from the queryset, overrides the base method to enalbe lazy calculation :param fieldnames: The model field names(columns) to utilise in creating the DataFrame. You can span a relationships in the usual Django ORM way by using the foreign key field name separated by double underscores and refer to a field in a related model. :param index: specify the field to use for the index. If the index field is not in fieldnames it will be appended. This is mandatory for timeseries. :param verbose: If this is ``True`` then populate the DataFrame with the human readable versions for foreign key fields else use the actual values set in the model """ if self.count_invalid() < self.MAX_NUM_CALCULATION: outdated_values = self.filter(_is_valid=False) outdated_values.recalculation() #pylint: disable=E1101 read_calc_value = '_calc_value' in fieldnames if 'value' in fieldnames: fieldnames[fieldnames.index('value')] = '_calc_value' frame = read_frame(self, fieldnames=fieldnames, verbose=verbose, index_col=index, coerce_float=coerce_float) if '_calc_value' in frame.columns and not read_calc_value: new_labels = list(frame.columns) new_labels[new_labels.index('_calc_value')] = 'value' frame.columns = new_labels return frame
def similar_products2(deep_f): qs = Product.objects.all() df=read_frame(qs) df['idx'] = range(1, len(df) + 1) feature_list=[] asin_list=[] for prod in qs: feature_list.append(prod.get_features()) asin_list.append(prod.asin) nparray = np.asarray(feature_list) #print nparray tree = BallTree(nparray) dist, ind = tree.query(deep_f, k=5) print ind index = ind[0] recom = index[0:] recommended_asins =[]; for i in recom: recommended_asins.append(asin_list[i]) recommended_prods = Product.objects.filter(asin__in = recommended_asins) return recommended_prods # image_train = graphlab.SFrame(data=df) # cur_prod = image_train[18:19] # print cur_prod # print image_train # knn_model = graphlab.nearest_neighbors.create(image_train, features = ['features'],label = 'asin',distance = 'levenshtein',method = 'ball_tree') # knn_model.save('my_knn') # #knn_model= graphlab.load_model('my_knn') # #print knn_model.query(cur_prod) # #knn_model = graphlab.nearest_neighbors.create(image_train, features = ['features'],label = 'keywords')
def similar_products(product): qs = Product.objects.all() df=read_frame(qs) df['idx'] = range(1, len(df) + 1) feature_list=[] asin_list=[] product_index = 0 inn=0 for prod in qs: feature_list.append(prod.get_features()) asin_list.append(prod.asin) if prod.asin == product.asin: product_index = inn inn+=1 nparray = np.asarray(feature_list) #print nparray tree = BallTree(nparray) dist, ind = tree.query(nparray[product_index], k=5) print ind index = ind[0] recom = index[1:] recommended_asins =[]; for i in recom: recommended_asins.append(asin_list[i]) recommended_prods = Product.objects.filter(asin__in = recommended_asins) return recommended_prods
def test_duplicate_annotation(self): qs = MyModel.objects.all() qs = qs.values('index_col') qs = qs.annotate(col1=Sum('col1')) qs = qs.values() df = read_frame(qs) self.assertEqual(list(df.columns), ['id', 'index_col', 'col1', 'col2', 'col3', 'col4'])
def dataset_detail(request, dataset_id): dataset = get_object_or_404(DataSet, pk=dataset_id) DataSetModel = getattr(shop.models, dataset.code) qs = DataSetModel.objects.all() df = read_frame(qs) df.to_pickle("dataset/{}".format(dataset.code)) datahtml = df.to_html() return render(request, 'shop/dataset/detail.html', {'dataset': dataset, 'datavalues': datahtml})
def test_related_cols(self): qs = TradeLog.objects.all() cols = ["log_datetime", "symbol", "symbol__isin", "trader__name", "price", "volume", "note__note"] df = read_frame(qs, cols, verbose=False) self.assertEqual(df.shape, (qs.count(), len(cols))) self.assertListEqual(list(qs.values_list("symbol__isin", flat=True)), df.symbol__isin.tolist()) self.assertListEqual(list(qs.values_list("trader__name", flat=True)), df.trader__name.tolist())
def test_values(self): qs = MyModel.objects.all() qs = qs.extra(select={"ecol1": "col1+1"}) qs = qs.values("index_col", "ecol1", "col1") qs = qs.annotate(scol1 = Sum("col1")) df = read_frame(qs) self.assertEqual(list(df.columns), ['index_col', 'col1', 'scol1', 'ecol1']) self.assertEqual(list(df["col1"]), list(df["scol1"]))
def test_choices(self): MyModelChoice.objects.create(col1=1, col2=9999.99) MyModelChoice.objects.create(col1=2, col2=0.99) MyModelChoice.objects.create(col1=3, col2=45.6) MyModelChoice.objects.create(col1=2, col2=2.6) qs = MyModelChoice.objects.all() df = read_frame(qs, verbose=True) self.assertEqual(df.col1[0], 'First') self.assertEqual(df.col1[1], 'Second') self.assertEqual(df.col1[2], 'Third') self.assertEqual(df.col1[3], 'Second') df = read_frame(qs, verbose=False) self.assertEqual(df.col1[0], 1) self.assertEqual(df.col1[1], 2) self.assertEqual(df.col1[2], 3) self.assertEqual(df.col1[3], 2)
def get_openings_df(freq='H', **filter_args): # Grab openings in a pandas dataframe df = read_frame(SpaceStatus.objects.filter(**filter_args)) # Drop duplicate time index df = df[df.time.diff().dt.total_seconds() > 0] df.index = df.time # Reindex on a monotonic hourly time index index = pd.date_range(start=df.time.min(), end=df.time.max(), freq=freq) return df.reindex(index, method='pad')
def test_many_to_many(self): qs = Portfolio.objects.all() cols = ['name', 'securities__symbol', 'securities__tradelog__log_datetime'] df = read_frame(qs, cols, verbose=True) denormalized = Portfolio.objects.all().values_list(*cols) self.assertEqual(df.shape, (len(denormalized), len(cols))) for idx, row in enumerate(denormalized): self.assertListEqual( df.iloc[idx].tolist(), list(row) )
def get_user_data(username): """Get user's personal data.""" dfs = {} df = read_frame(Video.objects.all(), fieldnames=['id', 'video_id'] + VIDEO_FIELDS) dfs['all_video_ratings'] = df df = read_frame( VideoRating.objects.filter(user__user__username=username).all()) dfs['my_video_scores'] = df df = read_frame( ExpertRating.objects.filter(user__user__username=username).all()) dfs['my_expert_ratings'] = df df = read_frame( VideoReports.objects.filter(user__user__username=username).all()) df.columns = [ VIDEO_REPORT_FIELDS[x] if x in VIDEO_REPORT_FIELDS else x for x in df.columns ] dfs['my_video_reports'] = df df = read_frame( VideoComment.objects.filter(user__user__username=username).all()) dfs['my_video_comments'] = df df = read_frame( VideoCommentMarker.objects.filter(user__user__username=username).all(), fieldnames=['id', 'user', 'comment__id', 'user', 'which']) dfs['my_video_comment_markers'] = df return dfs
def read_ligand_batches(ligand_batch): object_capitalized = ligand_batch.capitalize() model = get_model_by_name(object_capitalized) if ligand_batch in ["peptideBatch","antibodyBatch", "complexBatch"]: df = read_frame(model.objects.all(), ["sid", "labeling", "concentration","buffer", "ph","purity", "produced_by__username", "production_date", "comment", "ligand__sid"]) df.replace([np.NaN], [None], inplace=True) df['purity'] = list(map(str, df['purity'].values)) df['concentration'] = list(map(str, df['concentration'].values)) elif ligand_batch == "virusBatch": df = read_frame(model.objects.all(), ["sid", "labeling", "concentration","buffer", "ph","purity", "produced_by__username", "production_date", "comment", "ligand__sid", "passage_history","active"]) df.replace([np.NaN], [None], inplace=True) df['active'] = list(map(str, df['active'].values)) df['passage_history'] = list(map(str, df['passage_history'].values)) df['purity'] = list(map(str, df['purity'].values)) df['concentration'] = list(map(str, df['concentration'].values) ) elif ligand_batch == "bufferBatch": df = read_frame(model.objects.all(), ["sid", "buffer", "ph", "produced_by__username", "production_date", "comment"]) df.replace([np.NaN], [None], inplace=True) df['ph']=list(map(str, df['ph'].values)) df['production_date']=list(map(str, df['production_date'].values)) df.replace(["None"],[None], inplace=True) df = df.rename(columns={"ligand__sid":"ligand","produced_by__username":"******"}) return df
def anticodon_counts(request, clade_txid, isotype): try: tax_qs = models.Taxonomy.objects.filter(taxid=clade_txid).values( 'name', 'rank', 'taxid', 'domain') if len(tax_qs) > 1: tax_qs = tax_qs.exclude(rank='assembly') tax = tax_qs.get() if tax['rank'] == 'class': tax['rank'] = 'taxclass' trna_qs = models.tRNA.objects.filter(Q(**{tax['rank']: tax['taxid']})) if isotype != 'All': trna_qs = trna_qs.filter(isotype=isotype) trna_qs = trna_qs.values('anticodon', 'isotype').annotate(clade=Count('anticodon')) clade_counts = read_frame(trna_qs) clade_counts = clade_counts.set_index(['isotype', 'anticodon']) domain_name = models.Taxonomy.objects.filter( taxid=tax['domain']).get().name trna_qs = models.tRNA.objects.filter(domain=tax['domain']) if isotype != 'All': trna_qs = trna_qs.filter(isotype=isotype) trna_qs = trna_qs.values('anticodon', 'isotype').annotate(domain=Count('anticodon')) domain_counts = read_frame(trna_qs) domain_counts = domain_counts.set_index(['isotype', 'anticodon']) counts = clade_counts.join(domain_counts).sort_index().reset_index() counts.columns = ['Isotype', 'Anticodon', tax['name'], domain_name] counts = counts.set_index(['Isotype', 'Anticodon']) counts.index.names = [None, None] return HttpResponse( counts.to_html(classes='table', border=0, justify='left', bold_rows=False, na_rep='0', sparsify=True)) except: return HttpResponse('Unknown server error')
def get_database_as_pd(): """Get database tables as pandas DataFrames.""" result_df = {} df = read_frame(Video.objects.all(), fieldnames=[ 'id', 'video_id', 'name', 'duration', 'language', 'publication_date', 'views', 'uploader' ] + VIDEO_FIELDS) result_df['videos'] = df df = read_frame(VideoRating.objects.all()) result_df['video_ratings'] = df df = read_frame(ExpertRating.objects.all()) result_df['expert_rating'] = df df = read_frame(DjangoUser.objects.all(), fieldnames=[ 'id', 'last_login', 'is_superuser', 'username', 'first_name', 'last_name', 'is_staff', 'is_active', 'date_joined', 'email', 'userpreferences__id' ] + [f"userpreferences__{x}" for x in VIDEO_FIELDS]) result_df['users'] = df df = read_frame(VideoComment.objects.all()) result_df['video_comment'] = df df = read_frame(VideoCommentMarker.objects.all(), fieldnames=['id', 'user', 'comment__id', 'user', 'which']) result_df['video_comment_marker'] = df return result_df
def scoreJson(request): print (request.body) qs = rankings.objects.all() df = read_frame(qs) df['weighted_points'] = df['cur_year_avg_weighted'] + df['two_year_ago_weighted'] + df['three_year_ago_weighted'] data = json.loads(request.body) x = data['Home'].capitalize() y = data['Away'].capitalize() home = df.loc[df['country_full'] == x] away = df.loc[df['country_full'] == y] frames = [home, away] result = pd.concat(frames) if x in df['country_full'].values and y in df['country_full'].values: X_test3 = ['average_rank', 'rank_difference', 'point_difference', 'is_stake'] row = pd.DataFrame(np.array([[np.nan, np.nan, np.nan, True]]), columns=X_test3) home_rank = result['rank'].iloc[0] home_points = result['weighted_points'].iloc[0] opp_rank = result['rank'].iloc[1] opp_points = result['weighted_points'].iloc[1] row['average_rank'] = (home_rank + opp_rank) / 2 row['rank_difference'] = home_rank - opp_rank row['point_difference'] = home_points - opp_points home_win = model.predict_proba(row) print(home_win) #dataF = pd.DataFrame({'x':data}) #print(dataF) #print(df) if home_win[0][0]>=0.45 and home_win[0][0]<=0.55: r="draw" print(r) return JsonResponse({'result':r}) if home_win[0][0]>0.55: r = result['country_full'].iloc[1], "win with a probability of",home_win[0][0] print(r) return JsonResponse({'result':r}) if home_win[0][1]>0.55: r = result['country_full'].iloc[0], "win with a probability of",home_win[0][1] print(r) return JsonResponse({'result':r}) else: return JsonResponse({'result':'Error team not found!'})
def json(request): qs = Stock.objects.all() df = read_frame(qs) df2 = df.groupby(['symbol']) # d1 = df2['symbol'] d = ["hhh", "hhhh", "kkkk"] d1 = df2.to_dict() context = { 'latest_question_list': "error", } template = loader.get_template('stock/json.html') return JsonResponse({'foo': d1})
def get_ratings_dataframe(self, run): rating_qs = self.filter(run=run).values("id", "parent_network__pk", "log_gamma", "log_gamma_uncertainty", "log_gamma_game_count").all() rating = read_frame(rating_qs) rating = rating.set_index("id") rating = rating.sort_index() rating["parent_network__pk"] = rating["parent_network__pk"].fillna(-1) rating["log_gamma"] = rating["log_gamma"].fillna(0) rating["log_gamma_uncertainty"] = rating["log_gamma_uncertainty"].fillna(0) rating["log_gamma_uncertainty"] = rating["log_gamma_uncertainty"].replace([np.inf, -np.inf], 0) rating["log_gamma_game_count"] = rating["log_gamma_game_count"].fillna(0) return rating
def MakeDf(self): """[summary] make pd.DataFrame(df) from candles, df.rows=['time', 'open', 'high', 'low', 'close', 'volume'], df.index = df.time, where df.time.dtype = datetime64[ns].len(df) = self.num_data Returns: [type]: [description] pd.DataFrame """ df = read_frame( self.datas.objects.filter( product_code=self.product_code).all().order_by("time")) df = df[["time", 'open', 'high', 'low', 'close', 'volume']] df = df.set_index("time") df = df[-self.num_data:] return df
def publication_tags(self): if self._publication_tags is None: self._publication_tags = read_frame( PublicationTags.objects.filter( publication__in=self.publication_queryset), fieldnames=['publication__id', 'tag__id', 'tag__name'], index_col='publication__id') self._publication_tags.rename(columns={ 'tag__name': 'name', 'tag__id': 'related__id' }, inplace=True) return self._publication_tags
def procesa_tabla(tabla): df= read_frame(tabla) for item in tabla: print(item.temperatura) for item in tabla: print(item.color) for item in tabla: print(item.inflamacion) print(df) return "Mi proceso"
def test_related_cols(self): qs = TradeLog.objects.all() cols = [ 'log_datetime', 'symbol', 'symbol__isin', 'trader__name', 'price', 'volume', 'note__note' ] df = read_frame(qs, cols, verbose=False) self.assertEqual(df.shape, (qs.count(), len(cols))) self.assertListEqual(list(qs.values_list('symbol__isin', flat=True)), df.symbol__isin.tolist()) self.assertListEqual(list(qs.values_list('trader__name', flat=True)), df.trader__name.tolist())
def get_user_data(username): """Get user's personal data.""" dfs = {} df = read_frame( VideoRating.objects.filter(user__user__username=username).all()) dfs['my_video_scores'] = df df = read_frame( ExpertRating.objects.filter(user__user__username=username).all()) dfs['my_expert_ratings'] = df df = read_frame( VideoComment.objects.filter(user__user__username=username).all()) dfs['my_video_comments'] = df df = read_frame( VideoCommentMarker.objects.filter(user__user__username=username).all(), fieldnames=['id', 'user', 'comment__id', 'user', 'which']) dfs['my_video_comment_markers'] = df return dfs
def index(request): boyds = BlackOystercatcher.objects.all() df = read_frame(boyds) ids = df['bird_id'] data = df.head(0) template = loader.get_template('data_playground/index.html') context = { 'props': json.dumps(ids.tolist()), 'df': df, 'data': data, 'ids': ids } return HttpResponse(template.render(context, request))
def bird_lookup(bird_type): """Combine datasets for given bird and year""" # Retrieve datasets routes = read_frame( Routes.objects.values('countrynum', 'statenum', 'route', 'routename', 'active', 'latitude', 'longitude')) weather = read_frame( Weather.objects.values('countrynum', 'statenum', 'route', 'year', 'routedataid', 'rpid')) species = read_frame(Species.objects.values('aou', 'english_common_name')) total_state_df = read_frame( UsStates.objects.filter(aou=bird_type).values('countrynum', 'statenum', 'route', 'year', 'routedataid', 'rpid', 'aou', 'stoptotal', 'speciestotal')) # Merge into one dataframe all_df = pd.merge(weather, routes, how='left', left_on=['countrynum', 'statenum', 'route'], right_on=['countrynum', 'statenum', 'route']) all_df = pd.merge(all_df, total_state_df, how='right', left_on=[ 'countrynum', 'statenum', 'route', 'routedataid', 'rpid', 'year' ], right_on=[ 'countrynum', 'statenum', 'route', 'routedataid', 'rpid', 'year' ]) all_df = pd.merge(all_df, species, how='left', on='aou') # Get sizes of dots per number of sightings all_df['species_size'] = all_df['speciestotal'].apply(species_sizer) all_df['routename'] = [capwords(state) for state in all_df['routename']] return (all_df)
def update_rules(request): if request.user.is_authenticated: my_tags = UserRule.objects.filter(user=request.user).all() df = read_frame(my_tags) df = df[[ 'begins_with', 'ends_with', 'description', 'category', 'tag', 'id' ]] df = df.values.tolist() template = loader.get_template('core_app/rule_details.html') context = {'results': df} return HttpResponse(template.render(context, request)) else: return redirect('home')
def sampleScenario(number_of_points=100, buffer_size_km=10, feature_names=[ "statenm", "statecd", "stateab", "subp", "n_inventor", "elev", "invyr", "tree", "spcd", "family", "ht_m", "ba_m2", "biomass_kg" ]): points = sampleScenario1pre(number_of_points=number_of_points) selections = selectFromBuffer(points, buffer_size_km) dfsels = map(lambda q: read_frame(q, fieldnames=feature_names), selections) ## compent if prefer custom feature selection dfsels = getSummaryStatistics(dfsels) return dfsels
def home(request): try: a = Start.objects.all() if request.method == "GET": b = read_frame(a) return render(request, 'myapp/home.html', {'b': b}) c = request.POST['resname'] m = request.POST['addSuggestion'] if (m == "0"): q = Start.objects.values("coupon").filter(name=c) qq = read_frame(q) print(q) # qqq = qq.coupon # return HttpResponse(q) return render(request, 'myapp/coupon.html', {'cou': qq}) else: b = read_frame(a) suggestion = AddSuggestion.objects.create(suggestion=c) return render(request, 'myapp/home.html', {'b': b}) except MultiValueDictKeyError: return render(request, 'myapp/home.html')
def handle(self, *args, **kwargs): # Create a version version_obj, created = Version.objects.get_or_create( reference='200101_demo', version_date=datetime(2020, 1, 1)) if kwargs['clean'] and not created: # Delete old data self.stdout.write('Deleting existing forecast...') forecast_objs = Forecast.objects.filter(version=version_obj) forecast_objs.delete() self.stdout.write('Existing forecast deleted') # Get past orders order_qs = OrderDetail.objects.values('warehouse__id', 'product__id', 'category__id', 'circuit__id', 'customer__id', 'ordered_quantity', 'order__ordered_at') order_df = read_frame(order_qs) order_df['ordered_quantity'] = order_df['ordered_quantity'].astype( 'int32') self.stdout.write('Version object created') # Create forecast dataframe forecast_df = order_df.rename( columns={ 'ordered_quantity': 'forecasted_quantity', 'order__ordered_at': 'forecast_date', }) # Generate different values based on defined rate forecast_df['forecasted_quantity'] = pd.to_numeric( forecast_df['forecasted_quantity'] * 0.7) forecast_df['edited_forecasted_quantity'] = pd.to_numeric( forecast_df['forecasted_quantity'] * 1.3) self.stdout.write('Creating forecasts...') forecast_objs = [ Forecast( warehouse_id=row['warehouse__id'], product_id=row['product__id'], category_id=row['category__id'], circuit_id=row['circuit__id'], customer_id=row['customer__id'], version_id=version_obj.id, forecast_date=row['forecast_date'], forecasted_quantity=row['forecasted_quantity'], edited_forecasted_quantity=row['edited_forecasted_quantity'], ) for i, row in forecast_df.iterrows() ] Forecast.objects.bulk_create(forecast_objs) self.stdout.write(self.style.SUCCESS('Forecasts created successfully'))
def prediction(request): template = 'stock_api/prediction.html' # filtering company kun_company = request.GET.get('company_abbr') qs = StockData.objects.filter( companyAbbr=kun_company) # RUSSELL 2000 INDEX(company name) df = read_frame(qs) data = df['open'] stock_data = np.array(data.values.reshape((len(data), 1))) stock_data.shape # (1258, 1) # Split the data into training/testing sets stock_X_train = stock_data[:350] stock_X_test = stock_data[700:979, ] # Split the targets into training/testing sets stock_y_train = stock_data[350:700] stock_y_test = stock_data[979:] regr = linear_model.LinearRegression() regr.fit(stock_X_train, stock_y_train) stock_y_pred = regr.predict(stock_X_test) # stock_y_pred stock_X_test # # Statistical parameter # #coefficients # coefficients = regr.coef_ # # mean squared error # MSE = mean_squared_error(mark_y_test, mark_y_pred) # # Explained variance score: 1 is perfect prediction # RSQ = r2_score(mark_y_test, mark_y_pred) # mark_y_pred_pd = pd.DataFrame(mark_y_pred.reshape(mark_y_pred.shape[1], -1), index=exam, columns=subject) # mark_X_test_pd = pd.DataFrame(mark_y_test.reshape(mark_y_test.shape[1], -1), index=exam, columns=subject) stock_y_pred_html = stock_y_pred #.to_html() stock_X_test_html = stock_X_test #.to_html() # plt.plot(stock_y_pred) # plt.plot(stock_X_test) print(stock_data[-1]) last_data = regr.predict(stock_data[-1]) print(last_data) context = { # 'MSE':MSE, # 'RSQ':RSQ, # 'coefficients':coefficients, 'stock_y_pred_html': stock_y_pred_html, 'stock_X_test_html': stock_X_test_html, } # return render(request, template, context) return JsonResponse({'tomorrow_predicted_value': last_data[0][0]})
def map2(): adr = mergedTables.objects.all() qs_adr = adr df_of_query_result_adr = read_frame(qs_adr) newTable_adr = df_of_query_result_adr m = folium.Map(location=[48.8566, 2.3522], tiles="Stamen Toner", zoom_start=2) #cergy=['49.034955','2.069925'] #pau=['43.319568','-0.360571'] newTable_ent_adr = newTable_adr[['ENT_LAT', 'ENT_LON']] newTable_stu_adr = newTable_adr[['ADR_LAT', 'ADR_LON']] newTable_site_adr = newTable_adr[['SITE_LAT', 'SITE_LON']] newTable_ent_adr = newTable_ent_adr.dropna(axis=0, subset=['ENT_LAT', 'ENT_LON']) newTable_stu_adr = newTable_stu_adr.dropna(axis=0, subset=['ADR_LAT', 'ADR_LON']) newTable_site_adr = newTable_site_adr.dropna( axis=0, subset=['SITE_LAT', 'SITE_LON']) #newTable_ent_adr= [[row['ENT_LAT'],row['ENT_LON']] for index,row in newTable_ent_adr.iterrows() ] #newTable_stu_adr= [[row['ADR_LAT'],row['ADR_LON']] for index,row in newTable_stu_adr.iterrows() ] #HeatMap(cergy).add_to(m) HeatMap(newTable_stu_adr).add_to(m) mc = MarkerCluster() folium.CircleMarker( [49.034955, 2.069925], radius=20, popup='Cergy Campus', color='red', ).add_to(m) folium.CircleMarker( [43.319568, -0.360571], radius=20, popup='Pau Campus', color='red', ).add_to(m) for i in range(0, len(newTable_stu_adr)): #mc.add_child(folium.Marker([newTable_ent_adr.iloc[i]['ENT_LAT'],newTable_ent_adr.iloc[i]['ENT_LON']],icon=folium.Icon(icon='cloud'))).add_to(m) mc.add_child( folium.Marker([ newTable_ent_adr.iloc[i]['ENT_LAT'], newTable_ent_adr.iloc[i]['ENT_LON'] ])).add_to(m) #mc.add_child(folium.Marker([newTable_stu_adr.iloc[i]['ADR_LAT'],newTable_stu_adr.iloc[i]['ADR_LON']],icon=folium.Icon(color='red'))).add_to(m) #folium.Marker([newTable_site_adr.iloc[i]['SITE_LAT'],newTable_site_adr.iloc[i]['SITE_LON']],icon=folium.Icon(icon='green')).add_to(m) #m.add_children(plugins.HeatMap(newTable_adr_lo, radius=15)) m.save(os.path.join(BASE_DIR, 'DjangoWeb V1\Interface\\templates\map.html')) return None
def get_meta_info(icustay_id): """ This function is supposed to return an df containing meta info like: - ward, moves, outcomes, admission ID, patient ID, etc FOR A GIVEN ICUSTAY. - this is what will become the labels later! :param icustay_id: :return: """ stay = ICUSTAY.objects.filter(icustayID=icustay_id) stay = read_frame(stay) stay['intime'] = pd.to_datetime(stay['intime']) stay['outtime'] = pd.to_datetime(stay['outtime']) # admission admission_obj_str = stay['admission'].values[0] # this is a string: `Admission object (199395)` admission_id = re.search(re.compile('(\d+)'), admission_obj_str).group() admission = Admission.objects.filter(admID=admission_id) admission = read_frame(admission) stay['admission'] = admission_id # patient subject_obj_str = stay['subject'].values[0] # this is a string: `Patient object (199395)` subject_id = re.search(re.compile('(\d+)'), subject_obj_str).group() patient = Patient.objects.filter(subjectID=subject_id) patient = read_frame(patient) stay['subject'] = subject_id # gather info: stay.drop(['first_ward_id', 'last_ward_id', 'first_cu', 'last_cu'], axis=1, inplace=True) for c in ['adm_time', 'disch_time', 'inpmor', 'pdismor', 'read']: stay[c] = admission[c] for c in ['gender', 'age', 'date_of_death_hosp']: stay[c] = patient[c] return stay
def protocol_summary(request): ''' Relies on django_highcharts for serializing data. Makes multiple chart rendering on a page more simple, however it doesn't appear to allow much in they way of customization. define a range, avg, diplay max and min ''' athlete = get_user(request) data = BoulderingRoutineMetrics.objects.filter(session__athlete=athlete) test = BoulderingRoutineMetrics.objects.values( 'min', 'max').filter(session__athlete=athlete) df = read_frame(data, verbose=False) df['avg'] = df['total_points'] / df['total_climbs'] df['range'] = df['max'] - df['min'] df = df.drop(['id', 'total_climbs', 'total_points'], axis=1).set_index('session') dataset = BoulderingRoutineMetrics.objects \ .values('session__sessionDate', 'min','max', 'total_points', 'total_climbs') \ .filter(session__athlete = athlete) df2 = read_frame(dataset, verbose=False).rename( columns={ 'session__sessionDate': 'session date', 'min': 'min value', 'max': 'max value' }) df3 = read_frame(dataset, fieldnames=['min','max'])\ .rename(columns={'session__sessionDate':'Session Date'}) # .drop(['total_points', 'total_climbs']) df4 = df2.merge(df3, how='left', left_index=True, right_index=True) df4['avg'] = df4['total_points'] / df4['total_climbs'] df4['range'] = df4['max value'] - df4['min value'] chart = serialize(df4, render_to='my-chart', kind="bar", output_type='json') return render(request, 'schedule/protocol_summary.html', {'chart': chart})
def get_stay_lab_timeseries(icustay_id): """ For a given admission ID -> get the ts with all the labevents. then get in and out time from an icustay and cut the bits out that fall between """ # get ICUstay: stay = ICUstay.objects.filter(icustayID=icustay_id) stay = read_frame(stay) stay['intime'] = pd.to_datetime(stay['intime']) stay['outtime'] = pd.to_datetime(stay['outtime']) admission_obj_str = stay['admission'].values[0] # this is a string: `Admission object (199395)` admission_id = re.search(re.compile('(\d+)'), admission_obj_str).group() stay_period = pd.Interval(stay['intime'].values[0], stay['outtime'].values[0]) # filter the lab_events: events = LabEventValue.objects.filter(admission_id=admission_id) events = read_frame(events) events['chart_time'] = pd.to_datetime(events['chart_time']) events.set_index('chart_time', inplace=True) idx = [t in stay_period for t in events.index.values] events = events.loc[idx].reset_index() events['icustayID'] = stay['icustayID'].unique()[0] # convert to ts: events_ts = _events_to_ts(events, variable_col='itemID', value='value').reset_index() if events_ts.empty: return events_ts intime = pd.Timestamp(stay['intime'].values[0]) events_ts = add_hours_elpased_to_events(events_ts, dt=intime) return events_ts
def results(request): movies = Movies.objects.all() movies_df = read_frame(movies) ratings = Ratings.objects.all() ratings_df = read_frame(ratings) data = pd.merge(movies_df, ratings_df, on="movieid") # creating dataframe with 'rating' count values ratings = pd.DataFrame(data.groupby('title')['rating'].mean()) ratings['num of ratings'] = pd.DataFrame( data.groupby('title')['rating'].count()) moviemat = data.pivot_table(index='userid', columns='title', values='rating') ratings.sort_values('num of ratings', ascending=False).head(10) currently_rated_movies = request.session.get('movies') results = {} for item in currently_rated_movies: # analysing correlation with similar movies _user_ratings = moviemat[item["title"]] similar_to_ = moviemat.corrwith(_user_ratings) corr_ = pd.DataFrame(similar_to_, columns=['Correlation']) corr_.dropna(inplace=True) # Similar movies like current title corr_.sort_values('Correlation', ascending=False).head(10) corr_ = corr_.join(ratings['num of ratings']) strongest_corr = corr_[corr_['num of ratings'] > 100].sort_values( 'Correlation', ascending=False).head(1) strongest_corr = strongest_corr.rename( columns={"num of ratings": "no_of_ratings"}) if not strongest_corr.empty: results[strongest_corr.index.values[0]] = Ratings.objects.filter( userid=request.user.id).filter( movieid=item["movieid"]).values_list( 'rating', flat=True)[0] * strongest_corr.Correlation[ 0] * strongest_corr.no_of_ratings[0] print(results) return render(request, 'nxtwatch/results.html', {'results': results})
def election(request): station_ids = request.GET.getlist('station_id') if len(station_ids) < 2: _response400("station_id is required at least 2") try: station_ids = [int(station_id) for station_id in station_ids] except ValueError: _response400(f"station_id is invalid: {station_ids}") df_stations = read_frame(Station.objects.all()) results = Election(df_stations, station_ids).run() response = dict(station_ids=station_ids, results=results) return JsonResponse(response, safe=False, json_dumps_params={'ensure_ascii': False})
def update_tags(request): if request.user.is_authenticated: my_tags = Tags.objects.filter( user=request.user).order_by('category').all() df = read_frame(my_tags) df = df[[ 'category', 'tag', 'drill_down', 'id', 'budget', 'fixed_cost' ]] df = df.values.tolist() template = loader.get_template('core_app/tag_details.html') context = {'results': df} return HttpResponse(template.render(context, request)) else: return redirect('home')
def get_list(request): custid = request.POST.get('custid') #history = purchases.objects.all cust = customer.objects.all customers = read_frame(customer.objects.all()) customers = customers['Customer_ID'] custid = int(custid) if custid in customers.unique(): #funtion df = read_frame(purchases.objects.all()) df = df.loc[df['Customer_ID'] == custid] array = df['Products'].astype(int) cat = read_frame(catalogue.objects.all()) cat = cat.head(5) pd.to_numeric(cat['objectID']) display = cat.loc[cat['objectID'].isin(array)] #function list1 = {"dataframe": cat, "customers": cust} return render(request, "get_list.html", list1) else: messages.error(request, 'Please enter valid username') return render(request, "index.html")
def players_ctx(pos, ctx, form, x_axis='points_per_game', y_axis='now_cost', size='selected_by_percent', limit=50): position = Position.objects.get(id=pos) players = Player.objects.filter(position=position).filter( minutes__gt=0).order_by('-' + x_axis) gw = Fixtures.objects.filter( finished=True).order_by('event_id').last().event_id ## Create DataFrame for Goalkeepers gkp = read_frame( players, fieldnames=[ 'first_name', 'second_name', 'team', 'points_per_game', 'total_points', 'now_cost', 'form', 'minutes', 'assists', 'goals_scored', 'own_goals', 'influence', 'influence_rank', 'creativity', 'creativity_rank', 'threat', 'threat_rank', 'clean_sheets', 'goals_conceded', 'saves', 'penalties_saved', 'yellow_cards', 'red_cards', 'dreamteam_count', 'selected_by_percent', 'transfers_in', 'transfers_out' ]) # Merge first_name and second_name gkp['name'] = gkp['first_name'] + ' ' + gkp['second_name'] gkp.drop(['first_name', 'second_name'], axis=1, inplace=True) # Change number of minutes to percent of time max_minutes = 90 * gw gkp.minutes = gkp.minutes.apply( lambda x: round(float(x) * 100 / max_minutes, 2)) # Filter min_filter = gkp.minutes >= limit gkp = gkp[min_filter] # Add data to ctx dictionary ctx['title'] = f'Chart - {position.name}s' ctx['x'] = list(gkp[x_axis]) ctx['y'] = list(gkp[y_axis]) ctx['max_size'] = max(gkp[size]) if len(gkp[size]) > 0 else 0 ctx['size'] = list(((gkp[size] / ctx['max_size']) + 1) * 10) ctx['players'] = gkp['name'].tolist() ctx['form'] = form x_regr, pred_regr = linear_regr(gkp[x_axis], gkp[y_axis]) ctx['x_regr'] = x_regr ctx['pred_regr'] = pred_regr x_regr_poly, pred_regr_poly = poly_regr(gkp[x_axis], gkp[y_axis]) ctx['x_regr_poly'] = x_regr_poly ctx['pred_regr_poly'] = pred_regr_poly return ctx
def get(self, *args, **kwargs): user_taste = generics.get_object_or_404(UserTaste, user=self.request.user) reviews_from_user = Review.objects.all().filter(created_by=user_taste) reviews_from_user_df = read_frame(reviews_from_user, fieldnames=['game_id__id', 'rating']) reviews_from_user_df = reviews_from_user_df.rename(columns={ 'game_id__id': 'game_key', 'rating': 'rating' }) return Response(selfmade_KnnWithMeans_approach(reviews_from_user_df))
def export_to_xls_search_history(self, request, queryset): df = read_frame(queryset, verbose=True, fieldnames=( 'user__user__id', 'user__user__username', 'date', 'name', )) df = translate_column_names(df) return export_to_xls(df, 'search_history' + request.GET.get('drf__day__gte ', '') + request.GET.get('drf__day__lte', '') + '.xls', engine='openpyxl')
def get_stocks_by_date_range(min: Optional[datetime] = None, max: Optional[datetime] = None) -> pd.DataFrame: """ Gets stock data from the database based on date range. """ from stocks.stocks.models import Stock if min is None: return get_stocks() if max is None: max = datetime.now() return read_frame(Stock.objects.filter(price_date__range=(min, max)))
def __init__(self): self.df = read_frame( get_user_model().objects.filter( date_joined__gte=(datetime.now() - timedelta(days=15)) ) ) self.df['date_joined'] = pd.to_datetime(self.df['date_joined']) # TODO: Optimise next queries self.active = self.df[self.df.is_active==True][ ['date_joined', 'id'] ].groupby('date_joined').count().resample('D').count() self.nonactive = self.df[self.df.is_active==False][ ['date_joined', 'id'] ].groupby('date_joined').count().resample('D').count()
def test_related_cols(self): qs = TradeLog.objects.all() cols = ['log_datetime', 'symbol', 'symbol__isin', 'trader__name', 'price', 'volume', 'note__note'] df = read_frame(qs, cols, verbose=False) self.assertEqual(df.shape, (qs.count(), len(cols))) self.assertListEqual( list(qs.values_list('symbol__isin', flat=True)), df.symbol__isin.tolist() ) self.assertListEqual( list(qs.values_list('trader__name', flat=True)), df.trader__name.tolist() )
def export_to_xls_exchange(self, request, queryset, ): df = read_frame(queryset, index_col='date', verbose=True, fieldnames=( 'date', 'user__user__id', 'user__user__username', 'user__user__email', 'exchange', 'user__score', 'user__total_score', 'user__total_exchange', )) df = translate_column_names(df) return export_to_xls(df, 'exchange' + request.GET.get('drf__day__gte ', '') + '_' + request.GET.get('drf__day__lte', '') + '.xls', engine='openpyxl')
def monthly_patients(self): dataframe = read_frame(PatientVaccination.objects.all()) dataframe['month'] = [date.strftime('%B') for date in dataframe['dateofvaccinereceiption']] groups = dataframe.groupby('month')['id'].count() return groups
def runRedo(self): ''' 将更新票项的过程中失败的数据重做直到成功 ''' # 查出需要进行重做的数据 self.writeSystemLog(u'重做过程开始执行') # 尝试进程登录 loginResult = self.login(self.username, self.password) if loginResult: self.writeSystemLog(u'登录成功!') else: self.writeSystemLog(u'登录失败!') raise Exception(u'登录失败!') # 执行时间变量的初始化 runStartTime = datetime.now() currentTime = datetime.now() timeSpend = currentTime - runStartTime # 获取总出错项 qs = RefreshRedo.objects.filter(state=u'redoing') redos = read_frame(qs) errorCount = len(redos) self.writeSystemLog(u'共有%d次错误需要重做' % errorCount) # 不停处理每一个信息项,直到没有错误需要重做,或者执行时间到了 while errorCount > 0: try: qs = RefreshRedo.objects.filter(state=u'redoing') redos = read_frame(qs) errorCount = len(redos) if errorCount == 0: self.writeSystemLog(u'已无项目需要处理,程序将退出') else: self.writeSystemLog(u'开始一次重做,共%d需要处理...' % errorCount) # 根据出错列表调用重新回订过程 successCount = 0 # 按唯一的日期获取数据,提高访问效率 for day in redos.beginDay.drop_duplicates(): self.writeSystemLog(u'检查%s的余票信息' % day) # 获取有余票的项 ticketInfo = pitcher.getTicketInfo(day) c1 = ticketInfo[u'余票'].apply(lambda x: int(x)) > 0 remain = ticketInfo[c1] remain[u'开航日期'] = day # 余票信息和重做记录关联,得出可以重做的票项 leftColumns = ['beginDay', 'beginTime', 'departure', 'arrival'] rightColumns = [u'开航日期', u'开航时间', u'出发码头', u'抵达码头'] todos = redos.merge(remain, left_on=leftColumns, right_on=rightColumns).to_dict(outtype='records') if todos: self.writeSystemLog(u'有%d个重做项出现余票' % len(todos)) else: self.writeSystemLog(u'无重做项有余票') # 避免过分频繁访问服务器 time.sleep(self.normalWaitingSecond) # 循环对有余票的项目进程操作 for todo in todos: # 初始化相关信息 departure = todo['departure'] arrival = todo['arrival'] beginDay = todo['beginDay'] beginTime = todo['beginTime'] cnt = todo['cnt'] remainCnt = int(todo[u'余票']) redoId = todo['id'] redo = RefreshRedo.objects.get(id=redoId) # 如果当前时间和开航日期0点的时间小于1天,则不再刷新这个票项 # 因为正常刷新提前5天前就刷新好了,所以不会有影响 # 这样做主要是防止重做票项无限增长,且去订之前日期的票 beginDateTime = parser.parse(beginDay) if (beginDateTime - currentTime).days < 1: redo.state = u'failed' redo.save() self.writeSystemLog( u'出发:%s,抵达:%s,开航时间:%s %s,人数:%s' % (departure, arrival, beginDay, beginTime, cnt)) self.writeSystemLog(u'该项已经超过可以重做的时间,已标记为失败!!!') continue # 尝试重调订票过程 dailyFlightId = pitcher.getDailyFlightId(beginDay, beginTime, departure, arrival) if dailyFlightId: self.writeSystemLog( u'出发:%s,抵达:%s,开航时间:%s %s,人数:%s' % (departure, arrival, beginDay, beginTime, cnt)) if remainCnt >= cnt: # 如果票数量够,按需票量抢 result = pitcher.orderTicket(dailyFlightId, cnt) if result: # 重做成功将记录标识为完成 redo.state = u'finished' redo.save() self.writeSystemLog(u'该项已经重做成功!') successCount += 1 else: self.writeSystemLog(u'虽有余票项但抢订失败!') else: # 如果票数不够,按实际票数抢 result = pitcher.orderTicket(dailyFlightId, remainCnt) if result: redo.cnt -= remainCnt redo.save() self.writeSystemLog(u'重做项余票数不够,但已抢回%d张' % remainCnt) else: self.writeSystemLog(u'虽有余票项但抢订失败!') # 避免过分频繁访问服务器(for todo1 in todos:) time.sleep(self.normalWaitingSecond) # 避免过分频繁访问服务器(for day in redos.beginDay.drop_duplicates()) time.sleep(self.normalWaitingSecond) # 完成一次重做,打印执行信息 errorCount -= successCount self.writeSystemLog(u'完成一次重做:%d项成功,%d项失败.' % (successCount, errorCount)) # 更新执行时间 currentTime = datetime.now() timeSpend = currentTime - runStartTime except Exception as e: self.writeSystemLog(u'发生异常:%s,程序将继续执行' % unicode(e)) # 检查是否是登录状态,如果登录状态丢失则重新登录 if not self.isLogin(): self.writeSystemLog(u'连接丢失,将重新登录...') loginErrorCount = 0 while True: loginResult = self.login(self.username, self.password) if loginResult: # 如果登录成功清空原来登录失败的记录 self.writeSystemLog(u'登录成功!') break else: loginErrorCount += 1 if loginErrorCount > self.maxLoginError: self.writeSystemLog(u'登录失败超过%d次,程序退出!' % self.maxLoginError) return else: self.writeSystemLog(u'登录失败!') self.writeSystemLog(u'等待%s秒... ...' % self.errorWaitingSecond) time.sleep(self.errorWaitingSecond) self.writeSystemLog(u'重做过程执行结束')
def monthly_vaccine(self): dataframe = read_frame(PatientVaccination.objects.all()) dataframe['month'] = [date.strftime('%B') for date in dataframe['dateofvaccinereceiption']] groups = dataframe.groupby(['month', 'patient_vaccine'])['id'].count().reset_index(name='count') return groups
def monthly_transactions(self): dataframe = read_frame(Transaction.objects.all()) dataframe['month'] = [date.strftime('%B') for date in dataframe['date']] dataframe['year'] = [date.strftime('%Y') for date in dataframe['date']] groups = dataframe.groupby(['year', 'month', 'type'])['amount'].sum().reset_index(name='amount') return groups
def top_recipients(self): dataframe = read_frame(Transaction.objects.all()) recipient_dataframe = dataframe[dataframe.type == 'Sent Transactions'] return recipient_dataframe.groupby(['recipient', 'type'])['amount'].sum().reset_index(name='amount').sort('amount', ascending=False)