ldsakjl

README.md

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
 oid sha256:211cb91d6d7d65b8e74afe1e4257af5ee70faf2d6c4cda8bb589d812e0fbe1a7
-size 248
+size 248

apps/Clustering.py

@@ -1,3 +1,183 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a11b565bd5dee71b1c3d05476f1d68629a468190c0b46f8ffd58200af4514039
-size 8727
+from io import BytesIO
+import streamlit as st
+import pandas as pd
+from scipy.cluster.hierarchy import linkage
+from datetime import date
+from dateutil.relativedelta import relativedelta
+import plotly.figure_factory as ff
+from fastdtw import fastdtw
+from scipy.spatial.distance import euclidean
+import numpy as np
+from modules import tables
+
+
+@st.cache(suppress_st_warning=True)
+def data_request(country_to_request, start, currency='USD', end=date.today()):
+    data = tables.EquityMaster(country=country_to_request, field='IQ_CLOSEPRICE_ADJ', currency=currency).query(rename=['asset'],
+                                                                                                                start=start, end=str(end))
+    adtv = tables.EquityMaster(country=country_to_request, field='IQ_VALUE_TRADED', currency=currency).query(rename=['asset'],
+                                                                                                             start=start, end=str(end)).median()
+    marketcap = tables.EquityMaster(country=country_to_request, field='IQ_MARKETCAP', currency=currency).query(rename=['asset'],
+                                                                                                               start=start, end=str(end)).median()
+    return data, adtv, marketcap
+
+
+@st.cache(suppress_st_warning=True)
+def data_filter(data, adtv, marketcap, adtv_threshold, mktcap_threshold, p):
+    adtv_filter = (adtv >= adtv_threshold)
+    adtv = adtv.loc[adtv_filter]
+    marketcap_filter = (marketcap >= mktcap_threshold)
+    marketcap = marketcap.loc[marketcap_filter]
+    data = data.loc[:, data.columns.isin(adtv.index)]
+    data = data.loc[:, data.columns.isin(marketcap.index)]
+
+    file_to_read = 'Data/Company_Base_Definitivo.xlsx'
+    company_base = pd.read_excel(file_to_read, sheet_name='Compilado')
+    id_to_ticker = {str(row['ID_Quant']): str(row['Ticker Bloomberg']).split()[0] for i, row in company_base.iterrows()}
+    data = data.loc[:, data.columns.isin(id_to_ticker.keys())]
+    data.columns = [id_to_ticker[col] for col in data.columns]
+
+    if isinstance(p, str):
+        returns_final = data.resample(p).last().pct_change().fillna(0)
+    else:
+        returns_final = data.iloc[::p].pct_change().fillna(0)
+    return returns_final
+
+
+def dist(correlation):
+    return ((1-correlation)/2.)**.5
+
+
+def to_excel(df_to_write):
+    output = BytesIO()
+    writer = pd.ExcelWriter(output, engine='xlsxwriter')
+    df_to_write.to_excel(writer, index=False, sheet_name='Sheet1')
+    workbook = writer.book
+    worksheet = writer.sheets['Sheet1']
+    format1 = workbook.add_format({'num_format': '0.00'})
+    worksheet.set_column('A:A', None, format1)
+    writer.save()
+    processed_data = output.getvalue()
+    return processed_data
+
+
+@st.cache(suppress_st_warning=True)
+def get_dtw_distance(x, y):
+    distance_dtw = fastdtw(x, y, dist=euclidean)[0]
+    return distance_dtw
+
+
+def clustering_basado_en_correlacion():
+
+    form = st.form("Correlation Clustering")
+    posible_countries = ('Todos', 'Argentina', 'Brazil', 'Chile', 'Colombia', 'Mexico', 'Peru')
+    countries = form.multiselect('¿Qué países desea visualizar?', posible_countries)
+    if 'Todos' in countries:
+        countries = ('Argentina', 'Brazil', 'Chile', 'Colombia', 'Mexico', 'Peru')
+
+    adtv_p = form.number_input('Ingrese el mínimo Average Daily Traded Value que desea considerar', value=1., format="%.2f")
+    mktcap_thresh = form.number_input('Ingrese el mínimo Market Cap que desea considerar', value=200., format="%.2f")
+    start_date = form.selectbox('Ingrese la fecha de inicio que desea considerar', ('3 Meses', '6 Meses', '1 Año'))
+    period = form.number_input('Defina la frecuencia en la que desea las observaciones (en días)', value=1)
+    accept = form.form_submit_button('Aceptar')
+
+    if accept:
+        start_date = str(date.today() - relativedelta(months=int(start_date[0])))
+        for country in countries:
+            data_, adtv_, marketcap_ = data_request(country, start_date)
+            # Filtramos para que se cumplan los filtros del usuario en los datos
+            returns = data_filter(data_, adtv_, marketcap_, adtv_p, mktcap_thresh, period)
+
+            # Normalizamos
+            base = (returns.subtract(returns.mean(0), axis=1)).div(returns.std(axis=0), axis=1)
+            base = base.sort_index(axis=1)
+
+            # Procedemos a calcular correlación y covarianza
+            corr, covs = base.corr(), base.cov()
+            file = to_excel(corr)
+
+            # Definimos la matriz de distancia
+            dist_matrix = dist(corr)
+
+            hierarchy = linkage(dist_matrix)
+            ct = 0.54 * max(hierarchy[:, 2])
+            fig = ff.create_dendrogram(dist_matrix, orientation='left', labels=list(base.columns),
+                                       color_threshold=ct, linkagefun=linkage)
+            
+            fig.update_layout(title='{} desde {} hasta {}'.format(country,
+                                                                  returns.index[0].date(),
+                                                                  returns.index[-1].date()))
+            if country == 'Brazil':
+                fig.update_layout(height=2000)
+            else:
+                fig.update_layout(height=900)
+
+            st.plotly_chart(fig, use_container_width=True)
+
+            st.download_button(label='Descargar Matriz de Correlación para {}'.format(country), data=file,
+                               file_name='{}_correlacion.xlsx'.format(country))
+
+
+def clustering_con_dtw():
+    form = st.form("Dynamic Time Warping Clustering")
+    posible_countries = ('Todos', 'Brazil', 'Argentina', 'Chile', 'Colombia', 'Mexico', 'Peru')
+    countries = form.multiselect('¿Qué países desea visualizar?', posible_countries)
+    if 'Todos' in countries:
+        countries = ('Brazil', 'Argentina', 'Chile', 'Colombia', 'Mexico', 'Peru')
+
+    adtv_p = form.number_input('Ingrese el mínimo Average Daily Traded Value que desea considerar', value=1.,
+                               format="%.2f")
+    mktcap_thresh = form.number_input('Ingrese el Mínimo Market Cap que desea considerar', value=200., format="%.2f")
+    start_date = form.selectbox('Ingrese la fecha de inicio que desea considerar', ('3 Meses', '6 Meses', '1 Año'))
+    period = form.number_input('Defina la frecuencia en la que desea las observaciones (en días)', value=1)
+    accept = form.form_submit_button('Aceptar')
+
+    if accept:
+        start_date = str(date.today() - relativedelta(months=int(start_date[0])))
+
+        for country in countries:
+            data_, adtv_, marketcap_ = data_request(country, start_date)
+            # Filtramos para que se cumplan los filtros del usuario en los datos
+            returns = data_filter(data_, adtv_, marketcap_, adtv_p, mktcap_thresh, period)
+            # Normalizamos returns
+            base = (returns.subtract(returns.mean(0), axis=1)).div(returns.std(axis=0), axis=1)
+            base = base.sort_index(axis=1)
+            # Procedemos a calcular correlación y covarianza
+            N = len(base[:base.index[0]].T)
+            # Creamos la Matriz de Distancias para DTW
+            Dist = np.zeros((N, N))
+            place = st.empty()
+            for i in range(N):
+                place.write("Cargando: " + str(round(i*100/N)) + " %")
+                for j in range(i - 1, N):
+                    company_1 = base.columns[i]
+                    company_2 = base.columns[j]
+                    Dist[i, j] = get_dtw_distance(base[company_1], base[company_2])
+                    # La matriz es simétrica
+                    Dist[j, i] = Dist[i, j]
+            # Creamos un DataFrame con la matriz de distancias
+            df = pd.DataFrame(Dist)
+            df.index = base.columns
+            df.columns = base.columns
+
+            # Pasamos el df a excel para descarga del usuario
+            file = to_excel(df)
+
+            hierarchy = linkage(Dist)
+            ct = 0.54 * max(hierarchy[:, 2])
+
+            fig = ff.create_dendrogram(Dist, orientation='left', labels=list(base.columns),
+                                       color_threshold=ct, linkagefun=linkage)
+            fig.update_layout(
+                title='{} desde {} hasta {}'.format(country, returns.index[0].date(), returns.index[-1].date()))
+
+            if country == 'Brazil':
+                fig.update_layout(height=2000)
+            else:
+                fig.update_layout(height=900)
+
+            st.plotly_chart(fig, use_container_width=True)
+
+            st.download_button(label='Descargar Matriz de distancias con DTW para {}'.format(country), data=file,
+                               file_name='{}_correlacion.xlsx'.format(country))
+

apps/Comandos_utiles.py

