"""All visualizations derive this base class"""

viz_type = None

verbose_name = "Base Viz"

credits = ""

is_timeseries = False

def __init__(self, datasource, form_data, slice_=None):

self.orig_form_data = form_data

if not datasource:

raise Exception("Viz is missing a datasource")

self.datasource = datasource

self.request = request

self.viz_type = form_data.get("viz_type")

self.slice = slice_

self.form_data = form_data

self.query = ""

self.token = self.form_data.get(

'token', 'token_' + uuid.uuid4().hex[:8])

self.metrics = self.form_data.get('metrics') or []

self.groupby = self.form_data.get('groupby') or []

self.status = None

self.error_message = None

def get_filter_url(self):

"""Returns the URL to retrieve column values used in the filter"""

data = self.orig_form_data.copy()

# Remove unchecked checkboxes because HTML is weird like that

ordered_data = MultiDict()

for key in sorted(data.keys()):

# if MultiDict is initialized with MD({key:[emptyarray]}),

# key is included in d.keys() but accessing it throws

try:

if data[key] is False:

del data[key]

continue

except IndexError:

pass

if isinstance(data, (MultiDict, ImmutableMultiDict)):

v = data.getlist(key)

else:

v = data.get(key)

if not isinstance(v, list):

v = [v]

for item in v:

ordered_data.add(key, item)

href = Href(

'/superset/filter/{self.datasource.type}/'

'{self.datasource.id}/'.format(**locals()))

return href(ordered_data)

def get_df(self, query_obj=None):

"""Returns a pandas dataframe based on the query object"""

if not query_obj:

query_obj = self.query_obj()

self.error_msg = ""

self.results = None

timestamp_format = None

if self.datasource.type == 'table':

dttm_col = self.datasource.get_col(query_obj['granularity'])

if dttm_col:

timestamp_format = dttm_col.python_date_format

# The datasource here can be different backend but the interface is common

self.results = self.datasource.query(query_obj)

self.query = self.results.query

self.status = self.results.status

self.error_message = self.results.error_message

df = self.results.df

# Transform the timestamp we received from database to pandas supported

# datetime format. If no python_date_format is specified, the pattern will

# be considered as the default ISO date format

# If the datetime format is unix, the parse will use the corresponding

# parsing logic.

if df is None or df.empty:

self.status = utils.QueryStatus.FAILED

self.error_message = "No data."

return pd.DataFrame()

else:

if DTTM_ALIAS in df.columns:

if timestamp_format in ("epoch_s", "epoch_ms"):

df[DTTM_ALIAS] = pd.to_datetime(df[DTTM_ALIAS], utc=False)

else:

df[DTTM_ALIAS] = pd.to_datetime(

df[DTTM_ALIAS], utc=False, format=timestamp_format)

if self.datasource.offset:

df[DTTM_ALIAS] += timedelta(hours=self.datasource.offset)

df.replace([np.inf, -np.inf], np.nan)

df = df.fillna(0)

return df

def get_extra_filters(self):

extra_filters = self.form_data.get('extra_filters')

if not extra_filters:

return {}

return json.loads(extra_filters)

def query_obj(self):

"""Building a query object"""

form_data = self.form_data

groupby = form_data.get("groupby") or []

metrics = form_data.get("metrics") or ['count']

extra_filters = self.get_extra_filters()

granularity = (

form_data.get("granularity") or form_data.get("granularity_sqla")

)

limit = int(form_data.get("limit") or 0)

timeseries_limit_metric = form_data.get("timeseries_limit_metric")

row_limit = int(

form_data.get("row_limit") or config.get("ROW_LIMIT"))

since = (

extra_filters.get('__from') or form_data.get("since", "1 year ago")

)

from_dttm = utils.parse_human_datetime(since)

now = datetime.now()

if from_dttm > now:

from_dttm = now - (from_dttm - now)

until = extra_filters.get('__to') or form_data.get("until", "now")

to_dttm = utils.parse_human_datetime(until)

if from_dttm > to_dttm:

raise Exception("From date cannot be larger than to date")

# extras are used to query elements specific to a datasource type

# for instance the extra where clause that applies only to Tables

extras = {

'where': form_data.get("where", ''),

'having': form_data.get("having", ''),

'having_druid': form_data.get('having_filters') \

if 'having_filters' in form_data else [],

'time_grain_sqla': form_data.get("time_grain_sqla", ''),

'druid_time_origin': form_data.get("druid_time_origin", ''),

}

