arthur-common 2.1.52__py3-none-any.whl → 2.1.54__py3-none-any.whl

arthur_common/aggregations/functions/shield_aggregations.py

@@ -10,7 +10,12 @@ from arthur_common.aggregations.aggregator import (
     SketchAggregationFunction,
 )
 from arthur_common.models.datasets import ModelProblemType
-from arthur_common.models.metrics import DatasetReference, NumericMetric, SketchMetric
+from arthur_common.models.metrics import (
+    BaseReportedAggregation,
+    DatasetReference,
+    NumericMetric,
+    SketchMetric,
+)
 from arthur_common.models.schema_definitions import (
     SHIELD_RESPONSE_SCHEMA,
     MetricColumnParameterAnnotation,
@@ -33,6 +38,15 @@ class ShieldInferencePassFailCountAggregation(NumericAggregationFunction):
     def description() -> str:
         return "Metric that counts the number of Shield inferences grouped by the prompt, response, and overall check results."
 
+    @staticmethod
+    def reported_aggregations() -> list[BaseReportedAggregation]:
+        return [
+            BaseReportedAggregation(
+                metric_name=ShieldInferencePassFailCountAggregation.METRIC_NAME,
+                description=ShieldInferencePassFailCountAggregation.description(),
+            ),
+        ]
+
     def aggregate(
         self,
         ddb_conn: DuckDBPyConnection,
@@ -93,6 +107,15 @@ class ShieldInferenceRuleCountAggregation(NumericAggregationFunction):
     def description() -> str:
         return "Metric that counts the number of Shield rule evaluations grouped by whether it was on the prompt or response, the rule type, the rule evaluation result, the rule name, and the rule id."
 
+    @staticmethod
+    def reported_aggregations() -> list[BaseReportedAggregation]:
+        return [
+            BaseReportedAggregation(
+                metric_name=ShieldInferenceRuleCountAggregation.METRIC_NAME,
+                description=ShieldInferenceRuleCountAggregation.description(),
+            ),
+        ]
+
     def aggregate(
         self,
         ddb_conn: DuckDBPyConnection,
@@ -176,6 +199,15 @@ class ShieldInferenceHallucinationCountAggregation(NumericAggregationFunction):
     def description() -> str:
         return "Metric that counts the number of Shield hallucination evaluations that failed."
 
+    @staticmethod
+    def reported_aggregations() -> list[BaseReportedAggregation]:
+        return [
+            BaseReportedAggregation(
+                metric_name=ShieldInferenceHallucinationCountAggregation.METRIC_NAME,
+                description=ShieldInferenceHallucinationCountAggregation.description(),
+            ),
+        ]
+
     def aggregate(
         self,
         ddb_conn: DuckDBPyConnection,
@@ -231,6 +263,15 @@ class ShieldInferenceRuleToxicityScoreAggregation(SketchAggregationFunction):
     def description() -> str:
         return "Metric that reports a distribution (data sketch) on toxicity scores returned by the Shield toxicity rule."
 
+    @staticmethod
+    def reported_aggregations() -> list[BaseReportedAggregation]:
+        return [
+            BaseReportedAggregation(
+                metric_name=ShieldInferenceRuleToxicityScoreAggregation.METRIC_NAME,
+                description=ShieldInferenceRuleToxicityScoreAggregation.description(),
+            ),
+        ]
+
     def aggregate(
         self,
         ddb_conn: DuckDBPyConnection,
@@ -307,6 +348,15 @@ class ShieldInferenceRulePIIDataScoreAggregation(SketchAggregationFunction):
     def description() -> str:
         return "Metric that reports a distribution (data sketch) on PII scores returned by the Shield PII rule."
 
+    @staticmethod
+    def reported_aggregations() -> list[BaseReportedAggregation]:
+        return [
+            BaseReportedAggregation(
+                metric_name=ShieldInferenceRulePIIDataScoreAggregation.METRIC_NAME,
+                description=ShieldInferenceRulePIIDataScoreAggregation.description(),
+            ),
+        ]
+
     def aggregate(
         self,
         ddb_conn: DuckDBPyConnection,
@@ -389,6 +439,15 @@ class ShieldInferenceRuleClaimCountAggregation(SketchAggregationFunction):
     def description() -> str:
         return "Metric that reports a distribution (data sketch) on over the number of claims identified by the Shield hallucination rule."
 
+    @staticmethod
+    def reported_aggregations() -> list[BaseReportedAggregation]:
+        return [
+            BaseReportedAggregation(
+                metric_name=ShieldInferenceRuleClaimCountAggregation.METRIC_NAME,
+                description=ShieldInferenceRuleClaimCountAggregation.description(),
+            ),
+        ]
+
     def aggregate(
         self,
         ddb_conn: DuckDBPyConnection,
@@ -453,6 +512,15 @@ class ShieldInferenceRuleClaimPassCountAggregation(SketchAggregationFunction):
     def description() -> str:
         return "Metric that reports a distribution (data sketch) on the number of valid claims determined by the Shield hallucination rule."
 
+    @staticmethod
+    def reported_aggregations() -> list[BaseReportedAggregation]:
+        return [
+            BaseReportedAggregation(
+                metric_name=ShieldInferenceRuleClaimPassCountAggregation.METRIC_NAME,
+                description=ShieldInferenceRuleClaimPassCountAggregation.description(),
+            ),
+        ]
+
     def aggregate(
         self,
         ddb_conn: DuckDBPyConnection,
@@ -517,6 +585,15 @@ class ShieldInferenceRuleClaimFailCountAggregation(SketchAggregationFunction):
     def description() -> str:
         return "Metric that reports a distribution (data sketch) on the number of invalid claims determined by the Shield hallucination rule."
 
+    @staticmethod
+    def reported_aggregations() -> list[BaseReportedAggregation]:
+        return [
+            BaseReportedAggregation(
+                metric_name=ShieldInferenceRuleClaimFailCountAggregation.METRIC_NAME,
+                description=ShieldInferenceRuleClaimFailCountAggregation.description(),
+            ),
+        ]
+
     def aggregate(
         self,
         ddb_conn: DuckDBPyConnection,
@@ -581,6 +658,15 @@ class ShieldInferenceRuleLatencyAggregation(SketchAggregationFunction):
     def description() -> str:
         return "Metric that reports a distribution (data sketch) on the latency of Shield rule evaluations. Dimensions are the rule result, rule type, and whether the rule was applicable to a prompt or response."
 
+    @staticmethod
+    def reported_aggregations() -> list[BaseReportedAggregation]:
+        return [
+            BaseReportedAggregation(
+                metric_name=ShieldInferenceRuleLatencyAggregation.METRIC_NAME,
+                description=ShieldInferenceRuleLatencyAggregation.description(),
+            ),
+        ]
+
     def aggregate(
         self,
         ddb_conn: DuckDBPyConnection,
@@ -643,6 +729,18 @@ class ShieldInferenceRuleLatencyAggregation(SketchAggregationFunction):
 
 class ShieldInferenceTokenCountAggregation(NumericAggregationFunction):
     METRIC_NAME = "token_count"
+    SUPPORTED_MODELS = [
+        "gpt-4o",
+        "gpt-4o-mini",
+        "gpt-3.5-turbo",
+        "o1-mini",
+        "deepseek-chat",
+        "claude-3-5-sonnet-20241022",
+        "gemini/gemini-1.5-pro",
+        "meta.llama3-1-8b-instruct-v1:0",
+        "meta.llama3-1-70b-instruct-v1:0",
+        "meta.llama3-2-11b-instruct-v1:0",
+    ]
 
     @staticmethod
     def id() -> UUID:
@@ -656,6 +754,27 @@ class ShieldInferenceTokenCountAggregation(NumericAggregationFunction):
     def description() -> str:
         return "Metric that reports the number of tokens in the Shield response and prompt schemas, and their estimated cost."
 
+    @staticmethod
+    def _series_name_from_model_name(model_name: str) -> str:
+        """Calculates name of reported series based on the model name considered."""
+        return f"token_cost.{model_name}"
+
+    @staticmethod
+    def reported_aggregations() -> list[BaseReportedAggregation]:
+        base_token_count_agg = BaseReportedAggregation(
+            metric_name=ShieldInferenceTokenCountAggregation.METRIC_NAME,
+            description=f"Metric that reports the number of tokens in the Shield response and prompt schemas.",
+        )
+        return [base_token_count_agg] + [
+            BaseReportedAggregation(
+                metric_name=ShieldInferenceTokenCountAggregation._series_name_from_model_name(
+                    model_name,
+                ),
+                description=f"Metric that reports the estimated cost for the {model_name} model of the tokens in the Shield response and prompt schemas.",
+            )
+            for model_name in ShieldInferenceTokenCountAggregation.SUPPORTED_MODELS
+        ]
+
     def aggregate(
         self,
         ddb_conn: DuckDBPyConnection,
@@ -708,25 +827,12 @@ class ShieldInferenceTokenCountAggregation(NumericAggregationFunction):
         resp = [metric]
 
         # Compute Cost for each model
-        models = [
-            "gpt-4o",
-            "gpt-4o-mini",
-            "gpt-3.5-turbo",
-            "o1-mini",
-            "deepseek-chat",
-            "claude-3-5-sonnet-20241022",
-            "gemini/gemini-1.5-pro",
-            "meta.llama3-1-8b-instruct-v1:0",
-            "meta.llama3-1-70b-instruct-v1:0",
-            "meta.llama3-2-11b-instruct-v1:0",
-        ]
-
         # Precompute input/output classification to avoid recalculating in loop
         location_type = results["location"].apply(
             lambda x: "input" if x == "prompt" else "output",
         )
 
-        for model in models:
+        for model in self.SUPPORTED_MODELS:
             # Efficient list comprehension instead of apply
             cost_values = [
                 calculate_cost_by_tokens(int(tokens), model, loc_type)
@@ -747,5 +853,10 @@ class ShieldInferenceTokenCountAggregation(NumericAggregationFunction):
                 ["location"],
                 "ts",
             )
-            resp.append(self.series_to_metric(f"token_cost.{model}", model_series))
+            resp.append(
+                self.series_to_metric(
+                    self._series_name_from_model_name(model),
+                    model_series,
+                ),
+            )
         return resp

arthur_common/models/datasets.py

@@ -7,6 +7,7 @@ class ModelProblemType(str, Enum):
     ARTHUR_SHIELD = "arthur_shield"
     CUSTOM = "custom"
     MULTICLASS_CLASSIFICATION = "multiclass_classification"
+    AGENTIC_TRACE = "agentic_trace"
 
 
 class DatasetFileType(str, Enum):

arthur_common/models/metrics.py

@@ -193,7 +193,10 @@ class MetricsColumnParameterSchema(MetricsParameterSchema, BaseColumnParameterSc
     parameter_type: Literal["column"] = "column"
 
 
-class MetricsColumnListParameterSchema(MetricsParameterSchema, BaseColumnParameterSchema):
+class MetricsColumnListParameterSchema(
+    MetricsParameterSchema,
+    BaseColumnParameterSchema,
+):
     # list column parameter schema specific to default metrics
     parameter_type: Literal["column_list"] = "column_list"
 
@@ -211,9 +214,7 @@ MetricsColumnSchemaUnion = (
 
 
 CustomAggregationParametersSchemaUnion = (
-    BaseDatasetParameterSchema
-    | BaseLiteralParameterSchema
-    | BaseColumnParameterSchema
+    BaseDatasetParameterSchema | BaseLiteralParameterSchema | BaseColumnParameterSchema
 )
 
 
@@ -224,6 +225,14 @@ class DatasetReference:
     dataset_id: UUID
 
 
+class BaseReportedAggregation(BaseModel):
+    # in future will be used by default metrics
+    metric_name: str = Field(description="Name of the reported aggregation metric.")
+    description: str = Field(
+        description="Description of the reported aggregation metric and what it aggregates.",
+    )
+
+
 class AggregationSpecSchema(BaseModel):
     name: str = Field(description="Name of the aggregation function.")
     id: UUID = Field(description="Unique identifier of the aggregation function.")
@@ -240,6 +249,17 @@ class AggregationSpecSchema(BaseModel):
     aggregate_args: list[MetricsParameterSchemaUnion] = Field(
         description="List of parameters to the aggregation's aggregate function.",
     )
+    reported_aggregations: list[BaseReportedAggregation] = Field(
+        description="List of aggregations reported by the metric.",
+    )
+
+    @model_validator(mode="after")
+    def at_least_one_reported_agg(self) -> Self:
+        if len(self.reported_aggregations) < 1:
+            raise ValueError(
+                "Aggregation spec must specify at least one reported aggregation.",
+            )
+        return self
 
     @model_validator(mode="after")
     def column_dataset_references_exist(self) -> Self:
@@ -262,26 +282,23 @@ class AggregationSpecSchema(BaseModel):
         return self
 
 
-class BaseReportedAggregation(BaseModel):
-    # in future will be used by default metrics
-    metric_name: str = Field(description="Name of the reported aggregation metric.")
-    description: str = Field(
-        description="Description of the reported aggregation metric and what it aggregates.",
-    )
-
-
 class ReportedCustomAggregation(BaseReportedAggregation):
-    value_column: str = Field(description="Name of the column returned from the SQL query holding the metric value.")
-    timestamp_column: str = Field(description="Name of the column returned from the SQL query holding the timestamp buckets.")
+    value_column: str = Field(
+        description="Name of the column returned from the SQL query holding the metric value.",
+    )
+    timestamp_column: str = Field(
+        description="Name of the column returned from the SQL query holding the timestamp buckets.",
+    )
     metric_kind: AggregationMetricType = Field(
         description="Return type of the reported aggregation metric value.",
     )
-    dimension_columns: list[str] = Field(description="Name of any dimension columns returned from the SQL query. Max length is 1.")
+    dimension_columns: list[str] = Field(
+        description="Name of any dimension columns returned from the SQL query. Max length is 1.",
+    )
 
-    @field_validator('dimension_columns')
+    @field_validator("dimension_columns")
     @classmethod
     def validate_dimension_columns_length(cls, v: list[str]) -> str:
         if len(v) > 1:
-            raise ValueError('Only one dimension column can be specified.')
+            raise ValueError("Only one dimension column can be specified.")
         return v
-

arthur_common/models/schema_definitions.py

@@ -367,6 +367,38 @@ def create_shield_inference_feedback_schema() -> DatasetListType:
     )
 
 
+def AGENTIC_TRACE_SCHEMA() -> DatasetSchema:
+    return DatasetSchema(
+        alias_mask={},
+        columns=[
+            DatasetColumn(
+                id=uuid4(),
+                source_name="trace_id",
+                definition=create_dataset_scalar_type(DType.STRING),
+            ),
+            DatasetColumn(
+                id=uuid4(),
+                source_name="start_time",
+                definition=create_dataset_scalar_type(DType.TIMESTAMP),
+            ),
+            DatasetColumn(
+                id=uuid4(),
+                source_name="end_time",
+                definition=create_dataset_scalar_type(DType.TIMESTAMP),
+            ),
+            DatasetColumn(
+                id=uuid4(),
+                source_name="root_spans",
+                definition=create_dataset_list_type(
+                    create_dataset_scalar_type(
+                        DType.JSON,
+                    ),  # JSON blob to preserve hierarchy
+                ),
+            ),
+        ],
+    )
+
+
 def SHIELD_SCHEMA() -> DatasetSchema:
     return DatasetSchema(
         alias_mask={},
@@ -423,6 +455,32 @@ def SHIELD_SCHEMA() -> DatasetSchema:
 SHIELD_RESPONSE_SCHEMA = create_shield_response_schema().to_base_type()
 SHIELD_PROMPT_SCHEMA = create_shield_prompt_schema().to_base_type()
 
+
+# Agentic trace schema base type for API responses
+def create_agentic_trace_response_schema() -> DatasetObjectType:
+    return create_dataset_object_type(
+        {
+            "count": create_dataset_scalar_type(DType.INT),
+            "traces": create_dataset_list_type(
+                create_dataset_object_type(
+                    {
+                        "trace_id": create_dataset_scalar_type(DType.STRING),
+                        "start_time": create_dataset_scalar_type(DType.TIMESTAMP),
+                        "end_time": create_dataset_scalar_type(DType.TIMESTAMP),
+                        "root_spans": create_dataset_list_type(
+                            create_dataset_scalar_type(
+                                DType.JSON,
+                            ),  # JSON blob for infinite depth
+                        ),
+                    },
+                ),
+            ),
+        },
+    )
+
+
+AGENTIC_TRACE_RESPONSE_SCHEMA = create_agentic_trace_response_schema().to_base_type()
+
 SEGMENTATION_ALLOWED_DTYPES = [DType.INT, DType.BOOL, DType.STRING, DType.UUID]
 SEGMENTATION_ALLOWED_COLUMN_TYPES = [
     ScalarType(dtype=d_type) for d_type in SEGMENTATION_ALLOWED_DTYPES

arthur_common/models/shield.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 from enum import Enum
 from typing import Any, Dict, List, Optional, Self, Type, Union
 
@@ -26,6 +27,15 @@ class RuleScope(str, Enum):
     TASK = "task"
 
 
+class MetricType(str, Enum):
+    QUERY_RELEVANCE = "QueryRelevance"
+    RESPONSE_RELEVANCE = "ResponseRelevance"
+    TOOL_SELECTION = "ToolSelection"
+
+    def __str__(self):
+        return self.value
+
+
 class BaseEnum(str, Enum):
     @classmethod
     def values(cls) -> list[Any]:
@@ -240,6 +250,27 @@ class RuleResponse(BaseModel):
     )
 
 
+class MetricResponse(BaseModel):
+    id: str = Field(description="ID of the Metric")
+    name: str = Field(description="Name of the Metric")
+    type: MetricType = Field(description="Type of the Metric")
+    metric_metadata: str = Field(description="Metadata of the Metric")
+    config: Optional[str] = Field(
+        description="JSON-serialized configuration for the Metric",
+        default=None,
+    )
+    created_at: datetime = Field(
+        description="Time the Metric was created in unix milliseconds",
+    )
+    updated_at: datetime = Field(
+        description="Time the Metric was updated in unix milliseconds",
+    )
+    enabled: Optional[bool] = Field(
+        description="Whether the Metric is enabled",
+        default=None,
+    )
+
+
 class TaskResponse(BaseModel):
     id: str = Field(description=" ID of the task")
     name: str = Field(description="Name of the task")
@@ -249,7 +280,12 @@ class TaskResponse(BaseModel):
     updated_at: int = Field(
         description="Time the task was created in unix milliseconds",
     )
+    is_agentic: bool = Field(description="Whether the task is agentic or not")
     rules: List[RuleResponse] = Field(description="List of all the rules for the task.")
+    metrics: Optional[List[MetricResponse]] = Field(
+        description="List of all the metrics for the task.",
+        default=None,
+    )
 
 
 class UpdateRuleRequest(BaseModel):
@@ -484,3 +520,125 @@ class NewRuleRequest(BaseModel):
                     detail="Examples must be provided to onboard a ModelSensitiveDataRule",
                 )
         return self
+
+
+class RelevanceMetricConfig(BaseModel):
+    """Configuration for relevance metrics including QueryRelevance and ResponseRelevance"""
+
+    relevance_threshold: Optional[float] = Field(
+        default=None,
+        description="Threshold for determining relevance when not using LLM judge",
+    )
+    use_llm_judge: bool = Field(
+        default=True,
+        description="Whether to use LLM as a judge for relevance scoring",
+    )
+
+
+class NewMetricRequest(BaseModel):
+    type: MetricType = Field(
+        description="Type of the metric. It can only be one of QueryRelevance, ResponseRelevance, ToolSelection",
+        examples=["UserQueryRelevance"],
+    )
+    name: str = Field(
+        description="Name of metric",
+        examples=["My User Query Relevance"],
+    )
+    metric_metadata: str = Field(description="Additional metadata for the metric")
+    config: Optional[RelevanceMetricConfig] = Field(
+        description="Configuration for the metric. Currently only applies to UserQueryRelevance and ResponseRelevance metric types.",
+        default=None,
+    )
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example1": {
+                "type": "QueryRelevance",
+                "name": "My User Query Relevance",
+                "metric_metadata": "This is a test metric metadata",
+            },
+            "example2": {
+                "type": "QueryRelevance",
+                "name": "My User Query Relevance with Config",
+                "metric_metadata": "This is a test metric metadata",
+                "config": {"relevance_threshold": 0.8, "use_llm_judge": False},
+            },
+            "example3": {
+                "type": "ResponseRelevance",
+                "name": "My Response Relevance",
+                "metric_metadata": "This is a test metric metadata",
+                "config": {"use_llm_judge": True},
+            },
+        },
+    )
+
+    @field_validator("type")
+    def validate_metric_type(cls, value):
+        if value not in MetricType:
+            raise ValueError(
+                f"Invalid metric type: {value}. Valid types are: {', '.join([t.value for t in MetricType])}",
+            )
+        return value
+
+    @model_validator(mode="before")
+    def set_config_type(cls, values):
+        if not isinstance(values, dict):
+            return values
+
+        metric_type = values.get("type")
+        config_values = values.get("config")
+
+        # Map metric types to their corresponding config classes
+        metric_type_to_config = {
+            MetricType.QUERY_RELEVANCE: RelevanceMetricConfig,
+            MetricType.RESPONSE_RELEVANCE: RelevanceMetricConfig,
+            # Add new metric types and their configs here as needed
+        }
+
+        config_class = metric_type_to_config.get(metric_type)
+
+        if config_class is not None:
+            if config_values is None:
+                # Default config when none is provided
+                config_values = {"use_llm_judge": True}
+            elif isinstance(config_values, dict):
+                # Handle mutually exclusive parameters
+                if (
+                    "relevance_threshold" in config_values
+                    and "use_llm_judge" in config_values
+                    and config_values["use_llm_judge"]
+                ):
+                    raise HTTPException(
+                        status_code=400,
+                        detail="relevance_threshold and use_llm_judge=true are mutually exclusive. Set use_llm_judge=false when using relevance_threshold.",
+                        headers={"full_stacktrace": "false"},
+                    )
+
+                # If relevance_threshold is set but use_llm_judge isn't, set use_llm_judge to false
+                if (
+                    "relevance_threshold" in config_values
+                    and "use_llm_judge" not in config_values
+                ):
+                    config_values["use_llm_judge"] = False
+
+                # If neither is set, default to use_llm_judge=True
+                if (
+                    "relevance_threshold" not in config_values
+                    and "use_llm_judge" not in config_values
+                ):
+                    config_values["use_llm_judge"] = True
+
+            if isinstance(config_values, BaseModel):
+                config_values = config_values.model_dump()
+
+            values["config"] = config_class(**config_values)
+        elif config_values is not None:
+            # Provide a nice error message listing supported metric types
+            supported_types = [t.value for t in metric_type_to_config.keys()]
+            raise HTTPException(
+                status_code=400,
+                detail=f"Config is only supported for {', '.join(supported_types)} metric types",
+                headers={"full_stacktrace": "false"},
+            )
+
+        return values

arthur_common/models/task_job_specs.py

@@ -1,13 +1,23 @@
-from typing import Literal, Optional
+from enum import Enum
+from typing import Literal, Optional, Self
 from uuid import UUID
 
 from pydantic import BaseModel, Field
 
-from arthur_common.models.shield import NewRuleRequest
+from arthur_common.models.shield import (
+    NewMetricRequest,
+    NewRuleRequest,
+    model_validator,
+)
 
 onboarding_id_desc = "An identifier to assign to the created model to make it easy to retrieve. Used by the UI during the GenAI model creation flow."
 
 
+class TaskType(str, Enum):
+    TRADITIONAL = "traditional"
+    AGENTIC = "agentic"
+
+
 class CreateModelTaskJobSpec(BaseModel):
     job_type: Literal["create_model_task"] = "create_model_task"
     connector_id: UUID = Field(
@@ -21,6 +31,20 @@ class CreateModelTaskJobSpec(BaseModel):
     initial_rules: list[NewRuleRequest] = Field(
         description="The initial rules to apply to the created model.",
     )
+    task_type: TaskType = Field(
+        default=TaskType.TRADITIONAL,
+        description="The type of task to create.",
+    )
+    initial_metrics: list[NewMetricRequest] = Field(
+        description="The initial metrics to apply to agentic tasks.",
+    )
+
+    @model_validator(mode="after")
+    def initial_metric_required(self) -> Self:
+        if self.task_type == TaskType.TRADITIONAL:
+            if not len(self.initial_metrics) == 0:
+                raise ValueError("No initial_metrics when task_type is TRADITIONAL")
+        return self
 
 
 class CreateModelLinkTaskJobSpec(BaseModel):

arthur_common/tools/aggregation_analyzer.py

@@ -207,7 +207,7 @@ class FunctionAnalyzer:
             )
         # Check if X implements the required methods
         required_methods = ["aggregate", "id", "description", "display_name"]
-        static_methods = ["description", "id", "display_name"]
+        static_methods = ["description", "id", "display_name", "reported_aggregations"]
         for method in required_methods:
             if not hasattr(agg_func, method) or not callable(getattr(agg_func, method)):
                 raise AttributeError(
@@ -253,6 +253,7 @@ class FunctionAnalyzer:
             metric_type=metric_type,
             init_args=aggregation_init_args,
             aggregate_args=aggregate_args,
+            reported_aggregations=agg_func.reported_aggregations(),
         )
 
 

{arthur_common-2.1.52.dist-info → arthur_common-2.1.54.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arthur-common
-Version: 2.1.52
+Version: 2.1.54
 Summary: Utility code common to Arthur platform components.
 License: MIT
 Author: Arthur