Ejemplo n.º 1
0
 def load_agg_data(records: tp.List[dict]) -> dpv.PivotTable:
     n = sum(len(col) for col in records[0])
     return dpv.PivotTable(
         id=str(pd.Timestamp.now()),
         data=records,
         unusedOrientationCutoff=n + 1,
     )
def pivot_table(app_option):
    df = get_df(app_option)

    p = pd.pivot_table(
        df,
        index=[
            "load_balance",
            "cost_mix",
            "job_type",
            "cluster_name",
        ],
        values=[
            "latency",
            "gb_price",
        ],
        aggfunc={
            "latency": np.mean,
            "gb_price": np.mean,
        },
    )
    p = p.reset_index()
    vals = list(p.values.tolist())
    cols = list(p.columns)
    flat_p = vals
    flat_p.insert(0, cols)
    pivot = dash_pivottable.PivotTable(data=flat_p,
                                       cols=["load_balance"],
                                       rows=["cost_mix"],
                                       vals=["gb_price"])
    return [html.Div([pivot])]
Ejemplo n.º 3
0
def show_edd(contents, filename):
    if contents is not None:
        df = upload_2_df(contents, filename)
        data = df.to_dict('records')
        pivot = dash_pivottable.PivotTable(id='table',
                                           data=data,
                                           menuLimit=5000)
        return pivot
Ejemplo n.º 4
0
def Excelsheet_ui(df):
    Excelsheet = [
        html.H5("Create Excelsheet for data"),
        dpivot.PivotTable(id='table',
                          data=df.to_dict('records'),
                          cols=[i for i in df.columns],
                          colOrder="key_a_to_z",
                          rows=[],
                          rowOrder="key_a_to_z",
                          rendererName="Grouped Column Chart",
                          aggregatorName="Average",
                          vals=[],
                          valueFilter={}),
    ]
    return Excelsheet
Ejemplo n.º 5
0
def update_data(start_date, end_date):
    start_date = datetime.date(int(start_date.split('-')[0]), int(start_date.split('-')[1]), int(start_date.split('-')[2]))
    end_date = datetime.date(int(end_date.split('-')[0]), int(end_date.split('-')[1]), int(end_date.split('-')[2]))
    df2 = df[(df.DREG >= start_date) & (df.DREG <= end_date)]
    data2 = [df2.columns.tolist()] + df2.values.tolist()
    idd = str(random.randint(10000, 99999))
    layout = [
        dash_pivottable.PivotTable(
            id=idd,
            data=data2,
            cols=['SEGMENT'],
            rows=['TYPEOFCLIENTS'],
            vals=['CNT']
        )]

    return layout
Ejemplo n.º 6
0
    def show_pivottable(self, team=0):
        tm = self.projects[team]
        cycle_names = [s for s in tm.workflow]

        # Create a new data frame to normalize data
        cycle_data = tm.cycle_data.copy()
        # Convert to date only (insted of date time)
        cycle_data[cycle_names] = (
            cycle_data[cycle_names].astype("<M8[D]").astype("<M8[ns]"))

        # Need to convert to list since this is what the
        data = cycle_data.values.tolist()
        data.insert(0, cycle_data.columns.to_list())
        layout = html.Div(children=[
            html.H1(children="Pivot Table"),
            html.Div(dash_pivottable.PivotTable(data=data)),
        ])
        return layout
Ejemplo n.º 7
0
    def time_series_pivot_table_preset_btn_clicked(*inputs_ignored):
        """Make a new pivot table according to the most recently clicked button.

        We can't have a callback function for each button because
        https://dash.plotly.com/callback-gotchas "A component/property pair can only be the Output
        of one callback"."""

        # From https://dash.plotly.com/advanced-callbacks "Determining which Input has fired"
        ctx = dash.callback_context
        if not ctx.triggered:
            # Use the first as the default when page is loaded.
            preset = more_itertools.first(TimeSeriesPivotTablePreset)
        else:
            preset = TimeSeriesPivotTablePreset.get_by_btn_id(
                ctx.triggered[0]["prop_id"].split(".")[0])

        # Each PivotTable needs a unique id as a work around for
        # https://github.com/plotly/dash-pivottable/issues/10
        return dash_pivottable.PivotTable(
            id=preset.tbl_id,
            data=per_timeseries_stats.pivottable_data,
            **preset.pivot_table_parameters,
        )
Ejemplo n.º 8
0
def generate_table(dframe: pd.DataFrame,
                   **options: str) -> dash_pivottable.PivotTable:
    return dash_pivottable.PivotTable(data=[dframe.columns.to_list()] +
                                      dframe.values.tolist(),
                                      **options)
Ejemplo n.º 9
0
from django_plotly_dash import DjangoDash
from .middleware import get_current_dataset
import pandas as pd

dset = get_current_dataset()
sd = pd.read_excel(dset, sheet_name=None, header=None)
hd = sd['Index'][[1, 4]].loc[3:].values.tolist()
dini = {k[0].strip(): k[1].split('%') for k in hd}
sd.pop('Index', None)
pv = []
for k in sd:
    pv.append(
        dbc.Alert('Dataset: %s' % k,
                  style={
                      "height": "35px",
                      "padding-top": "2px",
                      "margin-top": "3px",
                      "margin-bottom": "1px",
                      "font-weight": "bold"
                  }))
    pv.append(
        dash_pivottable.PivotTable(data=sd[k].values.tolist(),
                                   rendererName=dini[k][0],
                                   cols=dini[k][1].split('&'),
                                   rows=dini[k][2].split('&'),
                                   aggregatorName=dini[k][3],
                                   vals=dini[k][4].split('&'),
                                   unusedOrientationCutoff='Infinity'))
    #pv.append(html.Hr())
app = DjangoDash('NomaDash')  # replaces dash.Dash
app.layout = html.Div(pv)
Ejemplo n.º 10
0
    )


app = dash.Dash(__name__)
app.title = "Dash Pivottable"
server = app.server

app.layout = html.Div(
    [
        Header("Dash Pivottable", app),
        dash_pivottable.PivotTable(
            id="table",
            data=data,
            cols=["Day of Week"],
            colOrder="key_a_to_z",
            rows=["Party Size"],
            rowOrder="key_a_to_z",
            rendererName="Grouped Column Chart",
            aggregatorName="Average",
            vals=["Total Bill"],
            valueFilter={"Day of Week": {"Thursday": False}},
        ),
        html.Div(id="output"),
    ]
)


