evidently.renderers

Submodules

base_renderer module

class BaseRenderer(color_options: Optional[ColorOptions] = None)

Bases: object

Base class for all renderers

Attributes:

color_options : ColorOptions

class DetailsInfo(title: str, info: evidently.model.widget.BaseWidgetInfo, id: str = )

Bases: object

Attributes:

id : str

info : BaseWidgetInfo

title : str

class MetricRenderer(color_options: Optional[ColorOptions] = None)

Bases: BaseRenderer

Attributes:

color_options : ColorOptions

Methods:

render_html(obj)

render_json(obj)

class RenderersDefinitions(typed_renderers: dict = , default_html_test_renderer: Optional[evidently.renderers.base_renderer.TestRenderer] = None, default_html_metric_renderer: Optional[evidently.renderers.base_renderer.MetricRenderer] = None)

Bases: object

Attributes:

default_html_metric_renderer : Optional[MetricRenderer] = None

default_html_test_renderer : Optional[TestRenderer] = None

typed_renderers : dict

class TestHtmlInfo(name: str, description: str, status: str, details: List[DetailsInfo], groups: Dict[str, str])

Bases: object

Attributes:

description : str

details : List[DetailsInfo]

groups : Dict[str, str]

name : str

status : str

Methods:

with_details(title: str, info: BaseWidgetInfo)

class TestRenderer(color_options: Optional[ColorOptions] = None)

Bases: BaseRenderer

Attributes:

color_options : ColorOptions

Methods:

html_description(obj)

json_description(obj)

render_html(obj)

render_json(obj)

default_renderer(wrap_type)

html_widgets module

class ColumnDefinition(title: str, field_name: str, type: evidently.renderers.html_widgets.ColumnType = <ColumnType.STRING: 'string'>, sort: Optional[evidently.renderers.html_widgets.SortDirection] = None, options: Optional[dict] = None)

Bases: object

Attributes:

field_name : str

options : Optional[dict] = None

sort : Optional[SortDirection] = None

title : str

type : ColumnType = 'string'

Methods:

as_dict()

class ColumnType(value)

Bases: Enum

An enumeration.

Attributes:

HISTOGRAM = 'histogram'

LINE = 'line'

SCATTER = 'scatter'

STRING = 'string'

class CounterData(label: str, value: str)

Bases: object

Attributes:

label : str

value : str

Methods:

static float(label: str, value: float, precision: int)

create CounterData for float value with given precision.

• Parameters

• label – counter label

• value – float value of counter

• precision – decimal precision

static int(label: str, value: int)

create CounterData for int value.

• Parameters

• label – counter label

• value – int value

static string(label: str, value: str)

create CounterData for string value with given precision.

• Parameters

• label – counter label

• value – string value of counter

class DetailsPartInfo(title: str, info: Union[BaseWidgetInfo, PlotlyGraphInfo])

Bases: object

Attributes:

info : Union[BaseWidgetInfo, PlotlyGraphInfo]

title : str

class GraphData(title: str, data: dict, layout: dict)

Bases: object

Attributes:

data : dict

layout : dict

title : str

Methods:

static figure(title: str, figure: Figure)

create GraphData from plotly figure itself :param title: title of graph :param figure: plotly figure for getting data from

class HeatmapData(name: str, matrix: pandas.core.frame.DataFrame)

Bases: object

Attributes:

matrix : DataFrame

name : str

class HistogramData(name: str, x: list, y: List[Union[int, float]])

Bases: object

Attributes:

name : str

x : list

y : List[Union[int, float]]

class RichTableDataRow(fields: dict, details: Optional[RowDetails] = None)

Bases: object

Attributes:

details : Optional[RowDetails]

fields : dict

class RowDetails(parts: Optional[List[DetailsPartInfo]] = None)

Bases: object

Attributes:

parts : List[DetailsPartInfo]

Methods:

with_part(title: str, info: Union[BaseWidgetInfo, PlotlyGraphInfo])

class SortDirection(value)

Bases: Enum

An enumeration.

Attributes:

ASC = 'asc'

DESC = 'desc'

class TabData(title: str, widget: evidently.model.widget.BaseWidgetInfo)

Bases: object

Attributes:

title : str

widget : BaseWidgetInfo

class WidgetSize(value)

Bases: Enum

An enumeration.

Attributes:

FULL = 2

HALF = 1

counter(*, counters: List[CounterData], title: str = '', size: WidgetSize = WidgetSize.FULL)

