fiddler-evals 0.6.0__tar.gz → 0.7.0.dev1__tar.gz

{fiddler_evals-0.6.0/fiddler_evals.egg-info → fiddler_evals-0.7.0.dev1}/PKG-INFO

@@ -1,14 +1,17 @@
 Metadata-Version: 2.4
 Name: fiddler-evals
-Version: 0.6.0
+Version: 0.7.0.dev1
 Summary: Python SDK for evaluating LLM Applications
 Author-email: Fiddler AI <support@fiddler.ai>
 Maintainer-email: Fiddler AI <support@fiddler.ai>
 Project-URL: Homepage, https://fiddler.ai
 Project-URL: Documentation, https://docs.fiddler.ai/
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: pip>=21.0
 Requires-Dist: requests<3
@@ -36,7 +39,7 @@ A comprehensive toolkit for evaluating Large Language Model (LLM) applications,
 
 ## Requirements
 
-- Python 3.10 or higher
+- Python 3.11 or higher
 - Access to a Fiddler Platform instance
 - API token from Fiddler Platform
 

{fiddler_evals-0.6.0 → fiddler_evals-0.7.0.dev1}/PUBLIC.md

@@ -14,7 +14,7 @@ A comprehensive toolkit for evaluating Large Language Model (LLM) applications,
 
 ## Requirements
 
-- Python 3.10 or higher
+- Python 3.11 or higher
 - Access to a Fiddler Platform instance
 - API token from Fiddler Platform
 

{fiddler_evals-0.6.0 → fiddler_evals-0.7.0.dev1}/README.md

@@ -14,7 +14,7 @@ The Fiddler Evals SDK is a comprehensive toolkit for evaluating Large Language M
 
 ### Prerequisites
 
-- Python 3.10 or higher
+- Python 3.11 or higher
 - Access to a Fiddler platform instance
 
 ### Installation

fiddler_evals-0.7.0.dev1/fiddler_evals/VERSION

@@ -0,0 +1 @@
+0.7.0.dev1

{fiddler_evals-0.6.0 → fiddler_evals-0.7.0.dev1}/fiddler_evals/entities/application.py

