def selectables(cls, bag, agg_spec): """ Create a list of statements from spec :type bag: mongosql.bag.ModelPropertyBags :rtype: list[sqlalchemy.sql.elements.ColumnElement] """ # TODO: calculation expressions for selection: http://docs.mongodb.org/manual/meta/aggregation-quick-reference/ selectables = [] for comp_field, comp_expression in agg_spec.items(): # Column reference if isinstance(comp_expression, basestring): selectables.append(bag.columns[comp_expression].label(comp_field)) continue # Computed expression assert isinstance(comp_expression, dict), 'Aggregate: Expression should be either a column name, or an object' assert len(comp_expression) == 1, 'Aggregate: expression can only contain a single operator' operator, expression = comp_expression.popitem() # Expression statement if isinstance(expression, int) and operator == '$sum': # Special case for count expression_stmt = expression elif isinstance(expression, basestring): # Column name expression_stmt = bag.columns[expression] # Json column? if bag.columns.is_column_json(expression): # PostgreSQL always returns text values from it, and for aggregation we usually need numbers :) expression_stmt = cast(expression_stmt, Float) elif isinstance(expression, dict): # Boolean expression expression_stmt = MongoCriteria.statement(bag, expression) # Need to cast it to int expression_stmt = cast(expression_stmt, Integer) else: raise AssertionError('Aggregate: expression should be either a column name, or an object') # Operator if operator == '$max': comp_stmt = func.max(expression_stmt) elif operator == '$min': comp_stmt = func.min(expression_stmt) elif operator == '$avg': comp_stmt = func.avg(expression_stmt) elif operator == '$sum': if isinstance(expression_stmt, int): # Special case for count comp_stmt = func.count() if expression_stmt != 1: comp_stmt *= expression_stmt else: comp_stmt = func.sum(expression_stmt) else: raise AssertionError('Aggregate: unsupported operator "{}"'.format(operator)) # Append selectables.append(comp_stmt.label(comp_field)) return selectables
def mark_payments_as_sent(transaction_label: str, batch_size: int = 1000) -> None: modified_sum = 0 min_id = db.session.query(func.min(Payment.id)).filter( Payment.transactionLabel == transaction_label).scalar() max_id = db.session.query(func.max(Payment.id)).filter( Payment.transactionLabel == transaction_label).scalar() if min_id is None or max_id is None: logger.info("No payments needed to be marked as sent") return now = datetime.datetime.utcnow() for batch_start in range(min_id, max_id + 1, batch_size): payments_ids = get_payments_ids_under_review(batch_start, batch_size, transaction_label) if len(payments_ids) == 0: continue payment_statuses_to_add: list[PaymentStatus] = [] for payment_id in payments_ids: payment_statuses_to_add.append( PaymentStatus(paymentId=payment_id, status=TransactionStatus.SENT, date=now)) db.session.bulk_save_objects(payment_statuses_to_add) mark_bookings_as_reimbursed_from_payment_ids(payments_ids, now) db.session.commit() modified_sum += len(payments_ids) logger.info("%d payments have been marked as sent for transaction %s", modified_sum, transaction_label)
def _build_query(self, table, filter_values): having = [] filter_cols = [] external_cols = _get_grouping(filter_values) for fil in self.filters: if isinstance(fil, ANDFilter): filter_cols.append(fil.filters[0].column_name) having.append(fil) elif isinstance(fil, RawFilter): having.append(fil) elif fil.column_name not in ['group', 'gender', 'group_leadership', 'disaggregate_by', 'table_card_group_by']: if fil.column_name not in external_cols and fil.column_name != 'maxmin': filter_cols.append(fil.column_name) having.append(fil) group_having = '' having_group_by = [] if ('disaggregate_by' in filter_values and filter_values['disaggregate_by'] == 'group') or \ (filter_values.get('table_card_group_by') == 'group_leadership'): having_group_by.append('group_leadership') elif 'group_leadership' in filter_values and filter_values['group_leadership']: group_having = "(MAX(CAST(gender as int4)) + MIN(CAST(gender as int4))) " \ "= :group_leadership and group_leadership=\'Y\'" having_group_by.append('group_leadership') filter_cols.append('group_leadership') elif 'gender' in filter_values and filter_values['gender']: group_having = "(MAX(CAST(gender as int4)) + MIN(CAST(gender as int4))) = :gender" table_card_group = [] if 'group_name' in self.group_by: table_card_group.append('group_name') s1 = alias(select([table.c.doc_id, table.c.group_case_id, table.c.group_name, table.c.group_id, (sqlalchemy.func.max(table.c.prop_value) + sqlalchemy.func.min(table.c.prop_value)).label('maxmin')] + filter_cols + external_cols, from_obj=table, group_by=([table.c.doc_id, table.c.group_case_id, table.c.group_name, table.c.group_id] + filter_cols + external_cols)), name='x') s2 = alias( select( [table.c.group_case_id, sqlalchemy.cast( cast(func.max(table.c.gender), Integer) + cast(func.min(table.c.gender), Integer), VARCHAR ).label('gender')] + table_card_group, from_obj=table, group_by=[table.c.group_case_id] + table_card_group + having_group_by, having=group_having ), name='y' ) group_by = list(self.group_by) if 'group_case_id' in group_by: group_by[group_by.index('group_case_id')] = s1.c.group_case_id group_by[group_by.index('group_name')] = s1.c.group_name return select( [sqlalchemy.func.count(s1.c.doc_id).label(self.key)] + group_by, group_by=[s1.c.maxmin] + filter_cols + group_by, having=AND(having).build_expression(s1), from_obj=join(s1, s2, s1.c.group_case_id == s2.c.group_case_id) ).params(filter_values)
def payments(): payments = Payment.query.join(Ticket).with_entities( Payment, func.min(Ticket.expires).label('first_expires'), func.count(Ticket.id).label('ticket_count'), ).group_by(Payment).order_by(Payment.id).all() return render_template('admin/payments.html', payments=payments)
def redditmeme_min_ts(subreddit: str) -> int: try: min_ts = cast( int, site_db.query(func.min( RedditMeme.timestamp)).filter_by(subreddit=subreddit).scalar(), ) return min_ts except Exception: return 0
def expiring(): expiring = BankPayment.query.join(Ticket).filter( BankPayment.state == 'inprogress', Ticket.expires < datetime.utcnow() + timedelta(days=3), ).with_entities( BankPayment, func.min(Ticket.expires).label('first_expires'), func.count(Ticket.id).label('ticket_count'), ).group_by(BankPayment).order_by('first_expires').all() return render_template('admin/payments-expiring.html', expiring=expiring)
def calc_percentile_sub(subreddit: str): subreddit_clause = cast(ClauseElement, RedditMeme.subreddit == subreddit) if not (timestamp := cast( Union[int, None], site_db.query(func.max(RedditMeme.timestamp)).filter( and_(subreddit_clause, cast(ClauseElement, RedditMeme.percentile != None))).scalar(), )): max_ts = (cast( Arrow, arrow.get( cast( int, site_db.query(func.min(RedditMeme.timestamp)).filter( subreddit_clause).scalar(), )), ).ceil("hour").shift(days=1))
def compile(self): # Json column? if self.is_column_json: # PostgreSQL always returns text values from it, and for aggregation we usually need numbers :) column = cast(self.column, Float) else: # Simply use column = self.column # Now, handle the operator, and apply it to the expression if self.operator == '$max': stmt = func.max(column) elif self.operator == '$min': stmt = func.min(column) elif self.operator == '$avg': stmt = func.avg(column) elif self.operator == '$sum': stmt = func.sum(column) else: raise InvalidQueryError( 'Aggregate: unsupported operator "{}"'.format(self.operator)) return self.labeled_expression(stmt)
def _build_query(self, table, filter_values): having = [] filter_cols = [] external_cols = _get_grouping(filter_values) for fil in self.filters: if isinstance(fil, ANDFilter): filter_cols.append(fil.filters[0].column_name) having.append(fil) elif isinstance(fil, RawFilter): having.append(fil) elif fil.column_name not in [ 'group', 'gender', 'group_leadership', 'disaggregate_by', 'table_card_group_by' ]: if fil.column_name not in external_cols and fil.column_name != 'maxmin': filter_cols.append(fil.column_name) having.append(fil) group_having = '' having_group_by = [] if ('disaggregate_by' in filter_values and filter_values['disaggregate_by'] == 'group') or \ (filter_values.get('table_card_group_by') == 'group_leadership'): having_group_by.append('group_leadership') elif 'group_leadership' in filter_values and filter_values[ 'group_leadership']: group_having = "(MAX(CAST(gender as int4)) + MIN(CAST(gender as int4))) " \ "= :group_leadership and group_leadership=\'Y\'" having_group_by.append('group_leadership') filter_cols.append('group_leadership') elif 'gender' in filter_values and filter_values['gender']: group_having = "(MAX(CAST(gender as int4)) + MIN(CAST(gender as int4))) = :gender" table_card_group = [] if 'group_name' in self.group_by: table_card_group.append('group_name') s1 = alias(select([ table.c.doc_id, table.c.group_case_id, table.c.group_name, table.c.group_id, (sqlalchemy.func.max(table.c.prop_value) + sqlalchemy.func.min(table.c.prop_value)).label('maxmin') ] + filter_cols + external_cols, from_obj=table, group_by=([ table.c.doc_id, table.c.group_case_id, table.c.group_name, table.c.group_id ] + filter_cols + external_cols)), name='x') s2 = alias(select([ table.c.group_case_id, sqlalchemy.cast( cast(func.max(table.c.gender), Integer) + cast(func.min(table.c.gender), Integer), VARCHAR).label('gender') ] + table_card_group, from_obj=table, group_by=[table.c.group_case_id] + table_card_group + having_group_by, having=group_having), name='y') group_by = list(self.group_by) if 'group_case_id' in group_by: group_by[group_by.index('group_case_id')] = s1.c.group_case_id group_by[group_by.index('group_name')] = s1.c.group_name return select([sqlalchemy.func.count(s1.c.doc_id).label(self.key)] + group_by, group_by=[s1.c.maxmin] + filter_cols + group_by, having=AND(having).build_expression(s1), from_obj=join(s1, s2, s1.c.group_case_id == s2.c.group_case_id)).params(filter_values)
def home(): total_texts = db_session.query( func.count(AllTweets.id).label('total_texts')).filter( AllTweets.context.is_(CONTEXT)).first().total_texts if total_texts == 0: return render_template("out.html") total_terms = db_session.query( func.count(Termos.id).label('total_terms')).filter( Termos.context.is_(CONTEXT)).first().total_terms total_processed = db_session.query( func.count(AllTweets.id).label("total_processed")).filter( AllTweets.context.is_(CONTEXT)).filter( AllTweets.processed == 1).first().total_processed date_max = db_session.query( AllTweets.id, func.max(AllTweets.date).label('last_date')).filter( AllTweets.context.is_(CONTEXT)).first().last_date date_min = db_session.query( AllTweets.id, func.min(AllTweets.date).label('last_date')).filter( AllTweets.context.is_(CONTEXT)).first().last_date termos, hashtags, usuarios_rt, usuarios_citados, bigram_trigram = load_from_db( 10) if HASHTAG == "True": query_a = Hashtags.query.filter( and_(Hashtags.hashtag.is_(SIDE_A), Hashtags.context.is_(CONTEXT))).first() query_b = Hashtags.query.filter( and_(Hashtags.hashtag.is_(SIDE_B), Hashtags.context.is_(CONTEXT))).first() else: query_a = Termos.query.filter( and_(Termos.termo.is_(SIDE_A), Termos.context.is_(CONTEXT))).first() query_b = Termos.query.filter( and_(Termos.termo.is_(SIDE_B), Termos.context.is_(CONTEXT))).first() total_a = 0 total_b = 0 percent_a = 0 percent_b = 0 total = 0 if query_a and query_b: total_a = float(query_a.frequencia) total_b = float(query_b.frequencia) total = total_a + total_b percent_a = (total_a / total) * 100 percent_b = (total_b / total) * 100 profiles_info = get_profile() dict_values = { 'total_texts': total_texts, 'total_terms': total_terms, 'total_processed': total_processed, 'date_max': date_max, 'date_min': date_min, 'side_a': SIDE_A, 'side_b': SIDE_B, 'termos': termos, 'hashtags': hashtags, 'usuarios_rt': usuarios_rt, 'usuarios_citados': usuarios_citados, 'total': (percent_a, percent_b), 'total_value': (int(total_a), int(total_b)), 'bigram_trigram': bigram_trigram, 'context': CONTEXT, 'profile_a': PROFILE_A, 'profile_b': PROFILE_B, 'dict_profile': profiles_info } return render_template("index.html", values=dict_values)
def sensi_report(info_role): """ get the UUID report of a dataset .. :quickref: Metadata; """ """ get the UUID report of a dataset .. :quickref: Metadata; """ params = request.args ds_id = params["id_dataset"] dataset = TDatasets.query.get_or_404(ds_id) id_import = params.get("id_import") id_module = params.get("id_module") query = (DB.session.query( Synthese, func.taxonomie.find_cdref(Synthese.cd_nom).label("cd_ref"), func.array_agg(LAreas.area_name).label("codeDepartementCalcule"), func.ref_nomenclatures.get_cd_nomenclature( Synthese.id_nomenclature_sensitivity).label("cd_sensi"), func.ref_nomenclatures.get_nomenclature_label( Synthese.id_nomenclature_bio_status, "fr").label("occStatutBiologique"), func.min(CorSensitivitySynthese.meta_update_date).label( "sensiDateAttribution"), func.min( CorSensitivitySynthese.sensitivity_comment).label("sensiAlerte"), TNomenclatures.cd_nomenclature, TNomenclatures.label_fr).select_from(Synthese).outerjoin( CorAreaSynthese, CorAreaSynthese.id_synthese == Synthese.id_synthese).outerjoin( LAreas, LAreas.id_area == CorAreaSynthese.id_area).outerjoin( CorSensitivitySynthese, CorSensitivitySynthese.uuid_attached_row == Synthese.unique_id_sinp, ).outerjoin( TNomenclatures, TNomenclatures.id_nomenclature == Synthese.id_nomenclature_sensitivity).filter( LAreas.id_type == func.ref_geo.get_id_area_type("DEP")) ) if id_module: query = query.filter(Synthese.id_module == id_module) query = query.filter(Synthese.id_dataset == ds_id) if id_import: query = query.outerjoin( TSources, TSources.id_source == Synthese.id_source).filter( TSources.name_source == "Import(id={})".format(id_import)) data = query.group_by(Synthese.id_synthese, TNomenclatures.cd_nomenclature, TNomenclatures.label_fr).all() str_productor = "" header = "" if len(data) > 0: index_productor = -1 if dataset.cor_dataset_actor: for index, actor in enumerate(dataset.cor_dataset_actor): # cd_nomenclature producteur = 6 if actor.nomenclature_actor_role.cd_nomenclature == "6": index_productor = index productor = (dataset.cor_dataset_actor[index_productor] if index_productor != -1 else None) if productor: if not productor.organism: str_productor = productor.role.nom_complet else: str_productor = productor.organism.nom_organisme data = [{ "cdNom": row.Synthese.cd_nom, "cdRef": row.cd_ref, "codeDepartementCalcule": ", ".join(row.codeDepartementCalcule), "identifiantOrigine": row.Synthese.entity_source_pk_value, "occStatutBiologique": row.occStatutBiologique, "identifiantPermanent": row.Synthese.unique_id_sinp, "sensiAlerte": row.sensiAlerte, "sensible": "Oui" if row.cd_sensi != "0" else "Non", "sensiDateAttribution": row.sensiDateAttribution, "sensiNiveau": f"{row.cd_nomenclature} = {row.label_fr}", } for row in data] sensi_version = DB.session.query( func.gn_commons.get_default_parameter( 'ref_sensi_version')).one_or_none() if sensi_version: sensi_version = sensi_version[0] # set an header only if the rapport is on a dataset header = f""""Rapport de sensibilité" "Jeu de données";"{dataset.dataset_name}" "Identifiant interne";"{dataset.id_dataset}" "Identifiant SINP";"{dataset.unique_dataset_id}" "Organisme/personne fournisseur";"{str_productor}" "Date de création du rapport";"{dt.datetime.now().strftime("%d/%m/%Y %Hh%M")}" "Nombre de données sensibles";"{len(list(filter(lambda row: row["sensible"] == "Oui", data)))}" "Nombre de données total dans le fichier";"{len(data)}" "sensiVersionReferentiel";"{sensi_version}" """ return my_csv_resp( filename="filename", data=data, columns=[ "cdNom", "cdRef", "codeDepartementCalcule", "identifiantOrigine", "occStatutBiologique", "identifiantPermanent", "sensiAlerte", "sensible", "sensiDateAttribution", "sensiNiveau", ], _header=header, )
def get_count(cls): with new_session() as session: min_id = session.query(func.min(ErrorReport.id)).scalar() or 0 max_id = session.query(func.max(ErrorReport.id)).scalar() or 0 return max_id - min_id
def get_count(cls): with new_session() as session: return (session.query(func.max(Result.id)).scalar() or 0) \ - (session.query(func.min(Result.id)).scalar() or 0)
def selectables(cls, bag, agg_spec): """ Create a list of statements from spec :type bag: mongosql.bag.ModelPropertyBags :rtype: list[sqlalchemy.sql.elements.ColumnElement] """ # TODO: calculation expressions for selection: http://docs.mongodb.org/manual/meta/aggregation-quick-reference/ selectables = [] for comp_field, comp_expression in agg_spec.items(): # Column reference if isinstance(comp_expression, string_types): selectables.append( bag.columns[comp_expression].label(comp_field)) continue # Computed expression assert isinstance( comp_expression, dict ), 'Aggregate: Expression should be either a column name, or an object' assert len( comp_expression ) == 1, 'Aggregate: expression can only contain a single operator' operator, expression = comp_expression.popitem() # Expression statement if isinstance(expression, int) and operator == '$sum': # Special case for count expression_stmt = expression elif isinstance(expression, string_types): # Column name expression_stmt = bag.columns[expression] # Json column? if bag.columns.is_column_json(expression): # PostgreSQL always returns text values from it, and for aggregation we usually need numbers :) expression_stmt = cast(expression_stmt, Float) elif isinstance(expression, dict): # Boolean expression expression_stmt = MongoCriteria.statement(bag, expression) # Need to cast it to int expression_stmt = cast(expression_stmt, Integer) else: raise AssertionError( 'Aggregate: expression should be either a column name, or an object' ) # Operator if operator == '$max': comp_stmt = func.max(expression_stmt) elif operator == '$min': comp_stmt = func.min(expression_stmt) elif operator == '$avg': comp_stmt = func.avg(expression_stmt) elif operator == '$sum': if isinstance(expression_stmt, int): # Special case for count comp_stmt = func.count() if expression_stmt != 1: comp_stmt *= expression_stmt else: comp_stmt = func.sum(expression_stmt) else: raise AssertionError( 'Aggregate: unsupported operator "{}"'.format(operator)) # Append selectables.append(comp_stmt.label(comp_field)) return selectables
def home(): total_texts = db_session.query(func.count(AllTweets.id).label('total_texts')).filter(AllTweets.context.is_(CONTEXT)).first().total_texts total_terms = db_session.query(func.count(Termos.id).label('total_terms')).filter(Termos.context.is_(CONTEXT)).first().total_terms total_processed = db_session.query(func.count(AllTweets.id).label("total_processed")).filter(AllTweets.context.is_(CONTEXT)).filter(AllTweets.processed==1).first().total_processed date_max = db_session.query(AllTweets.id, func.max(AllTweets.date).label('last_date')).filter(AllTweets.context.is_(CONTEXT)).first().last_date date_min = db_session.query(AllTweets.id, func.min(AllTweets.date).label('last_date')).filter(AllTweets.context.is_(CONTEXT)).first().last_date termos, hashtags, usuarios_rt, usuarios_citados, bigram_trigram = load_from_db(10) if HASHTAG == "True": query_a = Hashtags.query.filter(and_(Hashtags.hashtag.is_(SIDE_A),Hashtags.context.is_(CONTEXT))).first() query_b = Hashtags.query.filter(and_(Hashtags.hashtag.is_(SIDE_B),Hashtags.context.is_(CONTEXT))).first() else: query_a = Termos.query.filter(and_(Termos.termo.is_(SIDE_A),Termos.context.is_(CONTEXT))).first() query_b = Termos.query.filter(and_(Termos.termo.is_(SIDE_B),Termos.context.is_(CONTEXT))).first() total_a = 0 total_b = 0 percent_a = 0 percent_b = 0 total = 0 if query_a and query_b: total_a = float(query_a.frequencia) total_b = float(query_b.frequencia) total = total_a + total_b percent_a = (total_a / total) * 100 percent_b = (total_b / total) * 100 profiles_info = get_profile() query_texts = db_session.query(AllTweets) all_ = [] for q in query_texts: teste = q.text.decode('UTF-8') t = {} t['tweet_id'] = q.tweet_id t['user'] = q.user t['text'] = teste t['date'] = q.date all_.append(t) tweets = jsonify(**{'list': all_}) dict_values = { 'total_texts': total_texts, 'total_terms': total_terms, 'total_processed': total_processed, 'date_max': date_max, 'date_min': date_min, 'side_a': SIDE_A, 'side_b': SIDE_B, 'termos': termos, 'hashtags': hashtags, 'usuarios_rt': usuarios_rt, 'usuarios_citados': usuarios_citados, 'total': (percent_a, percent_b), 'total_value': (int(total_a), int(total_b)), 'bigram_trigram': bigram_trigram, 'context': CONTEXT, 'profile_a': PROFILE_A, 'profile_b': PROFILE_B, 'dict_profile': profiles_info } """ ------------------Paginação--------------------- """ current_page = request.args.get('page', 1, type=int) num_posts = total_texts total_num_pages = int(math.ceil(num_posts / items_per_page)) iter_pages = list(range(1, total_num_pages + 1)) """ ------------------Paginação--------------------- """ return render_template("home.html",values=dict_values, tweets=all_, iter_pages=iter_pages, current_page=current_page, total_pages=total_num_pages)
def map(): total_texts = db_session.query(func.count(AllTweets.id).label('total_texts')).filter(AllTweets.context.is_(CONTEXT)).first().total_texts total_terms = db_session.query(func.count(Termos.id).label('total_terms')).filter(Termos.context.is_(CONTEXT)).first().total_terms total_processed = db_session.query(func.count(AllTweets.id).label("total_processed")).filter(AllTweets.context.is_(CONTEXT)).filter(AllTweets.processed==1).first().total_processed date_max = db_session.query(AllTweets.id, func.max(AllTweets.date).label('last_date')).filter(AllTweets.context.is_(CONTEXT)).first().last_date date_min = db_session.query(AllTweets.id, func.min(AllTweets.date).label('last_date')).filter(AllTweets.context.is_(CONTEXT)).first().last_date termos, hashtags, usuarios_rt, usuarios_citados, bigram_trigram = load_from_db(10) if HASHTAG == "True": query_a = Hashtags.query.filter(and_(Hashtags.hashtag.is_(SIDE_A),Hashtags.context.is_(CONTEXT))).first() query_b = Hashtags.query.filter(and_(Hashtags.hashtag.is_(SIDE_B),Hashtags.context.is_(CONTEXT))).first() else: query_a = Termos.query.filter(and_(Termos.termo.is_(SIDE_A),Termos.context.is_(CONTEXT))).first() query_b = Termos.query.filter(and_(Termos.termo.is_(SIDE_B),Termos.context.is_(CONTEXT))).first() total_a = 0 total_b = 0 percent_a = 0 percent_b = 0 total = 0 if query_a and query_b: total_a = float(query_a.frequencia) total_b = float(query_b.frequencia) total = total_a + total_b percent_a = (total_a / total) * 100 percent_b = (total_b / total) * 100 profiles_info = get_profile() query_texts = db_session.query(AllTweets) all_ = [] for q in query_texts: teste = q.text.decode('UTF-8') t = {} t['tweet_id'] = q.tweet_id t['user'] = q.user t['text'] = teste t['date'] = q.date all_.append(t) tweets = jsonify(**{'list': all_}) dict_values = { 'total_texts': total_texts, 'total_terms': total_terms, 'total_processed': total_processed, 'date_max': date_max, 'date_min': date_min, 'side_a': SIDE_A, 'side_b': SIDE_B, 'termos': termos, 'hashtags': hashtags, 'usuarios_rt': usuarios_rt, 'usuarios_citados': usuarios_citados, 'total': (percent_a, percent_b), 'total_value': (int(total_a), int(total_b)), 'bigram_trigram': bigram_trigram, 'context': CONTEXT, 'profile_a': PROFILE_A, 'profile_b': PROFILE_B, 'dict_profile': profiles_info } def push_github(): data = [] geoms = [] tweet_features = [] with open('raw.json') as twtr_hamdata: for satir in twtr_hamdata: data.append(json.loads(satir)) for i in range(0,len(data)): geoms.append(data[i]["geo"]["coordinates"]) #print (geoms[i][0], geoms[i][1]) my_feature = Feature(geometry=Point((float(geoms[i][1]),float(geoms[i][0]))),\ properties={"user_location":data[i]["user"]["location"],\ "user_id": data[i]["id"],\ "user_name":data[i]["user"]["name"],\ "screen_name":data[i]["user"]["screen_name"],\ "followers_count":data[i]["user"]["followers_count"],\ "tweet":data[i]["text"],\ "tweet_time":data[i]["created_at"]}) tweet_features.append(my_feature) #print tweet_features tweet_FeatureCollection = FeatureCollection(tweet_features[:]) #print tweet_FeatureCollection["type"] try: #saveFile = open('tweets.geojson','a') data = json.dumps(tweet_FeatureCollection) #saveFile.close() except Exception as error: print ("Unable to write %s error"%error) g = Github('grandslav', '5kslj8130614') repo = g.get_user().get_repo("GeoJSONTweets") contents = repo.get_contents("/tweets.geojson") new_content = data # TODO: acrescentar arquivo em vez de substituir ("crimes01112018.geojson") repo.update_file("/tweets.geojson", "Updating geojson data", new_content, contents.sha) print("Arquivo .geojson atualizado") update = True if update: print("Atualizando geojson...") push_github() # faz um push no repositorio com arquivo geojson atualizado return render_template('map.html', values=dict_values, title='Map')