generate widget with given counters

• Parameters

  • title – widget title

  • counters – list of counters in widget

  • size – widget size

Example

>>> display_counters = [CounterData("value1", "some value"), CounterData.float("float", 0.111, 2)]
>>> widget_info = counter(counters=display_counters, title="counters example")

get_class_separation_plot_data(current_plot: DataFrame, reference_plot: Optional[DataFrame], target_name: str, color_options: ColorOptions)

get_heatmaps_widget(*, title: str = '', primary_data: HeatmapData, secondary_data: Optional[HeatmapData] = None, size: WidgetSize = WidgetSize.FULL, color_options: ColorOptions)

Create a widget with heatmap(s)

get_histogram_figure(*, primary_hist: HistogramData, secondary_hist: Optional[HistogramData] = None, color_options: ColorOptions, orientation: str = 'v')

get_histogram_figure_with_quantile(*, current: HistogramData, reference: Optional[HistogramData] = None, current_quantile: float, reference_quantile: Optional[float] = None, color_options: ColorOptions, orientation: str = 'v')

get_histogram_figure_with_range(*, primary_hist: HistogramData, secondary_hist: Optional[HistogramData] = None, left: Union[float, int], right: Union[float, int], orientation: str = 'v', color_options: ColorOptions)

get_histogram_for_distribution(*, current_distribution: Distribution, reference_distribution: Optional[Distribution] = None, title: str = '', xaxis_title: Optional[str] = None, yaxis_title: Optional[str] = None, color_options: ColorOptions)

get_pr_rec_plot_data(current_pr_curve: dict, reference_pr_curve: Optional[dict], color_options: ColorOptions)

get_roc_auc_tab_data(curr_roc_curve: dict, ref_roc_curve: Optional[dict], color_options: ColorOptions)

header_text(*, label: str, title: str = '', size: WidgetSize = WidgetSize.FULL)

generate widget with some text as header

• Parameters

  • label – text to display

  • title – widget title

  • size – widget size

histogram(*, title: str, primary_hist: HistogramData, secondary_hist: Optional[HistogramData] = None, color_options: ColorOptions, orientation: str = 'v', size: WidgetSize = WidgetSize.FULL, xaxis_title: Optional[str] = None, yaxis_title: Optional[str] = None)

generate widget with one or two histogram

• Parameters

  • title – widget title

  • primary_hist – first histogram to show in widget

  • secondary_hist – optional second histogram to show in widget

  • orientation – bars orientation in histograms

  • color_options – color options to use for widgets

  • size – widget size

  • xaxis_title – title for x-axis

  • yaxis_title – title for y-axis

Example

>>> ref_hist = HistogramData("Histogram 1", x=["a", "b", "c"], y=[1, 2, 3])
>>> curr_hist = HistogramData("Histogram 2", x=["a", "b", "c"], y=[3, 2 ,1])
>>> widget_info = histogram(
>>>     title="Histogram example",
>>>     primary_hist=ref_hist,
>>>     secondary_hist=curr_hist,
>>>     color_options=color_options
>>> )

plotly_data(*, title: str, data: dict, layout: dict, size: WidgetSize = WidgetSize.FULL)

generate plotly plot with given data and layout (can be generated from plotly).

• Parameters

  • title – widget title

  • data – plotly figure data

  • layout – plotly figure layout

  • size – widget size

Example

>>> figure = go.Figure(go.Bar(name="Bar plot", x=[1, 2, 3, 4], y=[10, 11, 20, 11]))
>>> f_dict = figure.to_plotly_json()
>>> widget_info = plotly_data(title="Some plot title", data=f_dict["data"], layout=f_dict["layout"])

plotly_figure(*, title: str, figure: Figure, size: WidgetSize = WidgetSize.FULL)

generate plotly plot based on given plotly figure object.

• Parameters

  • title – title of widget

  • figure – plotly figure which should be rendered as widget

  • size – size of widget, default to WidgetSize.FULL

Example

>>> bar_figure = go.Figure(go.Bar(name="Bar plot", x=[1, 2, 3, 4], y=[10, 11, 20, 11]))
>>> widget_info = plotly_figure(title="Bar plot widget", figure=bar_figure, size=WidgetSize.FULL)

plotly_graph(*, graph_data: GraphData, size: WidgetSize = WidgetSize.FULL)

generate plotly plot with given GraphData object.