@@ -89,12 +89,27 @@ class Application(BaseEntity):
     """
 
     id: UUID
+    """Unique identifier (UUID) of the application."""
+
     name: str
+    """Application name; unique within the project and immutable after creation."""
+
     created_at: datetime
+    """Server-side timestamp of when the application was created."""
+
     updated_at: datetime
+    """Server-side timestamp of when the application was last updated."""
+
     created_by: UserCompact
+    """Compact reference (id, full name, email) to the user who created the
+    application."""
+
     updated_by: UserCompact
+    """Compact reference (id, full name, email) to the user who last updated the
+    application."""
+
     project: ProjectCompact
+    """Compact reference (id and name) to the project containing this application."""
 
     @staticmethod
     def _get_url(id_: UUID | str | None = None) -> str:
@@ -420,11 +435,6 @@ class Application(BaseEntity):
         spans in the given time range, with coverage counts. Useful for
         building field mappings before adding spans to a dataset.
 
-        At most 10,000 matching spans are scanned. If more match, the
-        response sets ``sampled=True`` and the counts describe a sample
-        rather than the whole set — narrow ``filter``, ``search``, or the
-        time range to get exact coverage.
-
         Args:
             start_time: Start of the time range, inclusive. ISO 8601
                 string or a **timezone-aware** datetime. Naive datetimes
@@ -445,26 +455,61 @@ class Application(BaseEntity):
             :class:`~fiddler_evals.pydantic_models.span_fields.SpanFieldsResponse`:
                 Span attributes and evaluator outputs with counts.
 
+        Raises:
+            ApiError: If there's an error communicating with the Fiddler API.
+
+        Note:
+            Discovery scans at most 10,000 matching spans. Above that it sets
+            ``sampled=True`` and the counts describe a sample rather than the
+            full set — narrow the time range or the filter when you need exact
+            coverage. Attribute keys are reported exactly as stored, so they
+            can be copied directly into a
+            :class:`~fiddler_evals.pydantic_models.span_fields.FieldMapping`
+            for :meth:`~fiddler_evals.entities.dataset.Dataset.add_items_from_spans`.
+
         Example:
             .. code-block:: python
 
-                app = Application.get_by_id(app_id)
-                fields = app.get_span_fields(
-                    start_time="2025-01-01T00:00:00Z",
-                    end_time="2025-01-02T00:00:00Z",
-                    filter=QueryCondition(
-                        rules=[
-                            QueryRule(
-                                field="Span::span_type",
-                                operator=OperatorType.EQUAL,
-                                value="llm",
-                            )
-                        ]
-                    ),
-                    search=SearchFilter(query="refund", scope=SearchScope.INPUT),
+                from datetime import datetime, timedelta, timezone
+
+                from fiddler_evals import (
+                    Application,
+                    OperatorType,
+                    Project,
+                    QueryCondition,
+                    QueryRule,
+                )
+
+                # Get application instance
+                project = Project.get_by_name(name="fraud-detection-project")
+                application = Application.get_by_name(
+                    name="fraud-detection-app",
+                    project_id=project.id,
                 )
-                for attr in fields.span_attributes:
-                    print(f"{attr.key}: {attr.count}")
+
+                end_time = datetime.now(timezone.utc)
+                start_time = end_time - timedelta(days=7)
+
+                # Scope discovery to LLM spans only
+                llm_filter = QueryCondition(
+                    rules=[
+                        QueryRule(
+                            field="Span::span_type",
+                            operator=OperatorType.EQUAL,
+                            value="llm",
+                        ),
+                    ]
+                )
+
+                fields = application.get_span_fields(
+                    start_time=start_time,
+                    end_time=end_time,
+                    filter=llm_filter,
+                )
+
+                print(f"{fields.total_spans} spans scanned (sampled={fields.sampled})")
+                for attribute in sorted(fields.span_attributes, key=lambda a: -a.count):
+                    print(f"  {attribute.key}: {attribute.count}")
         """
         payload: dict = {
             "application_id": str(self.id),

{fiddler_evals-0.6.0 → fiddler_evals-0.7.0.dev1}/fiddler_evals/entities/dataset.py

@@ -115,16 +115,40 @@ class Dataset(BaseEntity):
     """
 
     id: UUID
+    """Unique identifier (UUID) of the dataset."""
+
     name: str
+    """Dataset name; unique within the application and immutable after creation."""
+
     created_at: datetime
+    """Server-side timestamp of when the dataset was created."""
+
     updated_at: datetime
+    """Server-side timestamp of when the dataset was last updated."""
+
     created_by: UserCompact
+    """Compact reference (id, full name, email) to the user who created the
+    dataset."""
+
     updated_by: UserCompact
+    """Compact reference (id, full name, email) to the user who last updated the
+    dataset."""
+
     project: ProjectCompact
+    """Compact reference (id and name) to the project containing this dataset."""
+
     application: ApplicationCompact
+    """Compact reference (id and name) to the application containing this dataset."""
+
     active: bool = True
+    """Whether the dataset is active; set at creation and changeable via
+    ``update()``. Defaults to ``True``."""
+
     description: str | None = None
+    """Optional human-readable description of the dataset; ``None`` if not set."""
+
     metadata: dict = field(default_factory=dict)
+    """Custom metadata dictionary attached to the dataset; empty when not set."""
 
     @staticmethod
     def _get_url(id_: UUID | str | None = None) -> str:
@@ -1289,21 +1313,36 @@ class Dataset(BaseEntity):
 
         Discovers what field keys exist in each JSON bucket (inputs,
         expected_outputs, metadata, extras) across the dataset's items,
-        with coverage counts and inferred data types.
+        with coverage counts and inferred data types. Use it to keep a new
+        :class:`~fiddler_evals.pydantic_models.span_fields.FieldMapping`
+        consistent with the field names the dataset already uses.
 
         Returns:
             :class:`~fiddler_evals.pydantic_models.span_fields.DatasetSchemaResponse`:
                 Item total, sampling flag, and field keys per bucket with
                 counts and types.
 
+        Raises:
+            ApiError: If there's an error communicating with the Fiddler API.
+
+        Note:
+            Experiment tasks bind to inputs by name, so reusing the existing
+            field names keeps new items consistent and replayable alongside
+            the items already in the dataset.
+
         Example:
             .. code-block:: python
 
-                dataset = Dataset.get_by_id(dataset_id)
+                # Get existing dataset
+                dataset = Dataset.get_by_name(
+                    name="fraud-detection-tests", application_id=application_id
+                )
+
+                # Inspect existing field names before adding more items
                 schema = dataset.get_schema()
                 print(f"{schema.total_items} items (sampled={schema.sampled})")
                 for field in schema.inputs:
-                    print(f"{field.key}: {field.data_type} ({field.count})")
+                    print(f"  inputs.{field.key}: {field.data_type} ({field.count})")
         """
         response = self._client().get(
             url=f"{self._get_url(self.id)}/schema",
@@ -1339,7 +1378,8 @@ class Dataset(BaseEntity):
                 rejected by the server; any UTC offset is accepted and
                 normalized to UTC server-side.
             end_time: End of the time range, exclusive. ISO 8601 string or a
-                **timezone-aware** datetime, same rules as ``start_time``.
+                **timezone-aware** datetime, same rules as ``start_time``. A
+                referenced span outside the window is treated as missing.
 
         Returns:
             :class:`~fiddler_evals.pydantic_models.span_fields.AddItemsFromSpansResponse`:
@@ -1354,24 +1394,45 @@ class Dataset(BaseEntity):
                 summary message. 400 if ``spans`` exceeds the per-request cap
                 or the dataset would exceed its item limit (default 10,000).
 
+        Note:
+            A failed call writes nothing, so retrying after fixing the
+            references cannot create duplicates. A successful call has no
+            idempotency key, however — repeating it with the same spans
+            creates duplicate dataset items. Mapped attribute keys are matched
+            exactly against stored span attribute keys; discover them first
+            with ``Application.get_span_fields()``.
+
         Example:
             .. code-block:: python
 
-                dataset = Dataset.get_by_id(dataset_id)
+                from fiddler_evals import FieldMapping, SpanReference
+
+                # Get existing dataset
+                dataset = Dataset.get_by_name(
+                    name="fraud-detection-tests", application_id=application_id
+                )
+
+                # Span references collected from POST /v3/spans/query
+                span_refs = [
+                    SpanReference(trace_id=span["trace_id"], span_id=span["span_id"])
+                    for span in spans
+                ]
+
+                # Map dataset fields to stored span attribute keys
+                mapping = FieldMapping(
+                    inputs={"user_query": "gen_ai.llm.input.user"},
+                    expected_outputs={"expected_response": "gen_ai.llm.output"},
+                    metadata={"model": "gen_ai.request.model"},
+                )
+
                 result = dataset.add_items_from_spans(
-                    spans=[
-                        {"trace_id": "abc123", "span_id": "def456"},
-                    ],
-                    mapping={
-                        "inputs": {"question": "fiddler.span.user.query"},
-                        "expected_outputs": {},
-                        "metadata": {},
-                        "extras": {},
-                    },
-                    start_time="2025-01-01T00:00:00Z",
-                    end_time="2025-01-02T00:00:00Z",
+                    spans=span_refs,
+                    mapping=mapping,
+                    start_time=start_time,
+                    end_time=end_time,
                 )
-                print(f"Created {result.items_created} items")
+                print(f"Created {result.items_created} dataset items")
+                print(f"Item IDs: {result.item_ids[:3]}")
         """
         # Coerce dicts through the models rather than forwarding them as-is, so
         # both input styles produce an identical request body and malformed

{fiddler_evals-0.6.0 → fiddler_evals-0.7.0.dev1}/fiddler_evals/entities/experiment.py

@@ -32,6 +32,8 @@ Note:
     lifecycle of evaluation runs from creation to completion or failure.
 """
 
+# pylint: disable=too-many-lines
+# (docstrings pushed this module past pylint's 1000-line cap; see PR)
 from __future__ import annotations
 
 import builtins
@@ -68,17 +70,54 @@ logger = logging.getLogger(__name__)
 
 
 class ExperimentStatus(str, enum.Enum):
+    """Lifecycle status of an experiment run.
+
+    An experiment is created with ``PENDING`` status, moves to
+    ``IN_PROGRESS`` when the runner starts processing dataset items, and
+    ends in ``COMPLETED``, ``FAILED``, or ``CANCELLED``.
+
+    A ``COMPLETED`` experiment does not imply that every item succeeded:
+    individual items can still be ``ExperimentItemStatus.FAILED``. Item
+    failures do not fail the experiment.
+    """
+
     PENDING = "PENDING"
+    """The experiment was created on the server; the run has not started yet."""
+
     IN_PROGRESS = "IN_PROGRESS"
+    """The runner is executing the task function and evaluators over the
+    dataset items."""
+
     COMPLETED = "COMPLETED"
+    """The run finished and results were published, even if some individual
+    items failed."""
+
     FAILED = "FAILED"
+    """The run aborted with an unrecoverable error, such as a task or scoring
+    function whose signature does not match the dataset item fields."""
+
     CANCELLED = "CANCELLED"
+    """The run was interrupted by the user or by system termination; results
+    already published are kept."""
 
 
 class ExperimentItemStatus(str, enum.Enum):
+    """Outcome of a single dataset item within an experiment run.
+
+    A ``SUCCESS`` item does not imply that every score succeeded: evaluator
+    errors are recorded per score (see ``ScoreStatus``), not on the item.
+    """
+
     SUCCESS = "SUCCESS"
+    """The task function returned outputs and all evaluators ran on this
+    item, even if some individual scores failed."""
+
     FAILED = "FAILED"
+    """The task function raised an exception on this item, so no evaluators
+    ran; ``error_reason`` and ``error_message`` are populated."""
+
     SKIPPED = "SKIPPED"
+    """The item was skipped and produced no result."""
 
 
 @dataclass
@@ -120,21 +159,60 @@ class Experiment(BaseEntity):
     """
 
     id: UUID
+    """Unique identifier (UUID) of the experiment."""
+
     name: str
+    """Experiment name; unique within the application and immutable after creation."""
+
     status: str
+    """Lifecycle status of the run; holds an ``ExperimentStatus`` value
+    (``PENDING``, ``IN_PROGRESS``, ``COMPLETED``, ``FAILED``, or ``CANCELLED``)."""
+
     created_at: datetime
+    """Server-side timestamp of when the experiment was created."""
+
     updated_at: datetime
+    """Server-side timestamp of when the experiment was last updated."""
+
     created_by: UserCompact
+    """Compact reference (id, full name, email) to the user who created the
+    experiment."""
+
     updated_by: UserCompact
+    """Compact reference (id, full name, email) to the user who last updated the
+    experiment."""
+
     project: ProjectCompact
+    """Compact reference (id and name) to the project containing this experiment."""
+
     application: ApplicationCompact
+    """Compact reference (id and name) to the application containing this
+    experiment."""
+
     dataset: DatasetCompact
+    """Compact reference (id and name) to the dataset the experiment ran against."""
+
     description: str | None = None
+    """Optional human-readable description of the experiment; ``None`` if not set."""
+
     error_reason: str | None = None
+    """Short reason for the failure; populated when the run fails or is canceled,
+    otherwise ``None``."""
+
     error_message: str | None = None
+    """Detailed error message for the failure; populated when the run fails or is
+    canceled, otherwise ``None``."""
+
     traceback: str | None = None
+    """Stack trace captured for the failure; populated when the run fails or is
+    canceled, otherwise ``None``."""
+
     duration_ms: int | None = None
+    """Total duration of the experiment run in milliseconds; set on completion,
+    otherwise ``None``."""
+
     metadata: dict = field(default_factory=dict)
+    """Custom metadata dictionary attached to the experiment; empty when not set."""
 
     @staticmethod
     def _get_url(id_: UUID | str | None = None) -> str:
@@ -548,7 +626,7 @@ class Experiment(BaseEntity):
             metadata: Optional new metadata dictionary for the experiment. If provided,
                      replaces the existing metadata completely. Use empty dict to clear.
             status: Optional new status for the experiment. Can be used to update
-                   experiment status (e.g., PENDING, RUNNING, COMPLETED, FAILED).
+                   experiment status (e.g., PENDING, IN_PROGRESS, COMPLETED, FAILED).
             error_reason: Required when status is FAILED. The reason for the experiment failure.
             error_message: Required when status is FAILED. Detailed error message for the failure.
             traceback: Required when status is FAILED. Stack trace information for debugging.
@@ -690,7 +768,7 @@ class Experiment(BaseEntity):
                   - dataset_item_id: UUID of the dataset item being evaluated
                   - outputs: Dictionary containing the outputs of the task function against dataset item
                   - duration_ms: Duration of the execution in milliseconds:
-                  - status: Status of the outputs of the task function / scoring against dataset item (PENDING, COMPLETED, FAILED, etc.)
+                  - status: Status of the outputs of the task function / scoring against dataset item (SUCCESS, FAILED, or SKIPPED)
                   - error_reason: Reason for failure, if applicable
                   - error_message: Detailed error message, if applicable
 
@@ -718,7 +796,7 @@ class Experiment(BaseEntity):
                         outputs={"answer": "The watermelon seeds pass through your digestive system"},
                         duration_ms=1000,
                         end_time=datetime.now(tz=timezone.utc),
-                        status="COMPLETED",
+                        status="SUCCESS",
                         error_reason=None,
                         error_message=None
                     ),
@@ -727,7 +805,7 @@ class Experiment(BaseEntity):
                         outputs={"answer": "The precise origin of fortune cookies is unclear"},
                         duration_ms=1000,
                         end_time=datetime.now(tz=timezone.utc),
-                        status="COMPLETED",
+                        status="SUCCESS",
                         error_reason=None,
                         error_message=None
                     )
@@ -745,7 +823,7 @@ class Experiment(BaseEntity):
                         "outputs": {"answer": result["answer"]},
                         "duration_ms": result["duration_ms"],
                         "end_time": result["end_time"],
-                        "status": "COMPLETED"
+                        "status": "SUCCESS"
                     }
                     for result in items
                 ]
@@ -818,7 +896,7 @@ class Experiment(BaseEntity):
                 # Filter items by status
                 completed_items = [
                     item for item in experiment.get_items()
-                    if item.status == "COMPLETED"
+                    if item.status == "SUCCESS"
                 ]
                 print(f"Completed items: {len(completed_items)}")
 
@@ -892,7 +970,7 @@ class Experiment(BaseEntity):
                     outputs={"prediction": "fraud", "confidence": 0.95},
                     duration_ms=1000,
                     end_time=datetime.now(tz=timezone.utc),
-                    status="COMPLETED"
+                    status="SUCCESS"
                 )
 
                 # Create scores from evaluators

{fiddler_evals-0.6.0 → fiddler_evals-0.7.0.dev1}/fiddler_evals/entities/project.py

@@ -89,9 +89,16 @@ class Project(BaseEntity):
     """
 
     id: UUID
+    """Unique identifier (UUID) of the project."""
+
     name: str
+    """Project name; unique within the organization and immutable after creation."""
+
     created_at: datetime
+    """Server-side timestamp of when the project was created."""
+
     updated_at: datetime
+    """Server-side timestamp of when the project was last updated."""
 
     @staticmethod
     def _get_url(id_: UUID | str | None = None) -> str:

{fiddler_evals-0.6.0 → fiddler_evals-0.7.0.dev1}/fiddler_evals/evaluators/answer_relevance.py

@@ -37,7 +37,7 @@ class AnswerRelevance(FiddlerLLMAAJEvaluator):
         retrieved_documents (list[str], optional): Reference documents for context.
 
     Returns:
-        Score: A Score object containing:
+        Score: A :class:`~fiddler_evals.pydantic_models.score.Score` object containing:
             - value: 1.0 for high, 0.5 for medium, 0.0 for low relevance
             - label: "high", "medium", or "low"
             - reasoning: Detailed explanation of the assessment
@@ -72,6 +72,8 @@ class AnswerRelevance(FiddlerLLMAAJEvaluator):
     """
 
     name = "answer_relevance"
+    """Evaluator identifier, recorded as ``evaluator_name`` on every
+    ``Score`` this evaluator produces."""
 
     def score(  # pylint: disable=arguments-differ
         self,
@@ -87,7 +89,7 @@ class AnswerRelevance(FiddlerLLMAAJEvaluator):
             retrieved_documents (list[str], optional): Reference documents for context.
 
         Returns:
-            Score: A Score object containing:
+            Score: A :class:`~fiddler_evals.pydantic_models.score.Score` object containing:
                 - value: 1.0 for high, 0.5 for medium, 0.0 for low relevance
                 - label: "high", "medium", or "low"
                 - reasoning: Detailed explanation of the assessment

{fiddler_evals-0.6.0 → fiddler_evals-0.7.0.dev1}/fiddler_evals/evaluators/base.py

@@ -59,6 +59,7 @@ class Evaluator(ABC):
                 is_match = output.strip().lower() == expected_output.strip().lower()
                 return Score(
                     name=f"{self.score_name_prefix}exact_match",
+                    evaluator_name=self.name,
                     value=1.0 if is_match else 0.0,
                     reasoning=f"Match: {is_match}"
                 )
@@ -169,12 +170,29 @@ class Evaluator(ABC):
             - Comparison: score(self, output: str, expected_output: str) -> Score
             - All parameters: score(self, input: str, output: str, context: list[str]) -> Score
 
+        The runner resolves each parameter by name. Alongside the task's outputs,
+        which are spread into the namespace by key, four parameters are always
+        available -- declare only the ones you need:
+
+        * ``inputs`` (``dict``) -- the dataset item's inputs, passed as a single
+          dict rather than spread.
+        * ``outputs`` (``dict``) -- everything the task returned.
+        * ``expected_outputs`` (``dict | None``) -- the item's expected outputs.
+        * ``session`` (``Session | None``) -- the OpenTelemetry spans captured
+          while the task ran. Declaring it opts the evaluator in to scoring the
+          execution itself (tool call order, retry counts, token usage, latency)
+          rather than only the final output string. Trace capture is best-effort,
+          so default it to ``None`` and handle that case.
+
+        All four are bound after the task outputs are spread, so a task output of
+        the same name cannot shadow them.
+
         Args:
             *args: Positional arguments specific to the evaluator's needs.
             **kwargs: Keyword arguments specific to the evaluator's needs.
 
         Returns:
-            Score | list[Score]: A single Score object or list of Score objects
+            Score | list[Score]: A single :class:`~fiddler_evals.pydantic_models.score.Score` object or list of Score objects
                 representing the evaluation results. Each Score should include:
                 - name: The score name (e.g., "has_zipcode")
                 - evaluator_name: The evaluator name (e.g., "RegexMatch")
@@ -216,7 +234,7 @@ class FiddlerEvaluator(Evaluator, ABC):
             data (dict[str, Any]): The API response data.
 
         Returns:
-            Score | list[Score]: A single Score object or list of Score objects.
+            Score | list[Score]: A single :class:`~fiddler_evals.pydantic_models.score.Score` object or list of Score objects.
         """
         scores_response = EvaluatorResponse(**data)
         if not scores_response.scores:

{fiddler_evals-0.6.0 → fiddler_evals-0.7.0.dev1}/fiddler_evals/evaluators/coherence.py

@@ -36,7 +36,7 @@ class Coherence(FiddlerLLMAAJEvaluator):
                                Used for context-aware coherence evaluation.
 
     Returns:
-        Score: A Score object containing:
+        Score: A :class:`~fiddler_evals.pydantic_models.score.Score` object containing:
             - name: "is_coherent"
             - evaluator_name: "Coherence"
             - value: 1.0 if coherent, 0.0 if incoherent
@@ -83,6 +83,8 @@ class Coherence(FiddlerLLMAAJEvaluator):
     """
 
     name = "coherence"
+    """Evaluator identifier, recorded as ``evaluator_name`` on every
+    ``Score`` this evaluator produces."""
 
     def score(self, prompt: str, response: str) -> Score:  # pylint: disable=arguments-differ
         """Score the coherence of a response.
@@ -92,7 +94,7 @@ class Coherence(FiddlerLLMAAJEvaluator):
             response (str): The response to evaluate for coherence.
 
         Returns:
-            Score: A Score object for coherence assessment.
+            Score: A :class:`~fiddler_evals.pydantic_models.score.Score` object for coherence assessment.
         """
         prompt = prompt.strip() if prompt else ""
         response = response.strip() if response else ""

{fiddler_evals-0.6.0 → fiddler_evals-0.7.0.dev1}/fiddler_evals/evaluators/conciseness.py

@@ -30,7 +30,7 @@ class Conciseness(FiddlerLLMAAJEvaluator):
         response (str): The LLM's response to evaluate for conciseness.
 
     Returns:
-        Score: A Score object containing:
+        Score: A :class:`~fiddler_evals.pydantic_models.score.Score` object containing:
             - value: 1.0 if concise, 0.0 if verbose
             - label: String representation of the boolean result
             - reasoning: Detailed explanation of the assessment
@@ -58,6 +58,8 @@ class Conciseness(FiddlerLLMAAJEvaluator):
     """
 
     name = "conciseness"
+    """Evaluator identifier, recorded as ``evaluator_name`` on every
+    ``Score`` this evaluator produces."""
 
     def score(self, response: str) -> Score:  # pylint: disable=arguments-differ
         """Score the conciseness of an answer.
@@ -66,7 +68,7 @@ class Conciseness(FiddlerLLMAAJEvaluator):
             response (str): The LLM's response to evaluate for conciseness.
 
         Returns:
-            Score: A Score object containing:
+            Score: A :class:`~fiddler_evals.pydantic_models.score.Score` object containing:
                 - value: 1.0 if concise, 0.0 if verbose
                 - label: String representation of the boolean result
                 - reasoning: Detailed explanation of the assessment