filters = form_data['filters'] if 'filters' in form_data \

else []

for col, vals in self.get_extra_filters().items():

if not (col and vals):

continue

elif col in self.datasource.filterable_column_names:

# Quote values with comma to avoid conflict

vals = ["'{}'".format(x) if "," in x else x for x in vals]

filters += [{

'col': col,

'op': 'in',

'val': ",".join(vals),

}]

d = {

'granularity': granularity,

'from_dttm': from_dttm,

'to_dttm': to_dttm,

'is_timeseries': self.is_timeseries,

'groupby': groupby,

'metrics': metrics,

'row_limit': row_limit,

'filter': filters,

'timeseries_limit': limit,

'extras': extras,

'timeseries_limit_metric': timeseries_limit_metric,

}

return d

@property

def cache_timeout(self):

if self.slice and self.slice.cache_timeout:

return self.slice.cache_timeout

if self.datasource.cache_timeout:

return self.datasource.cache_timeout

if (

hasattr(self.datasource, 'database') and

self.datasource.database.cache_timeout):

return self.datasource.database.cache_timeout

return config.get("CACHE_DEFAULT_TIMEOUT")

def get_json(self, force=False):

return json.dumps(

self.get_payload(force),

default=utils.json_int_dttm_ser, ignore_nan=True)

@property

def cache_key(self):

s = str([(k, self.form_data[k]) for k in sorted(self.form_data.keys())])

return hashlib.md5(s.encode('utf-8')).hexdigest()

def get_payload(self, force=False):

"""Handles caching around the json payload retrieval"""

cache_key = self.cache_key

payload = None

force = force if force else self.form_data.get('force') == 'true'

if not force and cache:

payload = cache.get(cache_key)

if payload:

is_cached = True

try:

cached_data = zlib.decompress(payload)

if PY3:

cached_data = cached_data.decode('utf-8')

payload = json.loads(cached_data)

except Exception as e:

logging.error("Error reading cache: " +

utils.error_msg_from_exception(e))

payload = None

logging.info("Serving from cache")

if not payload:

data = None

is_cached = False

cache_timeout = self.cache_timeout

stacktrace = None

try:

df = self.get_df()

if not self.error_message:

data = self.get_data(df)

except Exception as e:

logging.exception(e)

if not self.error_message:

self.error_message = str(e)

self.status = utils.QueryStatus.FAILED

data = None

stacktrace = traceback.format_exc()

payload = {

'cache_key': cache_key,

'cache_timeout': cache_timeout,

'data': data,

'error': self.error_message,

'filter_endpoint': self.filter_endpoint,

'form_data': self.form_data,

'query': self.query,

'status': self.status,

'stacktrace': stacktrace,

}

payload['cached_dttm'] = datetime.now().isoformat().split('.')[0]

logging.info("Caching for the next {} seconds".format(

cache_timeout))

data = self.json_dumps(payload)

if PY3:

data = bytes(data, 'utf-8')

if cache and self.status != utils.QueryStatus.FAILED:

try:

cache.set(

cache_key,

zlib.compress(data),

timeout=cache_timeout)

except Exception as e:

# cache.set call can fail if the backend is down or if

# the key is too large or whatever other reasons

logging.warning("Could not cache key {}".format(cache_key))

logging.exception(e)

cache.delete(cache_key)

payload['is_cached'] = is_cached

return payload

def json_dumps(self, obj):

return json.dumps(obj, default=utils.json_int_dttm_ser, ignore_nan=True)

@property

def data(self):

"""This is the data object serialized to the js layer"""

content = {

'form_data': self.form_data,

'filter_endpoint': self.filter_endpoint,

'token': self.token,

'viz_name': self.viz_type,

'filter_select_enabled': self.datasource.filter_select_enabled,

}

return content

def get_csv(self):

df = self.get_df()

include_index = not isinstance(df.index, pd.RangeIndex)

return df.to_csv(index=include_index, encoding="utf-8")

def get_values_for_column(self, column):

"""

Retrieves values for a column to be used by the filter dropdown.

:param column: column name

:return: JSON containing the some values for a column

"""

form_data = self.form_data

since = form_data.get("since", "1 year ago")

from_dttm = utils.parse_human_datetime(since)