• Parameters

  • graph_data – plot data for widget

  • size – size of widget to render

Example

>>> figure = go.Figure(go.Bar(name="Bar plot", x=[1, 2, 3, 4], y=[10, 11, 20, 11]))
>>> f_dict = figure.to_plotly_json()
>>> bar_graph_data = GraphData(title="Some plot title", data=f_dict["data"], layout=f_dict["layout"])
>>> widget_info = plotly_graph(graph_data=bar_graph_data, size=WidgetSize.FULL)

plotly_graph_tabs(*, title: str, figures: List[GraphData], size: WidgetSize = WidgetSize.FULL)

generate Tab widget with multiple graphs

• Parameters

  • title – widget title

  • figures – list of graphs with tab titles

  • size – widget size

Example

>>> bar_figure = go.Figure(go.Bar(name="Bar plot", x=[1, 2, 3, 4], y=[10, 11, 20, 11]))
>>> line_figure = go.Figure(go.Line(name="Bar plot", x=[1, 2, 3, 4], y=[10, 11, 20, 11]))
>>> widget_info = plotly_graph_tabs(
...     title="Tabbed widget",
...     figures=[GraphData.figure("Bar", bar_figure), GraphData.figure("Line", line_figure)],
... )

rich_table_data(*, title: str = '', size: WidgetSize = WidgetSize.FULL, rows_per_page: int = 10, columns: List[ColumnDefinition], data: List[RichTableDataRow])

generate widget with rich table: with additional column types and details for rows

• Parameters

  • title – widget title

  • size – widget size

  • rows_per_page – maximum number per page to show

  • columns – list of columns in table

  • data – list of dicts with data (key-value pairs, keys is according to ColumnDefinition.field_name)

Example

>>> columns_def = [
...     ColumnDefinition("Column A", "field_1"),
...     ColumnDefinition("Column B", "field_2", ColumnType.HISTOGRAM,
...                      options={"xField": "x", "yField": "y", "color": "#ed0400"}),
...     ColumnDefinition("Column C", "field_3", sort=SortDirection.ASC),
... ]
>>> in_table_data = [
...     RichTableDataRow(fields=dict(field_1="a", field_2=dict(x=[1, 2, 3], y=[10, 11, 3]), field_3="2")),
...     RichTableDataRow(
...         fields=dict(field_1="b", field_2=dict(x=[1, 2, 3], y=[10, 11, 3]), field_3="1"),
...         details=RowDetails()
...             .with_part("Some details", counter(counters=[CounterData("counter 1", "value")])
...         )
...     )
... ]
>>> widget_info = rich_table_data(title="Rich table", rows_per_page=10, columns=columns_def, data=in_table_data)

table_data(*, column_names: Iterable[str], data: Iterable[Iterable], title: str = '', size: WidgetSize = WidgetSize.FULL)

generate simple table with given columns and data

• Parameters

  • column_names – list of column names in display order

  • data – list of data rows (lists of object to show in table in order of columns), object will be converted to str

  • title – widget title

  • size – widget size

Example

>>> columns = ["Column A", "Column B"]
>>> in_table_data = [[1, 2], [3, 4]]
>>> widget_info = table_data(column_names=columns, data=in_table_data, title="Table")

widget_tabs(*, title: str = '', size: WidgetSize = WidgetSize.FULL, tabs: List[TabData])

generate widget with tabs which can contain any other widget.

• Parameters

  • title – widget title

  • size – widget size

  • tabs – list of TabData with widgets to include

Example

>>> columns = ["Column A", "Column B"]
>>> in_table_data = [[1, 2], [3, 4]]
>>> tab_data = [
...     TabData("Counters", counter(counters=[CounterData("counter", "value")], title="Counter")),
...     TabData("Table", table_data(column_names=columns, data=in_table_data, title="Table")),
... ]
>>> widget_info = widget_tabs(title="Tabs", tabs=tab_data)

widget_tabs_for_more_than_one(*, title: str = '', size: WidgetSize = WidgetSize.FULL, tabs: List[TabData])

Draw tabs widget only if there is more than one tab, otherwise just draw one widget

notebook_utils module

determine_template(mode: str)

render_utils module

get_distribution_plot_figure(*, current_distribution: Distribution, reference_distribution: Optional[Distribution], color_options: ColorOptions, orientation: str = 'v')

plot_distr(*, hist_curr, hist_ref=None, orientation='v', color_options: ColorOptions)