From 67146db40ae644f4e80d766fc0362863f4543c7e Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Fri, 13 Mar 2026 15:16:23 +0000 Subject: [PATCH] Regenerate client from commit 6d4f577 of spec repo --- .generator/schemas/v1/openapi.yaml | 775 +++++++++++++++++- docs/datadog_api_client.v1.model.rst | 329 ++++++++ .../v1/model/guided_table_column.py | 69 ++ .../model/guided_table_column_comparison.py | 47 ++ ...ble_column_comparison_with_other_column.py | 50 ++ ...olumn_comparison_with_other_column_type.py | 43 + ...uided_table_column_comparison_with_self.py | 44 + ..._table_column_comparison_with_self_type.py | 37 + .../v1/model/guided_table_column_format.py | 49 ++ .../v1/model/guided_table_column_function.py | 43 + .../v1/model/guided_table_compute_column.py | 118 +++ .../guided_table_compute_column_compute.py | 63 ++ .../model/guided_table_compute_column_type.py | 35 + .../model/guided_table_conditional_formats.py | 39 + .../v1/model/guided_table_events_query.py | 89 ++ .../guided_table_events_query_data_source.py | 50 ++ .../model/guided_table_events_query_search.py | 36 + .../v1/model/guided_table_formula_column.py | 106 +++ .../v1/model/guided_table_group_key.py | 39 + .../v1/model/guided_table_metrics_query.py | 76 ++ .../guided_table_metrics_query_data_source.py | 38 + .../guided_table_number_bar_column_format.py | 77 ++ ...ded_table_number_bar_column_format_mode.py | 38 + .../v1/model/guided_table_number_format.py | 69 ++ .../guided_table_number_format_precision.py | 34 + .../v1/model/guided_table_preset_column.py | 118 +++ .../guided_table_preset_column_preset.py | 46 ++ .../guided_table_preset_column_preset_type.py | 35 + .../model/guided_table_preset_column_type.py | 35 + .../v1/model/guided_table_query.py | 61 ++ .../guided_table_range_formatting_rule.py | 93 +++ ...uided_table_range_formatting_rule_scale.py | 44 + ...guided_table_range_formatting_rule_type.py | 35 + .../v1/model/guided_table_range_palette.py | 68 ++ .../v1/model/guided_table_request.py | 84 ++ .../guided_table_request_request_type.py | 35 + .../v1/model/guided_table_row_group_by.py | 79 ++ .../model/guided_table_row_group_by_format.py | 42 + .../v1/model/guided_table_rows.py | 54 ++ .../v1/model/guided_table_sort.py | 52 ++ .../v1/model/guided_table_storage_type.py | 53 ++ .../guided_table_text_formatting_rule.py | 95 +++ ...ided_table_text_formatting_rule_replace.py | 48 ++ ...ormatting_rule_replace_one_of4484404608.py | 56 ++ .../guided_table_threshold_formatting_rule.py | 101 +++ ...d_table_threshold_formatting_rule_value.py | 34 + .../model/guided_table_threshold_palette.py | 86 ++ .../model/guided_table_trend_column_format.py | 84 ++ .../guided_table_trend_column_format_mode.py | 35 + .../v1/model/table_widget_definition.py | 12 +- src/datadog_api_client/v1/models/__init__.py | 104 +++ 51 files changed, 3974 insertions(+), 8 deletions(-) create mode 100644 src/datadog_api_client/v1/model/guided_table_column.py create mode 100644 src/datadog_api_client/v1/model/guided_table_column_comparison.py create mode 100644 src/datadog_api_client/v1/model/guided_table_column_comparison_with_other_column.py create mode 100644 src/datadog_api_client/v1/model/guided_table_column_comparison_with_other_column_type.py create mode 100644 src/datadog_api_client/v1/model/guided_table_column_comparison_with_self.py create mode 100644 src/datadog_api_client/v1/model/guided_table_column_comparison_with_self_type.py create mode 100644 src/datadog_api_client/v1/model/guided_table_column_format.py create mode 100644 src/datadog_api_client/v1/model/guided_table_column_function.py create mode 100644 src/datadog_api_client/v1/model/guided_table_compute_column.py create mode 100644 src/datadog_api_client/v1/model/guided_table_compute_column_compute.py create mode 100644 src/datadog_api_client/v1/model/guided_table_compute_column_type.py create mode 100644 src/datadog_api_client/v1/model/guided_table_conditional_formats.py create mode 100644 src/datadog_api_client/v1/model/guided_table_events_query.py create mode 100644 src/datadog_api_client/v1/model/guided_table_events_query_data_source.py create mode 100644 src/datadog_api_client/v1/model/guided_table_events_query_search.py create mode 100644 src/datadog_api_client/v1/model/guided_table_formula_column.py create mode 100644 src/datadog_api_client/v1/model/guided_table_group_key.py create mode 100644 src/datadog_api_client/v1/model/guided_table_metrics_query.py create mode 100644 src/datadog_api_client/v1/model/guided_table_metrics_query_data_source.py create mode 100644 src/datadog_api_client/v1/model/guided_table_number_bar_column_format.py create mode 100644 src/datadog_api_client/v1/model/guided_table_number_bar_column_format_mode.py create mode 100644 src/datadog_api_client/v1/model/guided_table_number_format.py create mode 100644 src/datadog_api_client/v1/model/guided_table_number_format_precision.py create mode 100644 src/datadog_api_client/v1/model/guided_table_preset_column.py create mode 100644 src/datadog_api_client/v1/model/guided_table_preset_column_preset.py create mode 100644 src/datadog_api_client/v1/model/guided_table_preset_column_preset_type.py create mode 100644 src/datadog_api_client/v1/model/guided_table_preset_column_type.py create mode 100644 src/datadog_api_client/v1/model/guided_table_query.py create mode 100644 src/datadog_api_client/v1/model/guided_table_range_formatting_rule.py create mode 100644 src/datadog_api_client/v1/model/guided_table_range_formatting_rule_scale.py create mode 100644 src/datadog_api_client/v1/model/guided_table_range_formatting_rule_type.py create mode 100644 src/datadog_api_client/v1/model/guided_table_range_palette.py create mode 100644 src/datadog_api_client/v1/model/guided_table_request.py create mode 100644 src/datadog_api_client/v1/model/guided_table_request_request_type.py create mode 100644 src/datadog_api_client/v1/model/guided_table_row_group_by.py create mode 100644 src/datadog_api_client/v1/model/guided_table_row_group_by_format.py create mode 100644 src/datadog_api_client/v1/model/guided_table_rows.py create mode 100644 src/datadog_api_client/v1/model/guided_table_sort.py create mode 100644 src/datadog_api_client/v1/model/guided_table_storage_type.py create mode 100644 src/datadog_api_client/v1/model/guided_table_text_formatting_rule.py create mode 100644 src/datadog_api_client/v1/model/guided_table_text_formatting_rule_replace.py create mode 100644 src/datadog_api_client/v1/model/guided_table_text_formatting_rule_replace_one_of4484404608.py create mode 100644 src/datadog_api_client/v1/model/guided_table_threshold_formatting_rule.py create mode 100644 src/datadog_api_client/v1/model/guided_table_threshold_formatting_rule_value.py create mode 100644 src/datadog_api_client/v1/model/guided_table_threshold_palette.py create mode 100644 src/datadog_api_client/v1/model/guided_table_trend_column_format.py create mode 100644 src/datadog_api_client/v1/model/guided_table_trend_column_format_mode.py diff --git a/.generator/schemas/v1/openapi.yaml b/.generator/schemas/v1/openapi.yaml index daa9d89fc3..1b8843ed56 100644 --- a/.generator/schemas/v1/openapi.yaml +++ b/.generator/schemas/v1/openapi.yaml @@ -3942,6 +3942,773 @@ components: type: string x-enum-varnames: - GROUP + GuidedTableColumn: + description: Definition of a single column in a guided table widget. A column + can be a computed value, a preset comparison, or a formula. + oneOf: + - $ref: '#/components/schemas/GuidedTableComputeColumn' + - $ref: '#/components/schemas/GuidedTablePresetColumn' + - $ref: '#/components/schemas/GuidedTableFormulaColumn' + GuidedTableColumnComparison: + description: Comparison to display in a guided table column. + oneOf: + - $ref: '#/components/schemas/GuidedTableColumnComparisonWithSelf' + - $ref: '#/components/schemas/GuidedTableColumnComparisonWithOtherColumn' + GuidedTableColumnComparisonWithOtherColumn: + description: Comparison of a column value against another column. + properties: + column: + description: Name of the column to compare against. + example: '' + type: string + type: + $ref: '#/components/schemas/GuidedTableColumnComparisonWithOtherColumnType' + required: + - type + - column + type: object + GuidedTableColumnComparisonWithOtherColumnType: + enum: + - diff_from + - percent_of + - percent_diff_from + example: diff_from + type: string + x-enum-varnames: + - DIFF_FROM + - PERCENT_OF + - PERCENT_DIFF_FROM + GuidedTableColumnComparisonWithSelf: + description: Comparison of a column value against the column's own total (percent + of column total). + properties: + type: + $ref: '#/components/schemas/GuidedTableColumnComparisonWithSelfType' + required: + - type + type: object + GuidedTableColumnComparisonWithSelfType: + enum: + - percent_column_total + example: percent_column_total + type: string + x-enum-varnames: + - PERCENT_COLUMN_TOTAL + GuidedTableColumnFormat: + description: Visual formatting applied to values in a guided table column. Supports + number/bar mode and trend mode. + oneOf: + - $ref: '#/components/schemas/GuidedTableNumberBarColumnFormat' + - $ref: '#/components/schemas/GuidedTableTrendColumnFormat' + GuidedTableColumnFunction: + description: A function to apply when computing a column's value. + properties: + args: + description: Arguments passed to the function in order. + items: + oneOf: + - type: string + - type: number + - type: boolean + type: array + name: + description: Function name (e.g. `clamp_min`, `abs`, `round`). Not restricted + to a fixed set. + example: '' + type: string + required: + - name + type: object + GuidedTableComputeColumn: + description: A guided table column that computes an aggregation directly from + one of the table's base queries. + properties: + alias: + description: Display name shown as the column header. + type: string + comparison: + $ref: '#/components/schemas/GuidedTableColumnComparison' + compute: + $ref: '#/components/schemas/GuidedTableComputeColumnCompute' + format: + $ref: '#/components/schemas/GuidedTableColumnFormat' + functions: + description: Functions to apply sequentially to the computed value. + items: + $ref: '#/components/schemas/GuidedTableColumnFunction' + type: array + is_hidden: + description: Whether this column is hidden in the rendered table. + type: boolean + name: + description: Auto-generated name used to refer to this column. + example: '' + type: string + type: + $ref: '#/components/schemas/GuidedTableComputeColumnType' + required: + - name + - type + - compute + - format + type: object + GuidedTableComputeColumnCompute: + description: Aggregation configuration. + properties: + aggregation: + description: Aggregation type (e.g. `avg`, `sum`, `count`). + example: '' + type: string + filter: + description: Additional filter criteria. + type: string + property: + description: Attribute to aggregate on. Depends on the data source (e.g. + a log attribute). + type: string + query: + description: Name of the source query. + example: '' + type: string + required: + - query + - aggregation + type: object + GuidedTableComputeColumnType: + enum: + - compute + example: compute + type: string + x-enum-varnames: + - COMPUTE + GuidedTableConditionalFormats: + description: Conditional formatting rules for a guided table column. Either + an array of threshold-based rules or a single range-based rule. + oneOf: + - $ref: '#/components/schemas/GuidedTableThresholdConditionalFormats' + - $ref: '#/components/schemas/GuidedTableRangeConditionalFormats' + GuidedTableEventsQuery: + description: An events-platform query fragment used as source data for a guided + table. Covers logs, RUM, spans, CI pipelines, events, and product analytics. + properties: + alias: + description: Display alias for the query. + type: string + data_source: + $ref: '#/components/schemas/GuidedTableEventsQueryDataSource' + indexes: + description: Indexes to search for events. + items: + type: string + type: array + name: + description: Variable name used to reference this query in columns and formulas. + example: '' + type: string + search: + $ref: '#/components/schemas/GuidedTableEventsQuerySearch' + storage: + $ref: '#/components/schemas/GuidedTableStorageType' + required: + - name + - data_source + type: object + GuidedTableEventsQueryDataSource: + description: Events data source. + enum: + - logs + - rum + - spans + - ci_pipelines + - events + - product_analytics + example: logs + type: string + x-enum-varnames: + - LOGS + - RUM + - SPANS + - CI_PIPELINES + - EVENTS + - PRODUCT_ANALYTICS + GuidedTableEventsQuerySearch: + description: Search filter for matching events. + properties: + query: + description: Events search query string using events-platform search grammar. + type: string + type: object + GuidedTableFormulaColumn: + description: A guided table column that displays the result of evaluating a + formula over other columns. + properties: + alias: + description: Display name shown as the column header. + type: string + comparison: + $ref: '#/components/schemas/GuidedTableColumnComparison' + format: + $ref: '#/components/schemas/GuidedTableColumnFormat' + formula: + description: The formula expression to evaluate. + example: '' + type: string + is_hidden: + description: Whether this column is hidden in the rendered table. + type: boolean + name: + description: Auto-generated name used to refer to this column. + example: '' + type: string + type: + $ref: '#/components/schemas/FormulaType' + required: + - name + - type + - formula + - format + type: object + GuidedTableGroupKey: + description: Maps a specific base query to the field name used for grouping. + properties: + group_key: + description: Field name in the query result used as the grouping key. + example: '' + type: string + query: + description: Name of the source query. + example: '' + type: string + required: + - query + - group_key + type: object + GuidedTableMetricsQuery: + description: A metrics (or cloud cost) query fragment used as source data for + a guided table. Group-by and time/space aggregation are defined separately. + properties: + alias: + description: Display alias for the query. + type: string + data_source: + $ref: '#/components/schemas/GuidedTableMetricsQueryDataSource' + filter: + description: Filter string to apply to the metric query. + type: string + metric_name: + description: Name of the metric to query. + example: '' + type: string + name: + description: Variable name used to reference this query in columns and formulas. + example: '' + type: string + required: + - name + - data_source + - metric_name + type: object + GuidedTableMetricsQueryDataSource: + description: Metrics data source. + enum: + - metrics + - cloud_cost + example: metrics + type: string + x-enum-varnames: + - METRICS + - CLOUD_COST + GuidedTableNumberBarColumnFormat: + description: Formats a guided table column as a number or a bar. + properties: + conditional_formats: + $ref: '#/components/schemas/GuidedTableConditionalFormats' + mode: + $ref: '#/components/schemas/GuidedTableNumberBarColumnFormatMode' + number_format: + $ref: '#/components/schemas/GuidedTableNumberFormat' + required: + - mode + type: object + GuidedTableNumberBarColumnFormatMode: + enum: + - number + - bar + example: number + type: string + x-enum-varnames: + - NUMBER + - BAR + GuidedTableNumberFormat: + description: Number display format for a guided table column value. + properties: + precision: + $ref: '#/components/schemas/GuidedTableNumberFormatPrecision' + unit: + $ref: '#/components/schemas/NumberFormatUnit' + unit_scale: + $ref: '#/components/schemas/NumberFormatUnitScale' + type: object + GuidedTableNumberFormatPrecision: + description: Number of digits after the decimal point. Use `*` for full precision, + `integer` to show full integer values, or omit for automatic precision. + oneOf: + - type: string + - format: int32 + maximum: 100 + minimum: 0 + type: integer + GuidedTablePresetColumn: + description: A guided table column that displays values for the previous time + period based on another column's full query. + properties: + alias: + description: Display name shown as the column header. + type: string + comparison: + $ref: '#/components/schemas/GuidedTableColumnComparison' + format: + $ref: '#/components/schemas/GuidedTableColumnFormat' + functions: + description: Functions to apply sequentially to the computed value. + items: + $ref: '#/components/schemas/GuidedTableColumnFunction' + type: array + is_hidden: + description: Whether this column is hidden in the rendered table. + type: boolean + name: + description: Auto-generated name used to refer to this column. + example: '' + type: string + preset: + $ref: '#/components/schemas/GuidedTablePresetColumnPreset' + type: + $ref: '#/components/schemas/GuidedTablePresetColumnType' + required: + - name + - type + - preset + - format + type: object + GuidedTablePresetColumnPreset: + description: Preset configuration. + properties: + column: + description: Name of the column whose full query is reused. + example: '' + type: string + type: + $ref: '#/components/schemas/GuidedTablePresetColumnPresetType' + required: + - type + - column + type: object + GuidedTablePresetColumnPresetType: + enum: + - previous_period + example: previous_period + type: string + x-enum-varnames: + - PREVIOUS_PERIOD + GuidedTablePresetColumnType: + enum: + - preset + example: preset + type: string + x-enum-varnames: + - PRESET + GuidedTableQuery: + description: A base query used as source data for a guided table widget. Either + a metrics query or an events-platform query. + oneOf: + - $ref: '#/components/schemas/GuidedTableMetricsQuery' + - $ref: '#/components/schemas/GuidedTableEventsQuery' + GuidedTableRangeConditionalFormats: + description: Single range-based conditional formatting rule. + items: + $ref: '#/components/schemas/GuidedTableRangeFormattingRule' + maxItems: 1 + type: array + GuidedTableRangeFormattingRule: + description: Formats values according to where they fall on a color scale. + properties: + max: + description: Maximum value on the mapping scale. + format: double + type: number + min: + description: Minimum value on the mapping scale. + format: double + type: number + palette: + $ref: '#/components/schemas/GuidedTableRangePalette' + reverse: + description: Whether to reverse the palette scale direction. + type: boolean + scale: + $ref: '#/components/schemas/GuidedTableRangeFormattingRuleScale' + type: + $ref: '#/components/schemas/GuidedTableRangeFormattingRuleType' + required: + - type + - palette + type: object + GuidedTableRangeFormattingRuleScale: + description: Scale function for mapping values to colors. + enum: + - linear + - log + - pow + - sqrt + type: string + x-enum-varnames: + - LINEAR + - LOG + - POW + - SQRT + GuidedTableRangeFormattingRuleType: + enum: + - range + example: range + type: string + x-enum-varnames: + - RANGE + GuidedTableRangePalette: + description: Color palette used by range-based conditional formatting rules. + enum: + - transparent_to_green + - transparent_to_orange + - transparent_to_red + - transparent_to_blue + - red_transparent_green + - red_transparent_blue + - vivid_transparent_to_green + - vivid_transparent_to_orange + - vivid_transparent_to_red + - vivid_transparent_to_blue + - vivid_red_transparent_green + - vivid_red_transparent_blue + example: transparent_to_green + type: string + x-enum-varnames: + - TRANSPARENT_TO_GREEN + - TRANSPARENT_TO_ORANGE + - TRANSPARENT_TO_RED + - TRANSPARENT_TO_BLUE + - RED_TRANSPARENT_GREEN + - RED_TRANSPARENT_BLUE + - VIVID_TRANSPARENT_TO_GREEN + - VIVID_TRANSPARENT_TO_ORANGE + - VIVID_TRANSPARENT_TO_RED + - VIVID_TRANSPARENT_TO_BLUE + - VIVID_RED_TRANSPARENT_GREEN + - VIVID_RED_TRANSPARENT_BLUE + GuidedTableRequest: + description: "Request definition for the guided table widget \u2014 a structured, + guided format for defining a table of data. Used when the `graphing_new_table_widget_editor` + feature flag is enabled; otherwise use the classic `TableWidgetRequest`. Defines + base queries, how to produce rows, and how to compute columns." + example: + columns: + - compute: + aggregation: avg + query: query1 + format: + mode: number + name: column1 + type: compute + queries: + - data_source: metrics + metric_name: system.cpu.user + name: query1 + request_type: table + rows: + group_by: + - group_keys: + - group_key: service + query: query1 + name: groupBy1 + sort: + columns: + - column: column1 + order: desc + limit: 10 + properties: + columns: + description: Column definitions that describe how to compute and display + table values. + example: + - compute: + aggregation: avg + query: query1 + format: + mode: number + name: column1 + type: compute + items: + $ref: '#/components/schemas/GuidedTableColumn' + type: array + queries: + description: Base queries that provide the source data for the table. + example: + - data_source: metrics + metric_name: system.cpu.user + name: query1 + items: + $ref: '#/components/schemas/GuidedTableQuery' + minItems: 1 + type: array + request_type: + $ref: '#/components/schemas/GuidedTableRequestRequestType' + rows: + $ref: '#/components/schemas/GuidedTableRows' + required: + - request_type + - queries + - rows + - columns + type: object + GuidedTableRequestRequestType: + description: Identifies this as a guided table request. + enum: + - table + example: table + type: string + x-enum-varnames: + - TABLE + GuidedTableRowGroupBy: + description: Defines one group-by dimension used to produce the rows of a guided + table. + properties: + alias: + description: Display name used as the column header for this group-by. + type: string + format: + $ref: '#/components/schemas/GuidedTableRowGroupByFormat' + group_keys: + description: Mapping from each source query to the field name used as the + grouping key. Different data sources may use different field names for + the same concept. + items: + $ref: '#/components/schemas/GuidedTableGroupKey' + type: array + is_hidden: + description: Whether this group-by column is hidden in the rendered table. + type: boolean + name: + description: Auto-generated name for this group-by parameter. + example: '' + type: string + required: + - name + - group_keys + type: object + GuidedTableRowGroupByFormat: + description: Text formatting configuration for this group-by column. + properties: + text_formats: + items: + $ref: '#/components/schemas/GuidedTableTextFormattingRule' + type: array + type: object + GuidedTableRows: + description: Defines how to compute the rows of a guided table. + properties: + group_by: + description: Grouping dimensions that form each row. Must be non-empty. + items: + $ref: '#/components/schemas/GuidedTableRowGroupBy' + minItems: 1 + type: array + sort: + $ref: '#/components/schemas/GuidedTableSort' + required: + - group_by + - sort + type: object + GuidedTableSort: + description: Sort configuration for a guided table. + properties: + columns: + description: Columns to sort by, in order of application. + items: + $ref: '#/components/schemas/WidgetFieldSort' + type: array + limit: + description: Maximum number of rows to show after sorting. + example: 1 + format: int64 + minimum: 1 + type: integer + required: + - limit + - columns + type: object + GuidedTableStorageType: + description: Storage tier to target for an events-platform query in a guided + table. + enum: + - live + - hot + - online_archives + - driveline + - flex_tier + - case_insensitive + - cloud_prem + type: string + x-enum-varnames: + - LIVE + - HOT + - ONLINE_ARCHIVES + - DRIVELINE + - FLEX_TIER + - CASE_INSENSITIVE + - CLOUD_PREM + GuidedTableTextFormattingRule: + description: Rule for applying visual formatting to text values in a guided + table group-by column. + properties: + custom_bg_color: + description: Custom background color hex code. Used with `custom_bg` palette. + example: '#632ca6' + type: string + custom_fg_color: + description: Custom text color hex code. Used with `custom_text` palette. + example: '#632ca6' + type: string + match: + $ref: '#/components/schemas/TableWidgetTextFormatMatch' + palette: + $ref: '#/components/schemas/GuidedTableThresholdPalette' + replace: + $ref: '#/components/schemas/GuidedTableTextFormattingRuleReplace' + required: + - match + type: object + GuidedTableTextFormattingRuleReplace: + description: Optional replacement to apply to matched text. + oneOf: + - $ref: '#/components/schemas/TableWidgetTextFormatReplaceAll' + - $ref: '#/components/schemas/GuidedTableTextFormattingRuleReplaceOneOf4484404608' + GuidedTableTextFormattingRuleReplaceOneOf4484404608: + description: Replace a specific substring. + properties: + substring: + example: '' + type: string + type: + $ref: '#/components/schemas/TableWidgetTextFormatReplaceSubstringType' + with: + example: '' + type: string + required: + - type + - substring + - with + type: object + GuidedTableThresholdConditionalFormats: + description: Array of threshold-based conditional formatting rules. + items: + $ref: '#/components/schemas/GuidedTableThresholdFormattingRule' + type: array + GuidedTableThresholdFormattingRule: + description: Conditional formatting rule that applies when a value satisfies + a threshold comparator condition. + properties: + comparator: + $ref: '#/components/schemas/WidgetComparator' + custom_bg_color: + description: Custom background color. Used with `custom_bg` palette. + type: string + custom_fg_color: + description: Custom text color. Used with `custom_text` palette. + type: string + hide_value: + description: Whether to hide the data value when this rule matches. + type: boolean + image_url: + description: URL of an image to display as background. + type: string + palette: + $ref: '#/components/schemas/GuidedTableThresholdPalette' + value: + $ref: '#/components/schemas/GuidedTableThresholdFormattingRuleValue' + required: + - comparator + - palette + type: object + GuidedTableThresholdFormattingRuleValue: + description: Threshold value to compare against. + oneOf: + - format: double + type: number + - type: string + GuidedTableThresholdPalette: + description: Color palette used by threshold-based conditional formatting and + text formatting rules in a guided table. + enum: + - white_on_red + - black_on_light_red + - white_on_green + - black_on_light_green + - white_on_yellow + - black_on_light_yellow + - white_on_gray + - green_on_white + - yellow_on_white + - red_on_white + - gray_on_white + - red + - green + - orange + - gray + - custom_bg + - custom_text + - custom_image + example: white_on_red + type: string + x-enum-varnames: + - WHITE_ON_RED + - BLACK_ON_LIGHT_RED + - WHITE_ON_GREEN + - BLACK_ON_LIGHT_GREEN + - WHITE_ON_YELLOW + - BLACK_ON_LIGHT_YELLOW + - WHITE_ON_GRAY + - GREEN_ON_WHITE + - YELLOW_ON_WHITE + - RED_ON_WHITE + - GRAY_ON_WHITE + - RED + - GREEN + - ORANGE + - GRAY + - CUSTOM_BG + - CUSTOM_TEXT + - CUSTOM_IMAGE + GuidedTableTrendColumnFormat: + description: Formats a guided table column as a trend sparkline. + properties: + conditional_formats: + $ref: '#/components/schemas/GuidedTableConditionalFormats' + mode: + $ref: '#/components/schemas/GuidedTableTrendColumnFormatMode' + number_format: + $ref: '#/components/schemas/GuidedTableNumberFormat' + trend_options: + $ref: '#/components/schemas/WidgetFormulaCellDisplayModeOptions' + required: + - mode + - trend_options + type: object + GuidedTableTrendColumnFormatMode: + enum: + - trend + example: trend + type: string + x-enum-varnames: + - TREND HTTPLog: description: Structured log message. items: @@ -19454,11 +20221,15 @@ components: has_search_bar: $ref: '#/components/schemas/TableWidgetHasSearchBar' requests: - description: Widget definition. + description: Widget definition. Each item is either a classic `TableWidgetRequest` + or an experimental `GuidedTableRequest` (used when the `graphing_new_table_widget_editor` + feature flag is enabled). example: - q/apm_query/log_query: {} items: - $ref: '#/components/schemas/TableWidgetRequest' + oneOf: + - $ref: '#/components/schemas/TableWidgetRequest' + - $ref: '#/components/schemas/GuidedTableRequest' type: array time: $ref: '#/components/schemas/WidgetTime' diff --git a/docs/datadog_api_client.v1.model.rst b/docs/datadog_api_client.v1.model.rst index 707acb5bc9..67aed79abd 100644 --- a/docs/datadog_api_client.v1.model.rst +++ b/docs/datadog_api_client.v1.model.rst @@ -1215,6 +1215,335 @@ datadog\_api\_client.v1.model.group\_widget\_definition\_type module :members: :show-inheritance: +datadog\_api\_client.v1.model.guided\_table\_column module +---------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_column + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_column\_comparison module +---------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_column_comparison + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_column\_comparison\_with\_other\_column module +------------------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_column_comparison_with_other_column + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_column\_comparison\_with\_other\_column\_type module +------------------------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_column_comparison_with_other_column_type + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_column\_comparison\_with\_self module +---------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_column_comparison_with_self + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_column\_comparison\_with\_self\_type module +---------------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_column_comparison_with_self_type + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_column\_format module +------------------------------------------------------------------ + +.. automodule:: datadog_api_client.v1.model.guided_table_column_format + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_column\_function module +-------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_column_function + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_compute\_column module +------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_compute_column + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_compute\_column\_compute module +---------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_compute_column_compute + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_compute\_column\_type module +------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_compute_column_type + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_conditional\_formats module +------------------------------------------------------------------------ + +.. automodule:: datadog_api_client.v1.model.guided_table_conditional_formats + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_events\_query module +----------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_events_query + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_events\_query\_data\_source module +------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_events_query_data_source + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_events\_query\_search module +------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_events_query_search + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_formula\_column module +------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_formula_column + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_group\_key module +-------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_group_key + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_metrics\_query module +------------------------------------------------------------------ + +.. automodule:: datadog_api_client.v1.model.guided_table_metrics_query + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_metrics\_query\_data\_source module +-------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_metrics_query_data_source + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_number\_bar\_column\_format module +------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_number_bar_column_format + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_number\_bar\_column\_format\_mode module +------------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_number_bar_column_format_mode + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_number\_format module +------------------------------------------------------------------ + +.. automodule:: datadog_api_client.v1.model.guided_table_number_format + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_number\_format\_precision module +----------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_number_format_precision + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_preset\_column module +------------------------------------------------------------------ + +.. automodule:: datadog_api_client.v1.model.guided_table_preset_column + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_preset\_column\_preset module +-------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_preset_column_preset + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_preset\_column\_preset\_type module +-------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_preset_column_preset_type + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_preset\_column\_type module +------------------------------------------------------------------------ + +.. automodule:: datadog_api_client.v1.model.guided_table_preset_column_type + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_query module +--------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_query + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_range\_formatting\_rule module +--------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_range_formatting_rule + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_range\_formatting\_rule\_scale module +---------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_range_formatting_rule_scale + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_range\_formatting\_rule\_type module +--------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_range_formatting_rule_type + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_range\_palette module +------------------------------------------------------------------ + +.. automodule:: datadog_api_client.v1.model.guided_table_range_palette + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_request module +----------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_request + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_request\_request\_type module +-------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_request_request_type + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_row\_group\_by module +------------------------------------------------------------------ + +.. automodule:: datadog_api_client.v1.model.guided_table_row_group_by + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_row\_group\_by\_format module +-------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_row_group_by_format + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_rows module +-------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_rows + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_sort module +-------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_sort + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_storage\_type module +----------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_storage_type + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_text\_formatting\_rule module +-------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_text_formatting_rule + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_text\_formatting\_rule\_replace module +----------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_text_formatting_rule_replace + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_text\_formatting\_rule\_replace\_one\_of4484404608 module +------------------------------------------------------------------------------------------------------ + +.. automodule:: datadog_api_client.v1.model.guided_table_text_formatting_rule_replace_one_of4484404608 + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_threshold\_formatting\_rule module +------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_threshold_formatting_rule + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_threshold\_formatting\_rule\_value module +-------------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_threshold_formatting_rule_value + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_threshold\_palette module +---------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_threshold_palette + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_trend\_column\_format module +------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_trend_column_format + :members: + :show-inheritance: + +datadog\_api\_client.v1.model.guided\_table\_trend\_column\_format\_mode module +------------------------------------------------------------------------------- + +.. automodule:: datadog_api_client.v1.model.guided_table_trend_column_format_mode + :members: + :show-inheritance: + datadog\_api\_client.v1.model.heat\_map\_widget\_definition module ------------------------------------------------------------------ diff --git a/src/datadog_api_client/v1/model/guided_table_column.py b/src/datadog_api_client/v1/model/guided_table_column.py new file mode 100644 index 0000000000..bd5b05f1c6 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_column.py @@ -0,0 +1,69 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelComposed, + cached_property, +) + + +class GuidedTableColumn(ModelComposed): + def __init__(self, **kwargs): + """ + Definition of a single column in a guided table widget. A column can be a computed value, a preset comparison, or a formula. + + :param alias: Display name shown as the column header. + :type alias: str, optional + + :param comparison: Comparison to display in a guided table column. + :type comparison: GuidedTableColumnComparison, optional + + :param compute: Aggregation configuration. + :type compute: GuidedTableComputeColumnCompute + + :param format: Visual formatting applied to values in a guided table column. Supports number/bar mode and trend mode. + :type format: GuidedTableColumnFormat + + :param functions: Functions to apply sequentially to the computed value. + :type functions: [GuidedTableColumnFunction], optional + + :param is_hidden: Whether this column is hidden in the rendered table. + :type is_hidden: bool, optional + + :param name: Auto-generated name used to refer to this column. + :type name: str + + :param type: + :type type: GuidedTableComputeColumnType + + :param preset: Preset configuration. + :type preset: GuidedTablePresetColumnPreset + + :param formula: The formula expression to evaluate. + :type formula: str + """ + super().__init__(kwargs) + + @cached_property + def _composed_schemas(_): + # we need this here to make our import statements work + # we must store _composed_schemas in here so the code is only run + # when we invoke this method. If we kept this at the class + # level we would get an error because the class level + # code would be run when this module is imported, and these composed + # classes don't exist yet because their module has not finished + # loading + from datadog_api_client.v1.model.guided_table_compute_column import GuidedTableComputeColumn + from datadog_api_client.v1.model.guided_table_preset_column import GuidedTablePresetColumn + from datadog_api_client.v1.model.guided_table_formula_column import GuidedTableFormulaColumn + + return { + "oneOf": [ + GuidedTableComputeColumn, + GuidedTablePresetColumn, + GuidedTableFormulaColumn, + ], + } diff --git a/src/datadog_api_client/v1/model/guided_table_column_comparison.py b/src/datadog_api_client/v1/model/guided_table_column_comparison.py new file mode 100644 index 0000000000..02c8afa227 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_column_comparison.py @@ -0,0 +1,47 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelComposed, + cached_property, +) + + +class GuidedTableColumnComparison(ModelComposed): + def __init__(self, **kwargs): + """ + Comparison to display in a guided table column. + + :param type: + :type type: GuidedTableColumnComparisonWithSelfType + + :param column: Name of the column to compare against. + :type column: str + """ + super().__init__(kwargs) + + @cached_property + def _composed_schemas(_): + # we need this here to make our import statements work + # we must store _composed_schemas in here so the code is only run + # when we invoke this method. If we kept this at the class + # level we would get an error because the class level + # code would be run when this module is imported, and these composed + # classes don't exist yet because their module has not finished + # loading + from datadog_api_client.v1.model.guided_table_column_comparison_with_self import ( + GuidedTableColumnComparisonWithSelf, + ) + from datadog_api_client.v1.model.guided_table_column_comparison_with_other_column import ( + GuidedTableColumnComparisonWithOtherColumn, + ) + + return { + "oneOf": [ + GuidedTableColumnComparisonWithSelf, + GuidedTableColumnComparisonWithOtherColumn, + ], + } diff --git a/src/datadog_api_client/v1/model/guided_table_column_comparison_with_other_column.py b/src/datadog_api_client/v1/model/guided_table_column_comparison_with_other_column.py new file mode 100644 index 0000000000..45cd515235 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_column_comparison_with_other_column.py @@ -0,0 +1,50 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.guided_table_column_comparison_with_other_column_type import ( + GuidedTableColumnComparisonWithOtherColumnType, + ) + + +class GuidedTableColumnComparisonWithOtherColumn(ModelNormal): + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.guided_table_column_comparison_with_other_column_type import ( + GuidedTableColumnComparisonWithOtherColumnType, + ) + + return { + "column": (str,), + "type": (GuidedTableColumnComparisonWithOtherColumnType,), + } + + attribute_map = { + "column": "column", + "type": "type", + } + + def __init__(self_, column: str, type: GuidedTableColumnComparisonWithOtherColumnType, **kwargs): + """ + Comparison of a column value against another column. + + :param column: Name of the column to compare against. + :type column: str + + :param type: + :type type: GuidedTableColumnComparisonWithOtherColumnType + """ + super().__init__(kwargs) + + self_.column = column + self_.type = type diff --git a/src/datadog_api_client/v1/model/guided_table_column_comparison_with_other_column_type.py b/src/datadog_api_client/v1/model/guided_table_column_comparison_with_other_column_type.py new file mode 100644 index 0000000000..75d3e2c2d4 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_column_comparison_with_other_column_type.py @@ -0,0 +1,43 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class GuidedTableColumnComparisonWithOtherColumnType(ModelSimple): + """ + + + :param value: Must be one of ["diff_from", "percent_of", "percent_diff_from"]. + :type value: str + """ + + allowed_values = { + "diff_from", + "percent_of", + "percent_diff_from", + } + DIFF_FROM: ClassVar["GuidedTableColumnComparisonWithOtherColumnType"] + PERCENT_OF: ClassVar["GuidedTableColumnComparisonWithOtherColumnType"] + PERCENT_DIFF_FROM: ClassVar["GuidedTableColumnComparisonWithOtherColumnType"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +GuidedTableColumnComparisonWithOtherColumnType.DIFF_FROM = GuidedTableColumnComparisonWithOtherColumnType("diff_from") +GuidedTableColumnComparisonWithOtherColumnType.PERCENT_OF = GuidedTableColumnComparisonWithOtherColumnType("percent_of") +GuidedTableColumnComparisonWithOtherColumnType.PERCENT_DIFF_FROM = GuidedTableColumnComparisonWithOtherColumnType( + "percent_diff_from" +) diff --git a/src/datadog_api_client/v1/model/guided_table_column_comparison_with_self.py b/src/datadog_api_client/v1/model/guided_table_column_comparison_with_self.py new file mode 100644 index 0000000000..7c4e773197 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_column_comparison_with_self.py @@ -0,0 +1,44 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.guided_table_column_comparison_with_self_type import ( + GuidedTableColumnComparisonWithSelfType, + ) + + +class GuidedTableColumnComparisonWithSelf(ModelNormal): + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.guided_table_column_comparison_with_self_type import ( + GuidedTableColumnComparisonWithSelfType, + ) + + return { + "type": (GuidedTableColumnComparisonWithSelfType,), + } + + attribute_map = { + "type": "type", + } + + def __init__(self_, type: GuidedTableColumnComparisonWithSelfType, **kwargs): + """ + Comparison of a column value against the column's own total (percent of column total). + + :param type: + :type type: GuidedTableColumnComparisonWithSelfType + """ + super().__init__(kwargs) + + self_.type = type diff --git a/src/datadog_api_client/v1/model/guided_table_column_comparison_with_self_type.py b/src/datadog_api_client/v1/model/guided_table_column_comparison_with_self_type.py new file mode 100644 index 0000000000..6ceddc2dbe --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_column_comparison_with_self_type.py @@ -0,0 +1,37 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class GuidedTableColumnComparisonWithSelfType(ModelSimple): + """ + + + :param value: If omitted defaults to "percent_column_total". Must be one of ["percent_column_total"]. + :type value: str + """ + + allowed_values = { + "percent_column_total", + } + PERCENT_COLUMN_TOTAL: ClassVar["GuidedTableColumnComparisonWithSelfType"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +GuidedTableColumnComparisonWithSelfType.PERCENT_COLUMN_TOTAL = GuidedTableColumnComparisonWithSelfType( + "percent_column_total" +) diff --git a/src/datadog_api_client/v1/model/guided_table_column_format.py b/src/datadog_api_client/v1/model/guided_table_column_format.py new file mode 100644 index 0000000000..abb50c1b56 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_column_format.py @@ -0,0 +1,49 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelComposed, + cached_property, +) + + +class GuidedTableColumnFormat(ModelComposed): + def __init__(self, **kwargs): + """ + Visual formatting applied to values in a guided table column. Supports number/bar mode and trend mode. + + :param conditional_formats: Conditional formatting rules for a guided table column. Either an array of threshold-based rules or a single range-based rule. + :type conditional_formats: GuidedTableConditionalFormats, optional + + :param mode: + :type mode: GuidedTableNumberBarColumnFormatMode + + :param number_format: Number display format for a guided table column value. + :type number_format: GuidedTableNumberFormat, optional + + :param trend_options: Cell display mode options for the widget formula. (only if `cell_display_mode` is set to `trend`). + :type trend_options: WidgetFormulaCellDisplayModeOptions + """ + super().__init__(kwargs) + + @cached_property + def _composed_schemas(_): + # we need this here to make our import statements work + # we must store _composed_schemas in here so the code is only run + # when we invoke this method. If we kept this at the class + # level we would get an error because the class level + # code would be run when this module is imported, and these composed + # classes don't exist yet because their module has not finished + # loading + from datadog_api_client.v1.model.guided_table_number_bar_column_format import GuidedTableNumberBarColumnFormat + from datadog_api_client.v1.model.guided_table_trend_column_format import GuidedTableTrendColumnFormat + + return { + "oneOf": [ + GuidedTableNumberBarColumnFormat, + GuidedTableTrendColumnFormat, + ], + } diff --git a/src/datadog_api_client/v1/model/guided_table_column_function.py b/src/datadog_api_client/v1/model/guided_table_column_function.py new file mode 100644 index 0000000000..3157ecfba5 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_column_function.py @@ -0,0 +1,43 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import List, Union + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +class GuidedTableColumnFunction(ModelNormal): + @cached_property + def openapi_types(_): + return { + "args": ([str, float, bool],), + "name": (str,), + } + + attribute_map = { + "args": "args", + "name": "name", + } + + def __init__(self_, name: str, args: Union[List[Union[str, float, bool]], UnsetType] = unset, **kwargs): + """ + A function to apply when computing a column's value. + + :param args: Arguments passed to the function in order. + :type args: [str, float, bool], optional + + :param name: Function name (e.g. ``clamp_min`` , ``abs`` , ``round`` ). Not restricted to a fixed set. + :type name: str + """ + if args is not unset: + kwargs["args"] = args + super().__init__(kwargs) + + self_.name = name diff --git a/src/datadog_api_client/v1/model/guided_table_compute_column.py b/src/datadog_api_client/v1/model/guided_table_compute_column.py new file mode 100644 index 0000000000..d84f2f07b1 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_compute_column.py @@ -0,0 +1,118 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import List, Union, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.guided_table_column_comparison import GuidedTableColumnComparison + from datadog_api_client.v1.model.guided_table_compute_column_compute import GuidedTableComputeColumnCompute + from datadog_api_client.v1.model.guided_table_column_format import GuidedTableColumnFormat + from datadog_api_client.v1.model.guided_table_column_function import GuidedTableColumnFunction + from datadog_api_client.v1.model.guided_table_compute_column_type import GuidedTableComputeColumnType + from datadog_api_client.v1.model.guided_table_column_comparison_with_self import GuidedTableColumnComparisonWithSelf + from datadog_api_client.v1.model.guided_table_column_comparison_with_other_column import ( + GuidedTableColumnComparisonWithOtherColumn, + ) + from datadog_api_client.v1.model.guided_table_number_bar_column_format import GuidedTableNumberBarColumnFormat + from datadog_api_client.v1.model.guided_table_trend_column_format import GuidedTableTrendColumnFormat + + +class GuidedTableComputeColumn(ModelNormal): + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.guided_table_column_comparison import GuidedTableColumnComparison + from datadog_api_client.v1.model.guided_table_compute_column_compute import GuidedTableComputeColumnCompute + from datadog_api_client.v1.model.guided_table_column_format import GuidedTableColumnFormat + from datadog_api_client.v1.model.guided_table_column_function import GuidedTableColumnFunction + from datadog_api_client.v1.model.guided_table_compute_column_type import GuidedTableComputeColumnType + + return { + "alias": (str,), + "comparison": (GuidedTableColumnComparison,), + "compute": (GuidedTableComputeColumnCompute,), + "format": (GuidedTableColumnFormat,), + "functions": ([GuidedTableColumnFunction],), + "is_hidden": (bool,), + "name": (str,), + "type": (GuidedTableComputeColumnType,), + } + + attribute_map = { + "alias": "alias", + "comparison": "comparison", + "compute": "compute", + "format": "format", + "functions": "functions", + "is_hidden": "is_hidden", + "name": "name", + "type": "type", + } + + def __init__( + self_, + compute: GuidedTableComputeColumnCompute, + format: Union[GuidedTableColumnFormat, GuidedTableNumberBarColumnFormat, GuidedTableTrendColumnFormat], + name: str, + type: GuidedTableComputeColumnType, + alias: Union[str, UnsetType] = unset, + comparison: Union[ + GuidedTableColumnComparison, + GuidedTableColumnComparisonWithSelf, + GuidedTableColumnComparisonWithOtherColumn, + UnsetType, + ] = unset, + functions: Union[List[GuidedTableColumnFunction], UnsetType] = unset, + is_hidden: Union[bool, UnsetType] = unset, + **kwargs, + ): + """ + A guided table column that computes an aggregation directly from one of the table's base queries. + + :param alias: Display name shown as the column header. + :type alias: str, optional + + :param comparison: Comparison to display in a guided table column. + :type comparison: GuidedTableColumnComparison, optional + + :param compute: Aggregation configuration. + :type compute: GuidedTableComputeColumnCompute + + :param format: Visual formatting applied to values in a guided table column. Supports number/bar mode and trend mode. + :type format: GuidedTableColumnFormat + + :param functions: Functions to apply sequentially to the computed value. + :type functions: [GuidedTableColumnFunction], optional + + :param is_hidden: Whether this column is hidden in the rendered table. + :type is_hidden: bool, optional + + :param name: Auto-generated name used to refer to this column. + :type name: str + + :param type: + :type type: GuidedTableComputeColumnType + """ + if alias is not unset: + kwargs["alias"] = alias + if comparison is not unset: + kwargs["comparison"] = comparison + if functions is not unset: + kwargs["functions"] = functions + if is_hidden is not unset: + kwargs["is_hidden"] = is_hidden + super().__init__(kwargs) + + self_.compute = compute + self_.format = format + self_.name = name + self_.type = type diff --git a/src/datadog_api_client/v1/model/guided_table_compute_column_compute.py b/src/datadog_api_client/v1/model/guided_table_compute_column_compute.py new file mode 100644 index 0000000000..fda5ee65c3 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_compute_column_compute.py @@ -0,0 +1,63 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import Union + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +class GuidedTableComputeColumnCompute(ModelNormal): + @cached_property + def openapi_types(_): + return { + "aggregation": (str,), + "filter": (str,), + "_property": (str,), + "query": (str,), + } + + attribute_map = { + "aggregation": "aggregation", + "filter": "filter", + "_property": "property", + "query": "query", + } + + def __init__( + self_, + aggregation: str, + query: str, + filter: Union[str, UnsetType] = unset, + _property: Union[str, UnsetType] = unset, + **kwargs, + ): + """ + Aggregation configuration. + + :param aggregation: Aggregation type (e.g. ``avg`` , ``sum`` , ``count`` ). + :type aggregation: str + + :param filter: Additional filter criteria. + :type filter: str, optional + + :param _property: Attribute to aggregate on. Depends on the data source (e.g. a log attribute). + :type _property: str, optional + + :param query: Name of the source query. + :type query: str + """ + if filter is not unset: + kwargs["filter"] = filter + if _property is not unset: + kwargs["_property"] = _property + super().__init__(kwargs) + + self_.aggregation = aggregation + self_.query = query diff --git a/src/datadog_api_client/v1/model/guided_table_compute_column_type.py b/src/datadog_api_client/v1/model/guided_table_compute_column_type.py new file mode 100644 index 0000000000..fb8b088c0a --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_compute_column_type.py @@ -0,0 +1,35 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class GuidedTableComputeColumnType(ModelSimple): + """ + + + :param value: If omitted defaults to "compute". Must be one of ["compute"]. + :type value: str + """ + + allowed_values = { + "compute", + } + COMPUTE: ClassVar["GuidedTableComputeColumnType"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +GuidedTableComputeColumnType.COMPUTE = GuidedTableComputeColumnType("compute") diff --git a/src/datadog_api_client/v1/model/guided_table_conditional_formats.py b/src/datadog_api_client/v1/model/guided_table_conditional_formats.py new file mode 100644 index 0000000000..abbe89b9cc --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_conditional_formats.py @@ -0,0 +1,39 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelComposed, + cached_property, +) + + +class GuidedTableConditionalFormats(ModelComposed): + def __init__(self, **kwargs): + """ + Conditional formatting rules for a guided table column. Either an array of threshold-based rules or a single range-based rule. + """ + super().__init__(kwargs) + + @cached_property + def _composed_schemas(_): + # we need this here to make our import statements work + # we must store _composed_schemas in here so the code is only run + # when we invoke this method. If we kept this at the class + # level we would get an error because the class level + # code would be run when this module is imported, and these composed + # classes don't exist yet because their module has not finished + # loading + from datadog_api_client.v1.model.guided_table_threshold_formatting_rule import ( + GuidedTableThresholdFormattingRule, + ) + from datadog_api_client.v1.model.guided_table_range_formatting_rule import GuidedTableRangeFormattingRule + + return { + "oneOf": [ + [GuidedTableThresholdFormattingRule], + [GuidedTableRangeFormattingRule], + ], + } diff --git a/src/datadog_api_client/v1/model/guided_table_events_query.py b/src/datadog_api_client/v1/model/guided_table_events_query.py new file mode 100644 index 0000000000..d09887257a --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_events_query.py @@ -0,0 +1,89 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import List, Union, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.guided_table_events_query_data_source import GuidedTableEventsQueryDataSource + from datadog_api_client.v1.model.guided_table_events_query_search import GuidedTableEventsQuerySearch + from datadog_api_client.v1.model.guided_table_storage_type import GuidedTableStorageType + + +class GuidedTableEventsQuery(ModelNormal): + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.guided_table_events_query_data_source import GuidedTableEventsQueryDataSource + from datadog_api_client.v1.model.guided_table_events_query_search import GuidedTableEventsQuerySearch + from datadog_api_client.v1.model.guided_table_storage_type import GuidedTableStorageType + + return { + "alias": (str,), + "data_source": (GuidedTableEventsQueryDataSource,), + "indexes": ([str],), + "name": (str,), + "search": (GuidedTableEventsQuerySearch,), + "storage": (GuidedTableStorageType,), + } + + attribute_map = { + "alias": "alias", + "data_source": "data_source", + "indexes": "indexes", + "name": "name", + "search": "search", + "storage": "storage", + } + + def __init__( + self_, + data_source: GuidedTableEventsQueryDataSource, + name: str, + alias: Union[str, UnsetType] = unset, + indexes: Union[List[str], UnsetType] = unset, + search: Union[GuidedTableEventsQuerySearch, UnsetType] = unset, + storage: Union[GuidedTableStorageType, UnsetType] = unset, + **kwargs, + ): + """ + An events-platform query fragment used as source data for a guided table. Covers logs, RUM, spans, CI pipelines, events, and product analytics. + + :param alias: Display alias for the query. + :type alias: str, optional + + :param data_source: Events data source. + :type data_source: GuidedTableEventsQueryDataSource + + :param indexes: Indexes to search for events. + :type indexes: [str], optional + + :param name: Variable name used to reference this query in columns and formulas. + :type name: str + + :param search: Search filter for matching events. + :type search: GuidedTableEventsQuerySearch, optional + + :param storage: Storage tier to target for an events-platform query in a guided table. + :type storage: GuidedTableStorageType, optional + """ + if alias is not unset: + kwargs["alias"] = alias + if indexes is not unset: + kwargs["indexes"] = indexes + if search is not unset: + kwargs["search"] = search + if storage is not unset: + kwargs["storage"] = storage + super().__init__(kwargs) + + self_.data_source = data_source + self_.name = name diff --git a/src/datadog_api_client/v1/model/guided_table_events_query_data_source.py b/src/datadog_api_client/v1/model/guided_table_events_query_data_source.py new file mode 100644 index 0000000000..b2551bde89 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_events_query_data_source.py @@ -0,0 +1,50 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class GuidedTableEventsQueryDataSource(ModelSimple): + """ + Events data source. + + :param value: Must be one of ["logs", "rum", "spans", "ci_pipelines", "events", "product_analytics"]. + :type value: str + """ + + allowed_values = { + "logs", + "rum", + "spans", + "ci_pipelines", + "events", + "product_analytics", + } + LOGS: ClassVar["GuidedTableEventsQueryDataSource"] + RUM: ClassVar["GuidedTableEventsQueryDataSource"] + SPANS: ClassVar["GuidedTableEventsQueryDataSource"] + CI_PIPELINES: ClassVar["GuidedTableEventsQueryDataSource"] + EVENTS: ClassVar["GuidedTableEventsQueryDataSource"] + PRODUCT_ANALYTICS: ClassVar["GuidedTableEventsQueryDataSource"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +GuidedTableEventsQueryDataSource.LOGS = GuidedTableEventsQueryDataSource("logs") +GuidedTableEventsQueryDataSource.RUM = GuidedTableEventsQueryDataSource("rum") +GuidedTableEventsQueryDataSource.SPANS = GuidedTableEventsQueryDataSource("spans") +GuidedTableEventsQueryDataSource.CI_PIPELINES = GuidedTableEventsQueryDataSource("ci_pipelines") +GuidedTableEventsQueryDataSource.EVENTS = GuidedTableEventsQueryDataSource("events") +GuidedTableEventsQueryDataSource.PRODUCT_ANALYTICS = GuidedTableEventsQueryDataSource("product_analytics") diff --git a/src/datadog_api_client/v1/model/guided_table_events_query_search.py b/src/datadog_api_client/v1/model/guided_table_events_query_search.py new file mode 100644 index 0000000000..35d7a5ebeb --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_events_query_search.py @@ -0,0 +1,36 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import Union + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +class GuidedTableEventsQuerySearch(ModelNormal): + @cached_property + def openapi_types(_): + return { + "query": (str,), + } + + attribute_map = { + "query": "query", + } + + def __init__(self_, query: Union[str, UnsetType] = unset, **kwargs): + """ + Search filter for matching events. + + :param query: Events search query string using events-platform search grammar. + :type query: str, optional + """ + if query is not unset: + kwargs["query"] = query + super().__init__(kwargs) diff --git a/src/datadog_api_client/v1/model/guided_table_formula_column.py b/src/datadog_api_client/v1/model/guided_table_formula_column.py new file mode 100644 index 0000000000..a433330412 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_formula_column.py @@ -0,0 +1,106 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import Union, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.guided_table_column_comparison import GuidedTableColumnComparison + from datadog_api_client.v1.model.guided_table_column_format import GuidedTableColumnFormat + from datadog_api_client.v1.model.formula_type import FormulaType + from datadog_api_client.v1.model.guided_table_column_comparison_with_self import GuidedTableColumnComparisonWithSelf + from datadog_api_client.v1.model.guided_table_column_comparison_with_other_column import ( + GuidedTableColumnComparisonWithOtherColumn, + ) + from datadog_api_client.v1.model.guided_table_number_bar_column_format import GuidedTableNumberBarColumnFormat + from datadog_api_client.v1.model.guided_table_trend_column_format import GuidedTableTrendColumnFormat + + +class GuidedTableFormulaColumn(ModelNormal): + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.guided_table_column_comparison import GuidedTableColumnComparison + from datadog_api_client.v1.model.guided_table_column_format import GuidedTableColumnFormat + from datadog_api_client.v1.model.formula_type import FormulaType + + return { + "alias": (str,), + "comparison": (GuidedTableColumnComparison,), + "format": (GuidedTableColumnFormat,), + "formula": (str,), + "is_hidden": (bool,), + "name": (str,), + "type": (FormulaType,), + } + + attribute_map = { + "alias": "alias", + "comparison": "comparison", + "format": "format", + "formula": "formula", + "is_hidden": "is_hidden", + "name": "name", + "type": "type", + } + + def __init__( + self_, + format: Union[GuidedTableColumnFormat, GuidedTableNumberBarColumnFormat, GuidedTableTrendColumnFormat], + formula: str, + name: str, + type: FormulaType, + alias: Union[str, UnsetType] = unset, + comparison: Union[ + GuidedTableColumnComparison, + GuidedTableColumnComparisonWithSelf, + GuidedTableColumnComparisonWithOtherColumn, + UnsetType, + ] = unset, + is_hidden: Union[bool, UnsetType] = unset, + **kwargs, + ): + """ + A guided table column that displays the result of evaluating a formula over other columns. + + :param alias: Display name shown as the column header. + :type alias: str, optional + + :param comparison: Comparison to display in a guided table column. + :type comparison: GuidedTableColumnComparison, optional + + :param format: Visual formatting applied to values in a guided table column. Supports number/bar mode and trend mode. + :type format: GuidedTableColumnFormat + + :param formula: The formula expression to evaluate. + :type formula: str + + :param is_hidden: Whether this column is hidden in the rendered table. + :type is_hidden: bool, optional + + :param name: Auto-generated name used to refer to this column. + :type name: str + + :param type: Set the sort type to formula. + :type type: FormulaType + """ + if alias is not unset: + kwargs["alias"] = alias + if comparison is not unset: + kwargs["comparison"] = comparison + if is_hidden is not unset: + kwargs["is_hidden"] = is_hidden + super().__init__(kwargs) + + self_.format = format + self_.formula = formula + self_.name = name + self_.type = type diff --git a/src/datadog_api_client/v1/model/guided_table_group_key.py b/src/datadog_api_client/v1/model/guided_table_group_key.py new file mode 100644 index 0000000000..0bc4f5a716 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_group_key.py @@ -0,0 +1,39 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, +) + + +class GuidedTableGroupKey(ModelNormal): + @cached_property + def openapi_types(_): + return { + "group_key": (str,), + "query": (str,), + } + + attribute_map = { + "group_key": "group_key", + "query": "query", + } + + def __init__(self_, group_key: str, query: str, **kwargs): + """ + Maps a specific base query to the field name used for grouping. + + :param group_key: Field name in the query result used as the grouping key. + :type group_key: str + + :param query: Name of the source query. + :type query: str + """ + super().__init__(kwargs) + + self_.group_key = group_key + self_.query = query diff --git a/src/datadog_api_client/v1/model/guided_table_metrics_query.py b/src/datadog_api_client/v1/model/guided_table_metrics_query.py new file mode 100644 index 0000000000..e49b36fd0f --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_metrics_query.py @@ -0,0 +1,76 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import Union, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.guided_table_metrics_query_data_source import GuidedTableMetricsQueryDataSource + + +class GuidedTableMetricsQuery(ModelNormal): + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.guided_table_metrics_query_data_source import GuidedTableMetricsQueryDataSource + + return { + "alias": (str,), + "data_source": (GuidedTableMetricsQueryDataSource,), + "filter": (str,), + "metric_name": (str,), + "name": (str,), + } + + attribute_map = { + "alias": "alias", + "data_source": "data_source", + "filter": "filter", + "metric_name": "metric_name", + "name": "name", + } + + def __init__( + self_, + data_source: GuidedTableMetricsQueryDataSource, + metric_name: str, + name: str, + alias: Union[str, UnsetType] = unset, + filter: Union[str, UnsetType] = unset, + **kwargs, + ): + """ + A metrics (or cloud cost) query fragment used as source data for a guided table. Group-by and time/space aggregation are defined separately. + + :param alias: Display alias for the query. + :type alias: str, optional + + :param data_source: Metrics data source. + :type data_source: GuidedTableMetricsQueryDataSource + + :param filter: Filter string to apply to the metric query. + :type filter: str, optional + + :param metric_name: Name of the metric to query. + :type metric_name: str + + :param name: Variable name used to reference this query in columns and formulas. + :type name: str + """ + if alias is not unset: + kwargs["alias"] = alias + if filter is not unset: + kwargs["filter"] = filter + super().__init__(kwargs) + + self_.data_source = data_source + self_.metric_name = metric_name + self_.name = name diff --git a/src/datadog_api_client/v1/model/guided_table_metrics_query_data_source.py b/src/datadog_api_client/v1/model/guided_table_metrics_query_data_source.py new file mode 100644 index 0000000000..f1d7a90994 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_metrics_query_data_source.py @@ -0,0 +1,38 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class GuidedTableMetricsQueryDataSource(ModelSimple): + """ + Metrics data source. + + :param value: Must be one of ["metrics", "cloud_cost"]. + :type value: str + """ + + allowed_values = { + "metrics", + "cloud_cost", + } + METRICS: ClassVar["GuidedTableMetricsQueryDataSource"] + CLOUD_COST: ClassVar["GuidedTableMetricsQueryDataSource"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +GuidedTableMetricsQueryDataSource.METRICS = GuidedTableMetricsQueryDataSource("metrics") +GuidedTableMetricsQueryDataSource.CLOUD_COST = GuidedTableMetricsQueryDataSource("cloud_cost") diff --git a/src/datadog_api_client/v1/model/guided_table_number_bar_column_format.py b/src/datadog_api_client/v1/model/guided_table_number_bar_column_format.py new file mode 100644 index 0000000000..44f1c5ee1f --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_number_bar_column_format.py @@ -0,0 +1,77 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import List, Union, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.guided_table_conditional_formats import GuidedTableConditionalFormats + from datadog_api_client.v1.model.guided_table_number_bar_column_format_mode import ( + GuidedTableNumberBarColumnFormatMode, + ) + from datadog_api_client.v1.model.guided_table_number_format import GuidedTableNumberFormat + from datadog_api_client.v1.model.guided_table_threshold_formatting_rule import GuidedTableThresholdFormattingRule + from datadog_api_client.v1.model.guided_table_range_formatting_rule import GuidedTableRangeFormattingRule + + +class GuidedTableNumberBarColumnFormat(ModelNormal): + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.guided_table_conditional_formats import GuidedTableConditionalFormats + from datadog_api_client.v1.model.guided_table_number_bar_column_format_mode import ( + GuidedTableNumberBarColumnFormatMode, + ) + from datadog_api_client.v1.model.guided_table_number_format import GuidedTableNumberFormat + + return { + "conditional_formats": (GuidedTableConditionalFormats,), + "mode": (GuidedTableNumberBarColumnFormatMode,), + "number_format": (GuidedTableNumberFormat,), + } + + attribute_map = { + "conditional_formats": "conditional_formats", + "mode": "mode", + "number_format": "number_format", + } + + def __init__( + self_, + mode: GuidedTableNumberBarColumnFormatMode, + conditional_formats: Union[ + GuidedTableConditionalFormats, + List[GuidedTableThresholdFormattingRule], + List[GuidedTableRangeFormattingRule], + UnsetType, + ] = unset, + number_format: Union[GuidedTableNumberFormat, UnsetType] = unset, + **kwargs, + ): + """ + Formats a guided table column as a number or a bar. + + :param conditional_formats: Conditional formatting rules for a guided table column. Either an array of threshold-based rules or a single range-based rule. + :type conditional_formats: GuidedTableConditionalFormats, optional + + :param mode: + :type mode: GuidedTableNumberBarColumnFormatMode + + :param number_format: Number display format for a guided table column value. + :type number_format: GuidedTableNumberFormat, optional + """ + if conditional_formats is not unset: + kwargs["conditional_formats"] = conditional_formats + if number_format is not unset: + kwargs["number_format"] = number_format + super().__init__(kwargs) + + self_.mode = mode diff --git a/src/datadog_api_client/v1/model/guided_table_number_bar_column_format_mode.py b/src/datadog_api_client/v1/model/guided_table_number_bar_column_format_mode.py new file mode 100644 index 0000000000..3935bb3124 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_number_bar_column_format_mode.py @@ -0,0 +1,38 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class GuidedTableNumberBarColumnFormatMode(ModelSimple): + """ + + + :param value: Must be one of ["number", "bar"]. + :type value: str + """ + + allowed_values = { + "number", + "bar", + } + NUMBER: ClassVar["GuidedTableNumberBarColumnFormatMode"] + BAR: ClassVar["GuidedTableNumberBarColumnFormatMode"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +GuidedTableNumberBarColumnFormatMode.NUMBER = GuidedTableNumberBarColumnFormatMode("number") +GuidedTableNumberBarColumnFormatMode.BAR = GuidedTableNumberBarColumnFormatMode("bar") diff --git a/src/datadog_api_client/v1/model/guided_table_number_format.py b/src/datadog_api_client/v1/model/guided_table_number_format.py new file mode 100644 index 0000000000..d95fb8bcb0 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_number_format.py @@ -0,0 +1,69 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import Union, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + none_type, + unset, + UnsetType, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.guided_table_number_format_precision import GuidedTableNumberFormatPrecision + from datadog_api_client.v1.model.number_format_unit import NumberFormatUnit + from datadog_api_client.v1.model.number_format_unit_scale import NumberFormatUnitScale + from datadog_api_client.v1.model.number_format_unit_canonical import NumberFormatUnitCanonical + from datadog_api_client.v1.model.number_format_unit_custom import NumberFormatUnitCustom + + +class GuidedTableNumberFormat(ModelNormal): + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.guided_table_number_format_precision import GuidedTableNumberFormatPrecision + from datadog_api_client.v1.model.number_format_unit import NumberFormatUnit + from datadog_api_client.v1.model.number_format_unit_scale import NumberFormatUnitScale + + return { + "precision": (GuidedTableNumberFormatPrecision,), + "unit": (NumberFormatUnit,), + "unit_scale": (NumberFormatUnitScale,), + } + + attribute_map = { + "precision": "precision", + "unit": "unit", + "unit_scale": "unit_scale", + } + + def __init__( + self_, + precision: Union[GuidedTableNumberFormatPrecision, str, int, UnsetType] = unset, + unit: Union[NumberFormatUnit, NumberFormatUnitCanonical, NumberFormatUnitCustom, UnsetType] = unset, + unit_scale: Union[NumberFormatUnitScale, none_type, UnsetType] = unset, + **kwargs, + ): + """ + Number display format for a guided table column value. + + :param precision: Number of digits after the decimal point. Use ``*`` for full precision, ``integer`` to show full integer values, or omit for automatic precision. + :type precision: GuidedTableNumberFormatPrecision, optional + + :param unit: Number format unit. + :type unit: NumberFormatUnit, optional + + :param unit_scale: The definition of ``NumberFormatUnitScale`` object. + :type unit_scale: NumberFormatUnitScale, none_type, optional + """ + if precision is not unset: + kwargs["precision"] = precision + if unit is not unset: + kwargs["unit"] = unit + if unit_scale is not unset: + kwargs["unit_scale"] = unit_scale + super().__init__(kwargs) diff --git a/src/datadog_api_client/v1/model/guided_table_number_format_precision.py b/src/datadog_api_client/v1/model/guided_table_number_format_precision.py new file mode 100644 index 0000000000..af3e8fb767 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_number_format_precision.py @@ -0,0 +1,34 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelComposed, + cached_property, +) + + +class GuidedTableNumberFormatPrecision(ModelComposed): + def __init__(self, **kwargs): + """ + Number of digits after the decimal point. Use ``*`` for full precision, ``integer`` to show full integer values, or omit for automatic precision. + """ + super().__init__(kwargs) + + @cached_property + def _composed_schemas(_): + # we need this here to make our import statements work + # we must store _composed_schemas in here so the code is only run + # when we invoke this method. If we kept this at the class + # level we would get an error because the class level + # code would be run when this module is imported, and these composed + # classes don't exist yet because their module has not finished + # loading + return { + "oneOf": [ + str, + int, + ], + } diff --git a/src/datadog_api_client/v1/model/guided_table_preset_column.py b/src/datadog_api_client/v1/model/guided_table_preset_column.py new file mode 100644 index 0000000000..a545799660 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_preset_column.py @@ -0,0 +1,118 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import List, Union, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.guided_table_column_comparison import GuidedTableColumnComparison + from datadog_api_client.v1.model.guided_table_column_format import GuidedTableColumnFormat + from datadog_api_client.v1.model.guided_table_column_function import GuidedTableColumnFunction + from datadog_api_client.v1.model.guided_table_preset_column_preset import GuidedTablePresetColumnPreset + from datadog_api_client.v1.model.guided_table_preset_column_type import GuidedTablePresetColumnType + from datadog_api_client.v1.model.guided_table_column_comparison_with_self import GuidedTableColumnComparisonWithSelf + from datadog_api_client.v1.model.guided_table_column_comparison_with_other_column import ( + GuidedTableColumnComparisonWithOtherColumn, + ) + from datadog_api_client.v1.model.guided_table_number_bar_column_format import GuidedTableNumberBarColumnFormat + from datadog_api_client.v1.model.guided_table_trend_column_format import GuidedTableTrendColumnFormat + + +class GuidedTablePresetColumn(ModelNormal): + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.guided_table_column_comparison import GuidedTableColumnComparison + from datadog_api_client.v1.model.guided_table_column_format import GuidedTableColumnFormat + from datadog_api_client.v1.model.guided_table_column_function import GuidedTableColumnFunction + from datadog_api_client.v1.model.guided_table_preset_column_preset import GuidedTablePresetColumnPreset + from datadog_api_client.v1.model.guided_table_preset_column_type import GuidedTablePresetColumnType + + return { + "alias": (str,), + "comparison": (GuidedTableColumnComparison,), + "format": (GuidedTableColumnFormat,), + "functions": ([GuidedTableColumnFunction],), + "is_hidden": (bool,), + "name": (str,), + "preset": (GuidedTablePresetColumnPreset,), + "type": (GuidedTablePresetColumnType,), + } + + attribute_map = { + "alias": "alias", + "comparison": "comparison", + "format": "format", + "functions": "functions", + "is_hidden": "is_hidden", + "name": "name", + "preset": "preset", + "type": "type", + } + + def __init__( + self_, + format: Union[GuidedTableColumnFormat, GuidedTableNumberBarColumnFormat, GuidedTableTrendColumnFormat], + name: str, + preset: GuidedTablePresetColumnPreset, + type: GuidedTablePresetColumnType, + alias: Union[str, UnsetType] = unset, + comparison: Union[ + GuidedTableColumnComparison, + GuidedTableColumnComparisonWithSelf, + GuidedTableColumnComparisonWithOtherColumn, + UnsetType, + ] = unset, + functions: Union[List[GuidedTableColumnFunction], UnsetType] = unset, + is_hidden: Union[bool, UnsetType] = unset, + **kwargs, + ): + """ + A guided table column that displays values for the previous time period based on another column's full query. + + :param alias: Display name shown as the column header. + :type alias: str, optional + + :param comparison: Comparison to display in a guided table column. + :type comparison: GuidedTableColumnComparison, optional + + :param format: Visual formatting applied to values in a guided table column. Supports number/bar mode and trend mode. + :type format: GuidedTableColumnFormat + + :param functions: Functions to apply sequentially to the computed value. + :type functions: [GuidedTableColumnFunction], optional + + :param is_hidden: Whether this column is hidden in the rendered table. + :type is_hidden: bool, optional + + :param name: Auto-generated name used to refer to this column. + :type name: str + + :param preset: Preset configuration. + :type preset: GuidedTablePresetColumnPreset + + :param type: + :type type: GuidedTablePresetColumnType + """ + if alias is not unset: + kwargs["alias"] = alias + if comparison is not unset: + kwargs["comparison"] = comparison + if functions is not unset: + kwargs["functions"] = functions + if is_hidden is not unset: + kwargs["is_hidden"] = is_hidden + super().__init__(kwargs) + + self_.format = format + self_.name = name + self_.preset = preset + self_.type = type diff --git a/src/datadog_api_client/v1/model/guided_table_preset_column_preset.py b/src/datadog_api_client/v1/model/guided_table_preset_column_preset.py new file mode 100644 index 0000000000..727a5da731 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_preset_column_preset.py @@ -0,0 +1,46 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.guided_table_preset_column_preset_type import GuidedTablePresetColumnPresetType + + +class GuidedTablePresetColumnPreset(ModelNormal): + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.guided_table_preset_column_preset_type import GuidedTablePresetColumnPresetType + + return { + "column": (str,), + "type": (GuidedTablePresetColumnPresetType,), + } + + attribute_map = { + "column": "column", + "type": "type", + } + + def __init__(self_, column: str, type: GuidedTablePresetColumnPresetType, **kwargs): + """ + Preset configuration. + + :param column: Name of the column whose full query is reused. + :type column: str + + :param type: + :type type: GuidedTablePresetColumnPresetType + """ + super().__init__(kwargs) + + self_.column = column + self_.type = type diff --git a/src/datadog_api_client/v1/model/guided_table_preset_column_preset_type.py b/src/datadog_api_client/v1/model/guided_table_preset_column_preset_type.py new file mode 100644 index 0000000000..212e2603e8 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_preset_column_preset_type.py @@ -0,0 +1,35 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class GuidedTablePresetColumnPresetType(ModelSimple): + """ + + + :param value: If omitted defaults to "previous_period". Must be one of ["previous_period"]. + :type value: str + """ + + allowed_values = { + "previous_period", + } + PREVIOUS_PERIOD: ClassVar["GuidedTablePresetColumnPresetType"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +GuidedTablePresetColumnPresetType.PREVIOUS_PERIOD = GuidedTablePresetColumnPresetType("previous_period") diff --git a/src/datadog_api_client/v1/model/guided_table_preset_column_type.py b/src/datadog_api_client/v1/model/guided_table_preset_column_type.py new file mode 100644 index 0000000000..7453e4d081 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_preset_column_type.py @@ -0,0 +1,35 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class GuidedTablePresetColumnType(ModelSimple): + """ + + + :param value: If omitted defaults to "preset". Must be one of ["preset"]. + :type value: str + """ + + allowed_values = { + "preset", + } + PRESET: ClassVar["GuidedTablePresetColumnType"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +GuidedTablePresetColumnType.PRESET = GuidedTablePresetColumnType("preset") diff --git a/src/datadog_api_client/v1/model/guided_table_query.py b/src/datadog_api_client/v1/model/guided_table_query.py new file mode 100644 index 0000000000..849c201f98 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_query.py @@ -0,0 +1,61 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelComposed, + cached_property, +) + + +class GuidedTableQuery(ModelComposed): + def __init__(self, **kwargs): + """ + A base query used as source data for a guided table widget. Either a metrics query or an events-platform query. + + :param alias: Display alias for the query. + :type alias: str, optional + + :param data_source: Metrics data source. + :type data_source: GuidedTableMetricsQueryDataSource + + :param filter: Filter string to apply to the metric query. + :type filter: str, optional + + :param metric_name: Name of the metric to query. + :type metric_name: str + + :param name: Variable name used to reference this query in columns and formulas. + :type name: str + + :param indexes: Indexes to search for events. + :type indexes: [str], optional + + :param search: Search filter for matching events. + :type search: GuidedTableEventsQuerySearch, optional + + :param storage: Storage tier to target for an events-platform query in a guided table. + :type storage: GuidedTableStorageType, optional + """ + super().__init__(kwargs) + + @cached_property + def _composed_schemas(_): + # we need this here to make our import statements work + # we must store _composed_schemas in here so the code is only run + # when we invoke this method. If we kept this at the class + # level we would get an error because the class level + # code would be run when this module is imported, and these composed + # classes don't exist yet because their module has not finished + # loading + from datadog_api_client.v1.model.guided_table_metrics_query import GuidedTableMetricsQuery + from datadog_api_client.v1.model.guided_table_events_query import GuidedTableEventsQuery + + return { + "oneOf": [ + GuidedTableMetricsQuery, + GuidedTableEventsQuery, + ], + } diff --git a/src/datadog_api_client/v1/model/guided_table_range_formatting_rule.py b/src/datadog_api_client/v1/model/guided_table_range_formatting_rule.py new file mode 100644 index 0000000000..7b54049a28 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_range_formatting_rule.py @@ -0,0 +1,93 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import Union, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.guided_table_range_palette import GuidedTableRangePalette + from datadog_api_client.v1.model.guided_table_range_formatting_rule_scale import GuidedTableRangeFormattingRuleScale + from datadog_api_client.v1.model.guided_table_range_formatting_rule_type import GuidedTableRangeFormattingRuleType + + +class GuidedTableRangeFormattingRule(ModelNormal): + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.guided_table_range_palette import GuidedTableRangePalette + from datadog_api_client.v1.model.guided_table_range_formatting_rule_scale import ( + GuidedTableRangeFormattingRuleScale, + ) + from datadog_api_client.v1.model.guided_table_range_formatting_rule_type import ( + GuidedTableRangeFormattingRuleType, + ) + + return { + "max": (float,), + "min": (float,), + "palette": (GuidedTableRangePalette,), + "reverse": (bool,), + "scale": (GuidedTableRangeFormattingRuleScale,), + "type": (GuidedTableRangeFormattingRuleType,), + } + + attribute_map = { + "max": "max", + "min": "min", + "palette": "palette", + "reverse": "reverse", + "scale": "scale", + "type": "type", + } + + def __init__( + self_, + palette: GuidedTableRangePalette, + type: GuidedTableRangeFormattingRuleType, + max: Union[float, UnsetType] = unset, + min: Union[float, UnsetType] = unset, + reverse: Union[bool, UnsetType] = unset, + scale: Union[GuidedTableRangeFormattingRuleScale, UnsetType] = unset, + **kwargs, + ): + """ + Formats values according to where they fall on a color scale. + + :param max: Maximum value on the mapping scale. + :type max: float, optional + + :param min: Minimum value on the mapping scale. + :type min: float, optional + + :param palette: Color palette used by range-based conditional formatting rules. + :type palette: GuidedTableRangePalette + + :param reverse: Whether to reverse the palette scale direction. + :type reverse: bool, optional + + :param scale: Scale function for mapping values to colors. + :type scale: GuidedTableRangeFormattingRuleScale, optional + + :param type: + :type type: GuidedTableRangeFormattingRuleType + """ + if max is not unset: + kwargs["max"] = max + if min is not unset: + kwargs["min"] = min + if reverse is not unset: + kwargs["reverse"] = reverse + if scale is not unset: + kwargs["scale"] = scale + super().__init__(kwargs) + + self_.palette = palette + self_.type = type diff --git a/src/datadog_api_client/v1/model/guided_table_range_formatting_rule_scale.py b/src/datadog_api_client/v1/model/guided_table_range_formatting_rule_scale.py new file mode 100644 index 0000000000..4fe8689f98 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_range_formatting_rule_scale.py @@ -0,0 +1,44 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class GuidedTableRangeFormattingRuleScale(ModelSimple): + """ + Scale function for mapping values to colors. + + :param value: Must be one of ["linear", "log", "pow", "sqrt"]. + :type value: str + """ + + allowed_values = { + "linear", + "log", + "pow", + "sqrt", + } + LINEAR: ClassVar["GuidedTableRangeFormattingRuleScale"] + LOG: ClassVar["GuidedTableRangeFormattingRuleScale"] + POW: ClassVar["GuidedTableRangeFormattingRuleScale"] + SQRT: ClassVar["GuidedTableRangeFormattingRuleScale"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +GuidedTableRangeFormattingRuleScale.LINEAR = GuidedTableRangeFormattingRuleScale("linear") +GuidedTableRangeFormattingRuleScale.LOG = GuidedTableRangeFormattingRuleScale("log") +GuidedTableRangeFormattingRuleScale.POW = GuidedTableRangeFormattingRuleScale("pow") +GuidedTableRangeFormattingRuleScale.SQRT = GuidedTableRangeFormattingRuleScale("sqrt") diff --git a/src/datadog_api_client/v1/model/guided_table_range_formatting_rule_type.py b/src/datadog_api_client/v1/model/guided_table_range_formatting_rule_type.py new file mode 100644 index 0000000000..6b31454d22 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_range_formatting_rule_type.py @@ -0,0 +1,35 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class GuidedTableRangeFormattingRuleType(ModelSimple): + """ + + + :param value: If omitted defaults to "range". Must be one of ["range"]. + :type value: str + """ + + allowed_values = { + "range", + } + RANGE: ClassVar["GuidedTableRangeFormattingRuleType"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +GuidedTableRangeFormattingRuleType.RANGE = GuidedTableRangeFormattingRuleType("range") diff --git a/src/datadog_api_client/v1/model/guided_table_range_palette.py b/src/datadog_api_client/v1/model/guided_table_range_palette.py new file mode 100644 index 0000000000..6d814e82e6 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_range_palette.py @@ -0,0 +1,68 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class GuidedTableRangePalette(ModelSimple): + """ + Color palette used by range-based conditional formatting rules. + + :param value: Must be one of ["transparent_to_green", "transparent_to_orange", "transparent_to_red", "transparent_to_blue", "red_transparent_green", "red_transparent_blue", "vivid_transparent_to_green", "vivid_transparent_to_orange", "vivid_transparent_to_red", "vivid_transparent_to_blue", "vivid_red_transparent_green", "vivid_red_transparent_blue"]. + :type value: str + """ + + allowed_values = { + "transparent_to_green", + "transparent_to_orange", + "transparent_to_red", + "transparent_to_blue", + "red_transparent_green", + "red_transparent_blue", + "vivid_transparent_to_green", + "vivid_transparent_to_orange", + "vivid_transparent_to_red", + "vivid_transparent_to_blue", + "vivid_red_transparent_green", + "vivid_red_transparent_blue", + } + TRANSPARENT_TO_GREEN: ClassVar["GuidedTableRangePalette"] + TRANSPARENT_TO_ORANGE: ClassVar["GuidedTableRangePalette"] + TRANSPARENT_TO_RED: ClassVar["GuidedTableRangePalette"] + TRANSPARENT_TO_BLUE: ClassVar["GuidedTableRangePalette"] + RED_TRANSPARENT_GREEN: ClassVar["GuidedTableRangePalette"] + RED_TRANSPARENT_BLUE: ClassVar["GuidedTableRangePalette"] + VIVID_TRANSPARENT_TO_GREEN: ClassVar["GuidedTableRangePalette"] + VIVID_TRANSPARENT_TO_ORANGE: ClassVar["GuidedTableRangePalette"] + VIVID_TRANSPARENT_TO_RED: ClassVar["GuidedTableRangePalette"] + VIVID_TRANSPARENT_TO_BLUE: ClassVar["GuidedTableRangePalette"] + VIVID_RED_TRANSPARENT_GREEN: ClassVar["GuidedTableRangePalette"] + VIVID_RED_TRANSPARENT_BLUE: ClassVar["GuidedTableRangePalette"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +GuidedTableRangePalette.TRANSPARENT_TO_GREEN = GuidedTableRangePalette("transparent_to_green") +GuidedTableRangePalette.TRANSPARENT_TO_ORANGE = GuidedTableRangePalette("transparent_to_orange") +GuidedTableRangePalette.TRANSPARENT_TO_RED = GuidedTableRangePalette("transparent_to_red") +GuidedTableRangePalette.TRANSPARENT_TO_BLUE = GuidedTableRangePalette("transparent_to_blue") +GuidedTableRangePalette.RED_TRANSPARENT_GREEN = GuidedTableRangePalette("red_transparent_green") +GuidedTableRangePalette.RED_TRANSPARENT_BLUE = GuidedTableRangePalette("red_transparent_blue") +GuidedTableRangePalette.VIVID_TRANSPARENT_TO_GREEN = GuidedTableRangePalette("vivid_transparent_to_green") +GuidedTableRangePalette.VIVID_TRANSPARENT_TO_ORANGE = GuidedTableRangePalette("vivid_transparent_to_orange") +GuidedTableRangePalette.VIVID_TRANSPARENT_TO_RED = GuidedTableRangePalette("vivid_transparent_to_red") +GuidedTableRangePalette.VIVID_TRANSPARENT_TO_BLUE = GuidedTableRangePalette("vivid_transparent_to_blue") +GuidedTableRangePalette.VIVID_RED_TRANSPARENT_GREEN = GuidedTableRangePalette("vivid_red_transparent_green") +GuidedTableRangePalette.VIVID_RED_TRANSPARENT_BLUE = GuidedTableRangePalette("vivid_red_transparent_blue") diff --git a/src/datadog_api_client/v1/model/guided_table_request.py b/src/datadog_api_client/v1/model/guided_table_request.py new file mode 100644 index 0000000000..5a590cc3ed --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_request.py @@ -0,0 +1,84 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import List, Union, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.guided_table_column import GuidedTableColumn + from datadog_api_client.v1.model.guided_table_query import GuidedTableQuery + from datadog_api_client.v1.model.guided_table_request_request_type import GuidedTableRequestRequestType + from datadog_api_client.v1.model.guided_table_rows import GuidedTableRows + from datadog_api_client.v1.model.guided_table_compute_column import GuidedTableComputeColumn + from datadog_api_client.v1.model.guided_table_preset_column import GuidedTablePresetColumn + from datadog_api_client.v1.model.guided_table_formula_column import GuidedTableFormulaColumn + from datadog_api_client.v1.model.guided_table_metrics_query import GuidedTableMetricsQuery + from datadog_api_client.v1.model.guided_table_events_query import GuidedTableEventsQuery + + +class GuidedTableRequest(ModelNormal): + validations = { + "queries": { + "min_items": 1, + }, + } + + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.guided_table_column import GuidedTableColumn + from datadog_api_client.v1.model.guided_table_query import GuidedTableQuery + from datadog_api_client.v1.model.guided_table_request_request_type import GuidedTableRequestRequestType + from datadog_api_client.v1.model.guided_table_rows import GuidedTableRows + + return { + "columns": ([GuidedTableColumn],), + "queries": ([GuidedTableQuery],), + "request_type": (GuidedTableRequestRequestType,), + "rows": (GuidedTableRows,), + } + + attribute_map = { + "columns": "columns", + "queries": "queries", + "request_type": "request_type", + "rows": "rows", + } + + def __init__( + self_, + columns: List[ + Union[GuidedTableColumn, GuidedTableComputeColumn, GuidedTablePresetColumn, GuidedTableFormulaColumn] + ], + queries: List[Union[GuidedTableQuery, GuidedTableMetricsQuery, GuidedTableEventsQuery]], + request_type: GuidedTableRequestRequestType, + rows: GuidedTableRows, + **kwargs, + ): + """ + Request definition for the guided table widget — a structured, guided format for defining a table of data. Used when the ``graphing_new_table_widget_editor`` feature flag is enabled; otherwise use the classic ``TableWidgetRequest``. Defines base queries, how to produce rows, and how to compute columns. + + :param columns: Column definitions that describe how to compute and display table values. + :type columns: [GuidedTableColumn] + + :param queries: Base queries that provide the source data for the table. + :type queries: [GuidedTableQuery] + + :param request_type: Identifies this as a guided table request. + :type request_type: GuidedTableRequestRequestType + + :param rows: Defines how to compute the rows of a guided table. + :type rows: GuidedTableRows + """ + super().__init__(kwargs) + + self_.columns = columns + self_.queries = queries + self_.request_type = request_type + self_.rows = rows diff --git a/src/datadog_api_client/v1/model/guided_table_request_request_type.py b/src/datadog_api_client/v1/model/guided_table_request_request_type.py new file mode 100644 index 0000000000..4728ca4fd1 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_request_request_type.py @@ -0,0 +1,35 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class GuidedTableRequestRequestType(ModelSimple): + """ + Identifies this as a guided table request. + + :param value: If omitted defaults to "table". Must be one of ["table"]. + :type value: str + """ + + allowed_values = { + "table", + } + TABLE: ClassVar["GuidedTableRequestRequestType"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +GuidedTableRequestRequestType.TABLE = GuidedTableRequestRequestType("table") diff --git a/src/datadog_api_client/v1/model/guided_table_row_group_by.py b/src/datadog_api_client/v1/model/guided_table_row_group_by.py new file mode 100644 index 0000000000..1ff161127b --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_row_group_by.py @@ -0,0 +1,79 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import List, Union, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.guided_table_row_group_by_format import GuidedTableRowGroupByFormat + from datadog_api_client.v1.model.guided_table_group_key import GuidedTableGroupKey + + +class GuidedTableRowGroupBy(ModelNormal): + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.guided_table_row_group_by_format import GuidedTableRowGroupByFormat + from datadog_api_client.v1.model.guided_table_group_key import GuidedTableGroupKey + + return { + "alias": (str,), + "format": (GuidedTableRowGroupByFormat,), + "group_keys": ([GuidedTableGroupKey],), + "is_hidden": (bool,), + "name": (str,), + } + + attribute_map = { + "alias": "alias", + "format": "format", + "group_keys": "group_keys", + "is_hidden": "is_hidden", + "name": "name", + } + + def __init__( + self_, + group_keys: List[GuidedTableGroupKey], + name: str, + alias: Union[str, UnsetType] = unset, + format: Union[GuidedTableRowGroupByFormat, UnsetType] = unset, + is_hidden: Union[bool, UnsetType] = unset, + **kwargs, + ): + """ + Defines one group-by dimension used to produce the rows of a guided table. + + :param alias: Display name used as the column header for this group-by. + :type alias: str, optional + + :param format: Text formatting configuration for this group-by column. + :type format: GuidedTableRowGroupByFormat, optional + + :param group_keys: Mapping from each source query to the field name used as the grouping key. Different data sources may use different field names for the same concept. + :type group_keys: [GuidedTableGroupKey] + + :param is_hidden: Whether this group-by column is hidden in the rendered table. + :type is_hidden: bool, optional + + :param name: Auto-generated name for this group-by parameter. + :type name: str + """ + if alias is not unset: + kwargs["alias"] = alias + if format is not unset: + kwargs["format"] = format + if is_hidden is not unset: + kwargs["is_hidden"] = is_hidden + super().__init__(kwargs) + + self_.group_keys = group_keys + self_.name = name diff --git a/src/datadog_api_client/v1/model/guided_table_row_group_by_format.py b/src/datadog_api_client/v1/model/guided_table_row_group_by_format.py new file mode 100644 index 0000000000..32be3f7025 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_row_group_by_format.py @@ -0,0 +1,42 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import List, Union, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.guided_table_text_formatting_rule import GuidedTableTextFormattingRule + + +class GuidedTableRowGroupByFormat(ModelNormal): + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.guided_table_text_formatting_rule import GuidedTableTextFormattingRule + + return { + "text_formats": ([GuidedTableTextFormattingRule],), + } + + attribute_map = { + "text_formats": "text_formats", + } + + def __init__(self_, text_formats: Union[List[GuidedTableTextFormattingRule], UnsetType] = unset, **kwargs): + """ + Text formatting configuration for this group-by column. + + :param text_formats: + :type text_formats: [GuidedTableTextFormattingRule], optional + """ + if text_formats is not unset: + kwargs["text_formats"] = text_formats + super().__init__(kwargs) diff --git a/src/datadog_api_client/v1/model/guided_table_rows.py b/src/datadog_api_client/v1/model/guided_table_rows.py new file mode 100644 index 0000000000..de7c48c7ec --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_rows.py @@ -0,0 +1,54 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import List, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.guided_table_row_group_by import GuidedTableRowGroupBy + from datadog_api_client.v1.model.guided_table_sort import GuidedTableSort + + +class GuidedTableRows(ModelNormal): + validations = { + "group_by": { + "min_items": 1, + }, + } + + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.guided_table_row_group_by import GuidedTableRowGroupBy + from datadog_api_client.v1.model.guided_table_sort import GuidedTableSort + + return { + "group_by": ([GuidedTableRowGroupBy],), + "sort": (GuidedTableSort,), + } + + attribute_map = { + "group_by": "group_by", + "sort": "sort", + } + + def __init__(self_, group_by: List[GuidedTableRowGroupBy], sort: GuidedTableSort, **kwargs): + """ + Defines how to compute the rows of a guided table. + + :param group_by: Grouping dimensions that form each row. Must be non-empty. + :type group_by: [GuidedTableRowGroupBy] + + :param sort: Sort configuration for a guided table. + :type sort: GuidedTableSort + """ + super().__init__(kwargs) + + self_.group_by = group_by + self_.sort = sort diff --git a/src/datadog_api_client/v1/model/guided_table_sort.py b/src/datadog_api_client/v1/model/guided_table_sort.py new file mode 100644 index 0000000000..bf6a0895e4 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_sort.py @@ -0,0 +1,52 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import List, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.widget_field_sort import WidgetFieldSort + + +class GuidedTableSort(ModelNormal): + validations = { + "limit": { + "inclusive_minimum": 1, + }, + } + + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.widget_field_sort import WidgetFieldSort + + return { + "columns": ([WidgetFieldSort],), + "limit": (int,), + } + + attribute_map = { + "columns": "columns", + "limit": "limit", + } + + def __init__(self_, columns: List[WidgetFieldSort], limit: int, **kwargs): + """ + Sort configuration for a guided table. + + :param columns: Columns to sort by, in order of application. + :type columns: [WidgetFieldSort] + + :param limit: Maximum number of rows to show after sorting. + :type limit: int + """ + super().__init__(kwargs) + + self_.columns = columns + self_.limit = limit diff --git a/src/datadog_api_client/v1/model/guided_table_storage_type.py b/src/datadog_api_client/v1/model/guided_table_storage_type.py new file mode 100644 index 0000000000..e2aef95044 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_storage_type.py @@ -0,0 +1,53 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class GuidedTableStorageType(ModelSimple): + """ + Storage tier to target for an events-platform query in a guided table. + + :param value: Must be one of ["live", "hot", "online_archives", "driveline", "flex_tier", "case_insensitive", "cloud_prem"]. + :type value: str + """ + + allowed_values = { + "live", + "hot", + "online_archives", + "driveline", + "flex_tier", + "case_insensitive", + "cloud_prem", + } + LIVE: ClassVar["GuidedTableStorageType"] + HOT: ClassVar["GuidedTableStorageType"] + ONLINE_ARCHIVES: ClassVar["GuidedTableStorageType"] + DRIVELINE: ClassVar["GuidedTableStorageType"] + FLEX_TIER: ClassVar["GuidedTableStorageType"] + CASE_INSENSITIVE: ClassVar["GuidedTableStorageType"] + CLOUD_PREM: ClassVar["GuidedTableStorageType"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +GuidedTableStorageType.LIVE = GuidedTableStorageType("live") +GuidedTableStorageType.HOT = GuidedTableStorageType("hot") +GuidedTableStorageType.ONLINE_ARCHIVES = GuidedTableStorageType("online_archives") +GuidedTableStorageType.DRIVELINE = GuidedTableStorageType("driveline") +GuidedTableStorageType.FLEX_TIER = GuidedTableStorageType("flex_tier") +GuidedTableStorageType.CASE_INSENSITIVE = GuidedTableStorageType("case_insensitive") +GuidedTableStorageType.CLOUD_PREM = GuidedTableStorageType("cloud_prem") diff --git a/src/datadog_api_client/v1/model/guided_table_text_formatting_rule.py b/src/datadog_api_client/v1/model/guided_table_text_formatting_rule.py new file mode 100644 index 0000000000..d972007658 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_text_formatting_rule.py @@ -0,0 +1,95 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import Union, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.table_widget_text_format_match import TableWidgetTextFormatMatch + from datadog_api_client.v1.model.guided_table_threshold_palette import GuidedTableThresholdPalette + from datadog_api_client.v1.model.guided_table_text_formatting_rule_replace import ( + GuidedTableTextFormattingRuleReplace, + ) + from datadog_api_client.v1.model.table_widget_text_format_replace_all import TableWidgetTextFormatReplaceAll + from datadog_api_client.v1.model.guided_table_text_formatting_rule_replace_one_of4484404608 import ( + GuidedTableTextFormattingRuleReplaceOneOf4484404608, + ) + + +class GuidedTableTextFormattingRule(ModelNormal): + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.table_widget_text_format_match import TableWidgetTextFormatMatch + from datadog_api_client.v1.model.guided_table_threshold_palette import GuidedTableThresholdPalette + from datadog_api_client.v1.model.guided_table_text_formatting_rule_replace import ( + GuidedTableTextFormattingRuleReplace, + ) + + return { + "custom_bg_color": (str,), + "custom_fg_color": (str,), + "match": (TableWidgetTextFormatMatch,), + "palette": (GuidedTableThresholdPalette,), + "replace": (GuidedTableTextFormattingRuleReplace,), + } + + attribute_map = { + "custom_bg_color": "custom_bg_color", + "custom_fg_color": "custom_fg_color", + "match": "match", + "palette": "palette", + "replace": "replace", + } + + def __init__( + self_, + match: TableWidgetTextFormatMatch, + custom_bg_color: Union[str, UnsetType] = unset, + custom_fg_color: Union[str, UnsetType] = unset, + palette: Union[GuidedTableThresholdPalette, UnsetType] = unset, + replace: Union[ + GuidedTableTextFormattingRuleReplace, + TableWidgetTextFormatReplaceAll, + GuidedTableTextFormattingRuleReplaceOneOf4484404608, + UnsetType, + ] = unset, + **kwargs, + ): + """ + Rule for applying visual formatting to text values in a guided table group-by column. + + :param custom_bg_color: Custom background color hex code. Used with ``custom_bg`` palette. + :type custom_bg_color: str, optional + + :param custom_fg_color: Custom text color hex code. Used with ``custom_text`` palette. + :type custom_fg_color: str, optional + + :param match: Match rule for the table widget text format. + :type match: TableWidgetTextFormatMatch + + :param palette: Color palette used by threshold-based conditional formatting and text formatting rules in a guided table. + :type palette: GuidedTableThresholdPalette, optional + + :param replace: Optional replacement to apply to matched text. + :type replace: GuidedTableTextFormattingRuleReplace, optional + """ + if custom_bg_color is not unset: + kwargs["custom_bg_color"] = custom_bg_color + if custom_fg_color is not unset: + kwargs["custom_fg_color"] = custom_fg_color + if palette is not unset: + kwargs["palette"] = palette + if replace is not unset: + kwargs["replace"] = replace + super().__init__(kwargs) + + self_.match = match diff --git a/src/datadog_api_client/v1/model/guided_table_text_formatting_rule_replace.py b/src/datadog_api_client/v1/model/guided_table_text_formatting_rule_replace.py new file mode 100644 index 0000000000..4b7e084002 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_text_formatting_rule_replace.py @@ -0,0 +1,48 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelComposed, + cached_property, +) + + +class GuidedTableTextFormattingRuleReplace(ModelComposed): + def __init__(self, **kwargs): + """ + Optional replacement to apply to matched text. + + :param type: Table widget text format replace all type. + :type type: TableWidgetTextFormatReplaceAllType + + :param _with: Replace All type. + :type _with: str + + :param substring: + :type substring: str + """ + super().__init__(kwargs) + + @cached_property + def _composed_schemas(_): + # we need this here to make our import statements work + # we must store _composed_schemas in here so the code is only run + # when we invoke this method. If we kept this at the class + # level we would get an error because the class level + # code would be run when this module is imported, and these composed + # classes don't exist yet because their module has not finished + # loading + from datadog_api_client.v1.model.table_widget_text_format_replace_all import TableWidgetTextFormatReplaceAll + from datadog_api_client.v1.model.guided_table_text_formatting_rule_replace_one_of4484404608 import ( + GuidedTableTextFormattingRuleReplaceOneOf4484404608, + ) + + return { + "oneOf": [ + TableWidgetTextFormatReplaceAll, + GuidedTableTextFormattingRuleReplaceOneOf4484404608, + ], + } diff --git a/src/datadog_api_client/v1/model/guided_table_text_formatting_rule_replace_one_of4484404608.py b/src/datadog_api_client/v1/model/guided_table_text_formatting_rule_replace_one_of4484404608.py new file mode 100644 index 0000000000..45644b5182 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_text_formatting_rule_replace_one_of4484404608.py @@ -0,0 +1,56 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.table_widget_text_format_replace_substring_type import ( + TableWidgetTextFormatReplaceSubstringType, + ) + + +class GuidedTableTextFormattingRuleReplaceOneOf4484404608(ModelNormal): + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.table_widget_text_format_replace_substring_type import ( + TableWidgetTextFormatReplaceSubstringType, + ) + + return { + "substring": (str,), + "type": (TableWidgetTextFormatReplaceSubstringType,), + "_with": (str,), + } + + attribute_map = { + "substring": "substring", + "type": "type", + "_with": "with", + } + + def __init__(self_, substring: str, type: TableWidgetTextFormatReplaceSubstringType, _with: str, **kwargs): + """ + Replace a specific substring. + + :param substring: + :type substring: str + + :param type: Table widget text format replace sub-string type. + :type type: TableWidgetTextFormatReplaceSubstringType + + :param _with: + :type _with: str + """ + super().__init__(kwargs) + + self_.substring = substring + self_.type = type + self_._with = _with diff --git a/src/datadog_api_client/v1/model/guided_table_threshold_formatting_rule.py b/src/datadog_api_client/v1/model/guided_table_threshold_formatting_rule.py new file mode 100644 index 0000000000..8024b85d97 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_threshold_formatting_rule.py @@ -0,0 +1,101 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import Union, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.widget_comparator import WidgetComparator + from datadog_api_client.v1.model.guided_table_threshold_palette import GuidedTableThresholdPalette + from datadog_api_client.v1.model.guided_table_threshold_formatting_rule_value import ( + GuidedTableThresholdFormattingRuleValue, + ) + + +class GuidedTableThresholdFormattingRule(ModelNormal): + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.widget_comparator import WidgetComparator + from datadog_api_client.v1.model.guided_table_threshold_palette import GuidedTableThresholdPalette + from datadog_api_client.v1.model.guided_table_threshold_formatting_rule_value import ( + GuidedTableThresholdFormattingRuleValue, + ) + + return { + "comparator": (WidgetComparator,), + "custom_bg_color": (str,), + "custom_fg_color": (str,), + "hide_value": (bool,), + "image_url": (str,), + "palette": (GuidedTableThresholdPalette,), + "value": (GuidedTableThresholdFormattingRuleValue,), + } + + attribute_map = { + "comparator": "comparator", + "custom_bg_color": "custom_bg_color", + "custom_fg_color": "custom_fg_color", + "hide_value": "hide_value", + "image_url": "image_url", + "palette": "palette", + "value": "value", + } + + def __init__( + self_, + comparator: WidgetComparator, + palette: GuidedTableThresholdPalette, + custom_bg_color: Union[str, UnsetType] = unset, + custom_fg_color: Union[str, UnsetType] = unset, + hide_value: Union[bool, UnsetType] = unset, + image_url: Union[str, UnsetType] = unset, + value: Union[GuidedTableThresholdFormattingRuleValue, float, str, UnsetType] = unset, + **kwargs, + ): + """ + Conditional formatting rule that applies when a value satisfies a threshold comparator condition. + + :param comparator: Comparator to apply. + :type comparator: WidgetComparator + + :param custom_bg_color: Custom background color. Used with ``custom_bg`` palette. + :type custom_bg_color: str, optional + + :param custom_fg_color: Custom text color. Used with ``custom_text`` palette. + :type custom_fg_color: str, optional + + :param hide_value: Whether to hide the data value when this rule matches. + :type hide_value: bool, optional + + :param image_url: URL of an image to display as background. + :type image_url: str, optional + + :param palette: Color palette used by threshold-based conditional formatting and text formatting rules in a guided table. + :type palette: GuidedTableThresholdPalette + + :param value: Threshold value to compare against. + :type value: GuidedTableThresholdFormattingRuleValue, optional + """ + if custom_bg_color is not unset: + kwargs["custom_bg_color"] = custom_bg_color + if custom_fg_color is not unset: + kwargs["custom_fg_color"] = custom_fg_color + if hide_value is not unset: + kwargs["hide_value"] = hide_value + if image_url is not unset: + kwargs["image_url"] = image_url + if value is not unset: + kwargs["value"] = value + super().__init__(kwargs) + + self_.comparator = comparator + self_.palette = palette diff --git a/src/datadog_api_client/v1/model/guided_table_threshold_formatting_rule_value.py b/src/datadog_api_client/v1/model/guided_table_threshold_formatting_rule_value.py new file mode 100644 index 0000000000..81feb149c0 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_threshold_formatting_rule_value.py @@ -0,0 +1,34 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelComposed, + cached_property, +) + + +class GuidedTableThresholdFormattingRuleValue(ModelComposed): + def __init__(self, **kwargs): + """ + Threshold value to compare against. + """ + super().__init__(kwargs) + + @cached_property + def _composed_schemas(_): + # we need this here to make our import statements work + # we must store _composed_schemas in here so the code is only run + # when we invoke this method. If we kept this at the class + # level we would get an error because the class level + # code would be run when this module is imported, and these composed + # classes don't exist yet because their module has not finished + # loading + return { + "oneOf": [ + float, + str, + ], + } diff --git a/src/datadog_api_client/v1/model/guided_table_threshold_palette.py b/src/datadog_api_client/v1/model/guided_table_threshold_palette.py new file mode 100644 index 0000000000..0e91147548 --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_threshold_palette.py @@ -0,0 +1,86 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class GuidedTableThresholdPalette(ModelSimple): + """ + Color palette used by threshold-based conditional formatting and text formatting rules in a guided table. + + :param value: Must be one of ["white_on_red", "black_on_light_red", "white_on_green", "black_on_light_green", "white_on_yellow", "black_on_light_yellow", "white_on_gray", "green_on_white", "yellow_on_white", "red_on_white", "gray_on_white", "red", "green", "orange", "gray", "custom_bg", "custom_text", "custom_image"]. + :type value: str + """ + + allowed_values = { + "white_on_red", + "black_on_light_red", + "white_on_green", + "black_on_light_green", + "white_on_yellow", + "black_on_light_yellow", + "white_on_gray", + "green_on_white", + "yellow_on_white", + "red_on_white", + "gray_on_white", + "red", + "green", + "orange", + "gray", + "custom_bg", + "custom_text", + "custom_image", + } + WHITE_ON_RED: ClassVar["GuidedTableThresholdPalette"] + BLACK_ON_LIGHT_RED: ClassVar["GuidedTableThresholdPalette"] + WHITE_ON_GREEN: ClassVar["GuidedTableThresholdPalette"] + BLACK_ON_LIGHT_GREEN: ClassVar["GuidedTableThresholdPalette"] + WHITE_ON_YELLOW: ClassVar["GuidedTableThresholdPalette"] + BLACK_ON_LIGHT_YELLOW: ClassVar["GuidedTableThresholdPalette"] + WHITE_ON_GRAY: ClassVar["GuidedTableThresholdPalette"] + GREEN_ON_WHITE: ClassVar["GuidedTableThresholdPalette"] + YELLOW_ON_WHITE: ClassVar["GuidedTableThresholdPalette"] + RED_ON_WHITE: ClassVar["GuidedTableThresholdPalette"] + GRAY_ON_WHITE: ClassVar["GuidedTableThresholdPalette"] + RED: ClassVar["GuidedTableThresholdPalette"] + GREEN: ClassVar["GuidedTableThresholdPalette"] + ORANGE: ClassVar["GuidedTableThresholdPalette"] + GRAY: ClassVar["GuidedTableThresholdPalette"] + CUSTOM_BG: ClassVar["GuidedTableThresholdPalette"] + CUSTOM_TEXT: ClassVar["GuidedTableThresholdPalette"] + CUSTOM_IMAGE: ClassVar["GuidedTableThresholdPalette"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +GuidedTableThresholdPalette.WHITE_ON_RED = GuidedTableThresholdPalette("white_on_red") +GuidedTableThresholdPalette.BLACK_ON_LIGHT_RED = GuidedTableThresholdPalette("black_on_light_red") +GuidedTableThresholdPalette.WHITE_ON_GREEN = GuidedTableThresholdPalette("white_on_green") +GuidedTableThresholdPalette.BLACK_ON_LIGHT_GREEN = GuidedTableThresholdPalette("black_on_light_green") +GuidedTableThresholdPalette.WHITE_ON_YELLOW = GuidedTableThresholdPalette("white_on_yellow") +GuidedTableThresholdPalette.BLACK_ON_LIGHT_YELLOW = GuidedTableThresholdPalette("black_on_light_yellow") +GuidedTableThresholdPalette.WHITE_ON_GRAY = GuidedTableThresholdPalette("white_on_gray") +GuidedTableThresholdPalette.GREEN_ON_WHITE = GuidedTableThresholdPalette("green_on_white") +GuidedTableThresholdPalette.YELLOW_ON_WHITE = GuidedTableThresholdPalette("yellow_on_white") +GuidedTableThresholdPalette.RED_ON_WHITE = GuidedTableThresholdPalette("red_on_white") +GuidedTableThresholdPalette.GRAY_ON_WHITE = GuidedTableThresholdPalette("gray_on_white") +GuidedTableThresholdPalette.RED = GuidedTableThresholdPalette("red") +GuidedTableThresholdPalette.GREEN = GuidedTableThresholdPalette("green") +GuidedTableThresholdPalette.ORANGE = GuidedTableThresholdPalette("orange") +GuidedTableThresholdPalette.GRAY = GuidedTableThresholdPalette("gray") +GuidedTableThresholdPalette.CUSTOM_BG = GuidedTableThresholdPalette("custom_bg") +GuidedTableThresholdPalette.CUSTOM_TEXT = GuidedTableThresholdPalette("custom_text") +GuidedTableThresholdPalette.CUSTOM_IMAGE = GuidedTableThresholdPalette("custom_image") diff --git a/src/datadog_api_client/v1/model/guided_table_trend_column_format.py b/src/datadog_api_client/v1/model/guided_table_trend_column_format.py new file mode 100644 index 0000000000..01a9457d2c --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_trend_column_format.py @@ -0,0 +1,84 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + +from typing import List, Union, TYPE_CHECKING + +from datadog_api_client.model_utils import ( + ModelNormal, + cached_property, + unset, + UnsetType, +) + + +if TYPE_CHECKING: + from datadog_api_client.v1.model.guided_table_conditional_formats import GuidedTableConditionalFormats + from datadog_api_client.v1.model.guided_table_trend_column_format_mode import GuidedTableTrendColumnFormatMode + from datadog_api_client.v1.model.guided_table_number_format import GuidedTableNumberFormat + from datadog_api_client.v1.model.widget_formula_cell_display_mode_options import WidgetFormulaCellDisplayModeOptions + from datadog_api_client.v1.model.guided_table_threshold_formatting_rule import GuidedTableThresholdFormattingRule + from datadog_api_client.v1.model.guided_table_range_formatting_rule import GuidedTableRangeFormattingRule + + +class GuidedTableTrendColumnFormat(ModelNormal): + @cached_property + def openapi_types(_): + from datadog_api_client.v1.model.guided_table_conditional_formats import GuidedTableConditionalFormats + from datadog_api_client.v1.model.guided_table_trend_column_format_mode import GuidedTableTrendColumnFormatMode + from datadog_api_client.v1.model.guided_table_number_format import GuidedTableNumberFormat + from datadog_api_client.v1.model.widget_formula_cell_display_mode_options import ( + WidgetFormulaCellDisplayModeOptions, + ) + + return { + "conditional_formats": (GuidedTableConditionalFormats,), + "mode": (GuidedTableTrendColumnFormatMode,), + "number_format": (GuidedTableNumberFormat,), + "trend_options": (WidgetFormulaCellDisplayModeOptions,), + } + + attribute_map = { + "conditional_formats": "conditional_formats", + "mode": "mode", + "number_format": "number_format", + "trend_options": "trend_options", + } + + def __init__( + self_, + mode: GuidedTableTrendColumnFormatMode, + trend_options: WidgetFormulaCellDisplayModeOptions, + conditional_formats: Union[ + GuidedTableConditionalFormats, + List[GuidedTableThresholdFormattingRule], + List[GuidedTableRangeFormattingRule], + UnsetType, + ] = unset, + number_format: Union[GuidedTableNumberFormat, UnsetType] = unset, + **kwargs, + ): + """ + Formats a guided table column as a trend sparkline. + + :param conditional_formats: Conditional formatting rules for a guided table column. Either an array of threshold-based rules or a single range-based rule. + :type conditional_formats: GuidedTableConditionalFormats, optional + + :param mode: + :type mode: GuidedTableTrendColumnFormatMode + + :param number_format: Number display format for a guided table column value. + :type number_format: GuidedTableNumberFormat, optional + + :param trend_options: Cell display mode options for the widget formula. (only if ``cell_display_mode`` is set to ``trend`` ). + :type trend_options: WidgetFormulaCellDisplayModeOptions + """ + if conditional_formats is not unset: + kwargs["conditional_formats"] = conditional_formats + if number_format is not unset: + kwargs["number_format"] = number_format + super().__init__(kwargs) + + self_.mode = mode + self_.trend_options = trend_options diff --git a/src/datadog_api_client/v1/model/guided_table_trend_column_format_mode.py b/src/datadog_api_client/v1/model/guided_table_trend_column_format_mode.py new file mode 100644 index 0000000000..75f7ac4a1d --- /dev/null +++ b/src/datadog_api_client/v1/model/guided_table_trend_column_format_mode.py @@ -0,0 +1,35 @@ +# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +# This product includes software developed at Datadog (https://www.datadoghq.com/). +# Copyright 2019-Present Datadog, Inc. +from __future__ import annotations + + +from datadog_api_client.model_utils import ( + ModelSimple, + cached_property, +) + +from typing import ClassVar + + +class GuidedTableTrendColumnFormatMode(ModelSimple): + """ + + + :param value: If omitted defaults to "trend". Must be one of ["trend"]. + :type value: str + """ + + allowed_values = { + "trend", + } + TREND: ClassVar["GuidedTableTrendColumnFormatMode"] + + @cached_property + def openapi_types(_): + return { + "value": (str,), + } + + +GuidedTableTrendColumnFormatMode.TREND = GuidedTableTrendColumnFormatMode("trend") diff --git a/src/datadog_api_client/v1/model/table_widget_definition.py b/src/datadog_api_client/v1/model/table_widget_definition.py index 685d9a5c7e..73ea69a5d2 100644 --- a/src/datadog_api_client/v1/model/table_widget_definition.py +++ b/src/datadog_api_client/v1/model/table_widget_definition.py @@ -16,10 +16,11 @@ if TYPE_CHECKING: from datadog_api_client.v1.model.widget_custom_link import WidgetCustomLink from datadog_api_client.v1.model.table_widget_has_search_bar import TableWidgetHasSearchBar - from datadog_api_client.v1.model.table_widget_request import TableWidgetRequest from datadog_api_client.v1.model.widget_time import WidgetTime from datadog_api_client.v1.model.widget_text_align import WidgetTextAlign from datadog_api_client.v1.model.table_widget_definition_type import TableWidgetDefinitionType + from datadog_api_client.v1.model.table_widget_request import TableWidgetRequest + from datadog_api_client.v1.model.guided_table_request import GuidedTableRequest from datadog_api_client.v1.model.widget_legacy_live_span import WidgetLegacyLiveSpan from datadog_api_client.v1.model.widget_new_live_span import WidgetNewLiveSpan from datadog_api_client.v1.model.widget_new_fixed_span import WidgetNewFixedSpan @@ -30,7 +31,6 @@ class TableWidgetDefinition(ModelNormal): def openapi_types(_): from datadog_api_client.v1.model.widget_custom_link import WidgetCustomLink from datadog_api_client.v1.model.table_widget_has_search_bar import TableWidgetHasSearchBar - from datadog_api_client.v1.model.table_widget_request import TableWidgetRequest from datadog_api_client.v1.model.widget_time import WidgetTime from datadog_api_client.v1.model.widget_text_align import WidgetTextAlign from datadog_api_client.v1.model.table_widget_definition_type import TableWidgetDefinitionType @@ -38,7 +38,7 @@ def openapi_types(_): return { "custom_links": ([WidgetCustomLink],), "has_search_bar": (TableWidgetHasSearchBar,), - "requests": ([TableWidgetRequest],), + "requests": ([TableWidgetRequest, GuidedTableRequest],), "time": (WidgetTime,), "title": (str,), "title_align": (WidgetTextAlign,), @@ -59,7 +59,7 @@ def openapi_types(_): def __init__( self_, - requests: List[TableWidgetRequest], + requests: List[Union[TableWidgetRequest, GuidedTableRequest]], type: TableWidgetDefinitionType, custom_links: Union[List[WidgetCustomLink], UnsetType] = unset, has_search_bar: Union[TableWidgetHasSearchBar, UnsetType] = unset, @@ -78,8 +78,8 @@ def __init__( :param has_search_bar: Controls the display of the search bar. :type has_search_bar: TableWidgetHasSearchBar, optional - :param requests: Widget definition. - :type requests: [TableWidgetRequest] + :param requests: Widget definition. Each item is either a classic ``TableWidgetRequest`` or an experimental ``GuidedTableRequest`` (used when the ``graphing_new_table_widget_editor`` feature flag is enabled). + :type requests: [TableWidgetRequest, GuidedTableRequest] :param time: Time setting for the widget. :type time: WidgetTime, optional diff --git a/src/datadog_api_client/v1/models/__init__.py b/src/datadog_api_client/v1/models/__init__.py index 2220d357ae..cf04b731a0 100644 --- a/src/datadog_api_client/v1/models/__init__.py +++ b/src/datadog_api_client/v1/models/__init__.py @@ -207,6 +207,63 @@ from datadog_api_client.v1.model.group_type import GroupType from datadog_api_client.v1.model.group_widget_definition import GroupWidgetDefinition from datadog_api_client.v1.model.group_widget_definition_type import GroupWidgetDefinitionType +from datadog_api_client.v1.model.guided_table_column import GuidedTableColumn +from datadog_api_client.v1.model.guided_table_column_comparison import GuidedTableColumnComparison +from datadog_api_client.v1.model.guided_table_column_comparison_with_other_column import ( + GuidedTableColumnComparisonWithOtherColumn, +) +from datadog_api_client.v1.model.guided_table_column_comparison_with_other_column_type import ( + GuidedTableColumnComparisonWithOtherColumnType, +) +from datadog_api_client.v1.model.guided_table_column_comparison_with_self import GuidedTableColumnComparisonWithSelf +from datadog_api_client.v1.model.guided_table_column_comparison_with_self_type import ( + GuidedTableColumnComparisonWithSelfType, +) +from datadog_api_client.v1.model.guided_table_column_format import GuidedTableColumnFormat +from datadog_api_client.v1.model.guided_table_column_function import GuidedTableColumnFunction +from datadog_api_client.v1.model.guided_table_compute_column import GuidedTableComputeColumn +from datadog_api_client.v1.model.guided_table_compute_column_compute import GuidedTableComputeColumnCompute +from datadog_api_client.v1.model.guided_table_compute_column_type import GuidedTableComputeColumnType +from datadog_api_client.v1.model.guided_table_conditional_formats import GuidedTableConditionalFormats +from datadog_api_client.v1.model.guided_table_events_query import GuidedTableEventsQuery +from datadog_api_client.v1.model.guided_table_events_query_data_source import GuidedTableEventsQueryDataSource +from datadog_api_client.v1.model.guided_table_events_query_search import GuidedTableEventsQuerySearch +from datadog_api_client.v1.model.guided_table_formula_column import GuidedTableFormulaColumn +from datadog_api_client.v1.model.guided_table_group_key import GuidedTableGroupKey +from datadog_api_client.v1.model.guided_table_metrics_query import GuidedTableMetricsQuery +from datadog_api_client.v1.model.guided_table_metrics_query_data_source import GuidedTableMetricsQueryDataSource +from datadog_api_client.v1.model.guided_table_number_bar_column_format import GuidedTableNumberBarColumnFormat +from datadog_api_client.v1.model.guided_table_number_bar_column_format_mode import GuidedTableNumberBarColumnFormatMode +from datadog_api_client.v1.model.guided_table_number_format import GuidedTableNumberFormat +from datadog_api_client.v1.model.guided_table_number_format_precision import GuidedTableNumberFormatPrecision +from datadog_api_client.v1.model.guided_table_preset_column import GuidedTablePresetColumn +from datadog_api_client.v1.model.guided_table_preset_column_preset import GuidedTablePresetColumnPreset +from datadog_api_client.v1.model.guided_table_preset_column_preset_type import GuidedTablePresetColumnPresetType +from datadog_api_client.v1.model.guided_table_preset_column_type import GuidedTablePresetColumnType +from datadog_api_client.v1.model.guided_table_query import GuidedTableQuery +from datadog_api_client.v1.model.guided_table_range_formatting_rule import GuidedTableRangeFormattingRule +from datadog_api_client.v1.model.guided_table_range_formatting_rule_scale import GuidedTableRangeFormattingRuleScale +from datadog_api_client.v1.model.guided_table_range_formatting_rule_type import GuidedTableRangeFormattingRuleType +from datadog_api_client.v1.model.guided_table_range_palette import GuidedTableRangePalette +from datadog_api_client.v1.model.guided_table_request import GuidedTableRequest +from datadog_api_client.v1.model.guided_table_request_request_type import GuidedTableRequestRequestType +from datadog_api_client.v1.model.guided_table_row_group_by import GuidedTableRowGroupBy +from datadog_api_client.v1.model.guided_table_row_group_by_format import GuidedTableRowGroupByFormat +from datadog_api_client.v1.model.guided_table_rows import GuidedTableRows +from datadog_api_client.v1.model.guided_table_sort import GuidedTableSort +from datadog_api_client.v1.model.guided_table_storage_type import GuidedTableStorageType +from datadog_api_client.v1.model.guided_table_text_formatting_rule import GuidedTableTextFormattingRule +from datadog_api_client.v1.model.guided_table_text_formatting_rule_replace import GuidedTableTextFormattingRuleReplace +from datadog_api_client.v1.model.guided_table_text_formatting_rule_replace_one_of4484404608 import ( + GuidedTableTextFormattingRuleReplaceOneOf4484404608, +) +from datadog_api_client.v1.model.guided_table_threshold_formatting_rule import GuidedTableThresholdFormattingRule +from datadog_api_client.v1.model.guided_table_threshold_formatting_rule_value import ( + GuidedTableThresholdFormattingRuleValue, +) +from datadog_api_client.v1.model.guided_table_threshold_palette import GuidedTableThresholdPalette +from datadog_api_client.v1.model.guided_table_trend_column_format import GuidedTableTrendColumnFormat +from datadog_api_client.v1.model.guided_table_trend_column_format_mode import GuidedTableTrendColumnFormatMode from datadog_api_client.v1.model.http_log import HTTPLog from datadog_api_client.v1.model.http_log_error import HTTPLogError from datadog_api_client.v1.model.http_log_item import HTTPLogItem @@ -1379,6 +1436,53 @@ "GroupType", "GroupWidgetDefinition", "GroupWidgetDefinitionType", + "GuidedTableColumn", + "GuidedTableColumnComparison", + "GuidedTableColumnComparisonWithOtherColumn", + "GuidedTableColumnComparisonWithOtherColumnType", + "GuidedTableColumnComparisonWithSelf", + "GuidedTableColumnComparisonWithSelfType", + "GuidedTableColumnFormat", + "GuidedTableColumnFunction", + "GuidedTableComputeColumn", + "GuidedTableComputeColumnCompute", + "GuidedTableComputeColumnType", + "GuidedTableConditionalFormats", + "GuidedTableEventsQuery", + "GuidedTableEventsQueryDataSource", + "GuidedTableEventsQuerySearch", + "GuidedTableFormulaColumn", + "GuidedTableGroupKey", + "GuidedTableMetricsQuery", + "GuidedTableMetricsQueryDataSource", + "GuidedTableNumberBarColumnFormat", + "GuidedTableNumberBarColumnFormatMode", + "GuidedTableNumberFormat", + "GuidedTableNumberFormatPrecision", + "GuidedTablePresetColumn", + "GuidedTablePresetColumnPreset", + "GuidedTablePresetColumnPresetType", + "GuidedTablePresetColumnType", + "GuidedTableQuery", + "GuidedTableRangeFormattingRule", + "GuidedTableRangeFormattingRuleScale", + "GuidedTableRangeFormattingRuleType", + "GuidedTableRangePalette", + "GuidedTableRequest", + "GuidedTableRequestRequestType", + "GuidedTableRowGroupBy", + "GuidedTableRowGroupByFormat", + "GuidedTableRows", + "GuidedTableSort", + "GuidedTableStorageType", + "GuidedTableTextFormattingRule", + "GuidedTableTextFormattingRuleReplace", + "GuidedTableTextFormattingRuleReplaceOneOf4484404608", + "GuidedTableThresholdFormattingRule", + "GuidedTableThresholdFormattingRuleValue", + "GuidedTableThresholdPalette", + "GuidedTableTrendColumnFormat", + "GuidedTableTrendColumnFormatMode", "HTTPLog", "HTTPLogError", "HTTPLogItem",