now = datetime.now()

if from_dttm > now:

from_dttm = now - (from_dttm - now)

until = form_data.get("until", "now")

to_dttm = utils.parse_human_datetime(until)

if from_dttm > to_dttm:

raise Exception("From date cannot be larger than to date")

kwargs = dict(

column_name=column,

from_dttm=from_dttm,

to_dttm=to_dttm,

)

df = self.datasource.values_for_column(**kwargs)

return df[column].to_json()

def get_data(self, df):

return []

@property

def filter_endpoint(self):

return self.get_filter_url()

@property

def json_data(self):

"""A basic html table that is sortable and searchable"""

viz_type = "table"

verbose_name = _("Table View")

credits = 'a <a href="https://github.com/airbnb/superset">Superset</a> original'

is_timeseries = False

def should_be_timeseries(self):

fd = self.form_data

# TODO handle datasource-type-specific code in datasource

conditions_met = (

(fd.get('granularity') and fd.get('granularity') != 'all') or

(fd.get('granularity_sqla') and fd.get('time_grain_sqla'))

)

if fd.get('include_time') and not conditions_met:

raise Exception(

"Pick a granularity in the Time section or "

"uncheck 'Include Time'")

return fd.get('include_time')

def query_obj(self):

d = super(TableViz, self).query_obj()

fd = self.form_data

if fd.get('all_columns') and (fd.get('groupby') or fd.get('metrics')):

raise Exception(

"Choose either fields to [Group By] and [Metrics] or "

"[Columns], not both")

if fd.get('all_columns'):

d['columns'] = fd.get('all_columns')

d['groupby'] = []

order_by_cols = fd.get('order_by_cols') or []

d['orderby'] = [json.loads(t) for t in order_by_cols]

d['is_timeseries'] = self.should_be_timeseries()

return d

def get_data(self, df):

if not self.should_be_timeseries() and DTTM_ALIAS in df:

del df[DTTM_ALIAS]

return dict(

records=df.to_dict(orient="records"),

columns=list(df.columns),

)

def json_dumps(self, obj):

"""A pivot table view, define your rows, columns and metrics"""

viz_type = "pivot_table"

verbose_name = _("Pivot Table")

credits = 'a <a href="https://github.com/airbnb/superset">Superset</a> original'

is_timeseries = False

def query_obj(self):

d = super(PivotTableViz, self).query_obj()

groupby = self.form_data.get('groupby')

columns = self.form_data.get('columns')

metrics = self.form_data.get('metrics')

if not columns:

columns = []

if not groupby:

groupby = []

if not groupby:

raise Exception("Please choose at least one \"Group by\" field ")

if not metrics:

raise Exception("Please choose at least one metric")

if (

any(v in groupby for v in columns) or

any(v in columns for v in groupby)):

raise Exception("groupby and columns can't overlap")

d['groupby'] = list(set(groupby) | set(columns))

return d

def get_data(self, df):

if (

self.form_data.get("granularity") == "all" and

DTTM_ALIAS in df):

del df[DTTM_ALIAS]

df = df.pivot_table(

index=self.form_data.get('groupby'),

columns=self.form_data.get('columns'),

values=self.form_data.get('metrics'),

aggfunc=self.form_data.get('pandas_aggfunc'),

margins=True,

)

