class FilterDefinition(PythonModel):
# TODO(vedant) - In a future Dashboard Schema update, we will need to unify
# these filters such that they are common with AQT and Druid filter
# definitions.
@classmethod
def registry(cls):
return FilterProperty
@property
@FilterProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_string(value, 'id'))
def id(self):
return self.get('id')
@id.setter
@FilterProperty.setter()
def id(self, value):
self['id'] = value
@property
@FilterProperty.getter(
value_validate_function=lambda value: assert_string(value, 'name'))
def name(self):
return self.get('name')
@name.setter
@FilterProperty.setter()
def name(self, value):
self['name'] = value
@property
@FilterProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_string(
value, 'filter_on'),
)
def filter_on(self):
return self.get('filterOn')
@filter_on.setter
@FilterProperty.setter()
def filter_on(self, value):
self['filterOn'] = value
@property
@FilterProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_non_string_iterable(
value, 'filter_values', validate_filter_value),
)
def filter_values(self):
return self.get('filterValues')
@filter_values.setter
@FilterProperty.setter()
def filter_values(self, value):
self['filterValues'] = value
def validate_settings_item(key, value, argument_name):
formatted_value_name = '{0}[{1}]'.format(argument_name, key)
assert_string(key, 'Settings ID \'%s\'' % key)
assert_type(value, VisualizationSettings, argument_name=formatted_value_name)
key_argument_name = 'key %s' % key
value_argument_name = 'id %s' % value.id
assert_equals(key, value['id'], key_argument_name, value_argument_name)
def validate_size_item(key, value, argument_name):
formatted_value_name = '{0}[{1}]'.format(argument_name, key)
assert_string(key, 'Size ID \'%s\'' % key)
assert_type(value, LayoutSize, argument_name=formatted_value_name)
key_argument_name = 'key %s' % key
value_argument_name = 'id %s' % value.id
assert_equals(key, value['id'], key_argument_name, value_argument_name)
def validate_date_range_item(key, value, argument_name):
formatted_value_name = '{0}[{1}]'.format(argument_name, key)
assert_string(key, 'Date Range ID \'%s\'' % key)
assert_type(value, DateRangeSpecification, argument_name=formatted_value_name)
key_argument_name = 'key %s' % key
value_argument_name = 'id %s' % value.id
assert_equals(key, value['id'], key_argument_name, value_argument_name)
def validate_filter_item(key, value, argument_name):
formatted_value_name = '{0}[{1}]'.format(argument_name, key)
assert_string(key, 'Filter ID \'%s\'' % key)
assert_type(value, FilterDefinition, argument_name=formatted_value_name)
key_argument_name = 'key %s' % key
value_argument_name = 'id %s' % value.id
assert_equals(key, value['id'], key_argument_name, value_argument_name)
class CustomField(PythonModel):
@classmethod
def registry(cls):
return CustomFieldProperty
@property
@CustomFieldProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_non_string_iterable(
value, 'field_ids', string_type_validator
),
)
def field_ids(self):
return self.get('fieldIds')
@field_ids.setter
@CustomFieldProperty.setter()
def field_ids(self, value):
self['fieldIds'] = value
@property
@CustomFieldProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_string(value, 'formula'),
)
def formula(self):
return self.get('formula')
@formula.setter
@CustomFieldProperty.setter()
def formula(self, value):
self['formula'] = value
@property
@CustomFieldProperty.getter(
nullable=False, value_validate_function=lambda value: assert_string(value, 'id')
)
def id(self):
return self.get('id')
@id.setter
@CustomFieldProperty.setter()
def id(self, value):
self['id'] = value
@property
@CustomFieldProperty.getter(
value_validate_function=lambda value: assert_string(value, 'name')
)
def name(self):
return self.get('name')
@name.setter
@CustomFieldProperty.setter()
def name(self, value):
self['name'] = value
def assert_font_size(value, argument_name=None):
assert_string(value, argument_name)
integer_substring = value[:-2]
try:
int(integer_substring)
except ValueError:
message = ('Font size value must convertible to an integer. '
'Could not convert \'{value}\' to an integer.').format(
value=integer_substring)
raise ValueError(message)
def delete_series(self, series_id):
assert_string(series_id)
if series_id in self.series_order:
updated_value = self.series_order
updated_value.pop(series_id)
self._series_order = updated_value
if series_id in self.series_objects:
updated_objects = self.series_objects
updated_objects.pop(series_id)
self._series_objects = updated_objects
def deserialize_sort_order(value):
if isinstance(value, SortOrder):
return value
assert_string(value, 'sort_order')
formatted_value = SORT_ORDER_MAP.get(value.upper())
if not formatted_value:
raise ValueError('Unexpected value for SortOrder: \'{0}\''.format(value.name))
return formatted_value
class HeatMapSettings(PythonModel):
@classmethod
def registry(cls):
return HeatMapProperty
@property
@HeatMapProperty.getter(
nullable=False,
default_value=DEFAULT_SELECTED_FIELD,
value_validate_function=lambda value: assert_string(
value, 'selected_field'),
)
def selected_field(self):
return self.get('selectedField')
@selected_field.setter
@HeatMapProperty.setter()
def selected_field(self, value):
self['selectedField'] = value
@property
@HeatMapProperty.getter(
nullable=False,
default_value=DEFAULT_MAP_BASE_LAYER,
value_validate_function=lambda value: assert_in(
value, BASE_LAYERS, 'base_layer'),
)
def base_layer(self):
return self.get('baseLayer')
@base_layer.setter
@HeatMapProperty.setter()
def base_layer(self, value):
self['baseLayer'] = value
class VisualizationSettings(PythonModel):
@classmethod
def registry(cls):
return VisualizationSettingsProperty
@property
@VisualizationSettingsProperty.getter(
nullable=False, value_validate_function=lambda value: assert_string(value, 'id')
)
def id(self):
return self.get('id')
@id.setter
@VisualizationSettingsProperty.setter()
def id(self, value):
self['id'] = value
@property
@VisualizationSettingsProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_type(
value, TitleSettings, argument_name='title_settings'
),
)
def title_settings(self):
return self.get('titleSettings')
@title_settings.setter
@VisualizationSettingsProperty.setter(
value_parser_function=lambda values: TitleSettings(values)
)
def title_settings(self, value):
self['titleSettings'] = value
@property
@VisualizationSettingsProperty.getter(
nullable=False,
default_value=lambda: {},
value_validate_function=lambda value: assert_mapping(
value, 'view_type_settings', view_type_settings_validator
),
)
def view_type_settings(self):
return self.get('viewTypeSettings')
@view_type_settings.setter
@VisualizationSettingsProperty.setter(
value_parser_function=parse_view_type_settings
)
def view_type_settings(self, value):
self['viewTypeSettings'] = value
class DashboardOptions(PythonModel):
@classmethod
def registry(cls):
return OptionsProperty
@property
@OptionsProperty.getter(
nullable=False,
default_value=DEFAULT_TITLE,
value_validate_function=lambda value: assert_string(value, 'title'),
)
def title(self):
return self.get('title')
@title.setter
@OptionsProperty.setter()
def title(self, value):
self['title'] = value
@property
@OptionsProperty.getter(
nullable=False,
default_value=DEFAULT_COLUMN_COUNT,
value_validate_function=lambda value: assert_integer(
value, 'column_count', MINIMUM_COLUMN_COUNT
),
)
def column_count(self):
return self.get('columnCount')
@column_count.setter
@OptionsProperty.setter()
def column_count(self, value):
self['columnCount'] = value
@property
@OptionsProperty.getter(
serialized_property_name='showDashboardFilterButton',
nullable=False,
default_value=DEFAULT_SHOW_FILTER_BUTTON,
value_validate_function=lambda value: assert_boolean(
value, 'show_filter_button'
),
)
def show_filter_button(self):
return self.get('showDashboardFilterButton')
@show_filter_button.setter
@OptionsProperty.setter()
def show_filter_button(self, value):
self['showDashboardFilterButton'] = value
class BoxPlotSettings(PythonModel):
@classmethod
def registry(cls):
return BoxPlotProperty
@property
@BoxPlotProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_string(value, 'group_by'),
)
def group_by(self):
return self.get('groupBy')
@group_by.setter
@BoxPlotProperty.setter()
def group_by(self, value):
self['groupBy'] = value
class ExpandoTreeSettings(PythonModel):
@classmethod
def registry(cls):
return ExpandoTreeProperty
@property
@ExpandoTreeProperty.getter(
nullable=False,
default_value=DEFAULT_SELECTED_FIELD,
value_validate_function=lambda value: assert_string(value, 'selected_field'),
)
def selected_field(self):
return self.get('selectedField')
@selected_field.setter
@ExpandoTreeProperty.setter()
def selected_field(self, value):
self['selectedField'] = value
class LayoutSize(PythonModel):
@classmethod
def registry(cls):
return LayoutSizeProperty
@property
@LayoutSizeProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_string(value, 'id'))
def id(self):
return self.get('id')
@id.setter
@LayoutSizeProperty.setter()
def id(self, value):
self['id'] = value
@property
@LayoutSizeProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_integer(value, 'rows'),
default_value=DEFAULT_ROW_COUNT,
)
def rows(self):
return self.get('rows')
@rows.setter
@LayoutSizeProperty.setter()
def rows(self, value):
self['rows'] = value
@property
@LayoutSizeProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_integer(value, 'columns'),
default_value=DEFAULT_COLUMN_COUNT,
)
def columns(self):
return self.get('columns')
@columns.setter
@LayoutSizeProperty.setter()
def columns(self, value):
self['columns'] = value
class LayoutItem(PythonModel):
@classmethod
def registry(cls):
return LayoutItemProperty
# TODO(vedant) - Come up with a proper structure for frontEndSelections
# and/or filterModalSelections. Get rid of one of them since they have a
# very similar structure.
@property
@LayoutItemProperty.getter(
nullable=False,
default_value=lambda: [],
value_validate_function=lambda value: assert_non_string_iterable(
value, 'custom_fields', validate_custom_field),
)
def custom_fields(self):
return self.get('customFields')
@custom_fields.setter
@LayoutItemProperty.setter(
value_parser_function=lambda custom_field_objects: [
CustomField(custom_field_object)
for custom_field_object in custom_field_objects
])
def custom_fields(self, value):
self['customFields'] = value
@property
@LayoutItemProperty.getter(
nullable=False,
default_value=lambda: {},
value_validate_function=lambda value: assert_mapping(
value, 'filter_modal_selections'),
)
def filter_modal_selections(self):
return self.get('filterModalSelections')
@filter_modal_selections.setter
@LayoutItemProperty.setter()
def filter_modal_selections(self, value):
self['filterModalSelections'] = value
@property
@LayoutItemProperty.getter(
serialized_property_name='frontendSelectionsFilter',
nullable=False,
default_value=lambda: {},
value_validate_function=lambda value: assert_mapping(
value, 'front_end_selections_filter'),
)
def front_end_selections_filter(self):
return self.get('frontendSelectionsFilter')
@front_end_selections_filter.setter
@LayoutItemProperty.setter()
def front_end_selections_filter(self, value):
self['frontendSelectionsFilter'] = value
@property
@LayoutItemProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_string(value, 'id'))
def id(self):
return self.get('id')
@id.setter
@LayoutItemProperty.setter()
def id(self, value):
self['id'] = value
@property
@LayoutItemProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_string(value, 'query_id'),
)
def query_id(self):
return self.get('queryId')
@query_id.setter
@LayoutItemProperty.setter()
def query_id(self, value):
self['queryId'] = value
@property
@LayoutItemProperty.getter(
value_validate_function=lambda value: assert_string(value, 'name'))
def name(self):
return self.get('name')
@name.setter
@LayoutItemProperty.setter()
def name(self, value):
self['name'] = value
@property
@LayoutItemProperty.getter(
nullable=False,
default_value=DEFAULT_IS_ADVANCED_QUERY_ITEM,
value_validate_function=lambda value: assert_boolean(
value, 'is_advanced_query_item'),
)
def is_advanced_query_item(self):
return self.get('isAdvancedQueryItem')
@is_advanced_query_item.setter
@LayoutItemProperty.setter()
def is_advanced_query_item(self, value):
self['isAdvancedQueryItem'] = value
@property
@LayoutItemProperty.getter(
nullable=False,
default_value=DEFAULT_IS_LOCKED,
value_validate_function=lambda value: assert_boolean(
value, 'is_locked'),
)
def is_locked(self):
return self.get('isLocked')
@is_locked.setter
@LayoutItemProperty.setter()
def is_locked(self, value):
self['isLocked'] = value
@property
@LayoutItemProperty.getter(value_validate_function=lambda value:
assert_string(value, 'setting_id'))
def setting_id(self):
return self.get('settingId')
@setting_id.setter
@LayoutItemProperty.setter()
def setting_id(self, value):
self['settingId'] = value
@property
@LayoutItemProperty.getter(
serialized_property_name='type',
nullable=False,
value_validate_function=lambda value: assert_type(
value, VisualizationType, argument_name='item_type'),
value_formatter_function=lambda value: value.name,
)
def item_type(self):
return self.get('type')
@item_type.setter
@LayoutItemProperty.setter(
value_parser_function=deserialize_visualization_type)
def item_type(self, value):
self['type'] = value
@property
@LayoutItemProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_integer(
value, 'upper_x', lower_bound=UPPER_X_LOWER_BOUND),
)
def upper_x(self):
return self.get('upperX')
@upper_x.setter
@LayoutItemProperty.setter()
def upper_x(self, value):
self['upperX'] = value
@property
@LayoutItemProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_integer(
value, 'upper_x', lower_bound=UPPER_Y_LOWER_BOUND),
)
def upper_y(self):
return self.get('upperY')
@upper_y.setter
@LayoutItemProperty.setter()
def upper_y(self, value):
self['upperY'] = value
@property
@LayoutItemProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_string(value, 'size_id'),
)
def size_id(self):
return self.get('sizeId')
@size_id.setter
@LayoutItemProperty.setter()
def size_id(self, value):
self['sizeId'] = value
def title_font_size(self, value):
assert_string(value, 'title_font_size')
self['titleFontSize'] = value
class TitleSettings(PythonModel):
@classmethod
def registry(cls):
return TitleProperty
@property
@TitleProperty.getter(
nullable=False,
default_value='',
value_validate_function=lambda value: assert_string(value, 'subtitle'),
)
def subtitle(self):
return self.get('subtitle')
@subtitle.setter
@TitleProperty.setter()
def subtitle(self, value):
self['subtitle'] = value
@property
@TitleProperty.getter(
nullable=False,
default_value=DEFAULT_SUBTITLE_FONT_SIZE,
value_validate_function=lambda value: assert_font_size(
value, 'subtitle_font_size'
),
)
def subtitle_font_size(self):
return self.get('subtitleFontSize')
@subtitle_font_size.setter
@TitleProperty.setter()
def subtitle_font_size(self, value):
self['subtitleFontSize'] = value
@property
@TitleProperty.getter(
nullable=False,
default_value='',
value_validate_function=lambda value: assert_string(value, 'title'),
)
def title(self):
return self.get('title')
@title.setter
@TitleProperty.setter()
def title(self, value):
self['title'] = value
@property
@TitleProperty.getter(
nullable=False,
default_value=DEFAULT_SUBTITLE_FONT_SIZE,
value_validate_function=lambda value: assert_font_size(
value, 'title_font_size'
),
)
def title_font_size(self):
return self.get('titleFontSize')
@title_font_size.setter
@TitleProperty.setter()
def title_font_size(self, value):
self['titleFontSize'] = value
@property
@TitleProperty.getter(nullable=False, default_value=DEFAULT_TITLE_FONT_COLOR)
def title_font_color(self):
return self.get('titleFontColor')
@title_font_size.setter
@TitleProperty.setter()
def title_font_color(self, value):
self['titleFontColor'] = value
@property
@TitleProperty.getter(nullable=False, default_value=DEFAULT_TITLE_FONT_FAMILY)
def title_font_family(self):
return self.get('titleFontFamily')
@title_font_size.setter
@TitleProperty.setter()
def title_font_family(self, value):
self['titleFontFamily'] = value
def validate_filter_value(value, index, argument_name):
formatted_argument_name = '{0}[{1}]'.format(argument_name, index)
assert_string(value, formatted_argument_name)
class LegendSettings(PythonModel):
'''A model that represents settings for the legend of a visualization.
'''
@classmethod
def registry(cls):
return LegendProperty
@property
@LegendProperty.getter(
nullable=False,
default_value=DEFAULT_LEGEND_FONT_SIZE,
value_validate_function=lambda value: assert_font_size(
value, 'legend_font_size'
),
)
def legend_font_size(self):
return self.get('legendFontSize')
@legend_font_size.setter
@LegendProperty.setter()
def legend_font_size(self, value):
self['legendFontSize'] = value
@property
@LegendProperty.getter(
nullable=False,
default_value=DEFAULT_LEGEND_FONT_COLOR,
value_validate_function=lambda value: assert_string(value, 'legend_font_color'),
)
def legend_font_color(self):
return self.get('legendFontColor')
@legend_font_color.setter
@LegendProperty.setter()
def legend_font_color(self, value):
self['legendFontColor'] = value
@property
@LegendProperty.getter(
nullable=False,
default_value=DEFAULT_LEGEND_FONT_FAMILY,
value_validate_function=lambda value: assert_string(
value, 'legend_font_family'
),
)
def legend_font_family(self):
return self.get('legendFontFamily')
@legend_font_family.setter
@LegendProperty.setter()
def legend_font_family(self, value):
self['legendFontFamily'] = value
@property
@LegendProperty.getter(
nullable=False,
default_value=DEFAULT_LEGEND_PLACEMENT,
value_validate_function=lambda value: assert_enum(
value, LegendPlacement, 'LegendPlacement', 'legend_placement'
),
value_formatter_function=lambda value: camelcase(value.name.lower()),
)
def legend_placement(self):
return self.get('legendPlacement')
@legend_placement.setter
@LegendProperty.setter(value_parser_function=deserialize_legend_placement)
def legend_placement(self, value):
self['legendPlacement'] = value
@property
@LegendProperty.getter(
nullable=False,
default_value=DEFAULT_LEGEND_OVERLAP_WITH_CHART,
value_validate_function=lambda value: assert_boolean(
value, 'overlap_legend_with_chart'
),
)
def overlap_legend_with_chart(self):
return self.get('overlapLegendWithChart')
@overlap_legend_with_chart.setter
@LegendProperty.setter()
def overlap_legend_with_chart(self, value):
self['overlapLegendWithChart'] = value
@property
@LegendProperty.getter(
nullable=False,
default_value=DEFAULT_SHOW_LEGEND,
value_validate_function=lambda value: assert_boolean(value, 'show_legend'),
)
def show_legend(self):
return self.get('showLegend')
@show_legend.setter
@LegendProperty.setter()
def show_legend(self, value):
self['showLegend'] = value
class SeriesSettingsObject(PythonModel):
def __init__(self, values=None):
values = values or {}
if not values.get('color'):
# We want the generated colour to be stable as opposed to something
# that changes for each property invocation
values['color'] = generate_random_colour()
super(SeriesSettingsObject, self).__init__(values)
@classmethod
def registry(cls):
return SeriesObjectProperty
@property
@SeriesObjectProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_string(
value, 'color', COLOR_PATTERN
),
)
def color(self):
# TODO(vedant) - Replace all the misspelled references to 'color' with
# the proper spelling of 'colour'. (TONGUE IN CHEEK, DON'T TAKE
# LITERALLY)
return self.get('color')
@color.setter
@SeriesObjectProperty.setter()
def color(self, value):
self['color'] = value
@property
@SeriesObjectProperty.getter(
nullable=False,
default_value=DEFAULT_SERIES_DATA_LABEL_FONT_SIZE,
value_validate_function=lambda value: assert_font_size(
value, 'data_label_font_size'
),
)
def data_label_font_size(self):
return self.get('dataLabelFontSize')
@data_label_font_size.setter
@SeriesObjectProperty.setter()
def data_label_font_size(self, value):
self['dataLabelFontSize'] = value
@property
@SeriesObjectProperty.getter(
nullable=False,
default_value=DEFAULT_SERIES_DATA_LABEL_FORMAT,
value_validate_function=lambda value: assert_string(value, 'data_label_format'),
)
def data_label_format(self):
return self.get('dataLabelFormat')
@data_label_format.setter
@SeriesObjectProperty.setter()
def data_label_format(self, value):
self['dataLabelFormat'] = value
@property
@SeriesObjectProperty.getter(
nullable=False, value_validate_function=lambda value: assert_string(value, 'id')
)
def id(self):
return self.get('id')
@id.setter
@SeriesObjectProperty.setter()
def id(self, value):
self['id'] = value
@property
@SeriesObjectProperty.getter(
nullable=False,
default_value=DEFAULT_SERIES_DATA_IS_VISIBLE,
value_validate_function=lambda value: assert_boolean(value, 'is_visible'),
)
def is_visible(self):
return self.get('isVisible')
@is_visible.setter
@SeriesObjectProperty.setter()
def is_visible(self, value):
self['isVisible'] = value
@property
@SeriesObjectProperty.getter(
nullable=False,
default_value=DEFAULT_SERIES_DATA_LABEL,
value_validate_function=lambda value: assert_string(value, 'label'),
)
def label(self):
return self.get('label')
@label.setter
@SeriesObjectProperty.setter()
def label(self, value):
self['label'] = value
@property
@SeriesObjectProperty.getter(
nullable=False,
default_value=DEFAULT_SERIES_SHOW_CONSTITUENTS,
value_validate_function=lambda value: assert_boolean(
value, 'show_constituents'
),
)
def show_constituents(self):
return self.get('showConstituents')
@show_constituents.setter
@SeriesObjectProperty.setter()
def show_constituents(self, value):
self['showConstituents'] = value
@property
@SeriesObjectProperty.getter(
nullable=False,
default_value=DEFAULT_SERIES_SHOW_SERIES_VALUE,
value_validate_function=lambda value: assert_boolean(
value, 'show_series_value'
),
)
def show_series_value(self):
return self.get('showSeriesValue')
@show_series_value.setter
@SeriesObjectProperty.setter()
def show_series_value(self, value):
self['showSeriesValue'] = value
@property
@SeriesObjectProperty.getter(
nullable=False,
default_value=SeriesObjectAxis.Y1_AXIS,
value_validate_function=lambda value: assert_enum(
value, SeriesObjectAxis, 'SeriesObjectAxis', 'y_axis'
),
value_formatter_function=lambda value: camelcase(value.name.lower()),
)
def y_axis(self):
return self.get('yAxis')
@y_axis.setter
@SeriesObjectProperty.setter(
value_parser_function=lambda value: SeriesObjectAxis[snakecase(value).upper()]
)
def y_axis(self, value):
self['yAxis'] = value
def additional_axis_title_distance(self, value):
assert_string(value, 'additionalAxisTitleDistance')
self['additionalAxisTitleDistance'] = value
def labels_font_family(self, value):
assert_string(value, 'labels_font_family')
self['labelsFontFamily'] = value
class XAxisSettings(PythonModel):
'''Settings for the X-Axis for a given visualization.
'''
@classmethod
def registry(cls):
return XAxisProperty
@property
@XAxisProperty.getter(
nullable=False,
default_value=DEFAULT_XAXIS_GOAL_LINE,
value_validate_function=lambda value: assert_string(value, 'goal_line'),
)
def goal_line(self):
return self.get('goalLine')
@goal_line.setter
@XAxisProperty.setter()
def goal_line(self, value):
self['goalLine'] = value
@property
@XAxisProperty.getter(
nullable=False,
default_value=DEFAULT_XAXIS_GOAL_LINE_FONT_SIZE,
value_validate_function=lambda value: assert_string(
value, 'goal_line_font_size'
),
)
def goal_line_font_size(self):
return self.get('goalLineFontSize')
@goal_line_font_size.setter
@XAxisProperty.setter()
def goal_line_font_size(self, value):
self['goalLineFontSize'] = value
@property
@XAxisProperty.getter(
nullable=False,
default_value=DEFAULT_XAXIS_GOAL_LINE_LABEL,
value_validate_function=lambda value: assert_string(value, 'goal_line_label'),
)
def goal_line_label(self):
return self.get('goalLineLabel')
@goal_line_label.setter
@XAxisProperty.setter()
def goal_line_label(self, value):
self['goalLineLabel'] = value
@property
@XAxisProperty.getter(
nullable=False,
default_value=DEFAULT_XAXIS_LABEL_FONT_SIZE,
value_validate_function=lambda value: assert_string(value, 'labels_font_size'),
)
def labels_font_size(self):
return self.get('labelsFontSize')
@labels_font_size.setter
@XAxisProperty.setter()
def labels_font_size(self, value):
self['labelsFontSize'] = value
@property
@XAxisProperty.getter(
nullable=False,
default_value='',
value_validate_function=lambda value: assert_string(value, 'title'),
)
def title(self):
return self.get('title')
@title.setter
@XAxisProperty.setter()
def title(self, value):
self['title'] = value
@property
@XAxisProperty.getter(
nullable=False,
default_value=DEFAULT_XAXIS_TITLE_FONT_SIZE,
value_validate_function=lambda value: assert_string(value, 'title_font_size'),
)
def title_font_size(self):
return self.get('titleFontSize')
@title_font_size.setter
@XAxisProperty.setter()
def title_font_size(self, value):
assert_string(value, 'title_font_size')
self['titleFontSize'] = value
@property
@XAxisProperty.getter(
nullable=False,
default_value=DEFAULT_XAXIS_TITLE_FONT_COLOR,
value_validate_function=lambda value: assert_string(value, 'title_font_color'),
)
def title_font_color(self):
return self.get('titleFontColor')
@title_font_color.setter
@XAxisProperty.setter()
def title_font_color(self, value):
assert_string(value, 'title_font_color')
self['titleFontColor'] = value
@property
@XAxisProperty.getter(
nullable=False,
default_value=DEFAULT_XAXIS_TITLE_FONT_FAMILY,
value_validate_function=lambda value: assert_string(value, 'title_font_family'),
)
def title_font_family(self):
return self.get('titleFontFamily')
@title_font_family.setter
@XAxisProperty.setter()
def title_font_family(self, value):
assert_string(value, 'title_font_family')
self['titleFontFamily'] = value
@property
@XAxisProperty.getter(
nullable=False,
default_value=DEFAULT_XAXIS_LABEL_FONT_COLOR,
value_validate_function=lambda value: assert_string(value, 'labels_font_color'),
)
def labels_font_color(self):
return self.get('labelsFontColor')
@labels_font_color.setter
@XAxisProperty.setter()
def labels_font_color(self, value):
assert_string(value, 'labels_font_color')
self['labelsFontColor'] = value
@property
@XAxisProperty.getter(
nullable=False,
default_value=DEFAULT_XAXIS_LABEL_FONT_FAMILY,
value_validate_function=lambda value: assert_string(
value, 'labels_font_family'
),
)
def labels_font_family(self):
return self.get('labelsFontFamily')
@labels_font_family.setter
@XAxisProperty.setter()
def labels_font_family(self, value):
assert_string(value, 'labels_font_family')
self['labelsFontFamily'] = value
@property
@XAxisProperty.getter(
nullable=False,
default_value=DEFAULT_ADDITIONAL_TITLE_DISTANCE,
value_validate_function=lambda value: assert_string(
value, 'additional_axis_title_distance'
),
)
def additional_axis_title_distance(self):
return self.get('additionalAxisTitleDistance')
@additional_axis_title_distance.setter
@XAxisProperty.setter()
def additional_axis_title_distance(self, value):
assert_string(value, 'additionalAxisTitleDistance')
self['additionalAxisTitleDistance'] = value
class QueryDefinition(PythonModel):
@classmethod
def registry(cls):
return QueryProperty
@property
@QueryProperty.getter(
nullable=False,
default_value=lambda: [],
value_validate_function=lambda value: assert_non_string_iterable(
value, 'advancedFields', validate_advanced_field_item),
)
def advanced_fields(self):
return self.get('advancedFields')
@advanced_fields.setter
@QueryProperty.setter(
value_parser_function=lambda advanced_field_objects: [
AdvancedFieldDefinition(advanced_field_object)
for advanced_field_object in advanced_field_objects
])
def advanced_fields(self, value):
self['advancedFields'] = value
# TODO(pablo): come up with a proper structure for advancedFilters that
# mirrors the SerializedQueryFilter
@property
@QueryProperty.getter(
nullable=False,
default_value=lambda: [],
value_validate_function=lambda value: assert_non_string_iterable(
value, 'advancedFilters', validate_mapping),
)
def advanced_filters(self):
return self.get('advancedFilters')
@advanced_filters.setter
@QueryProperty.setter()
def advanced_filters(self, value):
self['advancedFilters'] = value
@property
@QueryProperty.getter(
nullable=False,
default_value=lambda: [],
value_validate_function=lambda value: assert_non_string_iterable(
value, 'advancedGroups', validate_mapping),
)
def advanced_groups(self):
return self.get('advancedGroups')
@advanced_groups.setter
@QueryProperty.setter()
def advanced_groups(self, value):
self['advancedGroups'] = value
@property
@QueryProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_string(value, 'id'))
def id(self):
return self.get('id')
@id.setter
@QueryProperty.setter()
def id(self, value):
self['id'] = value
@property
@QueryProperty.getter(
value_validate_function=lambda value: assert_string(value, 'name'))
def name(self):
return self.get('name')
@name.setter
@QueryProperty.setter()
def name(self, value):
self['name'] = value
@property
@QueryProperty.getter(
nullable=False,
serialized_property_name='magicFilters',
default_value=lambda: [],
value_validate_function=lambda value: assert_non_string_iterable(
value, 'magic_filter_ids', string_type_validator),
)
def magic_filter_ids(self):
return self.get('magicFilters')
@magic_filter_ids.setter
@QueryProperty.setter()
def magic_filter_ids(self, value):
self['magicFilters'] = value
@property
@QueryProperty.getter(
nullable=False,
default_value='',
value_validate_function=lambda value: assert_string(
value, 'date_range_id'),
)
def date_range_id(self):
return self.get('dateRangeId')
@date_range_id.setter
@QueryProperty.setter()
def date_range_id(self, value):
self['dateRangeId'] = value
@property
@QueryProperty.getter(
nullable=False,
default_value='',
value_validate_function=lambda value: assert_string(value, 'group_by'),
)
def group_by(self):
return self.get('groupBy')
@group_by.setter
@QueryProperty.setter()
def group_by(self, value):
self['groupBy'] = value
def title_font_color(self, value):
assert_string(value, 'title_font_color')
self['titleFontColor'] = value
class DateRangeSpecification(PythonModel):
@classmethod
def registry(cls):
return DateRangeProperty
@property
@DateRangeProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_string(value, 'id'))
def id(self):
return self.get('id')
@id.setter
@DateRangeProperty.setter()
def id(self, value):
self['id'] = value
@property
@DateRangeProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_enum(
value, DateRangeType, argument_name='date_type'),
value_formatter_function=lambda value: value.name,
)
def date_type(self):
return self.get('dateType')
@date_type.setter
@DateRangeProperty.setter(value_parser_function=deserialize_date_range)
def date_type(self, value):
self['dateType'] = value
@property
@DateRangeProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_datetime(
value, 'end_date'),
value_formatter_function=stringify_datetime,
)
def end_date(self):
return self.get('endDate')
@end_date.setter
@DateRangeProperty.setter(value_parser_function=convert_datetime)
def end_date(self, value):
start_date = self.get('startDate')
assert_datetime(value, 'end_date', start_date)
self['endDate'] = value
@property
@DateRangeProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_datetime(
value, 'start_date'),
value_formatter_function=stringify_datetime,
)
def start_date(self):
return self.get('startDate')
@start_date.setter
@DateRangeProperty.setter(value_parser_function=convert_datetime)
def start_date(self, value):
end_date = self.get('endDate')
assert_datetime(value, 'start_date', upper_bound=end_date)
self['startDate'] = value
def title_font_family(self, value):
assert_string(value, 'title_font_family')
self['titleFontFamily'] = value
class AdvancedFieldDefinition(PythonModel):
@classmethod
def registry(cls):
return AdvancedFieldProperty
@property
@AdvancedFieldProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_mapping(
value, 'calculation'),
)
def calculation(self):
return self.get('calculation')
@calculation.setter
@AdvancedFieldProperty.setter()
def calculation(self, value):
self['calculation'] = value
@property
@AdvancedFieldProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_mapping(
value, 'category'),
)
def category(self):
return self.get('category')
@category.setter
@AdvancedFieldProperty.setter()
def category(self, value):
self['category'] = value
@property
@AdvancedFieldProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_string(
value, 'canonicalName'),
)
def canonical_name(self):
return self.get('canonicalName')
@canonical_name.setter
@AdvancedFieldProperty.setter()
def canonical_name(self, value):
self['canonicalName'] = value
@property
@AdvancedFieldProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_string(value, 'id'))
def id(self):
return self.get('id')
@id.setter
@AdvancedFieldProperty.setter()
def id(self, value):
self['id'] = value
@property
@AdvancedFieldProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_string(
value, 'shortName'),
)
def short_name(self):
return self.get('shortName')
@short_name.setter
@AdvancedFieldProperty.setter()
def short_name(self, value):
self['shortName'] = value
@property
@AdvancedFieldProperty.getter(
nullable=False,
value_validate_function=lambda value: assert_mapping(value, 'source'),
)
def source(self):
return self.get('source')
@source.setter
@AdvancedFieldProperty.setter()
def source(self, value):
self['source'] = value
@property
@AdvancedFieldProperty.getter(
nullable=False,
default_value='',
value_validate_function=lambda value: assert_string(
value, 'description'),
)
def description(self):
return self.get('description')
@description.setter
@AdvancedFieldProperty.setter()
def description(self, value):
self['description'] = value
@property
@AdvancedFieldProperty.getter(
nullable=False,
default_value='',
value_validate_function=lambda value: assert_string(value, 'label'),
)
def label(self):
return self.get('label')
@label.setter
@AdvancedFieldProperty.setter()
def label(self, value):
self['label'] = value
def labels_font_color(self, value):
assert_string(value, 'labels_font_color')
self['labelsFontColor'] = value