@@ -1,3 +1,107 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:40f2f07338967fe215d5b1c06c146afecf2f5c2dac95ddeeb0818076047cc6b5
-size 4425
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Aug 31 15:01:56 2021
+
+@author: benjaminull
+"""
+import streamlit as st
+import pandas as pd
+import numpy as np
+import io
+import pybase64 as base64
+from plotly import graph_objs as go
+from datetime import datetime
+import plotly.express as px
+
+def get_table_excel_link(df, selected_stocks):
+    towrite = io.BytesIO()
+    downloaded_file = df.to_excel(towrite, encoding='utf-8', index=False,
+                                 header=True)
+    towrite.seek(0)  # reset pointer
+    file_name = 'Data'+ selected_stocks+'.xlsx'
+    style = 'style="color:black;text-decoration: none; font-size:18px;"'
+    name_mark = "Descargar " + selected_stocks + ".xlsx"
+    b64 = base64.b64encode(towrite.read()).decode()  # some strings
+    linko= f'<center><a href="data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64,{b64}" '+style+'download="'+file_name+'"><button>'+name_mark+'</button></a></center>'
+    return linko
+
+
+@st.cache(show_spinner=True)
+def charged_data():
+    regiones = {}
+    regiones['Latam'] = ['Argentina', 'Brazil', 'Chile', 'Colombia',
+                         'Mexico', 'Peru']
+    regiones['Europa'] = ['Italy', 'Spain', 'Germany', 'United Kingdom',
+                          'France']
+    regiones['Asia Emergente'] = ['South Korea', 'Taiwan', 'Hong Kong',
+                                  'India', 'Thailand', 'Indonesia']
+    regiones['USA'] = ['United States']
+    data_dict=np.load('dict_movilidad.npy', allow_pickle='TRUE').item()
+    return data_dict, regiones
+
+
+
+
+def comandos_utiles():
+    st.code("""CMD o Terminal\n> pip install streamlit """, language='python')
+    st.code("""CMD o Terminal\n> cd "ruta vista" \n> streamlit run app.py """,language='python')
+    code='''import streamlit as st \ndef comandos_utiles(): \n    col1, col2 = st.columns(2) \n    ...'''
+    st.code(code, language='python')
+    st.subheader("Elementos interactivos")
+    col1, col2 = st.columns(2)
+    col2.header(" ")
+    code2=('''var = col1.selectbox("Selectbox", ["Opcion 1", "Opcion 2", "Opcion 3"]) \nst.write(var)''')
+    col2.code(code2)
+    var = col1.selectbox("Selectbox", ["Opcion 1", "Opcion 2", "Opcion 3"])
+    col1.write(var)
+    var2 = col1.multiselect("Multiselect", ["Opcion 1", "Opcion 2", "Opcion 3"])
+    col1.write(var2)
+    code3=('''var = col1.multiselect("Selectbox", ["Opcion 1", "Opcion 2", "Opcion 3"]) \nst.write(var2)''')
+    col2.header(" ")
+    col2.code(code3)
+    var3 = col1.number_input("Number input")
+    col1.write(var3)
+    code4=('''var3 = col1.number_input("Number input") \nst.write(var3)''')
+    col2.header(" ")
+    col2.code(code4)
+    st.subheader("Tablas")
+    col1, col2 = st.columns(2)
+    df=pd.DataFrame([["1","2","3"],["2","5","6"],["7","8","9"]])
+    col1.write(df)
+    col2.header(" ")
+    col2.code("col1.write(df)")
+    col1.table(df)
+    col2.header(" ")
+    col2.header(" ")
+    col2.code("col1.table(df)")
+    col2.header(" ")
+    code_exc="""import io \nimport pybase64 as base6 \ndef get_table_excel_link(df, name):
+    towrite = io.BytesIO()
+    downloaded_file = df.to_excel(towrite, encoding='utf-8', index=False,
+                                 header=True)
+    towrite.seek(0)  # reset pointer
+    file_name = 'Data'+ name +'.xlsx'
+    style = 'style="color:black;text-decoration: none; font-size:18px;"'
+    name_mark = "Descargar " + name + ".xlsx"
+    b64 = base64.b64encode(towrite.read()).decode()  # some strings
+    linko= f'<center><a href="data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64,{b64}" '+style+'download="'+file_name+'"><button>'+name_mark+'</button></a></center>'
+    return linko \ncol1.markdown(get_table_excel_link(df, "tabla 1"),unsafe_allow_html=True)
+    """
+    col1.subheader("Descargar data frame")
+    col2.header(" ")
+    col1.header(" ")
+    col1.header(" ")
+    col2.code(code_exc)
+    col1.markdown(get_table_excel_link(df, "tabla 1"),unsafe_allow_html=True)
+    st.subheader("Graficos")
+    col1, col2 = st.columns((2,1))
+    col2.code("col1, col2 = st.columns((2,1)) \nfrom plotly import graph_objs as go \nimport plotly.express as px ")
+    df = px.data.tips()
+    fig = px.scatter(df, x="total_bill", y="tip", trendline="ols")
+    st.plotly_chart(fig)
+    st.code("""df = px.data.tips() \nfig = px.scatter(df, x="total_bill", y="tip", trendline="ols")\ncol1.plotly_chart(fig)""")
+        
+    
+    
+

apps/Comentarios.py

@@ -1,3 +1,623 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4a64b11b219002bef949d29c2f715b777046fa70a5beabcd7d779992f426362f
-size 27081
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import datetime
+from Scheduler.mailer_quant import Mailer
+from sqlalchemy import create_engine
+import psycopg2
+import graphviz as graphviz
+import plotly.graph_objects as go
+from logs_portal import log
+import io
+import boto3
+from Data.credentials import credentials_s3 as creds3
+from Data.credentials import credentials_postgresql as credpost
+from st_aggrid import GridOptionsBuilder, AgGrid, GridUpdateMode, DataReturnMode, JsCode
+
+
+def save_s3(key, secret_key, bucket, df, path):
+    with io.BytesIO() as output:
+        with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
+            df.to_excel(writer, index=False)
+        data = output.getvalue()
+    s3 = boto3.resource('s3', aws_access_key_id=key,
+                        aws_secret_access_key=secret_key)
+    s3.Bucket(bucket).put_object(Key=path, Body=data)
+
+
+def read_excel_s3(key, secret_key, bucket, path):
+    s3_client = boto3.client('s3', aws_access_key_id=key,
+                             aws_secret_access_key=secret_key)
+    response = s3_client.get_object(Bucket=bucket, Key=path)
+    data = response["Body"].read()
+    df = pd.read_excel(io.BytesIO(data), engine='openpyxl')
+    return df
+
+
+def display_table(df: pd.DataFrame):
+    # Configure AgGrid options
+    gb = GridOptionsBuilder.from_dataframe(df)
+    gb.configure_selection(selection_mode="single", use_checkbox=True,)
+    return AgGrid(
+        df, gridOptions=gb.build(),
+        update_mode=GridUpdateMode.SELECTION_CHANGED,
+        enable_enterprise_modules=True)
+
+
+def style_table():
+    style_table = """
+                <style>
+                tbody tr:hover {
+                           color:#BB1114;}
+                thead {
+                      background-color:#BB1114 ;
+                      color: #E8E8E8;
+                    }
+                tbody tr:nth-child(odd) {
+                      background-color: #fff;
+                    }
+                    # tbody tr:nth-child(even) {
+                    #   background-color: #eee;
+                    # }
+                tbody tr:nth-child(odd)
+                stTable {
+                    border-collapse: collapse;
+                    margin: 25px 0;
+                    font-size: 0.9em;
+                    min-width: 400px;
+                    box-shadow: 0 0 20px rgba(0, 0, 0, 0.15);
+                    }
+                </style>
+                """
+    st.markdown(style_table, unsafe_allow_html=True)
+
+
+def mostrar_tabla(info_fil, placeholder, select):
+    info_fil2 = info_fil.copy()
+    info_fil2 = info_fil2[select]
+    placeholder.table(info_fil2)
+
+
+@st.experimental_memo
+def leer_notas():
+    url = credpost["POSTGRESQL"]
+    engine = create_engine(url, echo=False)
+    data = pd.read_sql_query("SELECT * FROM notas_analistas", con=engine)
+    data.columns = ["Analista", "Comentario", "Date", "Empresa", "ID_Quant",
+                    "LV1", "Nota",
+                    "Pais", "Ticker Bloomberg", "Tipo de Comentario"]
+    data.index = pd.to_datetime(data['Date']).dt.strftime('%d/%m/%Y')
+    data.index.name = "Fecha"
+    data = data.sort_index(ascending=False)
+    return data
+
+
+@log
+def ver_nota():
+    select = ["Analista", "Tipo de Comentario", "Empresa", "Pais", "Nota",
+              "Comentario"]
+    key = creds3["S3_KEY_ID"]
+    secret_key = creds3["S3_SECRET_KEY"]
+    bucket = creds3["S3_BUCKET"]
+    path ="Analistas Empresa.xlsx"
+    style_table()
+    col1, col2, col3, col4 = st.columns(4)
+    data = leer_notas()
+    select = ["Analista", "Pais", "LV1", "Empresa", "Nota",
+              "Comentario"]
+    data3 = read_excel_s3(key, secret_key, bucket, path)
+    data4 = data3.copy()
+    autores = sorted(list(set(data4["Analista"].dropna())))
+    Autor = col1.selectbox("Analista", ["-"] + autores)
+    if Autor != "-":
+        data4 = data4[data4["Analista"] == Autor]
+        data = data[data["Analista"] == Autor]
+    pais = sorted(list(set(data4["Pais"].dropna())))
+    Pais = col2.selectbox("Pais", ["-"] + pais)
+    if Pais != "-":
+        data4 = data4[data4["Pais"] == Pais]
+        data = data[data["Pais"] == Pais]
+    industria = sorted(list(set(data4["LV1"].dropna())))
+    Industria = col3.selectbox("Industria", ["-"] + industria)
+    if Industria != "-":
+        data4 = data4[data4["LV1"] == Industria]
+        data = data[data["LV1"] == Industria]
+    empresa = sorted(list(set(data4["Empresa"].dropna())))
+    Empresa = col4.selectbox("Empresa", ["-"] + empresa)
+    if Empresa != "-":
+        data4 = data4[data4["Empresa"] == Empresa]
+        data = data[data["Empresa"] == Empresa]
+    info_fil = data
+    Ordenar_por = col1.selectbox("Ordenar por", ["Date", "Analista", "Pais",
+                                                 "LV1", "Empresa"])
+    mayor = col2.selectbox("Asc o desc", ["Descendiente",
+                                          "Ascendiente"])
+    fec_i = col3.date_input('Fecha de inicio', datetime.date(2021, 7, 1))
+    fec_f = col4.date_input('Fecha final')
+    placeholder = st.empty()
+    if mayor != "-" and Ordenar_por != "-":
+        var = Ordenar_por
+        if mayor == "Ascendiente":
+            info_fil = info_fil.sort_values(var, ascending=True)
+        else:
+            info_fil = info_fil.sort_values(var, ascending=False)
+    info_fil = info_fil[info_fil["Date"].dt.date >= fec_i]
+    info_fil = info_fil[info_fil["Date"].dt.date <= fec_f]
+    mostrar_tabla(info_fil, placeholder, select)
+
+
+@st.experimental_memo
+def read_mapeo_analistas():
+    key = creds3["S3_KEY_ID"]
+    secret_key = creds3["S3_SECRET_KEY"]
+    bucket = creds3["S3_BUCKET"]
+    path = "Analistas Empresa.xlsx"
+    return read_excel_s3(key, secret_key, bucket, path)
+
+
+@st.experimental_memo
+def read_company_db():
+    company_db = pd.pandas.read_excel("Data/Company_Base_Definitivo.xlsx",
+                                      sheet_name="Compilado",
+                                      engine="openpyxl")
+    return company_db
+
+
+def aggrid_notas(data):
+    gb = GridOptionsBuilder.from_dataframe(data)
+    # make columns editable
+    gb.configure_columns(["Nota",
+                          "Comentario"], editable=True)
+    gb.configure_column('Nota',
+                        cellEditor='agRichSelectCellEditor',
+                        cellEditorParams={'values': [1, 2, 3, 4, 5]}
+                        )
+    js = JsCode("""
+    function(e) {
+        let api = e.api;
+        let rowIndex = e.rowIndex;
+        let col = e.column.colId;
+        let rowNode = api.getDisplayedRowAtIndex(rowIndex);
+        api.flashCells({
+          rowNodes: [rowNode],
+          columns: [col],
+          flashDelay: 10000000000
+        });
+    };
+    """)
+    gb.configure_grid_options(onCellValueChanged=js) 
+    go = gb.build()
+    return AgGrid(data, gridOptions=go, key='grid1',
+                  allow_unsafe_jscode=True,
+                  reload_data=False, 
+                  fit_columns_on_grid_load=False,
+                  enable_enterprise_modules=True)
+
+
+def ingresar_nota():
+    try:
+        notas_df = leer_notas()
+        companydb_df = read_company_db()
+        companies_assigned_df = read_mapeo_analistas()
+        notas_df["Comentario"] = notas_df["Comentario"].fillna(" ")
+        analista = st.session_state["name"]
+        empresa_analista = sorted(
+                list(set(companies_assigned_df[companies_assigned_df["Analista"]
+                                                     == analista]["Empresa"])))
+        companies_fil = companies_assigned_df[
+            companies_assigned_df["Analista"] == analista]
+        data_fil_a = notas_df[notas_df["Analista"] == analista].drop_duplicates(
+            "Empresa")
+        data_fil = data_fil_a[["Empresa", "Nota", "Comentario"]]
+        data_fil = companies_fil.merge(data_fil,
+                                       on="Empresa",
+                                       how='left').reset_index()
+        data_fil["Nota"] = data_fil["Nota"].fillna(0)
+        data_fil["Comentario"] = data_fil["Comentario"].fillna(" ")
+        data_fil = data_fil[["Empresa",
+                             "Pais",
+                             "LV1",
+                             "Nota",
+                             "Comentario"]].sort_values("LV1")
+        notas = aggrid_notas(data_fil)
+        notas_f = notas["data"]
+        update_notas = []
+        for emp in notas_f.Empresa:
+            new_df = notas_f[notas_f.Empresa == emp]
+            old_df = data_fil[data_fil.Empresa == emp]
+            new_nota = new_df.iloc[0].Nota
+            new_comentario = new_df.iloc[0].Comentario
+            old_nota = old_df.iloc[0].Nota
+            old_comentario = old_df.iloc[0].Comentario
+            if old_nota != new_nota or old_comentario != new_comentario:
+                update_notas.append(notas_f[notas_f.Empresa == emp])
+        update_final = pd.concat(update_notas)
+        st.write(update_final)
+        submitted_2 = st.button("Update Notas")
+        if submitted_2:
+            today = datetime.datetime.today().strftime('%Y-%m-%d %H:%M:%S')
+            for emp in update_final.Empresa:
+                df_emp = update_final[update_final.Empresa==emp]
+                empresa_df = companydb_df[companydb_df['Short_Name']==emp].iloc[0]
+                pais = empresa_df['Portfolio_Country']
+                industria = empresa_df["LV1"]
+                id_quant = empresa_df["ID_Quant"]
+                tbloom = empresa_df['Ticker Bloomberg']
+                comentario = df_emp.iloc[0]["Comentario"]
+                nota = df_emp.iloc[0]["Nota"]
+                var = """(analista, comentario, date_nota, empresa, id_quant, lv1,
+                  nota, pais, ticker_bloomberg)"""
+                if "'" in emp:
+                    emp = emp.replace("'", "")
+                varlist = [analista, comentario, today, emp, id_quant,
+                           industria, nota, pais, tbloom]
+                # try:
+                url = credpost["POSTGRESQL"]
+                conn = psycopg2.connect(url, sslmode='require')
+                cur = conn.cursor()
+                cur.execute("INSERT INTO notas_test {Var}  VALUES %r; ".
+                            format(Var=var) % (tuple(varlist),))
+                conn.commit()
+                cur.close()
+                conn.close()
+                st.info("Nota ingresada exitosamente")
+                if emp != "-":
+                    asunto = "Actualizacion nota " + emp + " - " + analista
+                    mensaje = analista + " ha actualizado la nota de la empresa " + emp + " a " + str(nota)
+                else:
+                    asunto = "Actualizacion nota " + industria + " - " + analista
+                    mensaje = analista + " ha actualizado la nota de la industria " + industria + " a " + str(nota)
+                destinatario = st.session_state['mail']
+                mail = Mailer(asunto, mensaje, "", "[email protected]")
+                mail.send_message([#destinatario,
+                                   "[email protected],",
+                                   "[email protected]"])
+                # except:
+                #     st.error("Problemas al ingresar la nota")
+                #     asunto = "Actualizacion nota " + emp + " - " + analista
+                #     mensaje = analista + " ha tenido problemas con la nota de" + emp + " a " + str(nota)
+                #     mail = Mailer(asunto, mensaje, "", "[email protected]")
+                #     mail.send_message(["[email protected],",
+                #                        "[email protected]"])
+            st.experimental_memo.clear()
+    except Exception as exc:
+        st.write(exc)
+
+
+
+def ingresar_nota_ex():
+
+    Analistas = {
+        "fsutter": "Florencia Sutter",
+        "alehmann": "Alejandro Lehmann",
+        "bcosoi": "Benjamín Cosoi",
+        "chinojosa": "Carlos Hinojosa",
+        "gcatalan": "Gustavo Catalan",
+        "bull": "Benjamin Ul",
+        "ftaverne": "Francisca Taverne"
+        }
+    notas_df = leer_notas()
+    companydb_df = read_company_db()
+    companies_assigned_df = read_mapeo_analistas()
+    notas_df["Comentario"] = notas_df["Comentario"].fillna(" ")
+    if st.session_state.key in list(Analistas.keys()):
+        analista = Analistas[st.session_state.key]
+        data_analista = companies_assigned_df[companies_assigned_df["Analista"] == analista]
+        industrias_analista = sorted(list(
+            set(companies_assigned_df[companies_assigned_df["Analista"]
+                                                    == analista]["LV1"])))
+        empresa_analista = sorted(list(
+            set(companies_assigned_df[companies_assigned_df["Analista"]
+                                                 == analista]["Empresa"])))
+    else:
+        analista = st.session_state.key
+        data_analista = companies_assigned_df[
+            companies_assigned_df["Analista"] == analista]
+        industrias_analista = sorted(
+            list(set(companies_assigned_df[companies_assigned_df["Analista"]
+                                                    == analista]["LV1"])))
+        empresa_analista = sorted(
+            list(set(companies_assigned_df[companies_assigned_df["Analista"]
+                                                 == analista]["Empresa"])))
+    Countries = sorted(list(set(data_analista["Pais"])))
+    LV1s = sorted(list(set(data_analista["LV1"])))
+    industrias = []
+    for c in Countries:
+        for l in LV1s:
+            industrias.append(c + " - " + l)
+    col1, col2 = st.columns(2)
+    placeholder = col2.empty()
+    companies_fil = companies_assigned_df[
+        companies_assigned_df["Analista"] == analista]
+    data_fil_a = notas_df[notas_df["Analista"] == analista].drop_duplicates(
+        "Empresa")
+    data_fil = data_fil_a[["Empresa", "Nota"]]
+    data_fil = companies_fil.merge(data_fil,
+                                   on="Empresa",
+                                   how='left').fillna(0)
+    with col1:
+        notas_df2 = notas_df
+        porc_total = (notas_df.drop_duplicates("Empresa")["Nota"]>0).sum()/len(notas_df)
+        porc_emp_notas = (data_fil["Nota"] > 0).sum()/len(data_fil)*100
+        delta_per =  round(porc_total - porc_emp_notas, 2)
+        st.metric("% de empresas con nota", round(porc_emp_notas,2), delta_per)
+        notas_table = display_table(data_fil[["Empresa",
+                                              "Pais",
+                                              "LV1",
+                                              "Nota"]].sort_values("LV1"))
+
+        if len(notas_table["selected_rows"]) > 0:
+            emp_name = notas_table["selected_rows"][0]["Empresa"]
+            st.subheader("Comentario")
+            data_emp_df = data_fil_a[data_fil_a["Empresa"] == emp_name]
+            if len(data_emp_df) > 0:
+                st.write(data_emp_df.iloc[0]["Comentario"])
+                id_quant = data_emp_df.iloc[0]["ID_Quant"]
+                country = data_emp_df.iloc[0]["Pais"]
+            
+    
+    with placeholder.form("my_form2", True):
+        # col1, col2, col3, col4 = st.columns((3, 8, 2, 1.5))
+        Empresas = ["-"]+sorted(list(empresa_analista) + industrias)
+        st.markdown(
+            '<p style="font-size:12px; padding-left:0px; margin-bottom:0px;">Analista</p>',
+            unsafe_allow_html=True)
+        st.markdown('<h3 style="padding-left:0px;; margin-bottom:0px;"">'+analista+"</h3>",
+                      unsafe_allow_html=True)
+        if len(notas_table["selected_rows"]) <1:
+            empresa = st.selectbox('Empresa', Empresas)
+        else:
+            empresa = notas_table["selected_rows"][0]["Empresa"]
+            st.subheader(empresa)
+        tipo_comentario = "Nota"
+        nota = st.selectbox("Nota", [0, 1, 2, 3, 4, 5])
+        comentario = st.text_area('Comentario')
+        submitted_2 = st.form_submit_button("Publicar ")
+        var = """(analista, comentario, date_nota, empresa, id_quant, lv1,
+                  nota, pais, ticker_bloomberg)"""
+        today = datetime.datetime.today().strftime('%Y-%m-%d %H:%M:%S')
+    if submitted_2:
+        st.experimental_memo.clear()
+        empresa_df = companydb_df[companydb_df['Short_Name']==empresa].iloc[0]
+        pais = empresa_df['Portfolio_Country']
+        industria = empresa_df["LV1"]
+        id_quant = empresa_df["ID_Quant"]
+        tbloom = empresa_df['Ticker Bloomberg']
+        if "'" in empresa:
+            empresa = empresa.replace("'", "")
+        varlist = [analista, comentario, today, empresa, id_quant,
+                   industria, nota, pais, tbloom]
+        try:
+            url = credpost["POSTGRESQL"]
+            conn = psycopg2.connect(url, sslmode='require')
+            cur = conn.cursor()
+            cur.execute("INSERT INTO notas_analistas {Var}  VALUES %r; ".
+                        format(Var=var) % (tuple(varlist),))
+            conn.commit()
+            cur.close()
+            conn.close()
+            st.info("Nota ingresada exitosamente")
+            if empresa != "-":
+                asunto = "Actualizacion nota " + empresa + " - " + analista
+                mensaje = analista + " ha actualizado la nota de la empresa " + empresa + " a " + str(nota)
+            else:
+                asunto = "Actualizacion nota " + industria + " - " + analista
+                mensaje = analista + " ha actualizado la nota de la industria " + industria + " a " + str(nota)
+            destinatario = st.session_state['mail']
+            mail = Mailer(asunto, mensaje, "", "[email protected]")
+            mail.send_message([destinatario,
+                               "[email protected],",
+                               "[email protected]"])
+        except:
+            st.error("Problemas al ingresar la nota")
+            asunto = "Actualizacion nota " + empresa + " - " + analista
+            mensaje = analista + " ha tenido problemas con la nota de" + empresa + " a " + str(nota)
+            mail = Mailer(asunto, mensaje, "", "[email protected]")
+            mail.send_message(["[email protected],",
+                               "[email protected]"])
+    notas_df = leer_notas()
+    
+    # st.write(data_fil.columns)
+    # st.table(data_fil[["Analista","Empresa", "LV1","Nota", "Comentario"]])
+
+@log
+def estadisticas():
+    data = leer_notas()
+    st.subheader("Distribución de notas")
+    data = data[data["Nota"] != 0]
+    col1, col2 = st.columns((1.681, 1))
+    place = col1.empty()
+    val = col2.selectbox("Seleccione un analista", list(set(data["Analista"].dropna())))
+    data_fil = data[data["Analista"] == val]
+    data_fil["count"] = 1
+    data_fil2 = data_fil.groupby(by=["Nota"],
+                                 as_index=False).agg({"count": "sum"})
+    data_fil3 = data.sort_values("Date", ascending=False)
+    data_fil3 = data_fil3[data_fil3["ID_Quant"] == 0]
+    data_fil4 = data_fil3.groupby(by=["LV1", "Pais", "Empresa", "Date"],
+                                  as_index=False).agg({"Nota": "mean"})
+    data_fil3 = data_fil3.groupby(by=["LV1"],
+                                  as_index=False).agg({"Nota": "mean"})
+    l = []
+    for i in range(len(data_fil2)):
+        l.append(str(round(data_fil2.iloc[i]["Nota"])))
+    data_fil2["Nota "] = l
+    fig = px.bar(data_fil2, x="Nota ", y="count",
+                 color_discrete_sequence=['indianred'])
+    fig.update_layout(bargap=0.2)
+    place.plotly_chart(fig, use_container_width=True)
+    col2.header("Media = " + str(round(sum(data_fil2["Nota"]*data_fil2["count"])/sum(data_fil2["count"]),1)))
+    data["Datetime"] = pd.to_datetime(data["Date"], format='%Y-%m-%d %H:%M:%S',
+                                      errors='ignore')
+    data_fil4["Datetime"] = pd.to_datetime(data_fil4["Date"],
+                                           format='%Y-%m-%d %H:%M:%S',
+                                           errors='ignore')
+    st.subheader("Evolución por empresa")
+    col1, col2 = st.columns((2, 1))
+    placeholder = col1.empty()
+    pais = col2.selectbox("Seleccione un pais",
+                          ["-"] + sorted(list(set(data["Pais"].dropna()))))
+    if pais != "-":
+        data2 = data[data["Pais"] == pais]
+    else:
+        data2 = data
+    industria = col2.selectbox("Seleccione una industria",
+                               ["-"] + sorted(list(set(data2["LV1"].dropna()))))
+    if industria != "-":
+        data2 = data2[data2["LV1"] == industria]
+    else:
+        data2=data2
+    empr = col2.selectbox("Seleccione una empresa",
+                          ["-"] + sorted(list(set(data2["Empresa"].dropna()))))
+    if empr != "-":
+        notas_empr = data[data["Empresa"] == empr]
+    elif empr == "-" and pais == "-" and industria != "-":
+        notas_empr = data_fil4[data_fil4["LV1"]==industria]
+    elif empr == "-" and pais != "-" and industria == "-":
+        notas_empr = data_fil4[data_fil4["Pais"]==pais]
+    else:
+        notas_empr = data2
+    date_range = pd.date_range(notas_empr['Datetime'].min() - datetime.timedelta(days=4),
+                               datetime.datetime.today() + datetime.timedelta(days=1))
+    hist_notas = pd.DataFrame(index=date_range)
+    if empr == "-" and pais == "-" and industria == "-":
+        placeholder.empty()
+    else:
+        for empresa in list(set(notas_empr["Empresa"])):
+            l = []
+            a = 0
+            for i in list(date_range):
+                data3 = notas_empr[notas_empr["Empresa"] == empresa]
+                data3 = data3[data3["Datetime"].dt.date == i]
+                if len(data3) == 0:
+                    l.append(a)
+                else:
+                    a = data3.iloc[0]["Nota"]
+                    l.append(a)
+            hist_notas[empresa] = l
+            hist_notas["Date"] = list(hist_notas.index)
+        fig2 = px.line(hist_notas, x="Date", y=hist_notas.columns)
+        fig2.update_traces(textposition="bottom right")
+        placeholder.plotly_chart(fig2, use_container_width=True)
+    col2.header(" ")
+    col2.header(" ")
+    col1, col2 = st.columns((2, 1))
+    col1.subheader("Promedio por industria")
+    add_pais = col2.selectbox("Añadir Pais", ["-"] + list(set(data_fil4["Pais"])))
+    if add_pais != "-":
+        data_fil4 = data_fil4[data_fil4["Pais"] == add_pais]
+        data_fil4 = data_fil4.sort_values(by = "Datetime", ascending = False)
+        data_fil4 = data_fil4.drop_duplicates("LV1")
+        fig3 = go.Figure(data=[
+            go.Bar(name='General', x=data_fil3["LV1"], y=data_fil3["Nota"]),
+            go.Bar(name=add_pais, x=data_fil4["LV1"], y=data_fil4["Nota"])
+            ])
+        fig3.update_yaxes(range=[min(min(data_fil3['Nota']),
+                                     min(data_fil4['Nota']))/1.1,
+                                 max(max(data_fil3['Nota']),
+                                 max(data_fil4['Nota']))*1.1])
+    else:
+        fig3 = go.Figure(data=[
+            go.Bar(name='General', x=data_fil3["LV1"], y=data_fil3["Nota"])
+        ])
+        fig3.update_yaxes(range=[min(data_fil3['Nota'])/1.1,
+                                 max(data_fil3['Nota'])*1.1])
+    data_fil3 = data_fil3.sort_values("Nota")
+    fig3.update_layout(barmode='group',
+                       xaxis={'categoryorder': 'total descending'})
+
+    st.plotly_chart(fig3, use_container_width=True)
+
+
+def asignar_analista():
+    key = creds3["S3_KEY_ID"]
+    secret_key = creds3["S3_SECRET_KEY"]
+    bucket = creds3["S3_BUCKET"]
+    path ="Analistas Empresa.xlsx"
+    analista_emp = read_excel_s3(key, secret_key, bucket, path)
+    # analista_emp = pd.read_excel("Data/Analistas Empresa.xlsx", engine='openpyxl')
+    Analistas = {
+        "fsutter": "Florencia Sutter",
+        "alehmann": "Alejandro Lehmann",
+        "bcosoi": "Benjamín Cosoi",
+        "chinojosa": "Carlos Hinojosa",
+        "gcatalan": "Gustavo Catalan",
+        "bull": "Benjamin Ull",
+        "ftaverne": "Francisca Taverne"
+        }
+    analista_emp2 = analista_emp[["ID_Quant", "Analista", "Empresa", "LV1",
+                                  "Pais"]]
+    credenciales = pd.read_csv("Data/Credenciales_h.csv",
+                               names=['Usuario', 'Password', 'Area',
+                                        'Cargo','Mail','Nombre'])
+    analistas = credenciales[credenciales["Cargo"] == "Investment Analyst"]
+    col1, col2, col3 = st.columns(3)
+    analista = col1.selectbox("Analista",
+                              sorted(list(set(Analistas.values()))))
+    industria = col2.selectbox("Industria",
+                             sorted(list(set(analista_emp["LV1"]))))
+    col3.title(" ")
+    val = col3.checkbox("Seleccionar todos", value=True)
+    dicc ={}
+    with st.form("form"):
+        col1, col2 = st.columns(2)
+        col1.write("Asignar a: ")
+        col2.write("Industria: ")
+        col1.subheader(analista)
+        col2.subheader(industria)
+        col1.header(" ")
+        col2.header(" ")
+        col1, col2 = st.columns(2)
+        empresas = analista_emp[analista_emp["LV1"]==industria]["Empresa"]
+        i = 0
+        for empresa in empresas:
+            if i%2 == 0:
+                dicc[empresa] = col1.checkbox(empresa, value=val)
+                i += 1
+            else: 
+                dicc[empresa] = col2.checkbox(empresa, value=val)
+                i += 1
+        submit = st.form_submit_button("Asignar")
+    if submit:
+        for empresa in dicc.keys():
+            if dicc[empresa]:
+                cambio = analista_emp2[analista_emp2["Empresa"] == empresa]       
+                analista_emp2.loc[analista_emp2.Empresa == empresa, 'Analista'] = analista
+        save_s3(key, secret_key, bucket, analista_emp2, path)
+    style_table()
+    data_f = analista_emp2[["Analista", "Pais", "LV1", "Empresa"]]
+    data_f = data_f[data_f["Analista"] == analista]
+    graph = graphviz.Digraph()
+    for industry in list(set(data_f["LV1"])):
+        graph.edge(analista, industry)
+        d_ind = data_f[data_f["LV1"]==industry]
+    st.subheader("Mapeo Analista - Industrias")
+    st.graphviz_chart(graph)
+    d_ind = analista_emp2[["Analista", "Pais", "LV1", "Empresa"]]
+    d_ind = d_ind[d_ind["LV1"] == industria]
+    st.subheader("Analistas asignados a la industria " +  industria)
+    st.table(d_ind)
+
+
+def save_password():
+    key = creds3["S3_KEY_ID"]
+    secret_key = creds3["S3_SECRET_KEY"]
+    bucket = creds3["S3_BUCKET"]
+    path ='Claves.xlsx'
+    claves = read_excel_s3(key, secret_key, bucket, path)
+    col1, col2 = st.columns((1, 1.5))
+    with col1.form('Nueva clave'):
+        new_user = st.text_input("Ingresar usuario")
+        password = st.text_input("Ingresar clave")
+        plataforma = st.text_input("Plataforma")
+        submitted = st.form_submit_button('Ingresar')
+    if submitted:
+        claves = claves.append({"Clave": password,
+                                "Usuario": new_user,
+                                "Plataforma": plataforma
+                                }, ignore_index=True)
+        save_s3(key, secret_key, bucket, claves, path)
+    style_table()
+    claves.index = claves['Plataforma']
+    col2.table(claves[['Usuario','Clave']])
+    

apps/Google_Trends.py

@@ -1,3 +1,490 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:109b974aedf666d1ca13ae246aefa434313a2a271cad85165bb3e2768c23be78
-size 25533
+from modules import tables
+from google_tools import trends as gtrends
+import pandas as pd
+import numpy as np
+from datetime import timedelta, date
+from statsmodels.tsa.seasonal import seasonal_decompose
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import streamlit as st
+import io
+import boto3
+import openpyxl
+
+
+key ='AKIARYMZ4J2YQDB66VX4'
+secret_key = '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'
+bucket='portallvam'
+path ='Momentum.xlsx'
+
+
+def save_s3(key, secret_key, bucket, df, path):
+    with io.BytesIO() as output:
+        with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
+            for industry in df.keys():
+                df[industry].to_excel(writer, sheet_name=industry)
+        data = output.getvalue()
+    s3 = boto3.resource('s3', aws_access_key_id=key, aws_secret_access_key=secret_key)
+    s3.Bucket(bucket).put_object(Key=path, Body=data)
+
+
+def read_excel_s3(key, secret_key, bucket, path):
+    s3_client = boto3.client('s3', aws_access_key_id=key, aws_secret_access_key=secret_key)
+    response = s3_client.get_object(Bucket=bucket, Key=path)
+    data = response["Body"].read()
+    df = pd.read_excel(io.BytesIO(data), sheet_name=None, index_col='Unnamed: 0.1')
+    return df
+
+
+def generar_excel(ruta_guardado, Pestanas, Data):
+    wb = openpyxl.Workbook()
+    writer = pd.ExcelWriter(ruta_guardado)
+    for pestana in Pestanas:
+        wb.create_sheet(pestana)
+    std = wb.get_sheet_by_name('Sheet')
+    wb.remove_sheet(std)
+    wb.save(ruta_guardado)
+    for i, pestana in enumerate(Pestanas):
+        if pestana=='Real Estate Management & Development-CL':
+            pestana = 'Real Estate-CL'
+            Data['Real Estate Management & Development-CL'].to_excel(writer, sheet_name=pestana)
+        elif pestana=='Real Estate Management & Development-BR':
+            pestana = 'Real Estate-BR'
+            Data['Real Estate Management & Development-BR'].to_excel(writer, sheet_name=pestana)
+        else:
+            Data[pestana].to_excel(writer, sheet_name=Pestanas[i])
+    writer.save()
+
+
+def colores_corporativos(colors=None):
+
+    color_dict = {'red': (204, 0, 51),
+                   'light_blue': (110, 162, 201),
+                   'light_gray': (135, 146, 158),
+                   'grey': (105, 105, 105),
+                   'yellow': (195, 195, 9),
+                   'dark_purple': (119, 28, 95),
+                   'blue': (42, 83, 113),
+                   'purple': (159, 37, 127),
+                   'light_yellow': (252, 252, 196),
+                   'light_green': (122, 178, 153),
+                   'gray': (66, 74, 82)}
+
+    for key in color_dict:
+        color_dict[key] = tuple(v/255 for v in color_dict[key])
+
+    if colors is None:
+        return color_dict
+    else:
+        aux = {col: color_dict[col] for col in colors}
+        return aux
+
+
+corp_colors = list(colores_corporativos().values())
+colors2 = []
+for i in range(len(corp_colors)):
+    colors2.append("rgb" + str(corp_colors[i]))
+
+
+company_db = pd.read_excel('Data/Company_Base_Definitivo.xlsx', sheet_name='Compilado')
+id_to_ticker = {str(row['ID_Quant']): str(row['Ticker Bloomberg']).split()[0] for i, row in company_db.iterrows()}
+
+countries_dict = {'BR': 'Brazil', 'CL': 'Chile', 'US': 'Brazil',
+                  'US-Disease': 'Brazil'}
+
+
+@st.cache(suppress_st_warning=True)
+def data_request(countries, start, currency='USD'):
+    close_price = {'Brazil': [],
+                   'Chile': []}
+    market_cap = {'Brazil': [],
+                  'Chile': []}
+    for c in countries:
+        close_price[c] = tables.EquityMaster(field='IQ_CLOSEPRICE_ADJ', currency=currency, country=c).query(
+            rename=['asset'], start=start, expand=True)
+        market_cap[c] = tables.EquityMaster(field='IQ_MARKETCAP', currency=currency, country=c).query(
+            start=start, rename=['asset'], expand=True)
+
+        close_price[c] = close_price[c].loc[:, close_price[c].columns.isin(id_to_ticker.keys())]
+        close_price[c].columns = [id_to_ticker[col] for col in close_price[c].columns]
+
+        market_cap[c] = market_cap[c].loc[:, market_cap[c].columns.isin(id_to_ticker.keys())]
+        market_cap[c].columns = [id_to_ticker[col] for col in market_cap[c].columns]
+    return [close_price, market_cap]
+
+
+@st.cache(suppress_st_warning=True)
+def trends_request(keywords, today):
+    trends_frames_dict = {}
+    for sector, values in keywords.items():
+        if not (sector in ['Restaurantes']):
+            trends_frames_dict[sector] = {}
+            print('Buscando para ' + sector)
+            for country_name in values.columns:
+                words = values[country_name].dropna()
+                if '-' in country_name:
+                    fixed_country_name = country_name.split('-')[0].strip()
+                else:
+                    fixed_country_name = country_name
+                words_index = pd.DataFrame()
+                for word in words:
+                    new_data = gtrends.keyword_trend(word, fixed_country_name, end_date=today)
+                    if new_data is not None:
+                        words_index = pd.concat([words_index,
+                                                 new_data],
+                                                axis=1)
+                    else:
+                        print('No se encuentra data para ' + word)
+                trends_frames_dict[sector][country_name] = words_index
+                trends_frames_dict[sector][country_name].index.name = None
+    return trends_frames_dict
+
+
+def trends_frames_excel(dicc):
+    sheets_cl = []
+    sheets_br = []
+    for key_1 in dicc.keys():
+        for key_2 in dicc[key_1].keys():
+            if key_2=='CL':
+                sheets_cl .append(key_1 + '-' + key_2)
+            else:
+                sheets_br.append(key_1 + '-' + key_2)
+    trends_frames_dict_cl = {}
+    trends_frames_dict_br = {}
+    for key_1 in dicc.keys():
+        for key_2 in dicc[key_1].keys():
+            if key_2=='CL':
+                trends_frames_dict_cl[key_1 + '-'+ key_2] = dicc[key_1][key_2]
+            elif key_2=='BR':
+                trends_frames_dict_br[key_1 + '-' + key_2] = dicc[key_1][key_2]
+            elif key_2=='US' or key_2=='US-Disease':
+                trends_frames_dict_br[key_1 + '-' + key_2] = dicc[key_1][key_2]
+
+    generar_excel('Data/GT_CL.xlsx', sheets_cl, trends_frames_dict_cl)
+    df_cl = pd.read_excel('Data/GT_CL.xlsx', sheet_name=None)
+    st.write(df_cl)
+    save_s3(key=key, secret_key=secret_key, bucket=bucket, df=df_cl, path='GT_CL.xlsx')
+
+    generar_excel('Data/GT_BR.xlsx', sheets_br, trends_frames_dict_br)
+    df_br = pd.read_excel('Data/GT_BR.xlsx', sheet_name=None)
+    save_s3(key=key, secret_key=secret_key, bucket=bucket, df=df_br, path='GT_BR.xlsx')
+
+
+def read_trends_frames(country):
+    if country=='CL':
+        return read_excel_s3(key=key, secret_key=secret_key, bucket=bucket, path='GT_CL.xlsx')
+    elif country=='BR':
+        return read_excel_s3(key=key, secret_key=secret_key, bucket=bucket, path='GT_BR.xlsx')
+
+
+def report():
+    form = st.form('Report')
+    start_date = str(date.today() - timedelta(5 * 365))
+    select_countries = form.multiselect('¿Qué país(es) desea visualizar?', ['Todos', 'Chile', 'Brazil'])
+    if 'Todos' in select_countries:
+        select_countries = ['Chile', 'Brazil']
+    update_data = form.form_submit_button("Actualizar Datos")
+    accept = form.form_submit_button('Visualizar')
+    col1, col2 = st.columns(2)
+
+    if update_data:
+        xls = pd.ExcelFile('Data/keywords_definitivas_mongo.xlsx')
+        industry_filter = ['Pesca', 'Agricola', 'Financials-RP']
+        keywords_dict = {sheet: xls.parse(sheet) for sheet in xls.sheet_names
+                         if sheet not in industry_filter}
+        xls.close()
+        del xls
+
+        # Arreglamos una llave porque una hoja de excel alcanza el máximo de caracteres posible para un nombre.
+        new_key = "Real Estate Management & Development"
+        old_key = "Real Estate Management & Develo"
+        keywords_dict[new_key] = keywords_dict.pop(old_key)
+
+        trends_dict = trends_request(keywords_dict, date.today())
+        trends_frames_excel(trends_dict)
+        ud = pd.read_excel('Data/update_data.xlsx')
+        ud = ud[ud['View'] != 'Google Trends']
+        today = date.today().strftime('%d-%m-%Y')
+        ud = ud.append({"View": 'Google Trends',
+                    "Last_Update": today}, ignore_index=True)
+        ud.to_excel('Data/update_data.xlsx', index=False)
+
+    if accept:
+        close_price_dict, market_cap_dict = data_request(select_countries, start_date)
+
+        ew_index = {}
+        mw_index = {}
+        country_index = {}
+
+        if select_countries == ['Brazil']:
+            dates = {'Brazil': sorted(list(set(market_cap_dict['Brazil'].index)
+                                           .union(set(close_price_dict['Brazil'].index))))}
+        elif select_countries == ['Chile']:
+            dates = {'Chile': sorted(list(set(market_cap_dict['Chile'].index)
+                                          .union(set(close_price_dict['Chile'].index))))}
+        else:
+            dates = {'Brazil': sorted(list(set(market_cap_dict['Brazil'].index)
+                                           .union(set(close_price_dict['Brazil'].index)))),
+                     'Chile': sorted(list(set(market_cap_dict['Chile'].index)
+                                          .union(set(close_price_dict['Chile'].index))))}
+
+        for country in select_countries:
+            mkt = market_cap_dict[country]
+            cp = close_price_dict[country]
+            w = mkt.div(mkt.sum(1).values, axis=0)
+            rets = cp.pct_change()
+            country_index[country] = pd.DataFrame({'MW': (w * rets).sum(1),
+                                                   'EW': rets.mean(1)}).fillna(0)
+            industries_1 = np.unique(company_db[['LV1']].values)
+            industries_2 = np.unique(company_db[['LV2']].values)
+            industries = np.unique(np.concatenate([industries_1, industries_2]))
+            df_mw_index = pd.DataFrame(columns=industries, index=dates[country])
+            df_ew_index = pd.DataFrame(columns=industries, index=dates[country])
+            for industry in industries:
+                industry = str(industry)
+                mc = mkt.loc[:, mkt.columns.isin(company_db[company_db['LV1'] == industry]['Ticker'])]
+                prices = cp.loc[:, cp.columns.isin(company_db[company_db['LV1'] == industry]['Ticker'])]
+
+                w = mc.div(mc.sum(1).values, axis=0)
+                rets = prices.pct_change()
+                df_mw_index[industry] = (w * rets).sum(1)
+                df_ew_index[industry] = rets.mean(1)
+            mw_index[country] = df_mw_index.fillna(0)
+            ew_index[country] = df_ew_index.fillna(0)
+
+        xls = pd.ExcelFile('Data/keywords_definitivas_mongo.xlsx')
+        industry_filter = ['Pesca', 'Agricola', 'Financials-RP', 'Agriculture']
+        keywords_dict = {sheet: xls.parse(sheet) for sheet in xls.sheet_names
+                         if sheet not in industry_filter}
+        xls.close()
+        del xls
+
+        new_key = "Real Estate Management & Development"
+        old_key = "Real Estate Management & Develo"
+        keywords_dict[new_key] = keywords_dict.pop(old_key)
+
+        trends_frames = {}
+        trends_frames_cl = read_trends_frames('CL')
+        trends_frames_br = read_trends_frames('BR')
+
+        for key_cl in trends_frames_cl.keys():
+            trends_frames_cl[key_cl] = trends_frames_cl[key_cl].drop(columns='Unnamed: 0')
+
+        for key_br in trends_frames_br.keys():
+            trends_frames_br[key_br] = trends_frames_br[key_br].drop(columns='Unnamed: 0')
+
+        for industry in keywords_dict.keys():
+            if not industry=='Restaurantes':
+                countries_in_industry = keywords_dict[industry].columns
+                trends_frames[industry] = {}
+                for c in countries_in_industry:
+                    if c=='CL':
+                        if industry == 'Real Estate Management & Development':
+                            index = trends_frames_cl['Real Estate-CL'].index
+                            trends_frames[industry][c] = pd.DataFrame(columns=trends_frames_cl['Real Estate-CL'].columns,
+                                                                      index=index)
+                        else:
+                            index = trends_frames_cl[industry+'-CL'].index
+                            trends_frames_cl[industry+'-CL'] = trends_frames_cl[industry+'-CL'].loc[:, trends_frames_cl[industry+'-CL'].columns.notnull()]
+                            trends_frames[industry][c] = pd.DataFrame(columns=trends_frames_cl[industry+'-CL'].columns,
+                                                                      index=index)
+                    elif c=='BR':
+                        if industry == 'Real Estate Management & Development':
+                            index = trends_frames_br['Real Estate-BR'].index
+                            trends_frames[industry][c] = pd.DataFrame(columns=trends_frames_br['Real Estate-BR'].columns,
+                                                                      index=index)
+                        else:
+                            index = trends_frames_br[industry + '-BR'].index
+                            trends_frames[industry][c] = pd.DataFrame(columns=trends_frames_br[industry+'-BR'].columns,
+                                                                      index=index)
+                if 'CL' in countries_in_industry:
+                    if industry == 'Real Estate Management & Development':
+                        for col_cl in trends_frames_cl['Real Estate-CL'].columns:
+                            if col_cl in keywords_dict[industry]['CL'].values:
+                                trends_frames[industry]['CL'][col_cl] = trends_frames_cl['Real Estate-CL'][col_cl].dropna()
+                    else:
+                        for col_cl in trends_frames_cl[industry+'-CL'].columns:
+                            if col_cl in keywords_dict[industry]['CL'].values:
+                                trends_frames[industry]['CL'][col_cl] = trends_frames_cl[industry+'-CL'][col_cl].dropna()
+                if 'BR' in countries_in_industry:
+                    if industry == 'Real Estate Management & Development':
+                        for col_br in trends_frames_br['Real Estate-BR'].columns:
+                            if col_br in keywords_dict[industry]['BR'].values:
+                                trends_frames[industry]['BR'][col_br] = trends_frames_br['Real Estate-BR'][col_br].dropna()
+                    else:
+                        for col_br in trends_frames_br[industry+'-BR'].columns:
+                            if col_br in keywords_dict[industry]['BR'].values:
+                                trends_frames[industry]['BR'][col_br] = trends_frames_br[industry+'-BR'][col_br].dropna()
+        deseason = True
+        n_words = 5
+        for industry in keywords_dict.keys():
+            if not industry == 'Restaurantes':
+                countries_in_industry = keywords_dict[industry].columns
+                for c in countries_in_industry:
+                    trends_frames[industry][c] = trends_frames[industry][c].loc[:, trends_frames[industry][c].columns.notnull()]
+
+        summary = pd.DataFrame()
+        fig1 = make_subplots(rows=2, cols=1,
+                             subplot_titles=['Cambio Semanal', 'Cambio 1 Mes', 'Cambio 3 Meses', 'Cambio YTD'],
+                             horizontal_spacing=0.6, )
+        fig2 = make_subplots(rows=2, cols=1,
+                             subplot_titles=['Cambio Semanal', 'Cambio 1 Mes', 'Cambio 3 Meses', 'Cambio YTD'],
+                             horizontal_spacing=0.6)
+        for industry, dict_ in trends_frames.items():
+            for country, df_ in dict_.items():
+                if deseason:
+                    df_ = pd.DataFrame({col: df_[col] -
+                                             seasonal_decompose(df_[col], period=8).seasonal
+                                        for col in df_.columns})
+                summary[f'{industry}-{country}'] = df_.mean(1)
+        summary = (summary - summary.mean()) / summary.std()
+
+        delta_w = summary.diff(1).iloc[-1].sort_values(ascending=True)
+        delta_m = summary.diff(4).iloc[-1].sort_values(ascending=True)
+        delta_3m = summary.diff(12).iloc[-1].sort_values(ascending=True)
+        delta_ytd = summary.resample('Y').last().diff().iloc[-1].sort_values(ascending=True)
+
+        fig1.add_trace(go.Bar(x=delta_w.array, y=delta_w.index, orientation='h', marker_color=colors2[2],
+                              showlegend=False), row=1, col=1)
+
+        fig2.add_trace(go.Bar(x=delta_m.array, y=delta_m.index, orientation='h', marker_color=colors2[2],
+                              showlegend=False), row=1, col=1)
+
+        fig1.add_trace(go.Bar(x=delta_3m.array, y=delta_3m.index, orientation='h', marker_color=colors2[2],
+                              showlegend=False), row=2, col=1)
+
+        fig2.add_trace(go.Bar(x=delta_ytd.array, y=delta_ytd.index, orientation='h', marker_color=colors2[2],
+                              showlegend=False), row=2, col=1)
+
+        fig1.update_layout(title_text='Cambios en las Búsquedas', margin_b=0, margin_t=50, margin_r=0, margin_l=0)
+        fig2.update_layout(margin_b=0, margin_t=50, margin_r=0, margin_l=0)
+        col1.plotly_chart(fig1, use_container_width=True)
+        col2.plotly_chart(fig2, use_container_width=True)
+
+        for industry in trends_frames:
+            for i, (country, data) in enumerate(trends_frames[industry].items()):
+                if countries_dict[country] in select_countries:
+
+                    fig_indices1 = make_subplots(rows=2, cols=1, specs=[[{"secondary_y": True}],
+                                                                        [{"secondary_y": False}]],
+                                                 subplot_titles=['GT (zscore) vs Spread Histórico',
+                                                                 'Variación YoY GT Histórico'],
+                                                 horizontal_spacing=0.)
+                    fig_indices2 = make_subplots(rows=2, cols=1, specs=[[{"secondary_y": True}],
+                                                                        [{"secondary_y": False}]],
+                                                 subplot_titles=['GT (zscore) vs Spread Último Año',
+                                                                 'Variación YoY GT Último año'],
+                                                 horizontal_spacing=0.3)
+
+                    aux_df = summary[f'{industry}-{country}']
+                    aux_df.index.name = ''
+                    mm_year = aux_df.rolling(52).mean()
+                    mm_half = aux_df.rolling(26).mean()
+                    mm_quarter = aux_df.rolling(13).mean()
+                    mm_month = aux_df.rolling(4).mean()
+                    mm = pd.concat([mm_year, mm_half, mm_quarter, mm_month], axis=1)
+                    mm.columns = ['1Y', '6M', '3M', '1M']
+                    if deseason:
+                        p = '3M'
+                    else:
+                        p = '1Y'
+
+                    fig_indices1.add_trace(go.Scatter(x=mm[p].index, y=mm[p].array, line=dict(color=colors2[0]),
+                                                      showlegend=True, name=f'{p} MM GT Index'),
+                                           secondary_y=False, row=1, col=1)
+
+                    fig_indices1.update_layout(title_text=f'{industry} - {country}')
+                    fig_indices2.add_trace(
+                        go.Scatter(x=mm[p].iloc[-52:].index, y=mm[p].iloc[-52:].array, line=dict(color=colors2[0]),
+                                   showlegend=False, name=f'{p} MM GT Index'),
+                        secondary_y=False, row=1, col=1)
+
+                    mm_4w = data.mean(1).rolling(4).mean()
+                    yoy = mm_4w.pct_change(52)
+                    aux2 = pd.concat([yoy], axis=1)
+                    aux2.columns = ['YoY']
+                    aux2.index.name = ''
+
+                    fig_indices1.add_trace(go.Bar(x=aux2.dropna().index, y=aux2.dropna()['YoY'],
+                                                  marker_color=colors2[1], showlegend=False), row=2, col=1)
+                    fig_indices2.add_trace(go.Bar(x=aux2.dropna().iloc[-52:].index, y=aux2.dropna()['YoY'].iloc[-52:].array,
+                                                  marker_color=colors2[1], showlegend=False), row=2, col=1)
+
+                    if country == 'US' and industry == 'Pesca':
+                        country_ = 'Chile'
+                    else:
+                        country_ = countries_dict[country]
+
+                    spread_mw = (mw_index[country_][industry].rolling(52).apply(lambda x: (1 + x).prod()) -
+                                 country_index[country_]['MW'].rolling(52).apply(lambda x: (1 + x).prod()))
+                    spread_ew = (ew_index[country_][industry].rolling(52).apply(lambda x: (1 + x).prod()) -
+                                 country_index[country_]['EW'].rolling(52).apply(lambda x: (1 + x).prod()))
+
+                    spread = pd.DataFrame({'EW': spread_ew, 'MW': spread_mw})
+
+                    fig_indices1.add_trace(go.Scatter(x=spread['MW'].dropna().index, y=spread['MW'].dropna().array,
+                                                      name='Spread MW', line=dict(color=colors2[3])),
+                                           secondary_y=True, row=1, col=1)
+
+                    fig_indices2.add_trace(
+                        go.Scatter(x=spread['MW'].iloc[-260:].dropna().index, y=spread['MW'].iloc[-260:].dropna().array,
+                                   name='Spread MW', line=dict(color=colors2[3])),
+                        secondary_y=True, row=1, col=1)
+
+                    fig_indices1.update_xaxes(showticklabels=False)
+                    fig_indices2.update_xaxes(showticklabels=False)
+                    fig_indices1.layout.update(xaxis_rangeslider_visible=False, margin_b=20,
+                                               margin_r=20, margin_l=20,
+                                               legend=dict(orientation="h",
+                                                           yanchor="top",
+                                                           y=0.6,
+                                                           xanchor="right",
+                                                           x=1))
+                    fig_indices2.layout.update(xaxis_rangeslider_visible=False,
+                                               margin_b=20,
+                                               margin_r=20, margin_l=20,
+                                               legend=dict(orientation="h",
+                                                           yanchor="top",
+                                                           y=0.6,
+                                                           xanchor="right",
+                                                           x=1))
+                    fig_indices1.update_xaxes(showticklabels=True, row=2,
+                                              col=1)
+                    fig_indices2.update_xaxes(showticklabels=True, row=2,
+                                              col=1)
+
+                    fig_indices1.update_yaxes(tickformat=',.0%', row=2, col=1)
+                    fig_indices2.update_yaxes(tickformat=',.0%', row=2, col=1)
+
+                    if deseason:
+                        df1 = pd.DataFrame({col: data[col] -
+                                            seasonal_decompose(data[col]).seasonal
+                                            for col in data.columns})
+                    else:
+                        df1 = data
+
+                    # Top word's table plot
+                    last_week = df1.iloc[-1].sort_values(ascending=False)[:n_words] / 100
+                    all_time = df1.mean().sort_values(ascending=False)[:n_words] / 100
+
+                    fig_W = make_subplots(subplot_titles=['Top Words en ' + f'{industry} - {country}'])
+
+                    table = pd.concat([pd.Series(last_week.index),
+                                       pd.Series(all_time.index)], axis=1)
+                    table.columns = ['Top 1W', 'Top 5Y']
+                    fig_W.add_trace(go.Table(header=dict(values=table.columns),
+                                             cells=dict(values=[table['Top 1W'].values, table['Top 5Y'].values])))
+                    fig_W.update_layout(margin_b=0, margin_t=50,
+                                               margin_r=0, margin_l=0,
+                                               height=200)
+                    fig_indices1.update_layout(margin_b=0, margin_t=50,
+                                               margin_r=0, margin_l=0,
+                                               height=600)
+                    fig_indices2.update_layout(margin_b=0, margin_t=50,
+                                               margin_r=0, margin_l=0,
+                                               height=600)
+                    col1.plotly_chart(fig_indices1, use_container_width=True)
+                    col2.plotly_chart(fig_indices2, use_container_width=True)
+
+                    fig_W.update_layout(margin_b=0, margin_t=30, margin_r=10, margin_l=0)
+                    st.plotly_chart(fig_W, use_container_width=True)

apps/Home.py

@@ -1,3 +1,331 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:13c55d6844ab21cb85b970648c8c8a79a98b401b637549a96dd7f96c6f4f4873
-size 14238
+import pandas as pd
+from datetime import date
+from plotly import graph_objs as go
+import pybase64 as base64
+import numpy as np
+import investpy
+import streamlit as st
+import datetime as dt
+import io
+
+
+def get_table_excel_link(df, selected_stocks):
+    towrite = io.BytesIO()
+    downloaded_file = df.to_excel(towrite, encoding='utf-8', index=False,
+                                  header=True)
+    towrite.seek(0)  # reset pointer
+    file_name = 'Data'+ selected_stocks + '.xlsx'
+    style = 'style="color:black;text-decoration: none; font-size:18px;"'
+    name_mark = "Descargar " + selected_stocks + ".xlsx"
+    b64 = base64.b64encode(towrite.read()).decode()  # some strings
+    linko= f'<center><a href="data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64,{b64}" '+style+'download="'+file_name+'"><button>'+name_mark+'</button></a></center>'
+    return linko
+
+
+@st.cache
+def tabla_commodity(stocks, TODAY):
+    tabla = pd.DataFrame()
+    year_ago = date.today() - dt.timedelta(days=365)
+    year_ago = year_ago.strftime("%d/%m/%Y")
+    for stock in stocks:
+        precios = investpy.commodities.get_commodity_historical_data(
+                                                    commodity=stock,
+                                                    from_date=year_ago,
+                                                    to_date=TODAY)
+        precios = precios["Close"]
+        last_price = precios.iloc[-1]
+        oned = precios.iloc[-2]
+        onew = precios.iloc[-7]
+        onem = precios.iloc[-30]
+        oney = precios.iloc[0]
+        return1m = str(round((last_price/onem-1)*100, 2))+"%"
+        return1d = str(round((last_price/oned-1)*100, 2))+"%"
+        return1w = str(round((last_price/onew-1)*100, 2))+"%"
+        return1y = str(round((last_price/oney-1)*100, 2))+"%"
+        tabla = tabla.append([[return1d, return1w, return1m, return1y]])
+    tabla.columns = ["1d", "1w", "1m", "1y"]
+    tabla.index = stocks
+    return tabla
+
+
+@st.cache
+def tabla_indices(index, countries, TODAY):
+    tabla = pd.DataFrame()
+    year_ago = date.today() - dt.timedelta(days=365)
+    year_ago = year_ago.strftime("%d/%m/%Y")
+    for i in range(len(index)):
+        precios = investpy.get_index_historical_data(index=index[i],
+                                                     country=countries[i],
+                                                     from_date=year_ago,
+                                                     to_date=TODAY)
+        precios = precios["Close"]
+        last_price = precios.iloc[-1]
+        oned = precios.iloc[-2]
+        onew = precios.iloc[-7]
+        onem = precios.iloc[-30]
+        oney = precios.iloc[0]
+        return1m = str(round((last_price/onem-1)*100, 2))+"%"
+        return1d = str(round((last_price/oned-1)*100, 2))+"%"
+        return1w = str(round((last_price/onew-1)*100, 2))+"%"
+        return1y = str(round((last_price/oney-1)*100, 2))+"%"
+        tabla = tabla.append([[return1d, return1w, return1m, return1y]])
+    tabla.columns = ["1d", "1w", "1m", "1y"]
+    tabla.index = index
+    return tabla
+
+
+@st.cache
+def tabla_bonos(stocks, TODAY):
+    tabla = pd.DataFrame()
+    year_ago = date.today() - dt.timedelta(days=365)
+    year_ago = year_ago.strftime("%d/%m/%Y")
+    for stock in stocks:
+
+        precios = investpy.get_bond_historical_data(bond=stock,
+                                                    from_date=year_ago,
+                                                    to_date=TODAY)
+        precios = precios["Close"]
+        last_price = precios.iloc[-1]
+        oned = precios.iloc[-2]
+        onew = precios.iloc[-7]
+        onem = precios.iloc[-30]
+        oney = precios.iloc[0]
+        return1m = str(round((last_price-onem)*100, 2))+"%"
+        return1d = str(round((last_price -oned)*100, 2))+"%"
+        return1w = str(round((last_price -onew)*100, 2))+"%"
+        return1y = str(round((last_price - oney)*100, 2))+"%"
+        tabla = tabla.append([[return1d, return1w, return1m, return1y]])
+    tabla.columns = ["1d", "1w", "1m", "1y"]
+    tabla.index = stocks
+    return tabla
+
+
+def highlight_max(s):
+    if s.dtype == np.object:
+        is_neg = [False for _ in range(s.shape[0])]
+    else:
+        is_neg = s < 0
+    return ['color: red;' if cell else 'color:black' for cell in is_neg]
+
+
+def button_style():
+    style_button = """
+        <style>
+          button {
+            display: inline-block;
+            background-color: #e8e8e8;
+            border-radius: 15px;
+            border: 4px  #cccccc;
+            color: #4a4a4a;
+            text-align: center;
+            font-size: 12px;
+            padding: 2px;
+            width: 250px;
+            transition: all 0.5s;
+            cursor: pointer;
+            margin: 5px;
+          }
+          button span {
+            cursor: pointer;
+            display: inline-block;
+            position: relative;
+            transition: 0.5s;
+          }
+          button span:after {
+            content: '\00bb';
+            position: absolute;
+            opacity: 0;
+            top: 0;
+            right: -20px;
+            transition: 0.5s;
+          }
+          button:hover {
+            background-color: #bb1114;
+            color:#e8e8e8;
+          }
+          button:hover span {
+            padding-right: 25px;
+          }
+          button:hover span:after {
+            opacity: 1;
+            right: 0;
+            }
+         .stMarkdown{
+            margin-bottom:0px;}
+    </style>
+    """
+    st.markdown(style_button, unsafe_allow_html=True)
+
+
+def style_table():
+    # tr:hover {background-color: #E8E8E8;
+    #          color:#BB1114;}
+    style_table = """
+                <style>
+                tr { line-height: 5px; }
+                thead {
+                      background-color:#BB1114 ;
+                      color: #E8E8E8;
+                    }
+                tbody tr:nth-child(odd) {
+                      background-color: #fff;
+                    }
+                    tbody tr:nth-child(even) {
+                      background-color: #eee;
+                    }
+                .css-1rcck9u{
+                    padding:0.25rem;}
+                tbody tr:nth-child(odd)
+                stTable {
+                    border-collapse: collapse;
+                    background-color:red;
+                    margin: 25px 0;
+                    font-size: 0.9em;
+                    min-width: 400px;
+                    box-shadow: 0 0 20px rgba(0, 0, 0, 0.15);
+                    }
+                table{
+                    margin-top:0px;
+                    font-size:9px;
+                    padding:0px;
+                    height:200px;}
+                .st-cc, .st-cb{
+                    padding-top:5px;
+                    padding-bottom:5px;}
+                        h3, h1, h2, .svg-container {
+                  animation-duration: 3s;
+                  animation-name: slidein;
+                }
+                @keyframes slidein {
+                  from {
+                    margin-left: 100%;
+                    width: 300%
+                  }
+                  to {
+                    margin-left: 0%;
+                    width: 100%;
+                  }
+                }
+                </style>
+                """
+    st.markdown(style_table, unsafe_allow_html=True)
+
+
+def seleccionar_fecha(fecha_select):
+    if fecha_select == "1 week":
+        fec_in = date.today() - dt.timedelta(days=7)
+    elif fecha_select == "1 month":
+        fec_in = date.today() - dt.timedelta(days=30)
+    elif fecha_select == "3 month":
+        fec_in = date.today() - dt.timedelta(days=90)
+    elif fecha_select == "6 month":
+        fec_in = date.today() - dt.timedelta(days=180)
+    elif fecha_select == "1 year":
+        fec_in = date.today() - dt.timedelta(days=365)
+    elif fecha_select == "5 year":
+        fec_in = date.today() - dt.timedelta(days=365*5)
+    fec_in = fec_in.strftime("%d/%m/%Y")
+    return fec_in
+
+
+def stock_price():
+    style_table()
+    button_style()
+    TODAY = date.today().strftime("%d/%m/%Y")
+    YDAY = date.today() - dt.timedelta(days=1)
+    YDAY = YDAY.strftime("%d/%m/%Y")
+    commodity = ["Copper", "Silver", "Gold", "Platinum", 'Brent Oil',
+                 'Heating Oil']
+    # bonos = ["Brazil 10Y", "Mexico 10Y" , "Chile 10Y", "Colombia 10Y"
+    #          , "Peru 10Y"]
+    bonds10y = ["Brazil 10Y", "Mexico 10Y", "Chile 10Y", "Colombia 10Y",
+                "Peru 10Y", "China 10Y"]
+    index = ["S&P CLX IPSA", "S&P Merval", "Bovespa", "S&P 500"]
+    countries = ["chile", "argentina", "brazil", "united states"]
+    col1, col2, col3 = st.beta_columns(3)
+    cols = st.beta_columns((3, 2, 3, 2, 3, 2))
+    col1.markdown('<center><h1 style="font-size:22px;">Principales bonos 10Y</h1><center>', unsafe_allow_html=True) 
+    col2.markdown('<center><h1 style="font-size:22px;">Principales commodities</h1><center>', unsafe_allow_html=True)
+    col3.markdown('<center><h1 style="font-size:22px;">Principales indices</h1><center>', unsafe_allow_html=True)
+    selected_com = cols[2].selectbox("  ", commodity)
+    selected_index = cols[4].selectbox(" ", index)
+    selected_bonds = cols[0].selectbox(" ", bonds10y)
+    fecha_select = cols[3].selectbox("  ", ["1 year", "6 month", "3 month",
+                                            "1 month", "1 week"])
+    fecha_select2 = cols[5].selectbox("   ", ["1 year", "6 month", "3 month",
+                                              "1 month", "1 week"])
+    fecha_select3 = cols[1].selectbox("    ", ["1 year", "6 month", "3 month",
+                                               "1 month", "1 week"])
+    # fecha_select =cols[2].button("hola")
+    fec_in = seleccionar_fecha(fecha_select)
+    fec_in2 = seleccionar_fecha(fecha_select2)
+    fec_in3 = seleccionar_fecha(fecha_select3)
+    selected_country = countries[index.index(selected_index)]
+    data_bonds = investpy.get_bond_historical_data(bond=selected_bonds,
+                                                   from_date=fec_in3,
+                                                   to_date=TODAY)
+    data_com = investpy.commodities.get_commodity_historical_data(
+                                                        commodity=selected_com,
+                                                        from_date=fec_in,
+                                                        to_date=TODAY)
+    data_index = investpy.get_index_historical_data(index=selected_index,
+                                                    country=selected_country,
+                                                    from_date=fec_in2,
+                                                    to_date=TODAY)
+
+    def plot_raw_data(col, data, color, prefijo):
+        fig = go.Figure()
+        close_ = go.Scatter(x=data.index, y=data['Close'], name="stock_close",
+                            line=dict(color=color), fill='tonexty')
+        fig.add_trace(close_)
+        fig.layout.update(title_text="", xaxis_rangeslider_visible=True,
+                          width=300, height=200, margin_b=0, margin_t=0,
+                          margin_r=0, margin_l=0)
+        fig.update_yaxes(range=[min(data['Close'])/1.05,
+                                max(data['Close'])*1.05], tickprefix=prefijo)
+        col.plotly_chart(fig)
+    plot_raw_data(cols[0], data_bonds, 'seagreen', "")
+    plot_raw_data(cols[2], data_com, 'midnightblue', "$")
+    plot_raw_data(cols[4], data_index, 'dimgrey', "$")
+    col1, col2, col3 = st.beta_columns(3)
+    cols = st.beta_columns((3, 2, 3, 2, 3, 2))
+    last_price = data_bonds.iloc[-1]["Close"]
+    first_price = data_bonds.iloc[0]["Close"]
+    returns = round((last_price/first_price-1)*100, 2)
+    cols[0].markdown('<h4 style="font-size:12px; padding-left:15px; margin-bottom:0px;">'+"Precio"+"</h4>", unsafe_allow_html=True)
+    cols[0].markdown('<p style="font-size:25px; padding-left:30px;">'+"{:,}".format(last_price)+"%</p>", unsafe_allow_html=True)
+    if returns > 0:
+        cols[1].markdown('<p style="font-size:20px; padding-top:22px; color:green;">▲ '+str(returns)+" %</p>", unsafe_allow_html=True)
+    else:
+        cols[1].markdown('<p style="font-size:20px; padding-top:22px; color:red;">▼ '+str(returns)+" %</p>", unsafe_allow_html=True)
+    last_price2 = data_com.iloc[-1]["Close"]
+    first_price2 = data_com.iloc[0]["Close"]
+    returns2 = round((last_price2/first_price2-1)*100, 2)
+    cols[2].markdown('<h4 style="font-size:12px; padding-left:15px; margin-bottom:0px;">'+"Precio"+"</h4>", unsafe_allow_html=True)
+    cols[2].markdown('<p style="font-size:25px; padding-left:30px;">$'+"{:,}".format(last_price2)+"</p>", unsafe_allow_html=True)
+    if returns2 > 0:
+        cols[3].markdown('<p style="font-size:20px; padding-top:22px; color:green;">▲ '+str(returns2)+" %</p>", unsafe_allow_html=True)
+    else:
+        cols[3].markdown('<p style="font-size:20px; padding-top:22px; color:red;">▼ '+str(returns2)+" %</p>", unsafe_allow_html=True)
+    last_price3 = data_index.iloc[-1]["Close"]
+    first_price3 = data_index.iloc[0]["Close"]
+    returns3 = round((last_price3/first_price3-1)*100, 2)
+    cols[4].markdown('<h4 style="font-size:12px; padding-left:15px; margin-bottom:0px;">'+"Precio"+"</h4>", unsafe_allow_html=True)
+    cols[4].markdown('<p style="font-size:25px; padding-left:30px;">$'+"{:,}".format(last_price3)+"</p>", unsafe_allow_html=True)
+    if returns3 > 0:
+        cols[5].markdown('<p style="font-size:20px; padding-top:22px; color:green;">▲ '+str(returns3)+" %</p>", unsafe_allow_html=True)
+    else:
+        cols[5].markdown('<p style="font-size:20px; padding-top:22px; color:red;">▼ '+str(returns3)+" %</p>", unsafe_allow_html=True)
+    col1, col2, col3 = st.beta_columns(3)
+    col1.table(tabla_bonos(bonds10y, TODAY))
+    col2.table(tabla_commodity(commodity, TODAY))
+    col3.table(tabla_indices(index, countries, TODAY))
+
+    col1, col2, col3 = st.beta_columns(3)
+    col2.markdown(get_table_excel_link(data_com, selected_com),
+                  unsafe_allow_html=True)
+    col3.markdown(get_table_excel_link(data_index, selected_index),
+                  unsafe_allow_html=True)
+    col1.markdown(get_table_excel_link(data_bonds, selected_bonds),
+                  unsafe_allow_html=True)
+    get_table_excel_link

apps/Mom_industrias.py

@@ -1,3 +1,702 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c0043bb6c64abb60fb7db97c8943f1d27bd9a60bd3acdf824dde73a537c299ba
-size 32581
+import pandas as pd
+import os
+from plotly.subplots import make_subplots
+import plotly.graph_objects as go
+from datetime import datetime, timedelta, date
+import streamlit as st
+import sys
+from math import ceil
+from modules import tables
+import io
+import boto3
+from Data.credentials import credentials_s3 as creds3
+
+
+
+
+
+def save_s3(key, secret_key, bucket, df, path):
+    with io.BytesIO() as output:
+        with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
+            df.to_excel(writer, 'sheet_name')
+        data = output.getvalue()
+    s3 = boto3.resource('s3', aws_access_key_id=key,
+                        aws_secret_access_key=secret_key)
+    s3.Bucket(bucket).put_object(Key=path, Body=data)
+
+
+@st.experimental_memo
+def read_excel_s3(key, secret_key, bucket, path):
+    s3_client = boto3.client('s3', aws_access_key_id=key,
+                             aws_secret_access_key=secret_key)
+    response = s3_client.get_object(Bucket=bucket, Key=path)
+    data = response["Body"].read()
+    df = pd.read_excel(io.BytesIO(
+        data), sheet_name='sheet_name', index_col='date')
+    return df
+
+
+def sectors_lv1_dicc():
+    sectors_dicc = {}
+    company_db = pd.read_excel(
+        'Data/Company_Base_Definitivo.xlsx', sheet_name='Compilado')
+    sectors = list(company_db['LV1'].unique())
+    for sector in sectors:
+        sectors_dicc[sector] = list(set(list(company_db[company_db['LV1'] == sector]['Country'].unique()))
+                                    .intersection(['Argentina', 'Brazil', 'Chile', 'Colombia', 'Mexico', 'Peru']))
+    return sectors_dicc
+
+
+def colores_corporativos(colors=None):
+
+    color_dict = {'green': (55, 95, 77),
+                  'light_blue': (110, 162, 201),
+                  'light_gray': (135, 146, 158),
+                  'dark_purple': (119, 28, 95),
+                  'red': (204, 0, 51),
+                  'blue': (42, 83, 113),
+                  'purple': (159, 37, 127),
+                  'light_green': (122, 178, 153),
+                  'gray': (66, 74, 82),
+                  'yellow': (195, 195, 9),}
+
+    for key in color_dict:
+        color_dict[key] = tuple(v/255 for v in color_dict[key])
+
+    if colors is None:
+        return color_dict
+    else:
+        aux = {col: color_dict[col] for col in colors}
+        return aux
+
+
+def update_data(start=str(date.today()-timedelta(int(1.5*365))), today=str(date.today())):
+    fields = ['IQ_CLOSEPRICE_ADJ', 'IQ_MARKETCAP', 'IQ_VALUE_TRADED']
+    key = creds3["S3_KEY_ID"]
+    secret_key = creds3["S3_SECRET_KEY"]
+    bucket = creds3["S3_BUCKET"]
+    path = 'Momentum.xlsx'
+    for f in fields:
+        # Cargamos de Mongo data de empresas
+        save_s3(key=key, secret_key=secret_key, bucket=bucket,
+                df=tables.EquityMaster(field=f).query(
+                start=start, end=today, rename=['asset']),
+                path=f + '.xlsx')
+    ud = pd.read_excel('Data/update_data.xlsx')
+    ud = ud[ud['View'] != 'Mom Industrias']
+    today = date.today().strftime('%d-%m-%Y')
+    ud = ud.append({"View": 'Mom Industrias',
+                    "Last_Update": today}, ignore_index=True)
+    ud.to_excel('Data/update_data.xlsx', index=False)
+
+@st.cache(suppress_st_warning=True)
+def data_request(today, start, countries, criteria='LV1'):
+    """
+    Hace las consultas básicas necesarias para poder visaulizar StN.
+    :param today: fecha de hoy. Este parámetro está sólo para poder usar st.cache.
+    :param start: desde cuándo se está haciendo la consulta.
+    :param countries: países que solicita el usuario
+    :param criteria: Criterio a usar en country_sector.
+    :return: data_dict, company_db, country_sector)
+    """""
+    key = creds3["S3_KEY_ID"]
+    secret_key = creds3["S3_SECRET_KEY"]
+    bucket = creds3["S3_BUCKET"]
+    path = 'Momentum.xlsx'
+    # Cargamos mapeos
+    file = 'Data/Company_Base_Definitivo.xlsx'
+    company_db = pd.read_excel(file, sheet_name='Compilado', index_col='ID_Quant',
+                               engine='openpyxl')
+    # Pequeño arreglo de meli y globant
+    company_db.loc[[7, 72], 'Country'] = 'Brazil'
+
+    data_dict = {}
+
+    paths = ['IQ_CLOSEPRICE_ADJ.xlsx',
+             'IQ_MARKETCAP.xlsx', 'IQ_VALUE_TRADED.xlsx']
+    for p in paths:
+        data_dict[p[:-5]] = read_excel_s3(key=key,
+                                          secret_key=secret_key, bucket=bucket, path=p)
+
+    # Vemos solo las parejas de pais-sector que existen para ahorrar parejas
+    country_sector = (company_db[['Country', criteria]].drop_duplicates().
+                      sort_values(['Country', criteria]))
+
+    country_sector = country_sector.loc[country_sector['Country'].isin(
+        countries)]
+    return data_dict, company_db, country_sector
+
+
+def mm_eval(series):
+    return int(series.iloc[-1] > series.mean())
+
+
+@st.cache(suppress_st_warning=True)
+def country_request(country, start, end):
+    return tables.MacroMaster(country=country, instrument='INDEX').query(start=start, end=end)
+
+
+@st.cache(suppress_st_warning=True)
+def univ_request(company_db, c):
+    return company_db.query(f"Country == '{c}'").index.astype(str)
+
+
+@st.cache(suppress_st_warning=True)
+def mm_sum(prices_c, p_list):
+    return sum([prices_c.rolling(p * 20).apply(mm_eval) for p in p_list])
+
+
+@st.experimental_memo
+def dictionaries_maker(start, countries,  country_sector, criteria, company_db, data_dict):
+    rel_rets = {}
+    cs_ids = {}
+    w_hist = {}
+    bm_dict = {c: country_request(c, start, str(date.today()))
+               for c in countries}
+
+    for c in countries:
+        bm_rets = tables.MacroMaster(
+            country=c, instrument='INDEX').query(start=start)
+        rel_ret_c = {}
+        for s in country_sector.loc[country_sector['Country'] == c, criteria]:
+            univ = (company_db.query(f"Country == '{c}' and {criteria} == '{s}'")
+                    .index.astype(str))
+            univ = list(set(univ & data_dict['IQ_MARKETCAP'].columns
+                            & data_dict['IQ_CLOSEPRICE_ADJ'].columns))
+            w = data_dict['IQ_MARKETCAP'][univ].ffill().fillna(0)
+            w = w.div(w.sum(1), axis=0)
+            w_hist[f'{c}-{s}'] = w
+            p_ind = data_dict['IQ_CLOSEPRICE_ADJ'][univ].ffill()
+            ret_ind = (w * p_ind.pct_change()).fillna(0).sum(1)
+            rel_ret_c[s] = ret_ind - bm_rets
+            cs_ids[f'{c}-{s}'] = univ
+
+        rel_rets[c] = pd.DataFrame(rel_ret_c)
+
+    return rel_rets, cs_ids, w_hist, bm_dict
+
+
+def signal_to_noise():
+    """
+    Despliega un formulario de streamlit y grafica lo indicado por el usuario.
+    :return: None
+    """
+    form_stn = st.form("StN")
+    stn_view = form_stn.selectbox('¿Cómo desea visualizar StN?:',
+                                  ('Nivel o Cambios por País',
+                                   'Grafico Agregado de StN'))
+
+    if stn_view == 'Nivel o Cambios por País':
+        n = form_stn.slider('Inserte para cuántas semanas desea visualizar cambios (Con 0 se muestra el nivel StN).',
+                            min_value=0, max_value=12)
+    else:
+        n = 0
+
+    # Países a  visualizar
+    countries = form_stn.multiselect('País : ',
+                                     ('Todos', 'Argentina', 'Brazil',
+                                      'Chile', 'Colombia', 'Mexico', 'Peru'))
+    if 'Todos' in countries:
+        countries = ['Argentina', 'Brazil',
+                     'Chile', 'Colombia', 'Mexico', 'Peru']
+
+    countries_q = len(countries)
+
+    update_button = form_stn.form_submit_button("Actualizar datos")
+    if update_button:
+        update_data()
+
+    accept = form_stn.form_submit_button('Visualizar')
+
+    start = '2017'
+    criteria = 'LV1'
+
+    st.write("### Está visualizando: StN")
+
+    colors = list(colores_corporativos().values())
+    colors2 = []
+    for i in range(len(colors)):
+        colors2.append("rgb" + str(colors[i]))
+
+    if accept:
+
+        today = str(date.today())
+        # Acá cargamos los datos necesarios
+        data = data_request(today, start, countries)
+        data_dict = data[0]
+        company_db = data[1]
+        country_sector = data[2]
+        st.write('Data desde ' + start + ' hasta ' +
+                 str(data_dict['IQ_CLOSEPRICE_ADJ'].index[-1].date()))
+
+        rel_rets, cs_ids, w_hist, bm_dict = dictionaries_maker(start,
+                                                               countries,
+                                                               country_sector,
+                                                               criteria,
+                                                               company_db,
+                                                               data_dict)
+
+        stn_p = 20 * 5
+        signal_to_noise_dict = {c: df.rolling(stn_p).sum() / df.abs().rolling(stn_p).sum().abs()
+                                for c, df in rel_rets.items()}
+        if stn_view == 'Nivel o Cambios por País':
+            index = list(range(len(colors2)))
+            colors2 = dict(zip(index, colors2))
+            if n == 0:
+                st.write('### Nivel de StN')
+                fig = make_subplots(rows=1, cols=1, subplot_titles=countries)
+                if countries_q == 1:
+                    for i, (c, df) in enumerate(signal_to_noise_dict.items()):
+                        fig.add_trace(go.Bar(x=df.iloc[-1].sort_values().array, y=df.iloc[-1].sort_values().index,
+                                             orientation='h', showlegend=False,
+                                             marker_color=colors2[3]))
+                        fig.update_yaxes(visible=True, showticklabels=True)
+                        fig.update_xaxes(visible=False, showticklabels=False)
+                        fig.update_layout(height=800)
+                    with st.container():
+                        st.plotly_chart(fig, use_container_width=True)
+                else:
+                    col1, col2 = st.columns(2)
+                    titles_1 = []
+                    titles_2 = []
+                    for k in range(countries_q):
+                        if k % 2 == 0:
+                            titles_1.append(countries[k])
+                        else:
+                            titles_2.append(countries[k])
+
+                    fig1 = make_subplots(rows=1 + (countries_q > 2) + (countries_q > 4), cols=1,
+                                         subplot_titles=titles_1)
+                    fig2 = make_subplots(rows=1 + (countries_q > 2) + (countries_q > 4), cols=1,
+                                         subplot_titles=titles_2)
+
+                    for i, (c, df) in enumerate(signal_to_noise_dict.items()):
+                        if i % 2 == 0:
+                            fig1.add_trace(go.Bar(x=df.iloc[-1].sort_values().array, y=df.iloc[-1].sort_values().index,
+                                                  orientation='h', showlegend=False,
+                                                  marker_color=colors2[3]),
+                                           row=(i == 0) + 2 *
+                                           (i == 2) + 3 * (i == 4),
+                                           col=1)
+                        else:
+                            fig2.add_trace(go.Bar(x=df.iloc[-1].sort_values().array, y=df.iloc[-1].sort_values().index,
+                                                  orientation='h', showlegend=False,
+                                                  marker_color=colors2[3]),
+                                           row=(i == 1) + 2 *
+                                           (i == 3) + 3 * (i == 5),
+                                           col=1)
+
+                    fig1.update_yaxes(visible=True, showticklabels=True)
+                    fig2.update_yaxes(visible=True, showticklabels=True)
+                    fig1.update_xaxes(visible=False, showticklabels=False)
+                    fig2.update_xaxes(visible=False, showticklabels=False)
+                    fig1.update_layout(height=800)
+                    fig2.update_layout(height=800)
+                    col1.plotly_chart(fig1, use_container_width=True)
+                    col2.plotly_chart(fig2, use_container_width=True)
+            else:
+                fig = make_subplots(rows=1, cols=1, subplot_titles=countries)
+                if countries_q == 1:
+                    for i, (c, df) in enumerate(signal_to_noise_dict.items()):
+                        fig.add_trace(go.Bar(x=df.iloc[-1].sort_values().array, y=df.iloc[-1].sort_values().index,
+                                             orientation='h', showlegend=False,
+                                             marker_color=colors2[3]))
+                        fig.update_yaxes(visible=True, showticklabels=True)
+                        fig.update_xaxes(visible=False, showticklabels=False)
+                        fig.update_layout(height=800)
+                    with st.container():
+                        st.plotly_chart(fig, use_container_width=True)
+                else:
+                    st.write('### Cambios en ' + str(n) + ' Semanas')
+
+                    if countries_q == 1:
+                        fig = make_subplots(
+                            rows=1, cols=1, subplot_titles=countries)
+                        for i, (c, df) in enumerate(signal_to_noise_dict.items()):
+                            fig.add_trace(go.Bar(x=df.diff(5 * n).iloc[-1].sort_values().array,
+                                                 y=df.diff(
+                                                     5 * n).iloc[-1].sort_values().index,
+                                                 orientation='h', showlegend=False,
+                                                 marker_color=colors2[3]))
+                            fig.update_yaxes(visible=True, showticklabels=True)
+                            fig.update_xaxes(
+                                visible=False, showticklabels=False)
+                            fig.update_layout(height=800)
+                        with st.container():
+                            st.plotly_chart(fig, use_container_width=True)
+                    else:
+                        col1, col2 = st.columns(2)
+                        titles_1 = []
+                        titles_2 = []
+                        for k in range(countries_q):
+                            if k % 2 == 0:
+                                titles_1.append(countries[k])
+                            else:
+                                titles_2.append(countries[k])
+
+                        fig1 = make_subplots(rows=1 + (countries_q > 2) + (countries_q > 4),
+                                             cols=1, subplot_titles=titles_1)
+                        fig2 = make_subplots(rows=1 + (countries_q > 2) + (countries_q > 4),
+                                             cols=1, subplot_titles=titles_2)
+                        for i, (c, df) in enumerate(signal_to_noise_dict.items()):
+                            if i % 2 == 0:
+                                fig1.add_trace(go.Bar(x=df.diff(5 * n).iloc[-1].sort_values().array,
+                                                      y=df.diff(
+                                                          5 * n).iloc[-1].sort_values().index,
+                                                      orientation='h', showlegend=False,
+                                                      marker_color=colors2[3]),
+                                               row=(i == 0) + 2 * (i == 2) + 3 * (i == 4), col=1)
+                            else:
+                                fig2.add_trace(go.Bar(x=df.diff(5 * n).iloc[-1].sort_values().array,
+                                                      y=df.diff(
+                                                          5 * n).iloc[-1].sort_values().index,
+                                                      orientation='h', showlegend=False,
+                                                      marker_color=colors2[3]),
+                                               row=(i == 1) + 2 * (i == 3) + 3 * (i == 5), col=1)
+                        fig1.update_yaxes(visible=True, showticklabels=True)
+                        fig2.update_yaxes(visible=True, showticklabels=True)
+                        fig1.update_xaxes(visible=False, showticklabels=False)
+                        fig2.update_xaxes(visible=False, showticklabels=False)
+                        fig1.update_layout(height=1000, margin_b=20,
+                                           margin_r=20, margin_l=20)
+                        fig2.update_layout(height=1000, margin_b=20,
+                                           margin_r=20, margin_l=20)
+                        col1.plotly_chart(fig1, use_container_width=True)
+                        col2.plotly_chart(fig2, use_container_width=True)
+
+        if stn_view == 'Grafico Agregado de StN':
+            mc_th = 5000
+            aux_stn = pd.concat([df.rename(columns={s: f'{c}-{s}' for s in df.columns})
+                                 for c, df in signal_to_noise_dict.items() if c in countries], axis=1)
+            mc_per_ind = pd.Series([data_dict['IQ_MARKETCAP'][cs_ids[cs]].rolling(60, 10).mean().iloc[-1].sum()
+                                    for cs in aux_stn.columns], index=aux_stn.columns)
+
+            st.markdown('### StN General ')
+            col1, col2, col3 = st.columns(3)
+            aux_stn = aux_stn.loc[:, (mc_per_ind > mc_th).values]
+
+            # Ahora creamos los dataframes para cada margen de tiempo
+            stn_general = aux_stn.iloc[-1].sort_values()  # General
+            stn_1week = aux_stn.diff(5).iloc[-1].sort_values()  # 1 Week Chg
+            stn_1month = aux_stn.diff(20).iloc[-1].sort_values()  # 1 Month Chg
+
+            # Procedemos a graficar
+            fig1 = make_subplots(subplot_titles=['General'])
+            fig2 = make_subplots(subplot_titles=['1W Chg'])
+            fig3 = make_subplots(subplot_titles=['1M Chg'])
+            fig1.add_trace(
+                go.Bar(x=stn_general.array, y=stn_general.index,
+                       orientation='h', showlegend=False,
+                       marker_color=colors2[3]))
+            fig2.add_trace(
+                go.Bar(x=stn_1week.array, y=stn_1week.index, orientation='h',
+                       showlegend=False,
+                       marker_color=colors2[3]))
+            fig3.add_trace(
+                go.Bar(x=stn_1month.array, y=stn_1month.index, orientation='h',
+                       showlegend=False,
+                       marker_color=colors2[3]))
+            fig1.update_xaxes(visible=False, showticklabels=False)
+            fig2.update_xaxes(visible=False, showticklabels=False)
+            fig3.update_xaxes(visible=False, showticklabels=False)
+
+            col1.plotly_chart(fig1, use_container_width=True)
+            col2.plotly_chart(fig2, use_container_width=True)
+            col3.plotly_chart(fig3, use_container_width=True)
+
+
+def medias_moviles():
+    """
+       Despliega un formulario de streamlit y grafica lo indicado por el usuario.
+       :return: None
+       """
+    sectors_dict = sectors_lv1_dicc()
+    select_sector = st.selectbox(
+        'Qué sector desea visualizar?', list(sectors_dict.keys()))
+    form_mm = st.form("MM")
+    start = form_mm.date_input(
+        '¿Desde qué fecha desea visualizar?', value=date.today() - timedelta(365))
+    start = datetime.combine(start, datetime.min.time())
+    countries = form_mm.multiselect('¿Qué país(es) desea visualizar?', [
+                                    'Todos'] + sectors_dict[select_sector])
+    if 'Todos' in countries:
+        countries = sectors_dict[select_sector]
+
+    update_button = form_mm.form_submit_button("Actualizar datos")
+    if update_button:
+        update_data()
+
+    accept = form_mm.form_submit_button('Visualizar')
+
+    criteria = 'LV1'
+
+    st.write("### Está visualizando: Medias Moviles")
+
+    colors = list(colores_corporativos().values())
+    colors2 = []
+    for i in range(len(colors)):
+        colors2.append("rgb" + str(colors[i]))
+
+    if accept:
+
+        if not countries:
+            countries = sectors_dict[select_sector]
+
+        today = str(date.today())
+        # Acá cargamos los datos necesarios
+        data = data_request(today, start, countries)
+        data_dict = data[0]
+        company_db = data[1]
+        country_sector = data[2]
+
+        st.write('Data desde ' + str(start.date()) + ' hasta ' +
+                 str(data_dict['IQ_CLOSEPRICE_ADJ'].index[-1].date()))
+
+        rel_rets, cs_ids, w_hist, bm_dict = dictionaries_maker(start,
+                                                               countries,
+                                                               country_sector,
+                                                               criteria,
+                                                               company_db,
+                                                               data_dict)
+        stn_p = 20 * 5
+        signal_to_noise_dict = {
+            c: df.rolling(stn_p).sum() / df.abs().rolling(stn_p).sum().abs()
+            for c, df in rel_rets.items()}
+        st.write('Sector: ' + select_sector)
+        ma_p = [20, 60, 250]
+        aux_stn = pd.concat(
+            [df.rename(columns={s: f'{c}-{s}' for s in df.columns})
+             for c, df in signal_to_noise_dict.items() if c in countries],
+            axis=1)
+        aux_rr = pd.concat(
+            [df.rename(columns={s: f'{c}-{s}' for s in df.columns})
+             for c, df in rel_rets.items() if c in countries], axis=1)
+        aux_rr = aux_rr[aux_stn.columns]
+        if len(countries) > 1:
+            col1, col2 = st.columns(2)
+            titles_1 = []
+            titles_2 = []
+            dicc_tit_1 = {}
+            dicc_tit_2 = {}
+            for i, country in enumerate(countries):
+                if i % 2 == 0:
+                    title_1=str(country) + ' - ' + str(select_sector)
+                    titles_1.append(title_1)
+                    dicc_tit_1[title_1] = make_subplots()
+                else:
+                    title_2=str(country) + ' - ' + str(select_sector)
+                    titles_2.append(title_2)
+                    dicc_tit_2[title_2] = make_subplots()
+            countries_q = len(countries)
+            indices = list(range(ceil(countries_q / 2)))
+            m = 0
+            for i, c in enumerate(countries):
+                df = (aux_rr[c + '-' + select_sector] + 1).cumprod() - 1
+                df_mm = pd.DataFrame(
+                    {p: df.rolling(p, min_periods=1).mean() for p in ma_p})
+                df = df.to_frame()
+                df[[f'MA_{p}' for p in ma_p]] = df_mm
+                df = df.loc[df.index >= start]
+                df.rename(
+                    columns={c + '-' + select_sector: 'Indice'}, inplace=True)
+                df = df - df['Indice'][0]
+                if i % 2 == 0:
+                    list_plot_1 =list(dicc_tit_1.keys())
+                    for k in range(len(ma_p)):
+                        if k == 0:
+                            dicc_tit_1[list_plot_1[i//2 + i % 2]].add_trace(
+                                go.Scatter(x=df.index, y=df['Indice'],
+                                           line=dict(
+                                               color=colors2[len(ma_p) + 1]),
+                                           name='Indice'),
+                                row=indices[m] + 1, col=1)
+                        dicc_tit_1[list_plot_1[i//2 + i % 2]].add_trace(
+                            go.Scatter(x=df.index,
+                                       y=df['MA_' + str(ma_p[k])],
+                                       line=dict(color=colors2[k]),
+                                       name='MA_' + str(ma_p[k])),
+                            row=indices[m] + 1, col=1)
+                    dicc_tit_1[list_plot_1[i//2 + i % 2]].update_layout(
+                                        height=350, width=400)
+                    dicc_tit_1[list_plot_1[i//2 + i % 2]].layout.update(
+                        title_text=list_plot_1[i//2 + i % 2],
+                        xaxis_rangeslider_visible=False, margin_b=20,
+                        margin_r=20, margin_l=20,
+                        legend=dict(orientation="h",
+                                    yanchor="bottom",
+                                    y=1.0,
+                                    xanchor="right",
+                                    x=1))
+                    col1.plotly_chart(dicc_tit_1[list_plot_1[i//2 + i % 2]],
+                                      use_container_width=True)
+                else:
+                    list_plot_2 = list(dicc_tit_2.keys())
+                    for k in range(len(ma_p)):
+                        if k == 0:
+                            dicc_tit_2[list_plot_2[i//2]].add_trace(
+                                go.Scatter(x=df.index, y=df['Indice'],
+                                           line=dict(
+                                               color=colors2[len(ma_p) + 1]),
+                                           name='Indice'),
+                                row=indices[m] + 1, col=1)
+                        dicc_tit_2[list_plot_2[i//2]].add_trace(
+                            go.Scatter(x=df.index,
+                                       y=df['MA_' + str(ma_p[k])],
+                                       line=dict(color=colors2[k]),
+                                       name='MA_' + str(ma_p[k])),
+                            row=indices[m] + 1, col=1)
+                    dicc_tit_2[list_plot_2[i//2]].update_layout(
+                                        height=350, width=400)
+
+                    dicc_tit_2[list_plot_2[i//2]].layout.update(
+                        title_text=list_plot_2[i//2],
+                        xaxis_rangeslider_visible=False, margin_b=20,
+                        margin_r=20, margin_l=20,
+                        legend=dict(orientation="h",
+                                    yanchor="bottom",
+                                    y=1.0,
+                                    xanchor="right",
+                                    x=1))
+                    col2.plotly_chart(dicc_tit_2[list_plot_2[i//2]],
+                                          use_container_width=True)
+        else:
+            country = countries[0]
+            titles = [str(country) + ' - ' + str(select_sector)]
+            fig1 = make_subplots(rows=len(titles), cols=1,
+                                 subplot_titles=titles)
+            df = (aux_rr[country + '-' + select_sector] + 1).cumprod() - 1
+            df_mm = pd.DataFrame(
+                {p: df.rolling(p, min_periods=1).mean() for p in ma_p})
+            df = df.to_frame()
+            df[[f'MA_{p}' for p in ma_p]] = df_mm
+            df = df.loc[df.index >= start]
+            df.rename(columns={country + '-' +
+                      select_sector: 'Indice'}, inplace=True)
+            df = df - df['Indice'][0]
+            for k in range(len(ma_p)):
+                fig1.add_trace(go.Scatter(x=df.index,
+                                          y=df['MA_' + str(ma_p[k])],
+                                          line=dict(color=colors2[k]),
+                                          name='MA_' + str(ma_p[k]),
+                                          showlegend=True), row=1, col=1)
+            fig1.add_trace(go.Scatter(x=df.index, y=df['Indice'],
+                                      line=dict(color=colors2[len(ma_p) + 1]),
+                                      name='Indice',
+                                      showlegend=True),
+                           row=1, col=1)
+
+            fig1.update_layout(height=200, width=400, margin_b=0, margin_t=0,
+                               margin_r=0, margin_l=0)
+            st.plotly_chart(fig1, use_container_width=True)
+
+
+def difusion():
+    """
+    Despliega un formulario de streamlit y grafica lo indicado por el usuario.
+       :return: None
+    """
+    start = '2017'
+
+    form_dif = st.form("Difusión")
+    countries = form_dif.multiselect('¿Qué países quiere visualizar?',
+                                     ('Todos', 'Argentina', 'Brazil',
+                                      'Chile', 'Colombia', 'Mexico', 'Peru'))
+    if 'Todos' in countries:
+        countries = ['Argentina', 'Brazil',
+                     'Chile', 'Colombia', 'Mexico', 'Peru']
+
+    update_button = form_dif.form_submit_button("Actualizar datos")
+    if update_button:
+        update_data()
+
+    accept = form_dif.form_submit_button('Visualizar')
+
+    criteria = 'LV1'
+
+    st.write("### Está visualizando: Difusión")
+
+    colores = list(colores_corporativos().values())
+    colores2 = []
+
+    for i in range(len(colores)):
+        colores2.append("rgb" + str(colores[i]))
+
+    if accept:
+
+        today = str(date.today())
+        # Acá cargamos los datos necesarios
+        data = data_request(today, start, countries)
+        data_dict = data[0]
+        company_db = data[1]
+        country_sector = data[2]
+        st.write('Data desde ' + str(date.today() - timedelta(365)) + ' hasta ' + str(
+            data_dict['IQ_CLOSEPRICE_ADJ'].index[-1].date()))
+
+        rel_rets, cs_ids, w_hist, bm_dict = dictionaries_maker(start,
+                                                               countries,
+                                                               country_sector,
+                                                               criteria,
+                                                               company_db,
+                                                               data_dict)
+
+        p_list = [1, 3, 12]
+        prices = data_dict['IQ_CLOSEPRICE_ADJ'].ffill()
+
+        mm_countries = countries
+        start = datetime.today() - timedelta(365)
+
+        fig_mm = make_subplots(specs=[[{"secondary_y":
+                                        True}]]*len(mm_countries),
+                               subplot_titles=mm_countries,
+                               rows=len(mm_countries), cols=1)
+        for i, c in enumerate(mm_countries):
+            univ = univ_request(company_db, c)
+            univ = list(set(univ) & set(prices.columns))
+            prices_c = prices[univ].iloc[-500:]
+            mm_sum_df = sum([prices_c.rolling(p * 20).apply(mm_eval)
+                            for p in p_list])
+            mm_sum_df = mm_sum_df.iloc[-252:].dropna(how='all')
+
+            bull = (mm_sum_df == len(p_list)).sum(1) / mm_sum_df.notna().sum(1)
+            bear = (mm_sum_df == 0).sum(1) / mm_sum_df.notna().sum(1)
+            delta = (bull - bear).to_frame()
+            delta.columns = [f'Bull-Bear {c}']
+            bm_rets = bm_dict[c]
+            delta['aux'] = bm_rets
+            delta[f'{c} Index'] = (1 + delta['aux']).cumprod()
+
+            bull = bull.reindex(pd.to_datetime(bull.index))
+            bear = bear.reindex(pd.to_datetime(bear.index))
+            delta = delta.reindex(pd.to_datetime(delta.index))
+
+            bull = bull.loc[bull.index >= start]
+            bear = bear.loc[bear.index >= start]
+            delta = delta.loc[delta.index >= start]
+
+            # Bull
+            fig_mm.add_trace(go.Scatter(x=bull.index, y=bull.array,
+                                        name='Bull',
+                                        line=dict(color=colores2[5]),
+                                        showlegend=(i == 0)),
+                             secondary_y=False, row=i + 1,
+                             col=1)
+            # Bear
+            fig_mm.add_trace(go.Scatter(x=bear.index, y=bear.array, name='Bear', line=dict(color=colores2[0]),
+                                        showlegend=(i == 0)), secondary_y=False, row=i + 1,
+                             col=1)
+            # Bull-Bear
+            fig_mm.add_trace(
+                go.Scatter(x=delta.index, y=delta[f'Bull-Bear {c}'], name='Bull - Bear', line=dict(color=colores2[6]),
+                           showlegend=(i == 0)), row=i + 1, col=1)
+            # Indice
+            fig_mm.add_trace(go.Scatter(x=delta.index, y=delta[f'{c} Index'], name='Index ', line=dict(color='black'),
+                                        showlegend=(i == 0)), secondary_y=True, row=i + 1, col=1)
+            fig_mm.update_yaxes(title_text="Valor",
+                                secondary_y=False, row=i + 1, col=1)
+            fig_mm.update_layout(yaxis1={'tickformat': ',.0%'})
+            fig_mm.update_yaxes(title_text="Indice",
+                                secondary_y=True, row=i + 1, col=1)
+
+        with st.container():
+            fig_mm.update_layout(height=400 * len(mm_countries))
+            st.plotly_chart(fig_mm, use_container_width=True)

apps/Panel_de_control.py

@@ -1,3 +1,95 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8932e6a2d9f3f8eafe3e73eaca828ec682acf56b40ed2c6e3af3c66829fb8d99
-size 2832
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Jan  4 18:23:14 2022
+
+@author: bullm
+"""
+import plotly.graph_objects as go
+import plotly.express as px
+import pandas as pd
+import streamlit as st
+import numpy as np
+import matplotlib.pyplot as plt
+
+# path = 'C:\\Users\\bullm\\Desktop\\Portal_LVAM\\Data\\'
+# for key in stats_competencia.keys():
+#     print(key)
+#     stats_competencia[key].to_excel(path+key+'.xlsx')
+# tabla_factores_general.to_excel(path+'factores_general.xlsx')
+
+def spider_plot(df, title, alpha=0.1, n_dec=1, y=[]):
+
+    if len(y) == 0:
+        min_val = df.min().min()
+        min_val = np.floor(min_val-np.abs(min_val)*alpha, n_dec)
+        max_val = df.max().max()
+        max_val = np.ceil(max_val+np.abs(max_val)*alpha, n_dec)
+        mean_val = np.round((min_val + max_val)/2, 1)
+
+        y = [min_val, mean_val, max_val]
+
+    categories = list(df.index)
+    N = df.shape[0]
+
+    # We are going to plot the first line of the data frame.
+    # But we need to repeat the first value to close the circular graph:
+    values = np.round(df.iloc[:, 0].values.flatten().tolist(), 2)
+    values = np.hstack((values, values[0])).T
+
+    values2 = np.round(df.iloc[:, 1].values.flatten().tolist(), 2)
+    values2 = np.hstack((values2, values2[0])).T
+
+    # What will be the angle of each axis in the plot?
+    angles = [n / float(N) * 2 * np.pi for n in range(N)]
+    angles += angles[:1]
+
+    # Initialise the spider plot
+    fig = plt.figure(figsize=(10, 15))
+    ax = plt.subplot(111, polar=True)
+    ax.set_title(title, fontsize=20)
+
+    # Draw one axe per variable + add labels labels yet
+    plt.xticks(angles[:-1], categories, color="black", size=18)
+
+    # Draw ylabels
+    ax.set_rlabel_position(0)
+    plt.yticks(y, [str(i) for i in y], color="black", size=15)
+    plt.ylim(y[0], y[-1])
+
+
+
+    # Plot data
+    ax.plot(angles, values, linewidth=1, linestyle='solid', c='dimgrey')
+    ax.plot(angles, values2, linewidth=1, linestyle='solid', c='darkred')
+
+    handles, labels = ax.get_legend_handles_labels()
+
+    ax.legend(labels=['Cartera', 'Benchmark'], loc='lower left',
+              fontsize=15, bbox_to_anchor=(-0.1, -0.1))
+
+    # Fill area
+    ax.fill(angles, values, 'b', alpha=0.1)
+
+    return fig
+
+
+def panel_de_control():
+    df = pd.read_excel("Data/factores_general.xlsx")
+
+    radar = go.Scatterpolar(
+       r = list(df["Benchmark"]),
+       theta = list(df['Unnamed: 0']),
+       fill = 'toself'
+    )
+    radar2 = go.Scatterpolar(
+       r = list(df["Cartera"]),
+       theta = list(df['Unnamed: 0']),
+       fill = 'toself'
+    )
+    data = [radar, radar2]
+    fig = go.Figure(data = data)
+    col1, col2 = st.columns(2)
+    col1.plotly_chart(fig, use_container_width=True)
+    df.index= df['Unnamed: 0']
+    df = df[["Cartera", 'Benchmark']]
+    col2.pyplot(spider_plot(df, '', y=[0, 50, 100] ))