return df.to_html(

na_rep='',

classes=(

"dataframe table table-striped table-bordered "

"""Use html or markdown to create a free form widget"""

viz_type = "markup"

verbose_name = _("Markup")

is_timeseries = False

def get_df(self):

return True

def get_data(self, df):

markup_type = self.form_data.get("markup_type")

code = self.form_data.get("code", '')

if markup_type == "markdown":

code = markdown(code)

"""Use to create section headers in a dashboard, similar to `Markup`"""

viz_type = "separator"

verbose_name = _("Separator")

def get_data(self, df):

code = markdown(self.form_data.get("code", ''))

"""Build a colorful word cloud

Uses the nice library at:

https://github.com/jasondavies/d3-cloud

"""

viz_type = "word_cloud"

verbose_name = _("Word Cloud")

is_timeseries = False

def query_obj(self):

d = super(WordCloudViz, self).query_obj()

d['metrics'] = [self.form_data.get('metric')]

d['groupby'] = [self.form_data.get('series')]

return d

def get_data(self, df):

# Ordering the columns

df = df[[self.form_data.get('series'), self.form_data.get('metric')]]

# Labeling the columns for uniform json schema

df.columns = ['text', 'size']

"""Tree map visualisation for hierarchical data."""

viz_type = "treemap"

verbose_name = _("Treemap")

credits = '<a href="https://d3js.org">d3.js</a>'

is_timeseries = False

def _nest(self, metric, df):

nlevels = df.index.nlevels

if nlevels == 1:

result = [{"name": n, "value": v}

for n, v in zip(df.index, df[metric])]

else:

result = [{"name": l, "children": self._nest(metric, df.loc[l])}

for l in df.index.levels[0]]

return result

def get_data(self, df):

df = df.set_index(self.form_data.get("groupby"))

chart_data = [{"name": metric, "children": self._nest(metric, df)}

for metric in df.columns]

"""Calendar heatmap."""

viz_type = "cal_heatmap"

verbose_name = _("Calendar Heatmap")

credits = (

'<a href=https://github.com/wa0x6e/cal-heatmap>cal-heatmap</a>')

is_timeseries = True

def get_data(self, df):

form_data = self.form_data

df.columns = ["timestamp", "metric"]

timestamps = {str(obj["timestamp"].value / 10**9):

obj.get("metric") for obj in df.to_dict("records")}

start = utils.parse_human_datetime(form_data.get("since"))

end = utils.parse_human_datetime(form_data.get("until"))

domain = form_data.get("domain_granularity")

diff_delta = rdelta.relativedelta(end, start)

diff_secs = (end - start).total_seconds()

if domain == "year":

range_ = diff_delta.years + 1

elif domain == "month":

range_ = diff_delta.years * 12 + diff_delta.months + 1

elif domain == "week":

range_ = diff_delta.years * 53 + diff_delta.weeks + 1

elif domain == "day":

range_ = diff_secs // (24*60*60) + 1

else:

range_ = diff_secs // (60*60) + 1

return {

"timestamps": timestamps,

"start": start,

"domain": domain,

"subdomain": form_data.get("subdomain_granularity"),

"range": range_,

}

def query_obj(self):

qry = super(CalHeatmapViz, self).query_obj()

qry["metrics"] = [self.form_data["metric"]]

"""Base class for all nvd3 vizs"""

credits = '<a href="http://nvd3.org/">NVD3.org</a>'

viz_type = None

verbose_name = "Base NVD3 Viz"

"""Box plot viz from ND3"""

viz_type = "box_plot"

verbose_name = _("Box Plot")

sort_series = False

is_timeseries = True

def to_series(self, df, classed='', title_suffix=''):

label_sep = " - "

chart_data = []

for index_value, row in zip(df.index, df.to_dict(orient="records")):

if isinstance(index_value, tuple):

index_value = label_sep.join(index_value)

boxes = defaultdict(dict)

for (label, key), value in row.items():

if key == "median":

key = "Q2"

boxes[label][key] = value

for label, box in boxes.items():

if len(self.form_data.get("metrics")) > 1:

# need to render data labels with metrics

chart_label = label_sep.join([index_value, label])

else:

chart_label = index_value

chart_data.append({

"label": chart_label,

"values": box,

})

return chart_data

def get_data(self, df):

form_data = self.form_data

df = df.fillna(0)

# conform to NVD3 names

def Q1(series): # need to be named functions - can't use lambdas

return np.percentile(series, 25)

def Q3(series):

return np.percentile(series, 75)

whisker_type = form_data.get('whisker_options')

if whisker_type == "Tukey":

def whisker_high(series):

upper_outer_lim = Q3(series) + 1.5 * (Q3(series) - Q1(series))

series = series[series <= upper_outer_lim]

return series[np.abs(series - upper_outer_lim).argmin()]

def whisker_low(series):

lower_outer_lim = Q1(series) - 1.5 * (Q3(series) - Q1(series))

# find the closest value above the lower outer limit

series = series[series >= lower_outer_lim]

return series[np.abs(series - lower_outer_lim).argmin()]

elif whisker_type == "Min/max (no outliers)":

def whisker_high(series):

return series.max()

def whisker_low(series):

return series.min()

elif " percentiles" in whisker_type:

low, high = whisker_type.replace(" percentiles", "").split("/")

def whisker_high(series):

return np.percentile(series, int(high))

def whisker_low(series):

return np.percentile(series, int(low))

else:

raise ValueError("Unknown whisker type: {}".format(whisker_type))

def outliers(series):

above = series[series > whisker_high(series)]

below = series[series < whisker_low(series)]

# pandas sometimes doesn't like getting lists back here

return set(above.tolist() + below.tolist())

aggregate = [Q1, np.median, Q3, whisker_high, whisker_low, outliers]

df = df.groupby(form_data.get('groupby')).agg(aggregate)

chart_data = self.to_series(df)

"""Based on the NVD3 bubble chart"""

viz_type = "bubble"

verbose_name = _("Bubble Chart")

is_timeseries = False

def query_obj(self):

form_data = self.form_data

d = super(BubbleViz, self).query_obj()

d['groupby'] = list({

form_data.get('series'),

form_data.get('entity')

})

self.x_metric = form_data.get('x')

self.y_metric = form_data.get('y')

self.z_metric = form_data.get('size')

self.entity = form_data.get('entity')

self.series = form_data.get('series')

d['metrics'] = [

self.z_metric,

self.x_metric,

self.y_metric,

]

if not all(d['metrics'] + [self.entity, self.series]):

raise Exception("Pick a metric for x, y and size")

return d

def get_data(self, df):

df['x'] = df[[self.x_metric]]

df['y'] = df[[self.y_metric]]

df['size'] = df[[self.z_metric]]

df['shape'] = 'circle'

df['group'] = df[[self.series]]

series = defaultdict(list)

for row in df.to_dict(orient='records'):

series[row['group']].append(row)

chart_data = []

for k, v in series.items():

chart_data.append({

'key': k,

'values': v})

"""Based on the NVD3 bullet chart"""

viz_type = "bullet"

verbose_name = _("Bullet Chart")

is_timeseries = False

def query_obj(self):

form_data = self.form_data

d = super(BulletViz, self).query_obj()

self.metric = form_data.get('metric')

def as_strings(field):

value = form_data.get(field)

return value.split(',') if value else []

def as_floats(field):

return [float(x) for x in as_strings(field)]

self.ranges = as_floats('ranges')

self.range_labels = as_strings('range_labels')

self.markers = as_floats('markers')

self.marker_labels = as_strings('marker_labels')

self.marker_lines = as_floats('marker_lines')

self.marker_line_labels = as_strings('marker_line_labels')

d['metrics'] = [

self.metric,

]

if not self.metric:

raise Exception("Pick a metric to display")

return d

def get_data(self, df):

df = df.fillna(0)

df['metric'] = df[[self.metric]]

values = df['metric'].values

return {

'measures': values.tolist(),

'ranges': self.ranges or [0, values.max() * 1.1],

'rangeLabels': self.range_labels or None,

'markers': self.markers or None,

'markerLabels': self.marker_labels or None,

'markerLines': self.marker_lines or None,

'markerLineLabels': self.marker_line_labels or None,

"""Put emphasis on a single metric with this big number viz"""

viz_type = "big_number"

verbose_name = _("Big Number with Trendline")

credits = 'a <a href="https://github.com/airbnb/superset">Superset</a> original'

is_timeseries = True

def query_obj(self):

d = super(BigNumberViz, self).query_obj()

metric = self.form_data.get('metric')

if not metric:

raise Exception("Pick a metric!")

d['metrics'] = [self.form_data.get('metric')]

self.form_data['metric'] = metric

return d

def get_data(self, df):

form_data = self.form_data

df.sort_values(by=df.columns[0], inplace=True)

compare_lag = form_data.get("compare_lag")

return {

'data': df.values.tolist(),

'compare_lag': compare_lag,

'compare_suffix': form_data.get('compare_suffix', ''),

"""Put emphasis on a single metric with this big number viz"""

viz_type = "big_number_total"

verbose_name = _("Big Number")

credits = 'a <a href="https://github.com/airbnb/superset">Superset</a> original'

is_timeseries = False

def query_obj(self):

d = super(BigNumberTotalViz, self).query_obj()

metric = self.form_data.get('metric')

if not metric:

raise Exception("Pick a metric!")

d['metrics'] = [self.form_data.get('metric')]

self.form_data['metric'] = metric

return d

def get_data(self, df):

form_data = self.form_data

df.sort_values(by=df.columns[0], inplace=True)

return {

'data': df.values.tolist(),

'subheader': form_data.get('subheader', ''),

"""A rich line chart component with tons of options"""

viz_type = "line"

verbose_name = _("Time Series - Line Chart")

sort_series = False

is_timeseries = True

def to_series(self, df, classed='', title_suffix=''):

cols = []

for col in df.columns:

if col == '':

cols.append('N/A')

elif col is None:

cols.append('NULL')

else:

cols.append(col)

df.columns = cols

series = df.to_dict('series')

chart_data = []

for name in df.T.index.tolist():

ys = series[name]

if df[name].dtype.kind not in "biufc":

continue

if isinstance(name, string_types):

series_title = name

else:

name = ["{}".format(s) for s in name]

if len(self.form_data.get('metrics')) > 1:

series_title = ", ".join(name)

else:

series_title = ", ".join(name[1:])

if title_suffix:

series_title += title_suffix

d = {

"key": series_title,

"classed": classed,

"values": [

{'x': ds, 'y': ys[ds] if ds in ys else None}

for ds in df.index

],

}

chart_data.append(d)

return chart_data

def get_data(self, df):

fd = self.form_data

df = df.fillna(0)

if fd.get("granularity") == "all":

raise Exception("Pick a time granularity for your time series")

df = df.pivot_table(

index=DTTM_ALIAS,

columns=fd.get('groupby'),

values=fd.get('metrics'))

fm = fd.get("resample_fillmethod")

if not fm:

fm = None

how = fd.get("resample_how")

rule = fd.get("resample_rule")

if how and rule:

df = df.resample(rule, how=how, fill_method=fm)

if not fm:

df = df.fillna(0)

if self.sort_series:

dfs = df.sum()

dfs.sort_values(ascending=False, inplace=True)

df = df[dfs.index]

if fd.get("contribution"):

dft = df.T

df = (dft / dft.sum()).T

rolling_periods = fd.get("rolling_periods")

rolling_type = fd.get("rolling_type")

if rolling_type in ('mean', 'std', 'sum') and rolling_periods:

if rolling_type == 'mean':

df = pd.rolling_mean(df, int(rolling_periods), min_periods=0)

elif rolling_type == 'std':

df = pd.rolling_std(df, int(rolling_periods), min_periods=0)

elif rolling_type == 'sum':

df = pd.rolling_sum(df, int(rolling_periods), min_periods=0)

elif rolling_type == 'cumsum':

df = df.cumsum()

num_period_compare = fd.get("num_period_compare")

if num_period_compare:

num_period_compare = int(num_period_compare)

prt = fd.get('period_ratio_type')

if prt and prt == 'growth':

df = (df / df.shift(num_period_compare)) - 1

elif prt and prt == 'value':

df = df - df.shift(num_period_compare)

else:

df = df / df.shift(num_period_compare)

df = df[num_period_compare:]

chart_data = self.to_series(df)

time_compare = fd.get('time_compare')

if time_compare:

query_object = self.query_obj()

delta = utils.parse_human_timedelta(time_compare)

query_object['inner_from_dttm'] = query_object['from_dttm']

query_object['inner_to_dttm'] = query_object['to_dttm']

query_object['from_dttm'] -= delta

query_object['to_dttm'] -= delta

df2 = self.get_df(query_object)

df2[DTTM_ALIAS] += delta

df2 = df2.pivot_table(

index=DTTM_ALIAS,

columns=fd.get('groupby'),

values=fd.get('metrics'))

chart_data += self.to_series(

df2, classed='superset', title_suffix="---")

chart_data = sorted(chart_data, key=lambda x: x['key'])

"""A rich line chart with dual axis"""

viz_type = "dual_line"

verbose_name = _("Time Series - Dual Axis Line Chart")

sort_series = False

is_timeseries = True

def query_obj(self):

d = super(NVD3DualLineViz, self).query_obj()

m1 = self.form_data.get('metric')

m2 = self.form_data.get('metric_2')

d['metrics'] = [m1, m2]

if not m1:

raise Exception("Pick a metric for left axis!")

if not m2:

raise Exception("Pick a metric for right axis!")

if m1 == m2:

raise Exception("Please choose different metrics"

" on left and right axis")

return d

def to_series(self, df, classed=''):

cols = []

for col in df.columns:

if col == '':

cols.append('N/A')

elif col is None:

cols.append('NULL')

else: