import plotly.graph_objects as go

from plotly import basedatatypes

def find_field(obj, field, basepath="", max_path_len=80, forbidden=["parent"]):

if obj is not None and len(basepath) < max_path_len:

for f in dir(obj):

joined_path = ".".join([basepath, f])

if f == field:

print(joined_path)

if (

(f not in forbidden)

and (not f.startswith("_"))

and (not f.endswith("_"))

):

find_field(eval("obj.%s" % (f,)), field, joined_path)

def find_all_xy_traces():

for field in dir(go):

call_str = "go.%s" % (field,)

call = eval(call_str)

try:

if issubclass(call, basedatatypes.BaseTraceType):

obj = call()

if "xaxis" in obj and "yaxis" in obj:

yield (call_str)

except TypeError:

pass

for call_str in find_all_xy_traces():

call = eval(call_str)

find_field(call(), "color", basepath=call_str)

print()

import test_data

import numpy as np

import plotly.express as px

from px_combine import px_combine_secondary_y, px_simple_combine

df = test_data.multilayered_data(d_divs=[2, 3, 4, 2], rwalk=0.1)

print(df)

last_cat = df.columns[3]

figs = []

for px_call, last_cat_0 in zip([px.line, px.bar], list(set(df[last_cat]))):

df_slice = df.loc[df[last_cat] == last_cat_0]

fig = px_call(

df_slice,

x="x",

y="y",

facet_row=df.columns[0],

facet_col=df.columns[1],

color=df.columns[2],

)

fig.update_layout(title="%s=%s" % (last_cat, last_cat_0,))

figs.append(fig)

figs[0].add_hline(y=1, row=1, col="all")

figs[1].add_vline(x=10, row="all", col=2)

figs[0].add_annotation(

x=0.25, y=0.5, xref="x domain", yref="y domain", row=2, col=3, text="yo"

)

figs[1].add_annotation(

x=0.5, y=0.35, xref="x domain", yref="y domain", row=1, col=2, text="budday"

)

figs[0].layout.barmode = "group"

figs[1].layout.barmode = "relative"

final_fig = px_simple_combine(*figs)

for fig in figs:

fig.show()

final_fig.show()

from itertools import product, cycle, chain

from functools import reduce

# reflow the colors

colorway = fig0.layout.template.layout.colorway

fig = make_subplots(*fig_grid_ref_shape(fig0))

for r, c in multi_index(*fig_grid_ref_shape(fig)):

for (tr, title), color in zip(

chain(

*[

zip(

f.select_traces(row=r + 1, col=c + 1),

cycle([f.layout.title.text]),

)

for f in [fig0, fig1]

]

),

cycle(colorway),

):

set_main_trace_color(tr, color)

# use figure title to differentiate the legend items

tr["name"] = "%s %s" % (title, tr["name"])

# TODO: argument to group legend items?

tr["legendgroup"] = None

fig.add_trace(tr, row=r + 1, col=c + 1)

fig.update_layout(fig0.layout)

# title will be wrong

fig.layout.title = None

# preserve bar mode

# if both figures have barmode set, the first is taken, otherwise the set one is taken

# TODO argument to force barmode? or the user can just update it after

fig.layout.barmode = get_first_set_barmode([fig0, fig1])

# also include annotations, shapes and layout images from fig1

for kw in ["annotations", "shapes", "images"]:

fig.layout[kw] += fig1.layout[kw]

def select_all_traces(figs):

traces = list(

reduce(

lambda a, b: a + b,

map(lambda t: list(go.Figure.select_traces(t)), figs),

[],

)

)

return traces

def check_trace_type_xy(tr):

return ("xaxis" in tr) and ("yaxis" in tr)

def check_figs_trace_types_xy(figs):

traces = select_all_traces(figs)

xy_traces = list(map(check_trace_type_xy, traces))

return xy_traces

def set_main_trace_color(tr, color):

# Set the main color of a trace

if type(tr) == type(go.Scatter()):

if tr["mode"] == "lines":

tr["line_color"] = color

else:

tr["marker_color"] = color

elif type(tr) == type(go.Bar()):

tr["marker_color"] = color

def get_first_set_barmode(figs):

barmode = None

try:

barmode = list(

filter(lambda x: x is not None, [f.layout.barmode for f in figs])

)[0]

except IndexError:

# if no figure sets barmode, then it is not set

pass

return barmode

if not all(check_figs_trace_types_xy([fig0, fig1])):

raise ValueError('Only subplots containing "xy" trace types may be combined')

if __name__ == "__main__":

fig_simple = simple_combine_example()

fig_secondary_y = secondary_y_combine_example()

fig_simple.show()

fig_secondary_y.show()

fig_secondary_y.write_json("/tmp/fig.json")

#/bin/bash

PYTHONPATH=proto/px_combine python3 proto/px_combine/multilayered_data_test.py

import numpy as np

import plotly.express as px

import pandas as pd

from random import sample

from itertools import product

from functools import reduce

def words(remove_non_letters=True):

with open("/usr/share/dict/british-english", "r") as fd:

ws = fd.readlines()

return [w.strip().replace("'s", "") for w in ws]

def aug_tips():

""" The tips data buf with "calories consumed". """

tips = px.data.tips()

calories = np.clip(

tips["total_bill"] * 30 + np.random.standard_normal(tips.shape[0]) * 100,

100,

None,

)

tips["calories_consumed"] = calories

return tips

def take(it, N):

return [next(it) for n in range(N)]

def multilayered_data(

N=20, d_divs=[2, 3, 4], rseed=np.random.RandomState(seed=2), rwalk=0.1

):

"""

ws = words()

tot_divs = np.cumprod(d_divs)[-1]

sample_i = np.arange(len(ws), dtype="int")

rseed.shuffle(sample_i)

names = iter(ws[i] for i in sample_i[: tot_divs + len(d_divs)])

x = np.arange(N)

cat_div_names = []

for div in d_divs:

# generate category names

div_names = [next(names) for _ in range(div)]

cat_div_names.append(div_names)

cat_names = [next(names) for _ in d_divs]

dfs = []

for cat_combo in product(*cat_div_names):

d = dict()

for cat_name, c in zip(cat_names, cat_combo):

d[cat_name] = c

d["x"] = x

if rwalk is not None:

y = np.cumsum(rseed.standard_normal(N)) * rwalk

else:

y = rseed.standard_normal(N)

d["y"] = y

dfs.append(pd.DataFrame(d))

# combine all the dicts

df = reduce(lambda a, b: pd.concat([a, b]), dfs, pd.DataFrame())

return df