apps/Scoring.py

@@ -1,3 +1,303 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0b057e466c7b6de2eb0bfc84e819aa6e92c8146eec53b36c94a9a13f055efe0b
-size 10397
+import pandas as pd
+import streamlit as st
+import pybase64 as base64
+import io
+from logs_portal import log
+import os
+from datetime import date
+from modules import tables
+import boto3
+from Data.credentials import credentials_s3 as creds3
+from streamlit_echarts import st_echarts
+from st_aggrid import GridOptionsBuilder, AgGrid, GridUpdateMode, DataReturnMode, JsCode
+import numpy as np
+from streamlit_lottie import st_lottie
+import json
+
+def generador_variable_pond(name, col_s1):
+    col_s1.markdown("""<p style="margin-top:35px;
+                                    font-size:20px;
+                                    text-align:center;
+                                    margin-bottom:30px;
+                                    ">{Var}</p>""".format(Var=name),
+                    unsafe_allow_html=True)
+
+
+def button_style():
+    style_button = """
+        <style>
+          button {
+            display: inline-block;
+            background-color: white;
+            border-radius: 15px;
+            border: 4px  #cccccc;
+            color: #4a4a4a;
+            text-align: center;
+            font-size: 18px;
+            padding: 2px;
+            width: 200px;
+            transition: all 0.5s;
+            cursor: pointer;
+            margin-top: 25px;
+          }
+          button span {
+            cursor: pointer;
+            display: inline-block;
+            position: relative;
+            transition: 0.5s;
+          }
+          button span:after {
+            content: '\00bb';
+            position: absolute;
+            opacity: 0;
+            top: 0;
+            right: -20px;
+            transition: 0.5s;
+          }
+          button:hover {
+            background-color: #bb1114;
+            color:#e8e8e8;
+          }
+          button:hover span {
+            padding-right: 25px;
+          }
+          button:hover span:after {
+            opacity: 1;
+            right: 0;
+      }
+    </style>
+    """
+    st.markdown(style_button, unsafe_allow_html=True)
+
+
+
+
+def get_table_excel_link(df, name):
+    towrite = io.BytesIO()
+    writer = pd.ExcelWriter(towrite, engine='xlsxwriter')
+    downloaded_file = df.to_excel(writer, encoding='utf-8', index=False, 
+                                  header=True)
+    workbook = writer.book
+    worksheet = writer.sheets["Sheet1"]
+    #set the column width as per your requirement
+    worksheet.set_column('A:BZ', 18)
+    writer.save()
+    towrite.seek(0)  # reset pointer
+    file_name = 'Scoring.xlsx'
+    style = 'style="color:black;text-decoration: none; font-size:18px;" '
+    name_mark = name
+    b64 = base64.b64encode(towrite.read()).decode()  # some strings
+    linko = f'<center><a href="data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64,{b64}" '+style+'download="'+file_name+'"><button>'+name_mark+'</button></a></center>'
+    return linko
+
+
+
+
+
+def read_excel_s3(key, secret_key, bucket, path):
+    s3_client = boto3.client('s3', aws_access_key_id = key, aws_secret_access_key= secret_key)
+    response =  s3_client.get_object(Bucket=bucket, Key=path)
+    data = response["Body"].read()
+    df = pd.read_excel(io.BytesIO(data), engine='openpyxl')
+    return df
+
+
+def display_table(df: pd.DataFrame, name):
+    # Configure AgGrid options
+    gb = GridOptionsBuilder.from_dataframe(df)
+    gb.configure_selection(selection_mode="multiple", use_checkbox=True,)
+    gb.configure_column(name, headerCheckboxSelection = True)
+    gb.configure_columns(("TICKER", "COUNTRY", "LV1"), pinned=True)
+    return AgGrid(
+        df, gridOptions=gb.build(),
+        update_mode=GridUpdateMode.SELECTION_CHANGED,
+        enable_enterprise_modules=True)
+
+@st.experimental_memo
+def read_scoring():
+    key = creds3["S3_KEY_ID"]
+    secret_key = creds3["S3_SECRET_KEY"]
+    bucket = creds3["S3_BUCKET"]
+    path ="scoring.xlsx"
+    scoring = read_excel_s3(key, secret_key, bucket, path)
+    return scoring
+
+
+
+
+
+# @log
+def general():
+
+    with open("Data/lotties/99268-laading-22.json", "r") as f:
+        spinner = json.load(f)
+    cols1, cols2= st.sidebar.columns((3,1))
+    place = cols2.empty()
+    with place:
+        st_lottie(spinner)
+    # scoring.index = scoring['Ticker']
+    button_style()
+    scoring_completo = read_scoring()
+    col1, col2, col3 = st.columns((4,1,1))
+    col1.write("Last Update: " + scoring_completo.iloc[0]["TODAY"])
+    col1.write("Valores en MM USD")
+    place1=col2.empty()
+    place2 =col3.empty()
+    scoring_completo = scoring_completo.drop(columns=["TODAY"])
+    scoring_completo[["Nota", 'W Latino', "W Small", 'Nota ESG']] = scoring_completo[["Nota", "W Latino", 'W Small', 'Nota ESG']].fillna(0)
+    scoring = scoring_completo.copy()
+    # convert just columns "a" and "b"
+    metrics = ['MOMENTUM Precio', 'MOMENTUM Fundamental',
+               'VALUE','PROF', 'Distres_Prom', 'PROF', 'Delta 1M', 'QUALITY', 'Nota ESG']
+    metrics2 = ['Market_Cap'] +  metrics
+    
+    scoring[metrics2] = scoring[metrics2].round()
+    scoring[["W Latino", "W Small", "BM Latino", "BM Small"]] = scoring[["W Latino", "W Small", "BM Latino", "BM Small"]] * 100
+    scoring[["W Latino", "W Small", "BM Latino", "BM Small"]] = scoring[["W Latino", "W Small", "BM Latino", "BM Small"]].round(2).fillna(0)
+    metrics_aggrid = ['Ticker', 'Portfolio_Country', 'LV1', 'Market_Cap',
+                       'ADTV','Large/Small', 'Delta 1M','Distres_Prom', 'MOMENTUM Precio', 'MOMENTUM Fundamental',
+                       'VALUE','PROF', 'QUALITY', 'Score', "Nota",
+                        'Nota ESG', 'Stop Loss', "W Latino", "W Small", "BM Latino","BM Small"]
+    scoring = scoring[metrics_aggrid]
+    scoring[metrics_aggrid] = scoring[metrics_aggrid].replace(np.nan, -1)
+    
+    metrics3 = ['TICKER', 'COUNTRY', 'LV1', 'MKT CAP', 'ADTV', 'L/S', 'Δ 1M',
+                'DISTRES', 'MOM PREC',
+                'MOM FUND', 'VALUE','PROF', 'QUALITY', 'SCORE',
+                "NOTA", 'ESG', 'STOP LOSS', "W LAT", "W SMALL", "BM LAT", "BM SMALL"]
+    metrics4 = [
+        'MOM PREC', 'MOM FUND', 'VALUE', 'QUALITY','DISTRES', 'PROF']
+    scoring.columns = metrics3
+    button = st.button("Refresh")
+    r = display_table(scoring, 'TICKER')
+    rad = 'Home'
+    if button:
+        st.experimental_memo.clear()
+        st.experimental_rerun()
+    with place1:
+        link = get_table_excel_link(scoring_completo, "Scoring completo")
+        st.markdown(link, unsafe_allow_html=True)
+    with place2:
+        link2 = get_table_excel_link(scoring, "Scoring resumen")
+        st.markdown(link2, unsafe_allow_html=True)
+    w_lat = []
+    w_small = []
+    bm_lat = []
+    bm_small = []
+    col1, col2, col3, col4, col5 = st.columns((1,1,1,1,3))
+    large = col1.checkbox("LUXMEXEQ", True)
+    small = col2.checkbox("LUXLATSML", True)
+    m1la = col3.checkbox("M1LA")
+    msm = col4.checkbox("MSLUELAN")
+    
+    if "large" not in st.session_state:
+        st.session_state.large=False
+    if "small" not in st.session_state:
+        st.session_state.small=False
+    if "bm_sm" not in st.session_state:
+        st.session_state.bm_sm=False
+    if "bm_lat" not in st.session_state:
+        st.session_state.bm_lat=False
+    
+    if large:
+        st.session_state.large = True
+    else:
+        st.session_state.large = False
+    if small:
+        st.session_state.small =True
+    else:
+        st.session_state.small = False
+    if m1la:
+        st.session_state.bm_lat = True
+    else:
+        st.session_state.bm_lat = False
+    if msm:
+        st.session_state.bm_sm =True
+    else:
+        st.session_state.bm_sm = False
+    col1, col2, col3 = st.columns((2.5, 1, 1))
+    try:
+        series_data = []
+        names=[]
+        for metric in metrics4:
+            w_lat.append((scoring[metric]*scoring["W LAT"]/100).sum())
+            w_small.append((scoring[metric]*scoring["W SMALL"]/100).sum())
+            bm_lat.append((scoring[metric]*scoring["BM LAT"]/100).sum())
+            bm_small.append((scoring[metric]*scoring["BM SMALL"]/100).sum())
+        if st.session_state.large:
+            series_data.append({"value":w_lat,
+                        "name": "LUXMEXEQ"})
+            names.append("LUXMEXEQ")
+        if st.session_state.small:
+            series_data.append({"value":w_small,
+                        "name": "LUXLATSML"})
+            names.append("LUXLATSML")
+        if st.session_state.bm_lat:
+            series_data.append({"value":bm_lat,
+                        "name": "M1LA"})
+            names.append("M1LA")
+        if st.session_state.bm_sm:
+            series_data.append({"value":bm_small,
+                        "name": "MSLUELAN"})
+            names.append("MSLUELAN")
+
+
+
+
+        if len(r['selected_rows'])>0:
+            for emp in r['selected_rows']:
+                selected = emp.copy()
+                name = selected['TICKER']
+                names.append(name)
+                indicators = []
+                series_value = []
+                for met in metrics4:
+                    indicators.append({'name': met, "max": 100})
+                    series_value.append(selected[met])
+                series_data.append({"value": series_value,
+                                    "name": name})
+                with col2:
+                    st.metric('SCORE PROMEDIO - ' + name,
+                              int(np.array(series_value).mean()))
+        else:
+            indicators = []
+            for met in metrics4:
+                indicators.append({'name': met, "max": 100})
+        option = {
+            "title": {"text": 'Score'},
+            "legend": {"data": names},
+            "radar": {
+                "indicator": indicators
+            },
+            "series": [
+                {
+                    "name": "",
+                    "type": "radar",
+                    "data": series_data,
+                }
+            ],
+        }
+        with col1:
+            st_echarts(option, height="400px", width="80%")
+    except Exception as exc:
+        st.write(exc)
+        pass
+    
+    # st.image("img/Scoring.png", width="100%")
+    place.empty()
+
+
+
+def diagrama():
+    
+    import pandas as pd
+    import pandas_profiling
+    import streamlit as st
+    
+    from streamlit_pandas_profiling import st_profile_report
+    st.image("img/Scoring.png")
+    df = read_scoring()
+    df=df[['MOMENTUM Precio','MOMENTUM Fundamental', 'VALUE','QUALITY', 'PROF','Distres_Prom','Score' ]]
+    pr = df.profile_report()
+    
+    st_profile_report(pr)

apps/Tasas.py

@@ -1,3 +1,950 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c8976b82926ce0f2bfa6c9fd0f4124038ddccbf1d97f62f99ecb2d4d40b5aa34
-size 39290
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Aug 24 09:38:58 2021
+
+@author: benjaminull
+"""
+import investpy
+import datetime as dt
+from datetime import date
+import streamlit as st
+from plotly import graph_objs as go
+import pandas as pd
+import pybase64 as base64
+import io
+from plotly.subplots import make_subplots
+from logs_portal import log
+
+
+def formatnum(numero):
+    return '{:,.2f}'.format(numero).replace(",", "@").replace(".", ",").replace("@", ".")
+
+
+def button_style():
+    style_button = """
+        <style>
+          button {
+            display: inline-block;
+            background-color: #e8e8e8;
+            border-radius: 15px;
+            border: 4px  #cccccc;
+            color: #4a4a4a;
+            text-align: center;
+            font-size: 20px;
+            padding: 2px;
+            width: 12em;
+            transition: all 0.5s;
+            cursor: pointer;
+            margin: 0px;
+            margin-top: 30px;
+          }
+          button span {
+            cursor: pointer;
+            display: inline-block;
+            position: relative;
+            transition: 0.5s;
+          }
+          button span:after {
+            content: '\00bb';
+            position: absolute;
+            opacity: 0;
+            top: 0;
+            right: -20px;
+            transition: 0.5s;
+          }
+          button:hover {
+            background-color: #bb1114;
+            color:#e8e8e8;
+          }
+          button:hover span {
+            padding-right: 25px;
+          }
+          button:hover span:after {
+            opacity: 1;
+            right: 0;
+            }
+         .stMarkdown{
+            margin-bottom:0px;}
+    </style>
+    """
+    st.markdown(style_button, unsafe_allow_html=True)
+
+
+def get_table_excel_link(df, selected_stocks):
+    towrite = io.BytesIO()
+    downloaded_file = df.to_excel(towrite, encoding='utf-8', index=False,
+                                  header=True)
+    towrite.seek(0)  # reset pointer
+    file_name = 'Data ' + selected_stocks+'.xlsx'
+    style = 'style="color:black;text-decoration: none; font-size:18px;"'
+    name_mark = "Descargar " + selected_stocks + ".xlsx"
+    b64 = base64.b64encode(towrite.read()).decode()  # some strings
+    linko= f'<center><a href="data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64,{b64}" '+style+'download="'+file_name+'"><button>'+name_mark+'</button></a></center>'
+    return linko
+
+
+def style_table():
+    # tr:hover {background-color: #E8E8E8;
+    #          color:#BB1114;}
+    style_table = """
+                <style>
+                tbody tr:hover { 
+                           color:#BB1114;}
+                tr { line-height: 5px; }
+                thead {
+                      background-color:#BB1114 ;
+                      color: #E8E8E8;
+                    }
+                tbody tr:nth-child(odd) {
+                      background-color: #fff;
+                    }
+                    tbody tr:nth-child(even) {
+                      background-color: #eee;
+                    }
+                .css-1rcck9u{
+                    padding:0.25rem;}
+                tbody tr:nth-child(odd)
+                stTable {
+                    border-collapse: collapse;
+                    background-color:red;
+                    margin: 25px 0;
+                    font-size: 0.9em;
+                    min-width: 400px;
+                    box-shadow: 0 0 20px rgba(0, 0, 0, 0.15);
+                    }
+                table{
+                    margin-top:0px;
+                    font-size:12px;
+                    padding:0px;
+                    height:200px;}
+
+                @keyframes slidein {
+                  from {
+                    margin-left: 100%;
+                    width: 300%
+                  }
+                  to {
+                    margin-left: 0%;
+                    width: 100%;
+                  }
+                }
+                </style>
+                """
+    st.markdown(style_table, unsafe_allow_html=True)
+
+
+def grafico_avanzado_com(col_filter, col_button, col_chart, lista, TODAY):
+    titulo = "Commodities"
+    options = lista
+    
+    fecha_0 = col_filter.selectbox("Periodo  ", ["1 year", "1 week",
+                                                 "1 month", "3 month",
+                                                 "6 month", "5 year",
+                                                 "10 year", "15 year"])
+    info = pd.DataFrame()
+    orden = ["Date"]
+
+    fecha1 = seleccionar_fecha(fecha_0)
+    fig2 = go.Figure()
+    for price in options:
+        data = investpy.commodities.get_commodity_historical_data(
+                                                 price,
+                                                 from_date=fecha1,
+                                                 to_date=TODAY)
+        info[price] = data['Close']
+        close_ = go.Scatter(x=data.index,
+                            y=data['Close']/data.iloc[0]["Close"],
+                            name=price)
+        fig2.add_trace(close_)
+        orden.append(price)
+    info["Date"] = info.index
+    info["Date"] = info["Date"].dt.date
+    info = info[orden]
+    col_button.markdown(get_table_excel_link(info, "Commodities"),
+                          unsafe_allow_html=True)
+    fig2.layout.update(title_text=titulo,
+                       xaxis_rangeslider_visible=True,
+                       height=500,
+                       margin_b=20,
+                       margin_r=20,
+                       margin_l=20,
+                       legend=dict(orientation="h",
+                                   yanchor="bottom",
+                                   y=1.02,
+                                   xanchor="right",
+                                   x=1))
+    col_chart.plotly_chart(fig2, use_container_width=True)
+
+
+def grafico_avanzado_div(col_chart, col_filter, col_button, monedabase, lista, TODAY):
+    button_style()
+    titulo = "Divisas"
+    base = "USD"
+    options = lista
+    fecha_0 = col_filter.selectbox("Periodo", ["1 year",
+                                               "1 week",
+                                               "1 month",
+                                               "3 month",
+                                               "6 month",
+                                               "5 year",
+                                               "10 year",
+                                               "15 year"])
+    info = pd.DataFrame()
+    orden = ["Date"]
+    fig = make_subplots(specs=[[{"secondary_y": True}]])
+    fecha1 = seleccionar_fecha(fecha_0)
+    i = 0
+    for price in options:
+        titulo = titulo 
+        selected_cc = base + "/" + price
+        data = investpy.currency_crosses.get_currency_cross_historical_data(selected_cc, from_date=fecha1, to_date=TODAY)
+        info[price] = data['Close']
+        close_ = go.Scatter(x=data.index,
+                            y=data['Close']/data.iloc[0]['Close'],
+                            name=price)
+        fig.add_trace(close_)
+        orden.append(price)
+        i = i+1
+    info["Date"] = info.index
+    info["Date"] = info["Date"].dt.date
+    info = info[orden]
+    col_button.markdown(get_table_excel_link(info, "Divisas"),
+                        unsafe_allow_html=True)
+    fig.layout.update(title_text=titulo,
+                      xaxis_rangeslider_visible=True,
+                      height=500,
+                      margin_b=20,
+                      margin_r=20,
+                      margin_l=20,
+                      legend=dict(orientation="h",
+                                    yanchor="bottom",
+                                    y=1.02,
+                                    xanchor="right",
+                                    x=1))
+    col_chart.plotly_chart(fig, use_container_width=True)
+import plotly.express as px
+
+def grafico_avanzado_ind(col_chart,
+                         col_filter,
+                         col_button,
+                         lista,
+                         countries,
+                         today, fechas):
+    button_style()
+    dict_indices = dict(zip(lista, countries))
+    fecha_0 = col_filter.selectbox("Periodo ", fechas)
+    fecha1 = seleccionar_fecha(fecha_0)
+    titulo = "Indices"
+    options = lista
+    info = pd.DataFrame()
+    orden = ["Date"]
+    fig2 = go.Figure()
+    i = 0
+    for price in options:
+        
+        data = investpy.get_index_historical_data(
+                                        index=price,
+                                        country=dict_indices[price],
+                                        from_date=fecha1,
+                                        to_date=today)
+        info[price] = data['Close']
+        close_ = go.Scatter(x=data.index,
+                            y=data['Close']/data.iloc[0]["Close"],
+                            name=price, 
+                            line=dict(
+                              color=px.colors.qualitative.Pastel[i]))
+                            
+        fig2.add_trace(close_)
+        orden.append(price)
+        i=i+1
+    info["Date"] = info.index
+    info["Date"] = info["Date"].dt.date
+    info = info[orden]
+    col_button.markdown(get_table_excel_link(info, "Indices"),
+                          unsafe_allow_html=True)
+    fig2.layout.update(title_text=titulo,
+                       xaxis_rangeslider_visible=True,
+                       height=500,
+                       margin_b=20,
+                       margin_r=20,
+                       margin_l=20,
+                       
+                       legend=dict(orientation="h",
+                                   yanchor="bottom",
+                                   y=1.02,
+                                   xanchor="right",
+                                   x=1))
+    col_chart.plotly_chart(fig2, use_container_width=True)
+
+
+def grafico_avanzado_tasas(col_filter, col_button, col_chart, bonds, TODAY):
+    titulo = "Tasas"
+    fecha_0 = col_filter.selectbox("Periodo   ", ["1 year", "1 week",
+                                                   "1 month", "3 month",
+                                                   "6 month", "5 year",
+                                                   "10 year", "15 year"])
+    fecha1 = seleccionar_fecha(fecha_0)
+    options = bonds
+    info = pd.DataFrame()
+    orden = ["Date"]
+    fig2 = go.Figure()
+    i = 0
+    for price in options:
+        i = i + 1
+        data = investpy.get_bond_historical_data(bond=price,
+                                                 from_date=fecha1,
+                                                 to_date=TODAY)
+        info[price] = data['Close']
+        close_ = go.Scatter(x=data.index,
+                            y=data['Close']/data.iloc[0]["Close"],
+                            name=price,
+                            line=dict(
+                              color=px.colors.qualitative.Pastel[i]))
+        fig2.add_trace(close_)
+        orden.append(price)
+    info["Date"] = info.index
+    info["Date"] = info["Date"].dt.date
+    info = info[orden]
+    col_button.markdown(get_table_excel_link(info, "Tasas"),
+                          unsafe_allow_html=True)
+    # place0.header(titulo)
+    fig2.layout.update(title_text=titulo,
+                       xaxis_rangeslider_visible=True,
+                       height=500,
+                       margin_b=20,
+                       margin_r=20,
+                       margin_l=20,
+                       
+                       legend=dict(orientation="h",
+                                   yanchor="bottom",
+                                   y=1.02,
+                                   xanchor="right",
+                                   x=1))
+    col_chart.plotly_chart(fig2, use_container_width=True)
+
+def view_macro():
+    col_filter1, col_button1, col_filter2, col_button2 = st.columns(4)
+    col_chart1, col_chart2 = st.columns(2)
+    
+    
+    index = ["S&P CLX IPSA",
+             "S&P Merval",
+             "Bovespa",
+             "S&P Lima General",
+             "COLCAP",
+             "S&P/BMV IPC",
+             "S&P 500",]
+             # "FTSE 100",
+             # "China A50",
+             # "Nikkei 225"]
+    countries = ["chile",
+                 "argentina",
+                 "brazil",
+                 "peru",
+                 "colombia",
+                 "mexico",
+                 "united states",]
+                  # "united kingdom",
+                  # "china",
+                  # "japan"]
+    place2_index_st = st.empty()
+    today = date.today().strftime("%d/%m/%Y")
+    fechas = ["1 year",
+              "1 week",
+              "1 month",
+              "3 month",
+              "6 month",
+              "5 year",
+              "10 year",
+              "15 year"]
+    cc2_i = ["USD", "EUR", 'MXN', "GBP"]
+    cc2_f = ["CLP", "EUR", "GBP", "MXN", "JPY", "BRL", "PEN"]
+    try:
+        grafico_avanzado_ind(col_chart1,
+                             col_filter1,
+                             col_button1,
+                             index,
+                             countries,
+                             today,
+                             fechas)
+    except Exception as exc:
+        st.write(exc)
+    grafico_avanzado_div(col_chart2,
+                         col_filter2,
+                         col_button2,
+                         cc2_i,
+                         cc2_f,
+                         today)
+    commodity = sorted(["Copper",
+                        "Silver",
+                        "Gold",
+                        "Platinum",
+                        'Brent Oil',
+                        'Crude Oil WTI',
+                        "Natural Gas"])
+    col_filter1, col_button1, col_filter2, col_button2 = st.columns(4)
+    col_chart1, col_chart2 = st.columns(2)
+    
+    
+    grafico_avanzado_com(col_filter1, col_button1, col_chart1, commodity, today)
+    bonds = ["Chile 10Y", "Peru 10Y", "China 10Y", "U.S. 10Y", "U.K. 10Y",
+                "Germany 10y", "Japan 10Y", "Brazil 10Y"]
+    try:
+        grafico_avanzado_tasas(col_filter2, col_button2, col_chart2, bonds, today)
+    except Exception as exc:
+        st.write(exc)
+        
+
+
+@st.cache
+def tabla_bonos(stocks, TODAY):
+    tabla = pd.DataFrame()
+    year_ago = date.today() - dt.timedelta(days=365)
+    year_ago = year_ago.strftime("%d/%m/%Y")
+    for stock in stocks:
+        precios = investpy.get_bond_historical_data(bond=stock,
+                                                    from_date=year_ago,
+                                                    to_date=TODAY)
+        precios = precios["Close"]
+        last_price = precios.iloc[-1]
+        oned = precios.iloc[-2]
+        onew = precios.iloc[-5]
+        onem = precios.iloc[-20]
+        oney = precios.iloc[0]
+        return1m = str(round((last_price - onem), 2))+"%"
+        return1d = str(round((last_price - oned), 2))+"%"
+        return1w = str(round((last_price - onew), 2))+"%"
+        return1y = str(round((last_price - oney), 2))+"%"
+        last_price = str(round(last_price, 2))+"%"
+        tabla = tabla.append([[last_price, return1d, return1w, return1m,
+                               return1y]])
+    tabla.columns = ["Tasa", "1d", "1w", "1m", "1y"]
+    tabla.index = stocks
+    return tabla
+
+
+@st.cache
+def tabla_pendiente(stocks, TODAY):
+    tabla = pd.DataFrame()
+    year_ago = date.today() - dt.timedelta(days=365)
+    year_ago = year_ago.strftime("%d/%m/%Y")
+    for stock in stocks:
+        precios1 = investpy.get_bond_historical_data(bond=stock + " 2Y",
+                                                     from_date=year_ago,
+                                                     to_date=TODAY)
+        precios2 = investpy.get_bond_historical_data(bond=stock + " 10Y",
+                                                     from_date=year_ago,
+                                                     to_date=TODAY)
+        precios = precios2 - precios1
+        precios = precios["Close"]
+        last_price = precios.iloc[-1]
+        oned = precios.iloc[-2]
+        onew = precios.iloc[-5]
+        onem = precios.iloc[-20]
+        oney = precios.iloc[0]
+        return1m = str(round((last_price - onem), 2))+"%"
+        return1d = str(round((last_price - oned), 2))+"%"
+        return1w = str(round((last_price - onew), 2))+"%"
+        return1y = str(round((last_price - oney), 2))+"%"
+        last_price = str(round((last_price), 2))+"%"
+        tabla = tabla.append([[last_price, return1d, return1w, return1m,
+                               return1y]])
+    tabla.columns = ["Pendiente", "1d", "1w", "1m", "1y"]
+    tabla.index = stocks
+    return tabla
+
+
+@st.cache
+def tabla_divisas(stocks, TODAY):
+    tabla = pd.DataFrame()
+    year_ago = date.today() - dt.timedelta(days=365)
+    year_ago = year_ago.strftime("%d/%m/%Y")
+    for stock in stocks:
+        precios = investpy.currency_crosses.get_currency_cross_historical_data(
+                                                    stock,
+                                                    from_date=year_ago,
+                                                    to_date=TODAY)
+        precios = precios["Close"]
+        last_price = precios.iloc[-1]
+        oned = precios.iloc[-2]
+        onew = precios.iloc[-5]
+        onem = precios.iloc[-20]
+        oney = precios.iloc[0]
+        return1m = str(round((last_price/onem-1)*100, 2))+"%"
+        return1d = str(round((last_price/oned-1)*100, 2))+"%"
+        return1w = str(round((last_price/onew-1)*100, 2))+"%"
+        return1y = str(round((last_price/oney-1)*100, 2))+"%"
+        last_price = "$" + str(round(last_price, 2))
+        tabla = tabla.append([[last_price, return1d, return1w, return1m,
+                               return1y]])
+    tabla.columns = ["Precio","1d", "1w", "1m", "1y"]
+    tabla.index = stocks
+    return tabla
+
+
+@st.cache
+def tabla_commodity(stocks, TODAY):
+    tabla = pd.DataFrame()
+    year_ago = date.today() - dt.timedelta(days=365)
+    year_ago = year_ago.strftime("%d/%m/%Y")
+    for stock in stocks:
+        precios = investpy.commodities.get_commodity_historical_data(
+                                                    commodity=stock,
+                                                    from_date=year_ago,
+                                                    to_date=TODAY)
+        precios = precios["Close"]
+        last_price = precios.iloc[-1]
+        oned = precios.iloc[-2]
+        onew = precios.iloc[-5]
+        onem = precios.iloc[-20]
+        oney = precios.iloc[0]
+        return1m = str(round((last_price/onem-1)*100, 2))+"%"
+        return1d = str(round((last_price/oned-1)*100, 2))+"%"
+        return1w = str(round((last_price/onew-1)*100, 2))+"%"
+        return1y = str(round((last_price/oney-1)*100, 2))+"%"
+        last_price = "$" + str(round(last_price, 2))
+        tabla = tabla.append([[last_price, return1d, return1w, return1m, return1y]])
+    tabla.columns = ["Precio","1d", "1w", "1m", "1y"]
+    tabla.index = stocks
+    return tabla
+
+
+@st.cache
+def tabla_indices(index, countries, TODAY):
+    tabla = pd.DataFrame()
+    year_ago = date.today() - dt.timedelta(days=365)
+    year_ago = year_ago.strftime("%d/%m/%Y")
+    for i in range(len(index)):
+        precios = investpy.get_index_historical_data(index=index[i],
+                                                     country=countries[i],
+                                                     from_date=year_ago,
+                                                     to_date=TODAY)
+        precios = precios["Close"]
+        last_price = precios.iloc[-1]
+        oned = precios.iloc[-2]
+        onew = precios.iloc[-5]
+        onem = precios.iloc[-20]
+        oney = precios.iloc[0]
+        return1m = str(round((last_price/onem-1)*100, 2))+"%"
+        return1d = str(round((last_price/oned-1)*100, 2))+"%"
+        return1w = str(round((last_price/onew-1)*100, 2))+"%"
+        return1y = str(round((last_price/oney-1)*100, 2))+"%"
+        last_price = "$" + str(round(last_price, 2))
+        tabla = tabla.append([[last_price, return1d, return1w, return1m, return1y]])
+    tabla.columns = ["Precio","1d", "1w", "1m", "1y"]
+    tabla.index = index
+    return tabla
+
+
+def to_number(valor):
+    if valor == "1w":
+        value = 0.25
+    if valor == "1m":
+        value = 1
+    elif valor == "3m":
+        value = 3
+    elif valor == "6m":
+        value = 6
+    return value
+
+
+def seleccionar_fecha(fecha_select):
+    if fecha_select == "1 week" or fecha_select == "1w":
+        fec_in = date.today() - dt.timedelta(days=7)
+    elif fecha_select == "1 month":
+        fec_in = date.today() - dt.timedelta(days=30)
+    elif fecha_select == "3 month":
+        fec_in = date.today() - dt.timedelta(days=90)
+    elif fecha_select == "6 month":
+        fec_in = date.today() - dt.timedelta(days=180)
+    elif fecha_select == "1 year":
+        fec_in = date.today() - dt.timedelta(days=365)
+    elif fecha_select == "5 year":
+        fec_in = date.today() - dt.timedelta(days=365*5)
+    elif fecha_select == "10 year":
+        fec_in = date.today() - dt.timedelta(days=365*10)
+    elif fecha_select == "15 year":
+        fec_in = date.today() - dt.timedelta(days=365*15)
+    fec_in = fec_in.strftime("%d/%m/%Y")
+    return fec_in
+
+
+
+
+
+
+@log
+def curva_yield():
+    today = date.today()
+    col1, col2 = st.columns(2)
+    pais = col1.selectbox("Pais", ["Chile", "Brazil", "Mexico", "Colombia",
+                                   "Peru", "Japan", "U.S."])
+    meses = col2.selectbox("periodo", ["1w", "1m", "3m", "6m", "1y"])
+    if meses == "1w":
+        one_months_ago = seleccionar_fecha(meses)
+    elif meses == "1y":
+        one_months_ago = today.replace(year=today.year - 1).strftime("%d/%m/%Y")
+    else:
+        mes = to_number(meses)
+        one_months_ago = today.replace(month=today.month - mes).strftime("%d/%m/%Y")
+    today = today.strftime("%d/%m/%Y")
+    if pais == "Chile":
+        bonos = ['Chile 1Y', 'Chile 2Y', 'Chile 3Y', 'Chile 4Y', 'Chile 5Y',
+                 'Chile 8Y', 'Chile 10Y']
+        proporcion = [1, 2, 3, 4, 5, 8, 10]
+    elif pais == "Brazil":
+        bonos = ['Brazil 3m', 'Brazil 6m', 'Brazil 1Y', 'Brazil 2Y',
+                 'Brazil 3Y', 'Brazil 5Y', 'Brazil 8Y', 'Brazil 10Y']
+        proporcion = [0.25, 0.5, 1, 2, 3, 5, 8, 10]
+    elif pais == "Mexico":
+        bonos = ['Mexico 3m', 'Mexico 6m', 'Mexico 1Y', "Mexico 3Y",
+                 'Mexico 5Y', 'Mexico 7Y', 'Mexico 10Y']
+        proporcion = [0.25, 0.5, 1, 3, 5, 7, 10]
+    elif pais == "Colombia":
+        bonos = ['Colombia 1Y', 'Colombia 4Y', 'Colombia 5Y', 'Colombia 10Y']
+        proporcion = [1, 4, 5, 10]
+    elif pais == "Peru":
+        bonos = ['Peru 2Y', 'Peru 5Y', 'Peru 10Y']
+        proporcion = [2, 5, 10]
+    elif pais == "Japan":
+        bonos = ['Japan 3m', 'Japan 6m', 'Japan 1Y', "Japan 2Y",
+                 'Japan 3Y', 'Japan 5Y', 'Japan 8Y', 'Japan 10Y']
+        proporcion = [0.25, 0.5, 1, 3, 5, 7, 10]
+    elif pais == "U.S.":
+        bonos = ['U.S. 3m', 'U.S. 6m', 'U.S. 1Y', "U.S. 2Y",
+                 'U.S. 3Y', 'U.S. 5Y', 'U.S. 8Y', 'U.S. 10Y']
+        proporcion = [0.25, 0.5, 1, 3, 5, 7, 10]
+    data_today = []
+    data_one_month = []
+    delta = []
+    for bono in bonos:
+        data_bono = investpy.bonds.get_bond_historical_data(bono,
+                                                            one_months_ago,
+                                                            today)
+        data_today.append(data_bono.iloc[-1]["Close"])
+        data_one_month.append(data_bono.iloc[0]["Close"])
+        delta.append(data_bono.iloc[-1]["Close"] - data_bono.iloc[0]["Close"])
+
+    def plot_tasas():
+        fig = go.Figure()
+        today = go.Scatter(x=proporcion, y=data_today, name="Yield today",
+                           line=dict(color="darkred"))
+        onemonth = go.Scatter(x=proporcion, y=data_one_month, name="Yield" +
+                              meses + " ago", line=dict(color="dimgrey"))
+        fig.add_trace(today)
+        fig.add_trace(onemonth)
+        fig.layout.update(title_text="",
+                          width=900, height=300, margin_b=0, margin_t=0,
+                          margin_r=0, margin_l=0, legend=dict(orientation="h",
+                                                              yanchor="bottom",
+                                                              y=1.0,
+                                                              xanchor="right",
+                                                              x=1),
+                          xaxis={'visible': False,
+                                 'showticklabels': False})
+        st.plotly_chart(fig)
+        fig2 = go.Figure()
+        fig2.add_trace(go.Bar(
+            x=proporcion,
+            y=delta,
+            name='Delta',
+            marker_color='dimgrey'
+        ))
+        if pais == "Brazil" or pais == "Mexico":
+            fig2.layout.update(title_text="",
+                               width=900, height=200, margin_b=0, margin_t=0,
+                               margin_r=0, margin_l=15,
+                               xaxis=go.layout.XAxis(tickangle=70))
+            fig2.update_xaxes(range=[-0.3, proporcion[-1]+0.5], ticktext=bonos,
+                              tickvals=proporcion)
+        else:
+            fig2.layout.update(title_text="",
+                               width=900, height=200, margin_b=0, margin_t=0,
+                               margin_r=0, margin_l=0,
+                               xaxis=go.layout.XAxis(tickangle=70))
+            fig2.update_xaxes(ticktext=bonos, tickvals=proporcion,
+                              range=[0.5, proporcion[-1]+0.5])
+        fig2.update_layout(barmode='group')
+        st.plotly_chart(fig2)
+    plot_tasas()
+
+
+def plot_raw_data(col, data, color, prefijo, ancho, largo):
+    fig = go.Figure()
+    close_ = go.Scatter(x=data.index, y=data['Close'], name="stock_close",
+                        line=dict(color=color), fill='tonexty')
+    fig.add_trace(close_)
+    fig.layout.update(title_text="", xaxis_rangeslider_visible=True,
+                      width=ancho, height=largo, margin_b=0, margin_t=0,
+                      margin_r=0, margin_l=0)
+    fig.update_yaxes(range=[min(data['Close'])/1.05,
+                            max(data['Close'])*1.05], tickprefix=prefijo)
+    col.plotly_chart(fig, use_container_width=True)
+
+
+# Brasil, Mexico, Chile, Colombia, Peru, USA, Alemania, UK, China, Japon
+@log
+def tasa10y_2y():
+    button_style()
+    TODAY = date.today().strftime("%d/%m/%Y")
+    bond_10y = ["Chile 10Y", "Peru 10Y", "China 10Y", "U.S. 10Y", "U.K. 10Y",
+                "Germany 10y", "Japan 10Y", "Brazil 10Y"]
+    bond_2y = ["Chile 2Y",
+               "Peru 2Y", "China 2Y", "U.S. 2Y", "U.K. 2Y", "Germany 2y",
+               "Japan 2Y", "Brazil 2Y"]
+    paises = ["Chile", "Peru", "China", "U.S.", "U.K.", "Alemania",
+              "Japon", "Brasil"]
+    col1, col2 = st.columns((1.681, 1))
+    selected = col1.selectbox("Seleccionar pais", paises)
+    fecha_select = col2.selectbox("  ", ["1 year", "1 week", "1 month",
+                                         "3 month",   "6 month", "5 year",
+                                         "10 year", "15 year"])
+    fec_in = seleccionar_fecha(fecha_select)
+    data_bonds10y = investpy.get_bond_historical_data(
+                                bond=bond_10y[paises.index(selected)],
+                                from_date=fec_in,
+                                to_date=TODAY)
+    data_bonds2y = investpy.get_bond_historical_data(
+                                bond=bond_2y[paises.index(selected)],
+                                from_date=fec_in,
+                                to_date=TODAY)
+    data_final = data_bonds10y["Close"]-data_bonds2y["Close"]
+    fig = go.Figure()
+    close_ = go.Scatter(x=data_bonds10y.index, y=data_final, name="Delta",
+                        line=dict(color="midnightblue"), fill='tonexty')
+    fig.add_trace(close_)
+    fig.layout.update(title_text="", xaxis_rangeslider_visible=True,
+                      width=900, height=400, margin_b=0, margin_t=0,
+                      margin_r=0, margin_l=0)
+    fig.update_yaxes(range=[min(data_final)/1.05,
+                            max(data_final)*1.05])
+    cols = st.columns((1.681*2.681, 1.681, 1))
+    col1, col2 = st.columns((1.681, 1))
+    col1.plotly_chart(fig, use_container_width=True)
+    data_final2 = pd.DataFrame()
+    data_final2["Date"] = list(data_final.index)
+    cierre = list(data_bonds10y["Close"]-data_bonds2y["Close"])
+    data_final2["Delta"] = list(data_bonds10y["Close"]-data_bonds2y["Close"])
+    last_price = cierre[-1]
+    first_price = cierre[0]
+    returns = round(((last_price - first_price)), 2)
+    cols[1].markdown('<p style="font-size:15px; padding-left:20px; margin-bottom:0px;">'+"Tasa 10Y - 2Y"+"</p>", unsafe_allow_html=True)
+    cols[1].markdown('<p style="font-size:35px; padding-left:30px;">'+formatnum(last_price)+"%</p>", unsafe_allow_html=True)
+    if returns > 0:
+        cols[2].markdown('<p style="font-size:22px; padding-top:27px; color:green;">▲ '+formatnum(returns)+" %</p>", unsafe_allow_html=True)
+    else:
+        cols[2].markdown('<p style="font-size:22px; padding-top:27px; color:red;">▼ '+formatnum(returns)+" %</p>", unsafe_allow_html=True)
+    st.markdown(get_table_excel_link(data_final2, selected),
+                unsafe_allow_html=True)
+    paises = ["Brazil", "Chile",
+              "Peru", "China", "U.S.", "U.K.", "Germany",
+              "Japan"]
+    style_table()
+    col2.dataframe(tabla_pendiente(paises, TODAY))
+
+
+@log
+def bonos():
+    st.sidebar.subheader("Opciones")
+    largo = 350
+    ancho = 450
+    button_style()
+    placeholder = st.empty()
+    placeholder1 = st.empty()
+    TODAY = date.today().strftime("%d/%m/%Y")
+    cols = st.columns((1.681*2.5, 1.681, 1))
+    col1, col2 = st.columns((1.6, 1))
+    paises = ["Brazil", "Mexico", "Chile", "Colombia",
+              "Peru", "China", "U.S.", "U.K.", "Germany",
+              "Japan"]
+    time = ["2Y", "10Y"]
+    # #################
+    selected_pais = cols[0].selectbox("  ", paises)
+    selected_time = cols[1].selectbox("  ", time)
+    fecha_select = cols[2].selectbox("  ", ["1 year", "1 week", "1 month",
+                                            "3 month",   "6 month", "5 year",
+                                            "10 year", "15 year"])
+    fec_in = seleccionar_fecha(fecha_select)
+    selected = selected_pais + " " + selected_time
+    data_bonds = investpy.get_bond_historical_data(bond=selected,
+                                                   from_date=fec_in,
+                                                   to_date=TODAY)
+
+    plot_raw_data(col1, data_bonds, 'dimgrey', "", ancho, largo)
+
+    last_price = data_bonds.iloc[-1]["Close"]
+    first_price = data_bonds.iloc[0]["Close"]
+    returns = round((last_price - first_price), 2)
+    cols[0].title("Tasa " + selected)
+    cols[1].markdown('<p style="font-size:15px; padding-left:20px; margin-bottom:0px;">'+"Tasa"+"</p>", unsafe_allow_html=True)
+    cols[1].markdown('<p style="font-size:35px; padding-left:30px;">'+formatnum(last_price)+"%</p>", unsafe_allow_html=True)
+    if returns > 0:
+        cols[2].markdown('<p style="font-size:22px; padding-top:27px; color:green;">▲ +'+ formatnum(returns)+" %</p>", unsafe_allow_html=True)
+    else:
+        cols[2].markdown('<p style="font-size:22px; padding-top:27px; color:red;">▼ '+formatnum(returns)+" %</p>", unsafe_allow_html=True)
+    # #################
+    style_table()
+    bonds10y = ["Brazil 10Y",
+                "Mexico 10Y",
+                "Chile 10Y",
+                "Colombia 10Y",
+                "Peru 10Y","China 10Y", "U.S. 10Y", "U.K. 10Y", "Germany 10y",
+                "Japan 10Y", ]
+    col2.dataframe(tabla_bonos(bonds10y, TODAY))
+    data_bonds["Date"] = data_bonds.index
+    data_bonds["Date"] = data_bonds["Date"].dt.date
+    data_toexcel = data_bonds[["Date", "Close"]]
+    st.markdown(get_table_excel_link(data_toexcel, selected),
+                unsafe_allow_html=True)
+    # graph_advance = st.sidebar.checkbox("Graficos avanzados")
+    # if graph_advance:
+
+
+
+@log
+def Commodities():
+    st.sidebar.subheader("Opciones")
+    largo = 350
+    ancho = 450
+    placeholder = st.empty()
+    placeholder1 = st.empty()
+    button_style()
+    TODAY = date.today().strftime("%d/%m/%Y")
+    col1, col2 = st.columns((1.681, 1))
+    cols = st.columns((1.681*2.681, 1.681, 1))
+    commodity = sorted(["Copper", "Silver", "Gold", "Platinum", 'Brent Oil',
+                        'Crude Oil WTI', "Natural Gas"])
+    # #################
+    selected_com = col1.selectbox("  ", commodity)
+    fecha_select = col2.selectbox("  ", ["1 year", "1 week", "1 month",
+                                         "3 month", "6 month", "5 year",
+                                         "10 year", "15 year"])
+    fec_in = seleccionar_fecha(fecha_select)
+    data_com = investpy.commodities.get_commodity_historical_data(
+                                                        commodity=selected_com,
+                                                        from_date=fec_in,
+                                                        to_date=TODAY)
+    col1, col2 = st.columns((1.681, 1))
+    plot_raw_data(col1, data_com, 'dimgrey', "", ancho, largo)
+    last_price = data_com.iloc[-1]["Close"]
+    first_price = data_com.iloc[0]["Close"]
+    returns = round(((last_price/first_price-1)*100), 2)
+    cols[0].title("Precio " + selected_com)
+    cols[1].markdown('<h4 style="font-size:15px; padding-left:20px; margin-bottom:0px;">'+"Precio"+"</h4>", unsafe_allow_html=True)
+    cols[1].markdown('<p style="font-size:30px; padding-left:30px;">$'+formatnum(last_price)+"</p>", unsafe_allow_html=True)
+    if returns > 0:
+        cols[2].markdown('<p style="font-size:22px; padding-top:27px; color:green;">▲ +'+formatnum(returns)+" %</p>", unsafe_allow_html=True)
+    else:
+        cols[2].markdown('<p style="font-size:22px; padding-top:27px; color:red;">▼ '+formatnum(returns)+" %</p>", unsafe_allow_html=True)
+    ##################
+
+    style_table()
+    col2.dataframe(tabla_commodity(commodity, TODAY))
+    data_com["Date"] = data_com.index
+    data_com["Date"] = data_com["Date"].dt.date
+    data_com_toexcel = data_com[["Date", "Close"]]
+    st.markdown(get_table_excel_link(data_com_toexcel, selected_com),
+                unsafe_allow_html=True)
+
+
+
+@log
+def Indices():
+    st.sidebar.subheader("Opciones")
+    largo = 350
+    ancho = 450
+    placeholder = st.empty()
+    placeholder1 = st.empty()
+    button_style()
+    TODAY = date.today().strftime("%d/%m/%Y")
+    col1, col2 = st.columns((1.681, 1))
+    cols = st.columns((1.681*2.681, 1.681, 1.2))
+    index = ["S&P CLX IPSA", "S&P Merval", "Bovespa", "S&P Lima General",
+             "COLCAP", "S&P/BMV IPC", "S&P 500", "FTSE 100", "China A50",
+             "Nikkei 225"]
+    countries = ["chile", "argentina", "brazil", "peru", "colombia", "mexico",
+                 "united states", "united kingdom", "china", "japan"]
+    ##################
+    selected_index = col1.selectbox("  ", index)
+    fecha_select = col2.selectbox("  ", ["1 year", "1 week", "1 month",
+                                         "3 month",   "6 month", "5 year",
+                                         "10 year", "15 year"])
+    fec_in = seleccionar_fecha(fecha_select)
+    data_index = investpy.get_index_historical_data(
+                                index=selected_index,
+                                country=countries[index.index(selected_index)],
+                                from_date=fec_in,
+                                to_date=TODAY)
+    col1, col2 = st.columns((1.681, 1))
+    plot_raw_data(col1, data_index, 'dimgrey', "", ancho, largo)
+    last_price = data_index.iloc[-1]["Close"]
+    first_price = data_index.iloc[0]["Close"]
+    returns = round(((last_price/first_price-1)*100), 2)
+    cols[0].title("Precio " + selected_index)
+    cols[1].markdown('<h4 style="font-size:15px; padding-left:20px; margin-bottom:0px;">'+"Precio"+"</h4>", unsafe_allow_html=True)
+    cols[1].markdown('<p style="font-size:30px; padding-left:30px;">$'+formatnum(last_price)+"</p>", unsafe_allow_html=True)
+    if returns > 0:
+        cols[2].markdown('<p style="font-size:22px; padding-top:27px; color:green;">▲ +'+formatnum(returns)+" %</p>", unsafe_allow_html=True)
+    else:
+        cols[2].markdown('<p style="font-size:22px; padding-top:27px; color:red;">▼ '+formatnum(returns)+" %</p>", unsafe_allow_html=True)
+    ##################
+    style_table()
+    col2.dataframe(tabla_indices(index, countries, TODAY))
+    data_index["Date"] = data_index.index
+    data_index["Date"] = data_index["Date"].dt.date
+    data_index_toexcel = data_index[["Date", "Close"]]
+    st.markdown(get_table_excel_link(data_index_toexcel, selected_index),
+                unsafe_allow_html=True)
+
+
+
+@log
+def Divisas():
+    st.sidebar.subheader("Opciones")
+    largo = 350
+    ancho = 450
+    placeholder = st.empty()
+    placeholder1 = st.empty()
+    button_style()
+    TODAY = date.today().strftime("%d/%m/%Y")
+    cols = st.columns(3)
+    cc1 = ["USD/CLP", "EUR/CLP", "GBP/CLP", "BRL/CLP", "JPY/CLP", "MXN/CLP",
+           "PEN/CLP"]
+    ##################
+    cc2_i = ["USD", "EUR", 'MXN', "GBP"]
+    cc2_f = ["CLP", "USD", "EUR", "GBP", "MXN", "JPY", "BRL", "PEN"]
+    ##################
+    selected_cc2_i = cols[0].selectbox("   ", cc2_i)
+    selected_cc2_f = cols[1].selectbox("     ", cc2_f)
+    selected_cc2 = selected_cc2_i + "/" + selected_cc2_f
+    fecha_select2 = cols[2].selectbox("    ", ["1 year", "1 week", "1 month",
+                                               "3 month",   "6 month",
+                                               "5 year", "10 year",
+                                               "15 year"])
+    fec_in2 = seleccionar_fecha(fecha_select2)
+    data_cc2 = investpy.currency_crosses.get_currency_cross_historical_data(
+                                selected_cc2, from_date=fec_in2, to_date=TODAY)
+    cols = st.columns((1.681*2.681, 1.681, 1))
+    col1, col2 = st.columns((1.681, 1))
+    plot_raw_data(col1, data_cc2, 'midnightblue', "", ancho, largo)
+    last_price = data_cc2.iloc[-1]["Close"]
+    first_price = data_cc2.iloc[0]["Close"]
+    returns = round(((last_price/first_price-1)*100), 2)
+    cols[0].title(selected_cc2)
+    cols[1].markdown('<p style="font-size:15px; padding-left:15px; margin-bottom:0px;">'+"Precio"+"</p>", unsafe_allow_html=True)
+    cols[1].markdown('<p style="font-size:30px; padding-left:30px;">' + formatnum(last_price)+ " "+selected_cc2_f +"</p>", unsafe_allow_html=True)
+    if returns > 0:
+        cols[2].markdown('<p style="font-size:22px; padding-top:27px; color:green;">▲ '+formatnum(returns)+" %</p>", unsafe_allow_html=True)
+    else:
+        cols[2].markdown('<p style="font-size:22px; padding-top:27px; color:red;">▼ '+formatnum(returns)+" %</p>", unsafe_allow_html=True)
+    style_table()
+    # col1.dataframe(tabla_indices(index, countries, TODAY))
+    # col2.dataframe(tabla_indices(index2, countries, TODAY))
+    data_cc2["Date"] = data_cc2.index
+    data_cc2["Date"] = data_cc2["Date"].dt.date
+    data_cc2_toexcel = data_cc2[["Date", "Close"]]
+    st.markdown(get_table_excel_link(data_cc2_toexcel, selected_cc2),
+                unsafe_allow_html=True)
+    col2.dataframe(tabla_divisas(cc1, TODAY))
+

apps/analisis_inmob.py

@@ -1,3 +1,347 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:606f196cbeba53cf826af70e6575b7cc6d481a544af2f5ddc0f448fc2244e3eb
-size 14998
+# Imports
+import pandas as pd
+import streamlit as st
+import pybase64 as base64
+# from modules.tables import RealEstateMaste
+from sqlalchemy import create_engine
+import plotly.express as px
+import io
+import urllib.request
+import bs4 as bs
+import scipy.stats as stats 
+import plotly.figure_factory as ff
+import scipy.stats as stats 
+import plotly.graph_objects as go
+import numpy as np
+from datetime import date
+from datetime import timedelta
+from Data.credentials import credentials_postgresql as credpost
+
+def formatnum(numero):
+    '''
+    Esta función permite dar formato a los montos de saldo y valor cuota en 
+    las cartolas.
+    '''
+    return '{:,.0f}'.format(numero).replace(",", "@").replace(".", ",").replace("@", ".")
+
+
+def get_UF():
+    link = "https://valoruf.cl/"
+    req = urllib.request.Request(link)
+    res = urllib.request.urlopen(req)
+    resData = res.read()
+    soup = bs.BeautifulSoup(resData)
+    uf = soup.find(class_="vpr").contents[0]
+    uf_value = uf.split(' ')[1]
+    uf_value = uf_value.replace('.', '')
+    uf_value = uf_value.replace(',', '.')
+    return uf_value
+
+
+def button_style():
+    style_button = """
+        <style>
+          button {
+            display: inline-block;
+            background-color: #e8e8e8;
+            border-radius: 15px;
+            border: 4px  #cccccc;
+            color: #4a4a4a;
+            text-align: center;
+            font-size: 18px;
+            padding: 2px;
+            width: 300px;
+            transition: all 0.5s;
+            cursor: pointer;
+            margin: 5px;
+          }
+          button span {
+            cursor: pointer;
+            display: inline-block;
+            position: relative;
+            transition: 0.5s;
+          }
+          button span:after {
+            content: '\00bb';
+            position: absolute;
+            opacity: 0;
+            top: 0;
+            right: -20px;
+            transition: 0.5s;
+          }
+          button:hover {
+            background-color: #bb1114;
+            color:#e8e8e8;
+          }
+          button:hover span {
+            padding-right: 25px;
+          }
+          button:hover span:after {
+            opacity: 1;
+            right: 0;
+      }
+    </style>
+    """
+    st.markdown(style_button, unsafe_allow_html=True)
+
+
+def plot_column(data, column, nom_var_inv, placeholder, sigmas=3, limite=None):
+    data = data.rename(columns=nom_var_inv)
+    column = nom_var_inv[column]
+    limit = data[column].mean() + sigmas * data[column].std()
+    data = data.loc[data[column] <= limit]
+    if limite is not None:
+        data = data.loc[data[column] <= limite]
+    fig = px.scatter_mapbox(data_frame=data, lat='latitud', lon='longitud',
+                            zoom=10, color=column,
+                            hover_data=['codigo', 'Superficie', 'dormitorios', 'banos', 'Precio en CLP'],
+                            color_continuous_scale=px.colors.diverging.RdYlBu,
+                            width=1000, height=800)
+    placeholder.plotly_chart(fig, use_container_width=True)
+
+def plot_column2(data, column, nom_var_inv, placeholder, zoom, sigmas=10, limite=None):
+    data = data.rename(columns=nom_var_inv)
+    column = nom_var_inv[column]
+    limit = data[column].mean() + sigmas * data[column].std()
+    data = data.loc[data[column] <= limit]
+    if limite is not None:
+        data = data.loc[data[column] <= limite]
+    fig = px.scatter_mapbox(data_frame=data, lat='latitud', lon='longitud',
+                            zoom=zoom, color=column,
+                            hover_data=['codigo', 'Superficie', 'dormitorios', 'banos', 'Precio en CLP', 'Comuna'],
+                            color_continuous_scale=px.colors.diverging.RdYlBu,
+                            width=1000, height=800,size='Superficie',size_max=25)
+    placeholder.plotly_chart(fig, use_container_width=True)
+
+
+def get_comuna(direction):
+    values = direction.split(',')
+    return values[-2]
+
+def unit_separator(string):
+    values = string.split(" ")
+    return values[0]
+
+
+def transform_df(scraping_df):
+    # Extract numbers from string
+    # Change datatype
+    # Add 'Comuna' and 'Región'
+    scraping_df[["Comuna"]] = scraping_df[["direccion"]].applymap(lambda x: get_comuna(x))
+    # Scrap UF value for date
+    #scraping_df[["Valor UF"]] = get_UF()
+    return scraping_df
+
+
+def get_table_excel_link(df, name):
+    towrite = io.BytesIO()
+    downloaded_file = df.to_excel(towrite, encoding='utf-8', index=False,
+                                  header=True)
+    towrite.seek(0)  # reset pointer
+    file_name = 'Data' + name + '.xlsx'
+    style = 'style="color:black;text-decoration: none; font-size:18px;"'
+    name_mark = "Descargar " + name + ".xlsx"
+    b64 = base64.b64encode(towrite.read()).decode()  # some strings
+    linko= f'<center><a href="data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64,{b64}" '+style+'download="'+file_name+'"><button>'+name_mark+'</button></a></center>'
+    return linko
+
+
+@st.cache(allow_output_mutation=True)
+def query_inmob():
+    url = credpost["POSTGRESQL"]
+    engine = create_engine(url, echo=False)
+    semana_pasada = date.today() - timedelta(7)
+    semana_pasada = semana_pasada.strftime("%Y-%m-%d")
+    data = pd.read_sql_query("""select * from scraping_inmob where Fecha >
+                             '{Fecha} 00:00:00' ORDER BY Fecha desc""".format(Fecha=semana_pasada)  , con=engine)
+    return data
+
+def run_scrapping():
+    button_style()
+    px.set_mapbox_access_token('pk.eyJ1IjoibW9rc2VuYmVyZyIsImEiOiJja3QwOTc3dHgyNzBhMnFsczJ2Y2w3bWJlIn0.m8c3duvR5hQVjbjEByorWQ')
+    data = query_inmob()
+    precio_uf = get_UF()
+    data["valor_uf"] = data["valor_peso"]/float(precio_uf)
+    data['predicted_venta_por_m2_UF']=data['predicted_venta_por_m2']/float(precio_uf)
+    nom_var = {"Precio en UF": "valor_uf",
+               "Precio en CLP": "valor_peso",
+               "Superficie": "superficie",
+               "Predicted venta por M2 en CLP": "predicted_venta_por_m2",
+               "Predicted venta por M2 en UF": "predicted_venta_por_m2_UF",
+               "Predicted arriendo por M2": "predicted_arriendo_por_m2",
+               "Predicted yield anual": "predicted_yield_anual"
+               }
+    nom_var_inv = {v: k for k, v in nom_var.items()}
+    var = list(nom_var.keys())
+    with st.form(key='my_form'):
+        col1, col2, col3, col4 = st.columns((9, 1, 9, 1))
+        cols = st.columns((9, 1, 5, 5))
+        pre_selection = col1.selectbox("Variable", var)
+        selection = nom_var[pre_selection]
+        mercado = col3.selectbox("Mercado", ["Venta", "Arriendo", "Todos"])
+        if mercado != "Todos":
+            mercado = mercado.lower()
+            data_mercado = data[data["mercado"] == mercado]
+        else:
+            data_mercado = data
+        cifras = len(str(int(max(data_mercado[selection]))))
+        tipo_prop = cols[0].selectbox("Tipo de propiedad",
+                                      ["Todos", "Casa", "Departamento"])
+        if tipo_prop != "Todos":
+            tipo_prop2 = tipo_prop.lower()
+            data_mercado = data_mercado[data_mercado["tipo_propiedad"] == tipo_prop2]
+        if cifras > 3:
+            corte = 10 ** (cifras - 3)
+            cota_final = (int(max(data_mercado[selection].dropna()))//corte+1) *corte
+            cota_inf = cols[2].number_input(label="Valor Mínimo",
+                                            min_value=0,
+                                            value=0,
+                                            max_value=cota_final
+                                            )
+            cota_sup = cols[3].number_input(label="Valor Máximo",
+                                            min_value=0,
+                                            value=cota_final,
+                                            max_value=cota_final
+                                            )
+        else:
+            cota_final = max(data_mercado[selection].dropna())+1
+            cota_inf = cols[2].number_input(label="Valor Mínimo",
+                                            min_value=0.0,
+                                            value=0.0,
+                                            step=0.1,
+                                            max_value=cota_final
+                                            )
+            cota_sup = cols[3].number_input(label="Valor Máximo",
+                                            min_value=0.0,
+                                            step=0.1,
+                                            value=cota_final,
+                                            max_value=cota_final
+                                            )
+        data_final = data_mercado[data_mercado[selection] < cota_sup]
+        data_final = data_final[data_final[selection] > cota_inf]
+        submit_button = st.form_submit_button(label='Actualizar')
+    col1, col2 = st.columns((0.65, 1))
+    placeholder = st.empty()
+    placeholder2 = st.empty()
+    placeholder2.markdown(get_table_excel_link(data, "Data Completa"),
+            unsafe_allow_html=True)
+    plot_column(data, selection, nom_var_inv, placeholder)
+    
+    if submit_button:
+        plot_column(data_final, selection, nom_var_inv, placeholder)
+
+        st.markdown(get_table_excel_link(data_final, " Data filtrada"),
+                    unsafe_allow_html=True)
+
+
+
+def scraping_localizado():
+    button_style()
+    data = query_inmob()
+    data = transform_df(data)
+    precio_uf = get_UF()
+    data["valor_uf"] = data["valor_peso"]/float(precio_uf)
+    data['predicted_venta_por_m2_UF'] = data['predicted_venta_por_m2']/float(precio_uf)
+    nom_var = {"Precio en UF": "valor_uf",
+               "Precio en CLP": "valor_peso",
+               "Superficie": "superficie",
+               "Predicted venta por M2 en CLP": "predicted_venta_por_m2",
+               "Predicted venta por M2 en UF": "predicted_venta_por_m2_UF",
+               "Predicted arriendo por M2": "predicted_arriendo_por_m2",
+               "Predicted yield anual": "predicted_yield_anual"
+               }
+    nom_var_inv = {v : k for k, v in nom_var.items()}
+    var = list(nom_var.keys())
+    with st.form(key='my_form'):
+        col1, col2, col3, col4 = st.columns((9, 1, 9, 1))
+        cols = st.columns((9, 1, 5, 5))
+        pre_selection = col1.selectbox("Variable", var)
+        selection = nom_var[pre_selection]
+        mercado = col3.selectbox("Mercado", ["Venta", "Arriendo", "Todos"])
+        banos = col1.slider("Baños", value=(1, 5), min_value=0, max_value=10)
+        dormitorios = col3.slider("Dormitorios", value=(1, 5), min_value=0,
+                                  max_value=10)
+        com = ["Todas"] + sorted(list(dict.fromkeys(data["Comuna"])))
+        comuna = col1.selectbox("Comuna", com)
+        zoom = col3.number_input("Zoom", value=12)
+        if mercado != "Todos":
+            mercado = mercado.lower()
+            data_mercado = data[data["mercado"] == mercado]
+        else:
+            data_mercado = data
+        if comuna != "Todas":
+            data_mercado = data_mercado[data_mercado["Comuna"] == comuna]
+        if len(data_mercado) > 0:
+            cifras = len(str(int(max(data_mercado[selection].dropna()))))
+        else:
+            cifras = 0
+        tipo_prop = cols[0].selectbox("Tipo de Propiedad",
+                                      ["Todos", "Casa", "Departamento"])
+        if tipo_prop != "Todos":
+            tipo_prop2 = tipo_prop.lower()
+            data_mercado = data_mercado[data_mercado["tipo_propiedad"] == tipo_prop2]
+        if cifras > 3:
+            corte = 10 ** (cifras - 3)
+            cota_final = (int(max(data_mercado[selection].dropna()))//corte+1)*corte
+            cota_inf = cols[2].number_input(label="Valor Mínimo",
+                                            min_value=0,
+                                            value=0,
+                                            max_value=cota_final
+                                            )
+            cota_sup = cols[3].number_input(label="Valor Máximo",
+                                            min_value=0,
+                                            value=cota_final,
+                                            max_value=cota_final
+                                            )
+        else:
+            cota_final = max(data_mercado[selection].dropna())+1
+            cota_inf = cols[2].number_input(label="Valor Mínimo",
+                                            min_value=0.0,
+                                            value=0.0,
+                                            step=0.1,
+                                            max_value=cota_final
+                                            )
+            cota_sup = cols[3].number_input(label="Valor Máximo",
+                                            min_value=0.0,
+                                            step=0.1,
+                                            value=cota_final,
+                                            max_value=cota_final
+                                            )
+            
+        data_final = data_mercado[data_mercado[selection] < cota_sup]
+        data_final = data_final[data_final[selection] > cota_inf]
+        data_final = data_final[data_final["banos"] > banos[0]]
+        data_final = data_final[data_final["banos"] < banos[1]]
+        data_final = data_final[data_final["dormitorios"] > dormitorios[0]]
+        data_final = data_final[data_final["dormitorios"] < dormitorios[1]]
+        st.write('Stats principales del análisis')
+        st.write('Valor promedio en UF por metro cuadrado: {:.2f} UF'.format((data_final['valor_uf']/data_final['superficie']).mean()))
+        st.write('Superficie promedio: {:.0f} m2'.format(data_final['superficie'].mean()))
+        st.write('N° de dormitorios promedio: {:.2f}'.format(data_final['dormitorios'].mean()))
+        st.write('N° de baños promedio: {:.2f}'.format(data_final['banos'].mean()))
+
+        submit_button = st.form_submit_button(label='Actualizar')
+    col1, col2 = st.columns((0.65, 1))
+    placeholder = st.empty()
+    placeholder2 = st.empty()
+    placeholder3 = st.empty()
+    placeholder2.markdown(get_table_excel_link(data, "Data Completa"),
+            unsafe_allow_html=True)
+    plot_column2(data, selection, nom_var_inv, placeholder, zoom)
+    dist_gamma = stats.gamma.rvs(1, scale=250000, size=2965) 
+    if submit_button:
+        plot_column2(data_final, selection, nom_var_inv, placeholder, zoom)
+        st.markdown(get_table_excel_link(data_final, " Data filtrada"),
+                    unsafe_allow_html=True)
+        data_hist = data_final[data_final["mercado"] == "venta"]
+        data_hist = data_hist[data_hist["valor_peso"] > 40000000]
+        data_hist = data_hist[data_hist["valor_peso"] < 1000000000]["valor_peso"] * 0.2
+        fig2 = px.histogram((data_hist), x='valor_peso')
+        #placeholder3.plotly_chart(fig2)
+        
+# streamlit run analisis_inmob.py
+# scraping_localizado()        
+        
+        
+        
+        

apps/mailer_quant.py

@@ -1,3 +1,63 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7d46e155d92c4daa20d3bd4e2e77b01895a32a82efd297ccb9e849f4daaa79d7
-size 2444
+import email, smtplib, ssl
+from datetime import datetime
+from email import encoders
+from email.mime.base import MIMEBase
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+import os 
+
+class Mailer():
+
+    def __init__(self, subject, body, html, receiver):
+        self.subject = subject
+        self.body = body
+        self.html = html
+        self.sender_email = os.environ.get('EMAIL_SENDER')
+        self.receiver_email = receiver
+        self.password = os.environ.get('EMAIL_PASSWORD')
+        self.message = None
+        self.create_message()
+        
+        
+    def create_message(self, filepath=None, filename=None):
+        # Create a multipart message and set headers
+        message = MIMEMultipart()
+        message["From"] = self.sender_email
+        message["To"] = self.receiver_email
+        message["Subject"] = self.subject
+        message["Bcc"] = self.receiver_email  # Recommended for mass emails
+        # Add body to email
+        if self.html:
+            message.attach(MIMEText(self.html, "html"))
+        elif self.body:
+            message.attach(MIMEText(self.body, "plain"))
+        #filename = "test.pdf"  # In same directory as script
+        # Open PDF file in binary mode
+        if filepath and filename:
+            with open(filepath, "rb") as attachment:
+                # Add file as application/octet-stream
+                # Email client can usually download this automatically as attachment
+                part = MIMEBase("application", "octet-stream")
+                part.set_payload(attachment.read())
+    
+            # Encode file in ASCII characters to send by email    
+            encoders.encode_base64(part)
+    
+            # Add header as key/value pair to attachment part
+            part.add_header(
+                "Content-Disposition",
+                f"attachment; filename= {filename}",
+            )
+    
+            # Add attachment to message and convert message to string
+            message.attach(part)
+        self.text = message.as_string()
+        return
+    
+    def send_message(self, receiver):    
+        # Log in to server using secure context and send email
+        context = ssl.create_default_context()
+        with smtplib.SMTP_SSL("smtp.gmail.com", 465, context=context) as server:
+            server.login(self.sender_email, self.password)
+            server.sendmail(self.sender_email, receiver, self.text)    
+            

apps/simulacion_vc.py

@@ -1,3 +1,1414 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e147bfa570fa63c05c0a2a0bce32de8c76ab8270ab302b9ba16eb4c6861a859b
-size 57640
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Sep 21 11:53:13 2021
+
+@author: benjaminull
+"""
+
+import numpy as np
+import streamlit as st
+import plotly.express as px
+import pandas as pd
+import scipy.stats as stats
+import plotly.express as px
+import scipy.stats as stats
+import plotly.graph_objects as go
+from sqlalchemy import create_engine
+import pybase64 as base64
+import io
+import matplotlib.pyplot as plt
+from io import StringIO
+import pandas as pd
+
+@st.cache(allow_output_mutation=True)
+def read_excel(path):
+    df = pd.read_excel(path)
+    return df
+
+@st.cache(allow_output_mutation=True)
+def read_excel2(path):
+    df = pd.read_excel(path)
+    return df
+
+def explorar_data():
+    df = read_excel('base_personas.xlsx')
+    df2 = read_excel2('base_personas.xlsx')
+    data = df.copy()
+    data2 = df2.copy()
+    l=[]
+
+    variable = st.selectbox(" ",list(data.columns))
+    for i in list(data2.columns):
+        if i not in ["FE", "EDAD", variable]:
+            try:
+                data2[i] =  data2[i]* data2["FE"]
+            except:
+                pass
+    col1, col2 = st.beta_columns(2)
+    minim = col1.number_input("Edad minima", min_value=0, max_value=105)
+    maxim = col2.number_input("Edad maxima", min_value=0, max_value=105, value=105)
+    data = data[data["EDAD"] < maxim]
+    data = data[data["EDAD"] > minim]
+    data2 = data2[data2["EDAD"] < maxim]
+    data2 = data2[data2["EDAD"] > minim]
+    pond = st.checkbox("Ponderar por FE")
+    import plotly.graph_objects as go
+    if pond:
+        data_f3 = data2.groupby([ variable, "EDAD"]).sum()
+        data_f3 = data_f3.loc[:,data_f3.columns[0]].unstack(level=1).replace(np.nan, 0)
+        st.write(data_f3)
+    
+    
+        fig = go.Figure()
+        for i in list(data_f3.index):
+            fig.add_trace(go.Scatter(
+                x=list(data_f3.columns), y=list(data_f3.loc[i,:]),
+                mode='lines',
+                line=dict(width=0.5),
+                stackgroup='one',
+                groupnorm='percent' # sets the normalization for the sum of the stackgroup
+            ))
+    
+        fig.update_layout(
+            showlegend=True,
+            xaxis_type='category',
+            yaxis=dict(
+                type='linear',
+                range=[1, 100],
+                ticksuffix='%'))
+        
+        st.plotly_chart(fig, use_container_width=True)
+
+    else:
+        data_f = data.groupby([ variable, "EDAD"]).count()
+        data_f2 = data_f.loc[:,data_f.columns[0]].unstack(level=1).replace(np.nan, 0)
+        st.write(data_f2)
+        fig = go.Figure()
+        for i in list(data_f2.index):
+            fig.add_trace(go.Scatter(
+                x=list(data_f2.columns), y=list(data_f2.loc[i,:]),
+                mode='lines',
+                line=dict(width=0.5),
+                stackgroup='one',
+                groupnorm='percent' # sets the normalization for the sum of the stackgroup
+            ))
+    
+        fig.update_layout(
+            showlegend=True,
+            xaxis_type='category',
+            yaxis=dict(
+                type='linear',
+                range=[1, 100],
+                ticksuffix='%'))
+        
+        st.plotly_chart(fig, use_container_width=True)
+    
+
+    # pr = data_f2.profile_report()
+
+    # st_profile_report(data_f2)
+
+def transform_df(scraping_df):
+    # Extract numbers from string
+    # Change datatype
+    # Add 'Comuna' and 'Región'
+    scraping_df[["Comuna"]] = scraping_df[[
+        "direccion"]].applymap(lambda x: get_comuna(x))
+    # Scrap UF value for date
+    #scraping_df[["Valor UF"]] = get_UF()
+    return scraping_df
+
+
+def get_table_excel_link(df, name):
+    towrite = io.BytesIO()
+    downloaded_file = df.to_excel(towrite, encoding='utf-8', index=False,
+                                  header=True)
+    towrite.seek(0)  # reset pointer
+    file_name = 'Data' + name + '.xlsx'
+    style = 'style="color:black;text-decoration: none; font-size:18px;"'
+    name_mark = "Descargar " + name + ".xlsx"
+    b64 = base64.b64encode(towrite.read()).decode()  # some strings
+    linko = f'<center><a href="data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64,{b64}" ' + \
+        style+'download="'+file_name+'"><button>'+name_mark+'</button></a></center>'
+    return linko
+
+
+def get_comuna(direction):
+    values = direction.split(',')
+    return values[-2]
+
+
+def formatnum(numero):
+    '''
+    Esta función permite dar formato a los montos de saldo y valor cuota en 
+    las cartolas.
+    '''
+    return '{:,.0f}'.format(numero).replace(",", "@").replace(".", ",").replace("@", ".")
+
+
+def sim_norm():
+    with st.form(key='my_form'):
+        col1, col2 = st.beta_columns(2)
+        sim = col1.number_input("Nº Simulaciones", min_value=1, value=100)
+        vc = col2.number_input("Cuota inicial", min_value=100)
+        col1, col2, col3 = st.beta_columns(3)
+        mu = col1.number_input("µ Fondo Arriesgado", value=0.1)
+        sigma = col1.number_input("σ Fondo Arriesgado", value=0.1)
+        mu2 = col2.number_input("µ Fondo Intermedio ", value=0.05)
+        sigma2 = col2.number_input("σ Fondo Intermedio", value=0.05)
+        mu3 = col3.number_input("µ Fondo Conservador", value=-0.01)
+        sigma3 = col3.number_input("σ Fondo Conservador", value=0.03)
+        # t= col1.number_input("Periodo", value=288)
+        # t2 = col2.number_input("Periodo ", value=120)
+        # t3 = col3.number_input("Periodo  ", value=72)
+        values = st.slider(
+            'Seleccione los años de cambio de fondo', 0, 40, (33, 38))
+        with st.beta_expander("Ajustar parámetros de distribucion de permanencia del cliente (gamma)"):
+            col1, col2 = st.beta_columns(2)
+            alpha = col1.number_input("alpha", value=1.5)
+            beta = col2.number_input("lambda", value=71.1)
+        submit_button = st.form_submit_button(label='Actualizar')
+    if submit_button:
+        t = values[0]*12
+        t2 = values[1]*12-t
+        t3 = 480-t2-t
+        mu = mu / 12
+        mu2 = mu2 / 12
+        mu3 = mu3 / 12
+        sigma = sigma / (12**(1/2))
+        sigma2 = sigma2 / (12**(1/2))
+        sigma3 = sigma3 / (12**(1/2))
+        var_al = np.random.normal(mu, sigma, size=(t, sim))
+        var_al2 = np.random.normal(mu2, sigma2, size=(t2, sim))
+        var_al3 = np.random.normal(mu3, sigma3, size=(t3, sim))
+        simulacion = np.zeros((t + t2 + t3, sim))
+        simulacion[0, :] = vc
+        dist_gamma = stats.gamma.rvs(alpha, scale=beta, size=sim).astype(int)+1
+        for i in range(1, t):
+            simulacion[i, :] = simulacion[i - 1, :] * (1 + var_al[i-1, :])
+        for i in range(t, t+t2):
+            simulacion[i, :] = simulacion[i - 1, :] * (1 + var_al2[t-i-1, :])
+        for i in range(t+t2, t+t2+t3):
+            simulacion[i, :] = simulacion[i - 1, :] * \
+                (1 + var_al3[t2+t-i-1, :])
+        retornos = np.zeros(sim)
+        for j in range(sim):
+            ingreso = 480-dist_gamma[j]
+            simulacion[0:ingreso, j] = None
+            simulacion[ingreso:480, j] = simulacion[ingreso:480, j] * \
+                vc/simulacion[ingreso, j]
+            retorno = (simulacion[-1, j]/simulacion[ingreso, j]
+                       )**(1/(dist_gamma[j]/12))-1
+            retornos[j] = retorno
+        df = pd.DataFrame(simulacion)
+        df["meses"] = list(df.index)
+        fig = px.line(df, x="meses", y=df.columns,
+                      title='Simulaciones')
+        fig.layout.update(xaxis_rangeslider_visible=True)
+        fig.add_vline(x=t, line_width=3, line_dash="dash", line_color="grey")
+        fig.add_vline(x=t+t2, line_width=3,
+                      line_dash="dash", line_color="grey")
+        fig.add_vrect(x0=0, x1=t, annotation_text="Arries",
+                      annotation_position="top",
+                      fillcolor="red", opacity=0.15, line_width=0)
+        fig.add_vrect(x0=t, x1=t+t2,
+                      annotation_text="Inter", annotation_position="top",
+                      fillcolor="midnightblue", opacity=0.15, line_width=0)
+        fig.add_vrect(x0=t + t2, x1=t + t2 + t3,
+                      annotation_text="Cons", annotation_position="top",
+                      fillcolor="seagreen", opacity=0.15, line_width=0)
+        fig.update_layout(height=600, width=950)
+        st.plotly_chart(fig, use_container_width=True)
+        st.subheader("Distribución de duracion de clientes")
+        df_in = pd.DataFrame(dist_gamma//12, columns=["ingreso"])
+        fig = px.histogram(df_in, x="ingreso", nbins=40)
+        fig.add_vline(x=(dist_gamma//12).mean(), line_width=3,
+                      line_dash="dash", line_color="midnightblue")
+        col1, col2 = st.beta_columns((3, 1))
+        col1.plotly_chart(fig, use_container_width=True)
+        col2.title("  ")
+        col2.header("µ = "+str((dist_gamma//12).mean())[0:4] + " años")
+        col2.subheader("σ = "+str((dist_gamma//12).std())[0:4] + " años")
+        st.subheader("Distribución de retorno anual")
+        col1, col2 = st.beta_columns((3, 1))
+        df_ret = pd.DataFrame(retornos, columns=["retornos"])
+        col2.title("  ")
+        col2.header("µ = "+str((retornos.mean()*100))[0:4] + "%")
+        col2.subheader("σ = "+str((retornos.std())*100)[0:4] + "%")
+        fig2 = px.histogram(df_ret, x="retornos", nbins=50)
+        retorno_fc = (1.053)*(1.0312)-1
+        if retornos.mean() > 0.0312:
+            posicion1 = "top right"
+            posicion2 = "top left"
+        else:
+            posicion2 = "top right"
+            posicion1 = "top left"
+        fig2.add_vline(x=retornos.mean(), line_width=3, line_dash="dash",
+                       line_color="midnightblue", annotation_font_color="midnightblue",
+                       annotation_position=posicion1,
+                       annotation_text=str(round(retornos.mean()*100, 1))+"%")
+        fig2.add_vline(x=0.0312, line_width=3, line_dash="dash",
+                       annotation_font_color="red",
+                       annotation_position=posicion2,
+                       line_color="red", annotation_text="3,12%")
+        fig2.add_vline(x=retorno_fc, line_width=3, line_dash="dash",
+                       annotation_font_color="green",
+                       annotation_position=posicion2,
+                       line_color="green", annotation_text=str(round(retorno_fc, 2)*100)+"%")
+        fig2.add_vline(x=0.00, line_width=3, line_dash="dash",
+                       line_color="yellow")
+        col1.plotly_chart(fig2, use_container_width=True)
+        col1, col2 = st.beta_columns((1, 8))
+        col2.write(str(round(sum(df_ret["retornos"] > 0.00)/len(df_ret)*100, 0)) +
+                   "%: Probabilidad de que un clientes tenga retorno mayor a 0%")
+        col2.write(str(round(sum(df_ret["retornos"] > 0.0312)/len(df_ret)*100, 0)) +
+                   "%: Probabilidad de que un clientes tenga un retorno mayor a 3,12% (Inflación)")
+        col2.write(str(round(sum(df_ret["retornos"] > retorno_fc)/len(df_ret)*100, 0)) +
+                   "%: Probabilidad de que un clientes tenga retorno mayor a "+str(round(retorno_fc, 2)*100)+"% (Fondo C)")
+
+
+def sim_2():
+    with st.form(key='my_form'):
+        col1, col2 = st.beta_columns(2)
+        sim = col1.number_input("Nº Simulaciones", min_value=1, value=100)
+        vc = col2.number_input("Cuota inicial", min_value=100)
+        col1, col2, col3 = st.beta_columns(3)
+        mu = col1.number_input("µ Fondo Arriesgado", value=0.1)
+        sigma = col1.number_input("σ Fondo Arriesgado", value=0.1)
+        mu2 = col2.number_input("µ Fondo Intermedio ", value=0.05)
+        sigma2 = col2.number_input("σ Fondo Intermedio", value=0.05)
+        mu3 = col3.number_input("µ Fondo Conservador", value=-0.01)
+        sigma3 = col3.number_input("σ Fondo Conservador", value=0.03)
+        values = st.slider('Seleccione los años de cambio de fondo', 0, 40,
+                           (33, 38))
+        with st.beta_expander("Ajustar parámetros de distribucion de permanencia del cliente (gamma)"):
+            col1, col2 = st.beta_columns(2)
+            alpha = col1.number_input("alpha", value=1.5)
+            beta = col2.number_input("lambda", value=71.1)
+        submit_button = st.form_submit_button(label='Actualizar')
+    if submit_button:
+        t = values[0]*12
+        t2 = values[1]*12-t
+        t3 = 480-t2-t
+        mu = mu / 12
+        mu2 = mu2 / 12
+        mu3 = mu3 / 12
+        sigma = sigma / (12 ** (1/2))
+        sigma2 = sigma2 / (12 ** (1/2))
+        sigma3 = sigma3 / (12 ** (1/2))
+        var_al = np.random.normal(mu, sigma, size=(t, sim))
+        var_al2 = np.random.normal(mu2, sigma2, size=(t2, sim))
+        var_al3 = np.random.normal(mu3, sigma3, size=(t3, sim))
+        simulacion = np.zeros((t + t2 + t3, sim))
+        simulacion[0, :] = vc
+        dist_gamma = stats.gamma.rvs(alpha, scale=beta, size=sim).astype(int)+1
+        for i in range(1, t):
+            simulacion[i, :] = simulacion[i - 1, :] * (1 + var_al[i-1, :])
+        for i in range(t, t+t2):
+            simulacion[i, :] = simulacion[i - 1, :] * (1 + var_al2[t-i-1, :])
+        for i in range(t+t2, t+t2+t3):
+            simulacion[i, :] = simulacion[i - 1, :] * \
+                (1 + var_al3[t2+t-i-1, :])
+        retornos = np.zeros(sim)
+        for j in range(sim):
+            ingreso = 480-dist_gamma[j]
+            simulacion[0:ingreso, j] = None
+            simulacion[ingreso:480, j] = simulacion[ingreso:480, j] * \
+                vc/simulacion[ingreso, j]
+            retorno = (simulacion[-1, j]/simulacion[ingreso, j]
+                       )**(1/(dist_gamma[j]/12))-1
+            retornos[j] = retorno
+        df = pd.DataFrame(simulacion)
+        df["meses"] = list(df.index)
+        fig = px.line(df, x="meses", y=df.columns,
+                      title='Simulaciones')
+        fig.layout.update(xaxis_rangeslider_visible=True)
+        fig.add_vline(x=t, line_width=3, line_dash="dash", line_color="grey")
+        fig.add_vline(x=t+t2, line_width=3, line_dash="dash",
+                      line_color="grey")
+        fig.add_vrect(x0=0, x1=t, annotation_text="Arries",
+                      annotation_position="top",
+                      fillcolor="red", opacity=0.15, line_width=0)
+        fig.add_vrect(x0=t, x1=t+t2,
+                      annotation_text="Inter", annotation_position="top",
+                      fillcolor="midnightblue", opacity=0.15, line_width=0)
+        fig.add_vrect(x0=t + t2, x1=t + t2 + t3,
+                      annotation_text="Cons", annotation_position="top",
+                      fillcolor="seagreen", opacity=0.15, line_width=0)
+        fig.update_layout(height=600, width=950)
+        st.plotly_chart(fig, use_container_width=True)
+        sigma_sim1 = np.random.normal(sigma, 0.009, size=480)
+        sigma_sim2 = np.random.normal(sigma2, 0.004, size=480)
+        sigma_sim3 = np.random.normal(sigma3, 0.001, size=480)
+        sigma_comb = np.zeros(480)
+        sigma_comb[0:t] = sigma_sim1[0:t]
+        sigma_comb[t:t+t2] = sigma_sim2[t:t+t2]
+        sigma_comb[t+t2:480] = sigma_sim3[t+t2:480]
+        sigma_comb2 = np.zeros(480)
+        retorno_comb = np.zeros(480)
+        for i in range(t):
+            sigma_comb2[i] = sigma_sim1[i] * (1-i/t) + sigma_sim2[i] * i/t
+            retorno_comb[i] = mu * (1-i/t) + mu2 * i/t
+        for j in range(480-t):
+            sigma_comb2[t + j] = sigma_sim2[t + j] * \
+                (1-j/(480-t)) + sigma_sim3[t + j] * j/(480-t)
+            retorno_comb[i] = mu2 * (1-j/(480-t)) + mu3 * j/(480-t)
+        dfsig = pd.DataFrame(sigma_sim1, columns=["sig"])
+        dfsig["mes"] = list(dfsig.index)
+        dfsig["sigma inter"] = sigma_sim2
+        dfsig["sigma cons"] = sigma_sim3
+        dfsig["sigma por periodos"] = sigma_comb
+        dfsig["sigma combinacion lineal"] = sigma_comb2
+        dfsig["sigma combinacion lineal"] = dfsig["sigma combinacion lineal"].abs()
+        var_al_comb = np.zeros(480)
+        patr_al_comb = np.zeros(480)
+        patr_al_comb[0] = vc
+        for i in range(1, 480):
+            var_al_comb[i] = np.random.normal(
+                retorno_comb[i],
+                dfsig["sigma combinacion lineal"].iloc[i],
+                size=1)
+            patr_al_comb[i] = patr_al_comb[i-1]*(1 + var_al_comb[i-1])
+        ingreso = 480-dist_gamma[0]
+
+        data_comb = pd.DataFrame(patr_al_comb, columns=["Precio"])
+        data_comb["mes"] = list(data_comb.index)
+        data_comb = data_comb[data_comb["mes"] >= ingreso]
+        data_comb["Precio"] = data_comb["Precio"]/data_comb.iloc[0]["Precio"]
+        fig2 = px.line(dfsig, x='mes', y=dfsig.columns,
+                       title='Simulaciones')
+        st.plotly_chart(fig2)
+        fig3 = px.line(data_comb, x='mes', y=data_comb.columns,
+                       title='Simulaciones')
+        st.plotly_chart(fig3)
+
+
+def sim_inmob():
+    url = """postgresql://tbgxsndupdarfp:5578576bc884e31a4f7e117a66a9dad8b13917e6a5262d85ff20f1f69cb4bf49@ec2-52-205-45-219.compute-1.amazonaws.com:5432/db5ktai215krcv"""
+    engine = create_engine(url, echo=False)
+    data = pd.read_sql_query("SELECT * FROM Scraping_inmob", con=engine)
+    data = transform_df(data)
+    col1, col2 = st.beta_columns((0.65, 1))
+    placeholder = st.empty()
+    placeholder2 = st.empty()
+    placeholder3 = st.empty()
+    placeholder4 = st.empty()
+    dist_gamma = stats.gamma.rvs(1, scale=250000, size=2965)
+    dist_norm = np.random.normal(734874, 1250, size=2965)
+    data_hist = data[data["mercado"] == "venta"]
+    data_hist = data_hist[data_hist["valor_peso"]
+                          < 400000000]["valor_peso"] * 0.2
+    fig2 = go.Figure()
+    fig3 = go.Figure()
+    fig4 = go.Figure()
+    fig2.add_trace(go.Histogram(x=dist_norm, name='Dist Ingreso'))
+    # fig2.add_vline(x=data_hist.mean(), line_width=3, line_dash="dash", line_color="darkred")
+    # fig2.add_vline(x=dist_gamma.mean(), line_width=3, line_dash="dash", line_color="darkblue")
+    fig3.add_trace(go.Histogram(x=data_hist, name='Data real'))
+    a = sorted(data_hist)
+    b = sorted(dist_norm)
+    dist_periodo = [(x)/y for x, y in zip(a, b)]
+    dist_periodo = [i for i in dist_periodo if i < 480]
+    fig4.add_trace(go.Histogram(x=dist_periodo, name='Dist periodo'))
+    # Overlay both histograms
+    # fig2.update_layout(barmode='overlay')
+    # Reduce opacity to see both histograms
+    fig2.update_traces(opacity=0.75)
+    #fig2 = px.histogram((data_hist), x='valor_peso', color_discrete_sequence=['indianred'])
+    placeholder2.plotly_chart(fig2, use_container_width=True)
+    placeholder.subheader("µ Capacidad de ahorro: $" +
+                          formatnum(dist_norm.mean()))
+    placeholder4.plotly_chart(fig3, use_container_width=True)
+    placeholder3.subheader("µ Pie vivienda: $" + formatnum(data_hist.mean()))
+    st.plotly_chart(fig4, use_container_width=True)
+    st.subheader("µ Period: " + formatnum(np.array(dist_periodo).mean()))
+    df = pd.DataFrame([a, b, dist_periodo])
+    df2 = df.T
+    st.markdown(get_table_excel_link(df2[df2[2] < 480], "Distribucion"),
+                unsafe_allow_html=True)
+    data_hist = data[data["mercado"] == "venta"]
+    data_hist = data_hist[data_hist["valor_peso"] > 40000000]
+    data_hist = data_hist[data_hist["valor_peso"]
+                          < 1000000000]["valor_peso"] * 0.2
+    fig2 = px.histogram((data_hist), x='valor_peso')
+
+
+def sim_ingreso_clientes():
+    with st.form(key='my_form'):
+        col1, col2 = st.beta_columns(2)
+        clientes1 = col1.number_input("Clientes nuevos año 1", value=1250)
+        clientes2 = col2.number_input("Clientes nuevos año 2", value=6750)
+        clientes3 = col1.number_input("Clientes nuevos año 3", value=17000)
+        clientes4 = col2.number_input("Clientes nuevos año 4", value=17000)
+        clientes5 = col1.number_input("Clientes nuevos año 5", value=8000)
+        col1, col2 = st.beta_columns(2)
+        cap_ahorro = col1.number_input("Capacidad de ahorro", 735000)
+        de_cap = col2.number_input("Desviacion estandar C.A.", 1250)
+        submit_button = st.form_submit_button(label='Actualizar')
+    if submit_button:
+        clientesm1 = clientes1/12
+        clientesm2 = clientes2/12
+        clientesm3 = clientes3/12
+        clientesm4 = clientes4/12
+        clientesm5 = clientes5/12
+        porc_mult = 0.46
+        porc_cp = 0.19
+        porc_lp = 0.35
+        inmob = np.zeros(60)
+        a = np.zeros(60)
+        b = np.zeros(60)
+        c = np.zeros(60)
+        cp = np.zeros(60)
+        lp = np.zeros(60)
+        inmob[0] = int(clientesm1 * porc_mult)
+        cp[0] = int(clientesm1 * porc_cp)
+        lp[0] = int(clientesm1 * porc_lp)
+        for i in range(1, 60):
+            if i < 12:
+                inmob[i] =int( clientesm1 * porc_mult + inmob[i-1])
+                cp[i] = int(clientesm1 * porc_cp + cp[i-1]) 
+                lp[i] = int(clientesm1 * porc_lp + lp[i-1])
+                a[i] = cp[i]
+                b[i] = lp[i]
+                c[i] = inmob[i]
+            elif i < 24:
+                inmob[i] = int(clientesm2 * porc_mult + inmob[i-1]) 
+                cp[i] = int(clientesm2 * porc_cp + cp[i-1])  + clientesm1 * porc_cp*0.8
+                lp[i] = int(clientesm2 * porc_lp + lp[i-1])
+                a[i] = cp[i]
+                b[i] = lp[i] + c[i-12]
+                c[i] = inmob[i] - c[i-12]
+            elif i < 36:
+                inmob[i] = int(clientesm3 * porc_mult + inmob[i-1])
+                cp[i] = int(clientesm3 * porc_cp + cp[i-1]) + clientesm2 * porc_cp*0.8
+                lp[i] = int(clientesm3 * porc_lp + lp[i-1])
+                a[i] = cp[i]
+                b[i] = lp[i]  + c[i-24] + c[i-12]
+                c[i] = inmob[i]  - c[i-24] - c[i-12]
+            elif i < 48:
+                inmob[i] = int(clientesm4 * porc_mult + inmob[i-1])
+                cp[i] = int(clientesm4 * porc_cp + cp[i-1])  - clientesm3 * porc_cp*0.8
+                lp[i] = int(clientesm4 * porc_lp + lp[i-1])
+                a[i] = cp[i] + c[i-36]
+                b[i] = lp[i]   + c[i-24] + c[i-12]
+                c[i] = inmob[i] - c[i-24] - c[i-12] - c[i-36]
+            elif i < 60:
+                inmob[i] = int(clientesm5 * porc_mult + inmob[i-1])
+                cp[i] = int(clientesm5 * porc_cp + cp[i-1]) + clientesm4 * porc_cp*0.8
+                lp[i] = int(clientesm5 * porc_lp + lp[i-1])
+                a[i] = cp[i] + c[i-36]
+                b[i] = lp[i]  + c[i-24] + c[i-12]
+                c[i] = inmob[i] - c[i-24] - c[i-12] - c[i-36] - c[i-48]
+        
+        inmob_res = np.zeros(60)
+        cp_res = np.zeros(60)
+        lp_res = np.zeros(60)
+        a_res = np.zeros(60)
+        b_res = np.zeros(60)
+        c_res = np.zeros(60)
+        for i in range(1, 60):
+            if i<12:
+                pass
+            elif i < 24:
+                cp_res[i] = - clientes1  * porc_cp*0.2
+                b_res[i] = clientes1 * porc_mult
+                c_res[i] = -clientes1 * porc_mult
+            elif i < 36:
+                cp_res[i] = - clientes2  * porc_cp * 0.2
+                b_res[i] = clientes2 * porc_mult
+                c_res[i] = -clientes2 * porc_mult
+            elif i < 48:
+                cp_res[i] = - clientes3  * porc_cp * 0.2
+                a_res[i] = clientes1 * porc_mult * 3
+                b_res[i] = clientes3 * porc_mult - clientes1 * 3 * porc_mult
+                c_res[i] = -clientes3 * porc_mult
+            elif i < 60:
+                cp_res[i] = - clientes4 * porc_mult * 0.2
+                a_res[i] =  clientes2 * 3 *porc_mult
+                b_res[i] = clientes3 * porc_mult  - clientes2 * 3 *porc_mult
+                c_res[i] = -clientes3 * porc_mult
+        st.write(cp-cp_res)
+        inmob[0] = int(clientesm1 * porc_mult)
+        cp[0] = int(clientesm1 * porc_cp)
+        lp[0] = int(clientesm1 * porc_lp)
+        anual = np.zeros((5,4))
+        anual_aum = np.zeros((5,4))
+        for i in range(5):
+            anual[i, 0] = int(sum(a[i*12:(i+1)*12]))
+            anual[i, 1] = int(sum(b[i*12:(i+1)*12]))
+            anual[i, 2] = int((sum(c[i*12:(i+1)*12])))
+        anual[:,3] = anual[:,0] +  anual[:,1] +  anual[:,2]
+        for i in range(5):
+            anual_aum[i, 0] = sum(((a - a_res)*cap_ahorro)[0:(i+1)*12])
+            anual_aum[i, 1] = sum(((b - b_res)*cap_ahorro)[0:(i+1)*12])
+            anual_aum[i, 2] = sum(((c - c_res)*cap_ahorro)[0:(i+1)*12])
+        anual_aum[:,3] = anual_aum[:,0] +  anual_aum[:,1] +  anual_aum[:,2]
+        data = pd.DataFrame([cp, lp, inmob, (cp - cp_res)*cap_ahorro, lp*cap_ahorro,
+                             (inmob - inmob_res)*cap_ahorro])
+        
+        anual[:,3] = anual[:,0] +  anual[:,1] +  anual[:,2]
+        cambios = np.zeros(5)
+        cambios[0] = 0
+        cambios[1] = int(clientes1 * porc_mult)
+        cambios[2] = int(clientes2* porc_mult)
+        cambios[3] = int((clientes3 + clientes1)* porc_mult)
+        cambios[4] = int((clientes2 + clientes4) * porc_mult)
+        retiros = np.zeros(5)
+        retiros[0] = 0
+        retiros[1] = int(clientes1 * porc_cp)
+        retiros[2] = int(clientes2 * porc_cp)
+        retiros[3] = int(clientes3 * porc_cp)
+        retiros[4] = int(clientes4 * porc_cp +clientes1 * porc_cp*porc_mult)
+        clientes_a = np.zeros(5)
+        clientes_b = np.zeros(5)
+        clientes_c = np.zeros(5)
+        clientes_a[0] = int(clientes1 * porc_cp)
+        clientes_b[0] = int(clientes1 * porc_lp)
+        clientes_c[0] = int(clientes1 * porc_mult)
+        
+        clientes_a[1] = int(clientes2 * porc_cp + clientes1 * porc_cp * 0.8)
+        clientes_b[1] = int(clientes1 * porc_lp + clientes2 * porc_lp +  clientes1 * porc_mult)
+        clientes_c[1] = int(clientes2 * porc_mult)
+        
+        clientes_a[2] = int(clientes3 * porc_cp + clientes2 * porc_cp * 0.8 + clientes1 * porc_cp * 0.8)
+        clientes_b[2] = int(clientes_b[1] + clientes2 * porc_mult + clientes3 * porc_lp )
+        clientes_c[2] = int(clientes3 * porc_mult)
+                
+        clientes_a[3] = int(clientes4 * porc_cp +  clientes1 * porc_mult + clientes2 * porc_cp * 0.8 + clientes1 * porc_cp * 0.8 + clientes3 * porc_cp * 0.8)
+        clientes_b[3] = int(clientes_b[2] - clientes1 * porc_mult + clientes3 * porc_mult + clientes4 * porc_lp)
+        clientes_c[3] = int(clientes4 * porc_mult)
+        
+        clientes_a[4] = int(clientes5 * porc_cp +  clientes1 * porc_mult +  clientes2 * porc_mult + clientes4 *0.8* porc_cp + clientes2 * porc_cp * 0.8 + clientes1 * porc_cp * 0.8 + clientes3 * porc_cp * 0.8)
+        clientes_b[4] = int(clientes_b[3] - clientes2 * porc_mult + clientes4 * porc_mult + clientes5 * porc_lp )
+        clientes_c[4] = int(clientes5 * porc_mult)
+        
+        
+        
+        data2 = pd.DataFrame(anual, columns = ["Depositos a", "Depositos b", "Depositos c", "Dep Total"])
+        data3 = pd.DataFrame(anual_aum, columns = ["a AUM", "b AUM", "c Aum", "Aum Total"])
+        data4 = pd.DataFrame([a,b,c])
+        st.write(data4)
+        data = data.T
+        data4 = data4.T
+        data4.columns = ["Fondo A", "Fondo B", "Fondo C"]
+        data3["Cambios"] = cambios
+        data3["Retiros"] = retiros
+        data3["Clientes a"] = clientes_a
+        data3["Clientes b"] = clientes_b
+        data3["Clientes c"] = clientes_c
+        data3["Dep totales"] = data2["Dep Total"]
+        fig = px.line(data4, x=data4.index, y=data4._)
+        st.plotly_chart(fig, use_container_width=True)
+        st.write(data3.T)
+        st.markdown(get_table_excel_link(data3.T, "Estimación demanda"),
+                    unsafe_allow_html=True)
+
+    
+import matplotlib.pyplot as plt
+import numpy as np
+import streamlit as st
+import time
+import statistics
+def simulacion_final():
+    import altair as alt
+    from altair import datum
+    with st.form("Form"):
+        cols = st.columns(3)
+        capital_inicial = cols[0].number_input("Capital inicial", value=1000000, format="%d")
+        cap_ahorro = cols[1].number_input("Capacidad de ahorro", value=750000, format='%d')
+        objetivo = cols[2].number_input("Objetivo", value=40000000, format="%u")
+        
+        button_2 = st.form_submit_button("Comenzar simulacion")
+    my_bar = st.sidebar.progress(0)
+    progress = 0
+    periodo = int(objetivo/cap_ahorro)+1
+    periodo_cambio = int(periodo*3/5)
+    periodo_cambio = int(periodo*3/5)
+    periodo_cambio2 = int(periodo*4/5)
+    l_1=[capital_inicial]
+    l_2=[0]
+    l_3 = []
+    l_4 = []
+    l_5 = []
+    l_6 = []
+    volatilidad = []
+    drawdown = False
+    corte_antes = False
+    cambio = 0
+    lista2=l_1+l_2+l_3
+    chart_row = st.empty()
+    if button_2:
+
+
+        for j in range(1,periodo+4):
+            lista =np.array(l_1+l_3+l_5)
+            if lista[-1] > objetivo:
+                corte_antes = True
+                corte = j
+                periodo = j
+                break
+            else:
+                if j <= 12:
+                    volatilidad.append(0)
+                # elif j < 12 and j >3:
+                    
+                #     volatilidad.append(statistics.stdev((lista[1:j]/lista[0:j-1])))
+                else:
+                    retornos = ((lista[j-11:j]-cap_ahorro)/lista[j-12:j-1])
+                    volatilidad.append(statistics.stdev(retornos))
+                    if statistics.stdev(retornos) > 0.13 and j==periodo_cambio:
+                        drawdown=True
+                        cambio =+ 6
+    
+                if j < periodo_cambio:
+                    sig = abs(np.random.normal(0.04,0.1))
+                    a = np.random.normal(0.018,sig)
+                    
+                elif j < periodo_cambio2 and not drawdown:
+                    sig = abs(np.random.normal(0.03,0.04))
+                    a = np.random.normal(0.01,sig)
+                    
+                    
+                elif j < periodo_cambio2 and drawdown:
+                    sig = abs(np.random.normal(0.04,0.1))
+                    a = np.random.normal(0.018,sig)
+                    
+                    drawdown=False
+                else:
+                    sig = abs(np.random.normal(0.005,0.01))
+                    a = np.random.normal(0,sig)
+                    
+                    
+                if j < (periodo_cambio + cambio):
+                    l_1.append(l_1[j-1]*(1+a) + cap_ahorro )
+                    l_2.append(j)
+    
+                if j >= (periodo_cambio + cambio) and j <periodo_cambio2:
+                    if (periodo_cambio + cambio) == j:
+                        l_3.append(l_1[j-1])
+                        l_4.append(j-1)
+                    l_3.append(l_3[j- periodo_cambio- cambio]*(1+a) + cap_ahorro )
+                    l_4.append(j)
+    
+                if j >= periodo_cambio2:
+                    if periodo_cambio2 == j:
+                        l_5.append(l_3[j - periodo_cambio - cambio])
+                        l_6.append(j-1)
+                    l_5.append(l_5[j- periodo_cambio2]*(1+a) + cap_ahorro )
+                    l_6.append(j)
+                    
+        vol =pd.DataFrame(volatilidad)
+        cols = st.columns(3)
+        col1, col2 = st.columns(2)
+        #st.line_chart(vol)
+        mas_tmpo = False
+        if lista[-1] < objetivo:
+            delta = objetivo-l_5[-1]
+            t_extra = int(delta/cap_ahorro)+1
+            periodo_ant=periodo
+            mas_tmpo=True
+            periodo = periodo + t_extra
+            for i in range(t_extra):
+                l_5.append(l_5[-1]+ cap_ahorro)
+                l_6.append(l_6[-1]+ 1)
+        lista =np.array(l_1+l_3+l_5)
+        col1.subheader("Analista")
+        col2.subheader("Cliente")
+
+        
+        for i in range(periodo+2):
+            time.sleep(0.01)
+            if mas_tmpo==True and i == periodo_ant:
+                st.write(t_extra)
+                col2.error("Mes " + str(i) +": Te faltan " + str(t_extra) + " meses para la meta")
+                time.sleep(3)
+            if corte_antes==True and i == corte:
+                col2.success("Mes " + str(i) +": Felcidiades llegaste antes a la meta")
+                time.sleep(3)
+            if cambio == 6 and i==(periodo_cambio):
+                col1.error("Mes " + str(i) +": Estas en drawdown se recomienda esperar 6 meses más")
+                col2.warning("Mes " + str(i) +": Debes esperar 6 mes mas para cambiarte")
+                time.sleep(3)
+            df = pd.DataFrame()
+            df2 = pd.DataFrame()
+            df3 = pd.DataFrame()
+            df["Mes"]=l_2[0:i+1]
+            df["Valor"]=l_1[0:i+1]
+            
+            if i >= (periodo_cambio+cambio):
+                
+                df2["Mes"]=l_4[0:i-periodo_cambio - cambio+1]
+                df2["Valor"] =l_3[0:i-periodo_cambio - cambio+1]
+                if i >= periodo_cambio2:
+                    df3["Mes"]=l_6[0:i-periodo_cambio2+2]
+                    df3["Valor"] =l_5[0:i-periodo_cambio2+2]
+            df["Fondo"] = ["Fondo Arriesgado"]*len(df)
+            df2["Fondo"] = ["Fondo Intermedio"]*len(df2)
+            df3["Fondo"] = ["Fondo Conservador"]*len(df3)
+            
+            df_f = pd.concat([df,df2, df3])
+            
+            df_f["Ahorro"] = df_f["Mes"]*cap_ahorro + capital_inicial
+            if i == (periodo_cambio+cambio):
+                col2.success("Mes " + str(i) +": Debes cambiarte al Fondo Intermedio")
+                time.sleep(3)
+            if i == periodo_cambio2:
+                col2.success("Mes " + str(i) +": Debes cambiarte al Fondo Conservador")
+                time.sleep(3)
+            fig = alt.Chart(df_f).mark_area(opacity=0.6).encode(
+                    x=alt.X('Mes',
+                            scale=alt.Scale(domain=(0, periodo - 1))
+                            ),
+                    y=alt.X('Valor',
+                            scale=alt.Scale(domain=(0, max(lista)*1.1))
+                            ),
+                  color=alt.Color("Fondo", scale=alt.Scale(scheme='pastel1'))
+              )
+            bar = fig.mark_bar().encode(y='Ahorro')
+          
+          
+            chart_row.altair_chart(bar + fig, use_container_width=True)
+        
+        my_bar.empty()
+        # from st_card import st_card
+        # with cols[0]:
+        #     st_card('Capital proyectado', value=df_f.iloc[-1]["Valor"], show_progress=True)
+        # with cols[1]:
+        #     st_card('Ganancia proyectada', value = df_f.iloc[-1]["Valor"] - df_f.iloc[-1]["Ahorro"],
+        #             delta=round((df_f.iloc[-1]["Valor"]/df_f.iloc[-1]["Ahorro"]-1)*100,0) ,
+        #             use_percentage_delta=True, delta_description='de retorno')
+        # with cols[2]:
+        #     st_card('Meses', value=int(df_f.iloc[-1]["Mes"]), delta=periodo_cambio, delta_description='En el Fondo Arriesgado')
+        # st.write(df_f)
+import streamlit.components.v1 as components
+def candidatos():
+    html_str ="""
+    <!DOCTYPE html>
+    <html lang="es">
+    <head>
+    <title>D3.js - Mapas</title>
+    <meta charset="utf-8"/>
+    <!-- d3 😍-->
+    <script src="https://d3js.org/d3.v7.min.js"></script>
+    <!--nuestro estilo -->
+    <link type="text/css" rel="stylesheet" href="style.css"/>
+    </head>
+    <body>
+    <h1>
+    Mapa por región de votos a Gabriel Boric
+    </h1>
+    <p>
+    <u>Fuente: https://www.futuro.cl/2021/11/elecciones-presidenciales-chile-2021-resultados-region-por-region-en-vivo/</u>
+    </p>
+    <div>
+    <div id="viz1", style = "width:50%">
+    <svg id="geoOrthographic1"></svg>
+    </div>
+    <script>
+    //Nos sirve para poder cargar los archivos y luego ejecutar createMap
+    Promise
+    .all([
+    d3.json('chile.geojson'),
+    d3.json('chile.geojson')
+    ])
+    .then(resolve => {
+    createMap1(resolve[1]);
+    createMap2(resolve[0]);
+    });
+    //creamos el mapa2
+    function createMap1(countries) {
+    const viz1 = d3.select("#viz1");
+    const ancho = viz1.style("width").substring(0, viz1.style("width").length - 2) - 10;
+    console.log("Ancho: " + ancho);
+    //como proyectamos lo que vamos a dibujar
+    //https://github.com/d3/d3-geo/blob/master/README.md#d3-geo
+    //https://github.com/d3/d3-geo-projection#geoConicEqualArea
+    const projection = d3.geoMercator()
+    //que tan cercano
+    .scale(550)
+    // .translate([ancho / 2, 250])
+    //desde el centro, lo podemos mover
+    .center([-55.6, -40]);
+    //definimos nuestro geoPath, lo que queremos dibujar
+    const geoPath = d3.geoPath().projection(projection);
+    //solo datos
+    const poblacion = [
+    {comuna: "Puente Alto", cantidad: 31.07},
+    {comuna: "Río Ibáñez", cantidad: 25},
+    {comuna: "Tocopilla", cantidad: 20.67},
+    {comuna: "Juan Fernández", cantidad: 28.12},
+    {comuna: "Caldera", cantidad: 19.24},
+    {comuna: "Castro", cantidad: 20.43},
+    {comuna: "Cañete", cantidad: 19.09},
+    {comuna: "La Unión", cantidad: 23.05},
+    {comuna: "Iquique", cantidad: 18.27},
+    {comuna: "San Esteban", cantidad: 28.12},
+    {comuna: "Putre", cantidad: 17.79},
+    {comuna: "Río Hurtado", cantidad: 25.92},
+    {comuna: "Torres del Paine", cantidad: 30.64},
+    {comuna: "Carahue", cantidad: 16.58},
+    {comuna: "Pelluhue", cantidad: 19.58},
+    {comuna: "Malloa", cantidad: 24.14},
+    ];
+    //geoArea nos da el area dado un GeoJson
+    //extent nos devuelve el minimo y maximo valor
+    const realFeatureSize = d3.extent(poblacion, function (d) {
+    return +d.cantidad
+    });
+    console.log("Mínimo y Máximo: ");
+    console.log(realFeatureSize);
+    //hacemos un escala para los colores
+    //veamos cual es el rango
+    //https://github.com/d3/d3-scale#scaleQuantize
+    const newFeatureColor = d3.scaleQuantize()
+    .domain(realFeatureSize)
+    .range(['#fee0d2','#fc9272','#de2d26']);
+    //Nada nuevo, aqui hacemos el dibujo
+    d3.select("#geoOrthographic1").selectAll("path")
+    .data(countries.features).enter()
+    .append("path")
+    .attr("d", geoPath)
+    .attr("id", d => d.id)
+    .attr("class", "countries")
+    .style("fill", d => {
+    //comentar la linea de abajo para ver que hace el resto
+    //return "grey"
+    console.log(d.properties.NOM_COM);
+    let poblacionEncontrada;
+    poblacion.forEach(function (e) {
+    console.log(d.properties.NOM_COM);
+    console.log(e.comuna);
+    if (e.comuna === d.properties.NOM_COM) {
+    poblacionEncontrada = e.cantidad;
+    }
+    });
+    return newFeatureColor(poblacionEncontrada)
+    })
+    .style("stroke", d => d3.rgb(newFeatureColor(d3.geoArea(d))).darker());
+    // //generamos la "grilla"
+    // const graticule = d3.geoGraticule();
+    //
+    // //dibujamos la grilla
+    // d3.select("#geoOrthographic1").insert("path", "path.countries")
+    // .datum(graticule)
+    // .attr("class", "graticule line")
+    // .attr("d", geoPath);
+    const zoom = d3.zoom()
+    .scaleExtent([1, 8])
+    .on('zoom', function (event) {
+    d3.select("#geoOrthographic1").selectAll('path')
+    .attr('transform', event.transform);
+    });
+    d3.select("#geoOrthographic1").call(zoom);
+    }
+    //creamos el mapa
+    //Nos sirve para poder cargar los archivos y luego ejecutar createMap
+    //creamos el mapa2
+    function createMap2(countries) {
+    const viz1 = d3.select("#viz2");
+    const ancho = viz1.style("width").substring(0, viz1.style("width").length - 2) - 10;
+    console.log("Ancho: " + ancho);
+    //como proyectamos lo que vamos a dibujar
+    //https://github.com/d3/d3-geo/blob/master/README.md#d3-geo
+    //https://github.com/d3/d3-geo-projection#geoConicEqualArea
+    const projection = d3.geoMercator()
+    //que tan cercano
+    .scale(550)
+    // .translate([ancho / 2, 250])
+    //desde el centro, lo podemos mover
+    .center([-55.6, -40]);
+    //definimos nuestro geoPath, lo que queremos dibujar
+    const geoPath = d3.geoPath().projection(projection);
+    //solo datos
+    const poblacion = [
+    {comuna: "Puente Alto", cantidad: 31.07},
+    {comuna: "Río Ibáñez", cantidad: 25},
+    {comuna: "Tocopilla", cantidad: 20.67},
+    {comuna: "Juan Fernández", cantidad: 28.12},
+    {comuna: "Caldera", cantidad: 19.24},
+    {comuna: "Castro", cantidad: 20.43},
+    {comuna: "Cañete", cantidad: 19.09},
+    {comuna: "La Unión", cantidad: 23.05},
+    {comuna: "Iquique", cantidad: 18.27},
+    {comuna: "San Esteban", cantidad: 28.12},
+    {comuna: "Putre", cantidad: 17.79},
+    {comuna: "Río Hurtado", cantidad: 25.92},
+    {comuna: "Torres del Paine", cantidad: 30.64},
+    {comuna: "Carahue", cantidad: 16.58},
+    {comuna: "Pelluhue", cantidad: 19.58},
+    {comuna: "Malloa", cantidad: 24.14},
+    ];
+    //geoArea nos da el area dado un GeoJson
+    //extent nos devuelve el minimo y maximo valor
+    const realFeatureSize = d3.extent(poblacion, function (d) {
+    return +d.cantidad
+    });
+    console.log("Mínimo y Máximo: ");
+    console.log(realFeatureSize);
+    //hacemos un escala para los colores
+    //veamos cual es el rango
+    //https://github.com/d3/d3-scale#scaleQuantize
+    const newFeatureColor = d3.scaleQuantize()
+    .domain(realFeatureSize)
+    .range(['#fee0d2','#fc9272','#de2d26']);
+    //Nada nuevo, aqui hacemos el dibujo
+    d3.select("#geoOrthographic2").selectAll("path")
+    .data(countries.features).enter()
+    .append("path")
+    .attr("d", geoPath)
+    .attr("id", d => d.id)
+    .attr("class", "countries")
+    .style("fill", d => {
+    //comentar la linea de abajo para ver que hace el resto
+    //return "grey"
+    console.log(d.properties.NOM_COM);
+    let poblacionEncontrada;
+    poblacion.forEach(function (e) {
+    console.log(d.properties.NOM_COM);
+    console.log(e.comuna);
+    if (e.comuna === d.properties.NOM_COM) {
+    poblacionEncontrada = e.cantidad;
+    }
+    });
+    return newFeatureColor(poblacionEncontrada)
+    })
+    .style("stroke", d => d3.rgb(newFeatureColor(d3.geoArea(d))).darker());
+    // //generamos la "grilla"
+    // const graticule = d3.geoGraticule();
+    //
+    // //dibujamos la grilla
+    // d3.select("#geoOrthographic1").insert("path", "path.countries")
+    // .datum(graticule)
+    // .attr("class", "graticule line")
+    // .attr("d", geoPath);
+    const zoom = d3.zoom()
+    .scaleExtent([1, 8])
+    .on('zoom', function (event) {
+    d3.select("#geoOrthographic2").selectAll('path')
+    .attr('transform', event.transform);
+    });
+    d3.select("#geoOrthographic2").call(zoom);
+    }
+    //creamos el mapa1
+    </script>
+    </div>
+    </body>
+    </html>
+    """
+    components.html(html_str, height=1000)
+# def simulacion_final():
+#     import altair as alt
+#     from altair import datum
+#     with st.form("Form"):
+#         cols = st.beta_columns(3)
+#         capital_inicial = cols[0].number_input("Objetivo", value=1000000, format="%d")
+#         cap_ahorro = cols[1].number_input("Capacidad de ahorro", value=750000, format='%d')
+#         objetivo = cols[2].number_input("Objetivo", value=40000000, format="%u")
+        
+#         button_2 = st.form_submit_button("Comenzar simulacion")
+#     l_1=[capital_inicial]
+#     l_2=[0]
+#     l_3=[np.nan]
+#     l_4=[np.nan]
+#     text=[]
+
+
+
+#     chart_row = st.empty()
+#     if button_2:
+#         my_bar = st.sidebar.progress(0)
+#         progress = 0
+#         periodo = int(objetivo/cap_ahorro)+1
+#         periodo_cambio = int(periodo*3/5)
+#         periodo_cambio2 = int(periodo*4/5)
+
+#         for j in range(1,periodo):
+
+#             a = np.random.normal(0.03,0.10)
+#             if j <periodo_cambio:
+#                 l_1.append(l_1[j-1]*(1+a) + cap_ahorro )
+#                 l_3.append(np.nan)
+#                 l_4.append(np.nan)
+#                 text.append("")
+#             elif j ==periodo_cambio:
+#                 l_1.append(l_1[j-1]*(1+a) + cap_ahorro )
+#                 l_3.append(l_1[j-1]*(1+a) + cap_ahorro )
+#                 l_4.append(np.nan)
+#                 text.append("")
+#             elif j > periodo_cambio and j < periodo_cambio2 :
+#                 a = a/3
+#                 l_1.append(np.nan)
+#                 l_3.append(l_3[j-1]*(1+a) + cap_ahorro)
+#                 l_4.append(np.nan)
+#                 text.append("")
+#             elif j == periodo_cambio2:
+#                 a = a/3
+#                 l_1.append(np.nan)
+#                 l_3.append(l_3[j-1]*(1+a) + cap_ahorro)
+#                 l_4.append(l_3[j-1]*(1+a) + cap_ahorro)
+#                 text.append("")
+#             else:
+#                 a = a/5
+#                 l_1.append(np.nan)
+#                 l_3.append(np.nan)
+#                 l_4.append(l_4[j-1]*(1+a) + cap_ahorro)
+#                 text.append("")
+#             l_2.append(j)
+#         drawd =[]
+#         for k in range(2,len(l_1)):
+            
+#             if (l_1[k] - l_1[k-1])/(l_1[k]) < -0.01:
+#                 periodo_cambio1_2 = periodo_cambio + 1
+#                 drawd.append(k)
+#             else:
+#                 periodo_cambio1_2=periodo_cambio
+        
+#         for i in range(periodo):
+#             progress = (i/periodo)
+#             my_bar = my_bar.progress(progress)
+#             time.sleep(0.001)
+#             df = pd.DataFrame()
+#             df["Mes"]=l_2[0:i+1]+l_2[0:i+1] +  l_2[0:i+1]
+#             df["Valor"]=l_1[0:i+1]+l_3[0:i+1] + l_4[0:i+1]
+#             if i <= periodo_cambio:
+#                 df["Fondo"]=["Fondo Arriesgado"]*len(df)
+#                 if i in drawd:
+#                         st.warning("Drawdown")
+#                         time.sleep(2)
+#             elif i > periodo_cambio and  i <= periodo_cambio2:
+#                 df["Fondo"]=["Fondo Arriesgado"]*(periodo_cambio+1) + ["Fondo Intermedio"]*(i-periodo_cambio) + ["Fondo Arriesgado"]*(periodo_cambio + 1) + ["Fondo Intermedio"]*(i-periodo_cambio) + ["Fondo Arriesgado"]*(periodo_cambio+1)  + ["Fondo Intermedio"]*(i-periodo_cambio)
+#             else:
+#                 a = ["Fondo Arriesgado"] * periodo_cambio
+#                 b = ["Fondo Intermedio"] * (periodo_cambio2 - periodo_cambio-1)
+#                 c = ["Fondo Conservador"] * (i-periodo_cambio2)
+#                 d = ["Fondo Arriesgado"] * (periodo_cambio+2)
+#                 e = ["Fondo Intermedio"] * (periodo_cambio2 - (periodo_cambio+2))
+#                 f = ["Fondo Conservador"]*(i-periodo_cambio2+2)
+#                 df["Fondo"]= a +  b + c + d + e + f + d + e + f
+#             df = df.dropna()
+            
+                
+                
+                
+#             if i == periodo_cambio:
+#                 placeholder=st.empty()
+#                 placeholder.info("Debes cambiarte al fondo intermedio")
+#                 time.sleep(3)
+#                 placeholder.empty()
+#             if i == periodo_cambio2:
+#                 placeholder=st.empty()
+#                 placeholder.info("Debes cambiarte al fondo conservador")
+#                 time.sleep(3)
+#                 placeholder.empty()
+#             # df=df.dropna()
+            
+#             fig = alt.Chart(df).mark_area(opacity=0.6).encode(
+#                     x=alt.X('Mes',
+#                             scale=alt.Scale(domain=(0, periodo - 1))
+#                             ),
+#                     y=alt.X('Valor',
+#                             scale=alt.Scale(domain=(0, max(l_1+l_3+l_4)*1.1))
+#                             ),
+#                   color=alt.Color("Fondo", scale=alt.Scale(scheme='category20'))
+#               )
+#             if i > periodo_cambio and i <= periodo_cambio2:
+#                 df["Cambio"]="Cambiate al fondo intermedio"
+#                 text = (
+#                     alt.Chart(df[df["Mes"]==periodo_cambio])
+#                     .mark_text(dy=-25, color="black")
+#                     .encode(x=alt.X("Mes"), y=alt.Y("Valor"), text="Cambio")
+#                 )
+            
+#                 chart_row.altair_chart(fig + text, use_container_width=True)
+#             if i > periodo_cambio2:
+#                 df["Cambio"]="Cambiate al fondo conservador"
+#                 text = (
+#                     alt.Chart(df[df["Mes"]==periodo_cambio2])
+#                     .mark_text(dy=-25, color="black")
+#                     .encode(x=alt.X("Mes"), y=alt.Y("Valor"), text="Cambio")
+#                 )
+#                 chart_row.altair_chart(fig, use_container_width=True)
+#             else:
+#                 chart_row.altair_chart(fig, use_container_width=True)
+#         cols = st.columns(3)
+#         ganancia=value=l_3[-1] - cap_ahorro * l_2[-1]
+#         my_bar.empty()
+#         # with cols[0]:
+#         #     st_card('Capital proyectado', value=l_3[-1], show_progress=True)
+#         # with cols[1]:
+#         #     st_card('Ganancia proyectada', value=ganancia, delta=round(ganancia/(cap_ahorro * l_2[-1])*100,0) ,
+#         #             use_percentage_delta=True, delta_description='de retorno')
+#         # with cols[2]:
+#         #     st_card('Meses', value=l_2[-1], delta=periodo_cambio, delta_description='En el Fondo Arriesgado')
+#         st.write(df)
+def prototipo_simulacion():
+    # import streamlit as st
+    # import time
+    # import numpy as np
+    # progress_bar = st.sidebar.progress(0)
+    # status_text = st.sidebar.empty()
+    # last_rows = np.random.randn(1, 1)
+    # chart = st.line_chart(last_rows)
+    # for i in range(1, 101):
+    #     new_rows = last_rows[-1, :] + np.random.randn(50, 1).cumsum(axis=0)
+    #     status_text.text("%i%% Complete" % i)
+    #     chart.add_rows(new_rows)
+    #     progress_bar.progress(i)
+    #     last_rows = new_rows
+    #     time.sleep(0.001)
+        
+    # progress_bar.empty()
+    # # Streamlit widgets automatically run the script from top to bottom. Since
+    # # this button is not connected to any other logic, it just causes a plain
+    # # rerun.
+    # st.button("Re-run")
+    # import numpy as np
+    # import matplotlib.pyplot as plt
+    # import matplotlib.animation as animation
+    # import streamlit as st
+    # import streamlit.components.v1 as components
+    
+    # def update_line(num, data, line):
+    #     line.set_data(data[..., :num])
+    #     return line,
+    
+    # fig = plt.figure()
+    
+    # # Fixing random state for reproducibility
+    # np.random.seed(19680801)
+    
+    # data = np.random.rand(2, 25)
+    # l, = plt.plot([], [], 'r-')
+    # plt.xlim(0, 1)
+    # plt.ylim(0, 1)
+    # plt.xlabel('x')
+    # plt.title('test')
+    # line_ani = animation.FuncAnimation(fig, update_line, 25, fargs=(data, l), interval=50, blit=True)
+    
+    # st.title("Embed Matplotlib animation in Streamlit")
+    # st.markdown("https://matplotlib.org/gallery/animation/basic_example.html")
+    # components.html(line_ani.to_jshtml(), height=1000)
+    # import matplotlib.pyplot as plt
+    # import numpy as np
+    # import streamlit as st
+    # import time
+    
+    # fig, ax = plt.subplots()
+    
+    # max_x = 5
+    # max_rand = 10
+    
+    # x = np.arange(0, max_x)
+    # ax.set_ylim(0, max_rand)
+    # line, = ax.plot(x, np.random.randint(0, max_rand, max_x))
+    # the_plot = st.pyplot(plt)
+    
+    # def init():  # give a clean slate to start
+    #     line.set_ydata([np.nan] * len(x))
+    
+    # def animate(i):  # update the y values (every 1000ms)
+    #     line.set_ydata(np.random.randint(0, max_rand, max_x))
+    #     the_plot.pyplot(plt)
+    
+    # init()
+    # for i in range(100):
+    #     animate(i)
+    #     time.sleep(0.1)
+    import plotly.express as px
+    from datetime import date
+    from datetime import timedelta
+    import numpy as np
+    df = px.data.gapminder()
+    cap_ahorro = 750000
+    Data = pd.DataFrame()
+    today =date.today()
+    l=[]
+    l2=[]
+    l3=[]
+    l4=[]
+    for i in range(53):
+        
+        for j in range(53):
+            l.append(i)
+            l2.append(j)
+            if j<=i:
+                l3.append(cap_ahorro*j)
+            else:
+                l3.append(0)
+            if j<40:
+                l4.append("Arriesgado")
+            elif j<47:
+                l4.append("Intermedio")
+            else:
+                l4.append("Conservador")
+    l5 = []     
+    l6 = []
+    Data["Mes"] = l
+    Data["Ahorro"] = l2      
+    Data["Total"] = l3   
+    Data["Fondo"] = l4
+    fig = px.bar(Data, x="Ahorro", y="Total", color="Fondo",
+      animation_frame="Mes")
+    fig.update_yaxes(range=[0, 50000000])
+    fig.update_xaxes(range=[0, 53])
+    st.plotly_chart(fig)
+    button = st.button("Activar")
+    if button:
+        chart_data = pd.DataFrame()
+        chart = st.area_chart(chart_data)
+        for i in range(100):
+            if i<70:
+                chart.add_rows(pd.DataFrame([[i*cap_ahorro,0, 0]], columns=['Fondo 1', 'Fondo 2', 'Fondo 3']))
+            elif i==70:
+                chart.add_rows(pd.DataFrame([[i*cap_ahorro,i*cap_ahorro,0]], columns=['Fondo 1', 'Fondo 2', 'Fondo 3']))
+                st.success("Debes cambiarte al fondo intermedio")
+            elif i<85:
+                chart.add_rows(pd.DataFrame([[0,i*cap_ahorro,0]], columns=['Fondo 1', 'Fondo 2', 'Fondo 3']))
+            elif i==85:
+                chart.add_rows(pd.DataFrame([[0,i*cap_ahorro,i*cap_ahorro]], columns=['Fondo 1', 'Fondo 2', 'Fondo 3']))
+                st.success("Debes cambiarte al fondo arriesgado")
+            else:
+                chart.add_rows(pd.DataFrame([[0,0, i*cap_ahorro]], columns=['Fondo 1', 'Fondo 2', 'Fondo 3']))
+            time.sleep(0.1)
+
+    cap_ahorro = 750000
+    from plotly.subplots import make_subplots
+    import plotly.graph_objects as go
+    import numpy as np
+    import plotly.graph_objects as go
+    Frames=[]
+    Frames2 =[]
+    
+    l_1=[]
+    l_2=[]
+    l_3=[]
+    text=[]
+    fig = make_subplots(rows=1, cols=1, subplot_titles = ('Subplot (1,1)'))
+    for i in range(53):
+        if i <40:
+            l_1.append(cap_ahorro*i)
+            l_3.append(np.nan)
+            text.append("")
+        elif i ==40:
+            l_1.append(cap_ahorro*i)
+            l_3.append(cap_ahorro*i)
+            text.append("")
+        else:
+            l_1.append(np.nan)
+            l_3.append(cap_ahorro*i)
+            text.append("")
+        l_2.append(i)
+
+        Frames.append(go.Scatter(x=l_2, y=l_1,
+                                 mode="lines+text",
+                                 text=text,
+                                 textposition="bottom center",
+                                 textsrc="bottom center",
+            textfont=dict(
+                family="sans serif",
+                size=10,
+                color="Black"
+            ), fill='tozeroy'))
+        Frames2.append(go.Scatter(x=l_2, y=l_3, fill='tozeroy'))
+        go.Annotations
+    Frames_finales=[Frames, Frames2]
+    fig.add_trace(go.Scatter(
+          x= [0],
+          y= [0],
+          mode = 'lines',
+          hoverinfo='name',
+          legendgroup= 'Fondo Arriesgado',
+          line_color= 'rgb(255, 79, 38)',
+          name= 'Fondo Arriesgado',
+          showlegend= True), row=1, col=1)  
+    fig.add_trace(go.Scatter(
+          x= [0],
+          y= [0],
+          mode = 'lines',
+          hoverinfo='name',
+          legendgroup= 'Fondo Conservador',
+          line_color= 'rgb(79, 38, 255)',
+          name= 'Fondo Conservador',
+          showlegend= True), row=1, col=1)
+    frames =[dict(name = k,
+                  data = [Frames[k],Frames2[k]],
+                  traces=[0,1]) for k in range(53)
+                      ]   
+    updatemenus=[dict(
+                type="buttons",
+                buttons=[dict(label="Play",
+                              method="animate",
+                              args=[None])])]
+    fig.update_yaxes(range=[0, 50000000])
+    fig.update_xaxes(range=[0, 53])
+    annotations1 = [dict(
+            x=40,
+            y=40*cap_ahorro,
+            text=text,
+            xanchor='auto',
+            yanchor='bottom',
+            showarrow=False,
+        )]
+
+    fig.update(frames=frames),
+    fig.update_layout(updatemenus=updatemenus)
+    
+    st.plotly_chart(fig)
+    import altair as alt
+    from altair import datum
+    l_1=[]
+    l_2=[]
+    l_3=[]
+    for i in range(51):
+        if i <41:
+            l_1.append(cap_ahorro*i)
+            l_3.append(np.nan)
+            text.append("")
+        elif i ==41:
+            l_1.append(cap_ahorro*i)
+            l_3.append(cap_ahorro*i)
+            text.append("")
+        else:
+            l_1.append(np.nan)
+            l_3.append(cap_ahorro*i)
+            text.append("")
+        l_2.append(i)
+    chart_row = st.empty()
+    button_2 = st.button("Comenzar simulació")
+    if button_2:
+        for i in range(51):
+            time.sleep(0.1)
+            df = pd.DataFrame()
+            
+            df["Mes"]=l_2[0:i+1]+l_2[0:i+1]
+            print(df["Mes"])
+            df["Valor"]=l_1[0:i+1]+l_3[0:i+1]
+            if i <= 41:
+                df["Fondo"]=["Fondo Arriesgado"]*len(df)
+            else:
+                df["Fondo"]=["Fondo Arriesgado"]*41 + ["Fondo Conservador"]*(i-41) + ["Fondo Arriesgado"]*43 + ["Fondo Conservador"]*(i-41)
+            if i == 41:
+                st.success("Debes cambiarte al fondo conservador")
+                time.sleep(1)
+            df=df.dropna()
+            fig = alt.Chart(df).mark_area(opacity=0.6).encode(
+                    x=alt.X('Mes',
+                            scale=alt.Scale(domain=(0, 50))
+                            ),
+                    y=alt.X('Valor',
+                            scale=alt.Scale(domain=(0, max(l_1+l_3)*1.1))
+                            ),
+                  color=alt.Color("Fondo", scale=alt.Scale(scheme='category20'))
+              )
+            if i > 41:
+                df["Cambio"]="Cambiate al fondo conservador"
+                text = (
+                    alt.Chart(df[df["Mes"]==41])
+                    .mark_text(dy=-25, color="black")
+                    .encode(x=alt.X("Mes"), y=alt.Y("Valor"), text="Cambio")
+                )
+
+                chart_row.altair_chart(fig + text, use_container_width=True)
+            else:
+                chart_row.altair_chart(fig, use_container_width=True)

apps/streamlit_larra.py

@@ -1,3 +1,131 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:426bf14fd18c7d386f1d0cb546bb956b295ac478fcce12cd3fabf5571930611e
-size 4020
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Nov  2 10:06:46 2021
+
+@author: benjaminull
+"""
+
+
+import pybase64 as base64
+import io
+import streamlit as st
+from plotly import graph_objs as go
+
+
+def formatnum_0(numero):
+    '''
+    Esta función permite dar formato a los montos de saldo y valor cuota en 
+    las cartolas.
+    '''
+    return '{:,.0f}'.format(numero).replace(",", "@").replace(".", ",").replace("@", ".")
+
+
+def formatnum_2(numero):
+    return '{:,.2f}'.format(numero).replace(",", "@").replace(".", ",").replace("@", ".")
+
+
+def macro_plot(col, data, color, prefijo, ancho, largo):
+    fig = go.Figure()
+    close_ = go.Scatter(x=data.index, y=data['Close'], name="stock_close",
+                        line=dict(color=color), fill='tonexty')
+    fig.add_trace(close_)
+    fig.layout.update(title_text="", xaxis_rangeslider_visible=True,
+                      width=ancho, height=largo, margin_b=0, margin_t=0,
+                      margin_r=0, margin_l=0)
+    fig.update_yaxes(range=[min(data['Close'])/1.05,
+                            max(data['Close'])*1.05], tickprefix=prefijo)
+    col.plotly_chart(fig, use_container_width=True)
+
+
+def get_table_excel_link(df, name):
+    towrite = io.BytesIO()
+    downloaded_file = df.to_excel(towrite, encoding='utf-8', index=False,
+                                  header=True)
+    towrite.seek(0)  # reset pointer
+    file_name = 'Data' + name + '.xlsx'
+    style = 'style="color:black;text-decoration: none; font-size:18px;"'
+    name_mark = "Descargar " + name + ".xlsx"
+    b64 = base64.b64encode(towrite.read()).decode()  # some strings
+    linko= f'<center><a href="data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64,{b64}" '+style+'download="'+file_name+'"><button>'+name_mark+'</button></a></center>'
+    return linko
+
+
+def selectbox_larra(label, options):
+    var = st.selectbox(label, sorted(list(set(options))))
+    return var
+
+def style_table():
+    style_table = """
+                <style>
+                tbody tr:hover {
+                           color:#BB1114;}
+                thead {
+                      background-color:#BB1114 ;
+                      color: #E8E8E8;
+                    }
+                tbody tr:nth-child(odd) {
+                      background-color: #fff;
+                    }
+                    tbody tr:nth-child(even) {
+                      background-color: #eee;
+                    }
+                tbody tr:nth-child(odd)
+                stTable {
+                    border-collapse: collapse;
+                    margin: 25px 0;
+                    font-size: 0.9em;
+                    min-width: 400px;
+                    box-shadow: 0 0 20px rgba(0, 0, 0, 0.15);
+                    }
+                </style>
+                """
+    st.markdown(style_table, unsafe_allow_html=True)
+
+
+
+def button_style():
+    style_button = """
+        <style>
+          button {
+            display: inline-block;
+            background-color: #e8e8e8;
+            border-radius: 15px;
+            border: 4px  #cccccc;
+            color: #4a4a4a;
+            text-align: center;
+            font-size: 18px;
+            padding: 2px;
+            width: 300px;
+            transition: all 0.5s;
+            cursor: pointer;
+            margin: 5px;
+          }
+          button span {
+            cursor: pointer;
+            display: inline-block;
+            position: relative;
+            transition: 0.5s;
+          }
+          button span:after {
+            content: '\00bb';
+            position: absolute;
+            opacity: 0;
+            top: 0;
+            right: -20px;
+            transition: 0.5s;
+          }
+          button:hover {
+            background-color: #bb1114;
+            color:#e8e8e8;
+          }
+          button:hover span {
+            padding-right: 25px;
+          }
+          button:hover span:after {
+            opacity: 1;
+            right: 0;
+      }
+    </style>
+    """
+    st.markdown(style_button, unsafe_allow_html=True)