@app.callback(
    Output("output", "children"),
    [
        Input("table", "cols"),
        Input("table", "rows"),
Ejemplo n.º 11
0
cursor = graph.run("MATCH (a:EfigaRecord) RETURN a")
rs = []
for record in cursor:
    rs.append(dict(record.values(0)[0]))

df = pd.DataFrame(rs)

#pivot_ui(df,outfile_path="pivottablejs.html")

app.title = 'Efiga Data'
app.layout = html.Div([
    dash_pivottable.PivotTable(id='table',
                               data=df.to_dict('records'),
                               cols=[],
                               colOrder="key_a_to_z",
                               rows=[],
                               rowOrder="key_a_to_z",
                               rendererName="Table",
                               aggregatorName="Count",
                               vals=[],
                               valueFilter={}),
    dcc.Markdown(id='output'),
    dcc.Markdown(id='output')
])


@app.callback(Output('output', 'children'), [
    Input('table', 'cols'),
    Input('table', 'rows'),
    Input('table', 'rowOrder'),
    Input('table', 'colOrder'),
    Input('table', 'aggregatorName'),
Ejemplo n.º 12
0
import dash_html_components as html

app = dash.Dash(__name__)

app.scripts.config.serve_locally = True
app.css.config.serve_locally = True

app.title = 'My Dash example'
app.layout = html.Div([
    dash_pivottable.PivotTable(
        id='table',
        data=data,
        cols=['Day of Week'],
        colOrder="key_a_to_z",
        rows=['Party Size'],
        rowOrder="key_a_to_z",
        rendererName="Grouped Column Chart",
        aggregatorName="Average",
        vals=["Total Bill"],
        valueFilter={'Day of Week': {
            'Thursday': False
        }}),
    dcc.Markdown(id='output')
])


@app.callback(Output('output', 'children'), [
    Input('table', 'cols'),
    Input('table', 'rows'),
    Input('table', 'rowOrder'),
    Input('table', 'colOrder'),
Ejemplo n.º 13
0
 dash_pivottable.PivotTable(
     id='table',
     data=data,
     cols=['Day of Week'],
     colOrder="key_a_to_z",
     rows=['Party Size'],
     rowOrder="key_a_to_z",
     rendererName="Grouped Column Chart",
     aggregatorName="Average",
     vals=["Total Bill"],
     valueFilter={'Day of Week': {'Thursday': False}},
     attrClassified=True,
     attrCategory=[
         {
             "name": "Payer",
             "subcategory": [
                 {
                     "name": "Test1",
                     "attributes": ['Payer Smoker'],
                     "subcategory": [
                         {
                             "name": "Test2",
                             "attributes": ['Payer Gender']
                         }
                     ]
                 }
             ]
         },
         {
             "name": "Money",
             "attributes": ['Tip', 'Total Bill']
         },
         {
             "name": "Others",
             "subcategory": [
                 {
                     "name": "Test1",
                     "attributes": ['Meal'],
                     "subcategory": [
                         {
                             "name": "Test2",
                             "attributes": ['Day of Week']
                         },
                         {
                             "name": "Test3",
                             "attributes": ['Party Size']
                         }
                     ]
                 },
             ]
         }
     ],
     attrLabel={
         'Tip': 'test label of tip'
     },
     unclassifiedAttrName="Others",
     attrOrder=["Meal", "Day of Week", "Party Size", "Total Bill", "Tip", "Payer Smoker", "Payer Gender"],
 ),
Ejemplo n.º 14
0
import dash_pivottable
import dash
import dash_core_components as dcc
from data import data
from dash.dependencies import Input, Output
import dash_html_components as html

app = dash.Dash(__name__)

app.scripts.config.serve_locally = True
app.css.config.serve_locally = True

app.layout = html.Div([
    dash_pivottable.PivotTable(id='table', data=data),
    dcc.Markdown(id='output')
])


@app.callback(Output('output', 'children'), [
    Input('table', 'cols'),
    Input('table', 'rows'),
    Input('table', 'rowOrder'),
    Input('table', 'colOrder'),
    Input('table', 'aggregatorName'),
    Input('table', 'rendererName')
])
def display_props(cols, rows, row_order, col_order, aggregator, renderer):
    return """
        Columns: {}
        
        rows: {}
Ejemplo n.º 15
0
    locations_src_file="./data/WPP2019_F01_LOCATIONS.XLSX",
    debug=debug,
)

app = dash.Dash(__name__)

app.layout = html.Div(children=[
    html.H1(children="世界人口予測", style={"textAlign": "center"}),
    dash_pivottable.PivotTable(
        data=pop_data,
        cols=["Time"],
        rows=["GeoRegName"],
        vals=["Population"],
        hiddenFromDragDrop=["Population"],
        hiddenFromAggregators=[
            "Time",
            "GeoRegName",
            "SubRegName",
            "Location",
            "PopType",
        ],
        aggregatorName="Sum",
    ),
])

if __name__ == "__main__":
    if not debug:
        app.run_server(host="0.0.0.0", port=8050)
    else:
        app.run_server(host="0.0.0.0", port=8050, debug=True)