참고소스 수정본

참고/guardrails-main/guardrails/classes/validation/validation_result.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+from typing_extensions import deprecated
+from typing import Any, Dict
+from pydantic import BaseModel
+from guardrails_ai.types import (
+    ValidationResult as IValidationResult,
+    PassResult as IPassResult,
+    FailResult as IFailResult,
+    ErrorSpan as ErrorSpan,
+)
+
+
+def to_validation_result(obj: Any) -> PassResult | FailResult | ValidationResult:
+    if isinstance(obj, dict):
+        outcome = obj.get("outcome")
+        if outcome == "pass":
+            return PassResult.model_validate(obj)
+        elif outcome == "fail":
+            return FailResult.model_validate(obj)
+    return ValidationResult.model_validate(obj)
+
+
+class ValidationResult(IValidationResult):
+    @classmethod
+    @deprecated("Use to_validation_result() instead.")
+    def from_interface(cls, i_validation_result: Any) -> "ValidationResult":
+        return to_validation_result(i_validation_result)
+
+    @classmethod
+    @deprecated("Use to_validation_result instead.")
+    def from_dict(cls, obj: Any) -> "ValidationResult":
+        return to_validation_result(obj)
+
+
+class PassResult(IPassResult, ValidationResult):
+    @deprecated("Use PassResult.model_dump() instead.")
+    def to_interface(self) -> dict[str, Any]:
+        return self.model_dump(exclude_none=True, by_alias=True)
+
+    @deprecated("Use PassResult.model_dump() instead.")
+    def to_dict(self) -> Dict[str, Any]:
+        return self.model_dump(exclude_none=True, by_alias=True)
+
+
+class FailResult(IFailResult, ValidationResult):
+    @classmethod
+    @deprecated("Use FailResult.model_validate() instead.")
+    def from_interface(cls, i_fail_result: Any) -> "FailResult":
+        return cls.model_validate(i_fail_result)
+
+    @classmethod
+    @deprecated("Use FailResult.model_validate() instead.")
+    def from_dict(cls, obj: Any) -> "FailResult":
+        return cls.model_validate(obj)
+
+    @deprecated("Use FailResult.model_dump() instead.")
+    def to_dict(self) -> Dict[str, Any]:
+        return self.model_dump(exclude_none=True, by_alias=True)
+
+
+class StreamValidationResult(BaseModel):
+    chunk: Any
+    original_text: str
+    metadata: Dict[str, Any]

참고/guardrails-main/guardrails/classes/validation/validation_summary.py

@@ -0,0 +1,56 @@
+# TODO Temp to update once generated class is in
+from typing import Iterator, List
+
+from guardrails.classes.generic.arbitrary_model import ArbitraryModel
+from guardrails_ai.types import FailResult
+from guardrails.classes.validation.validator_logs import ValidatorLogs
+from guardrails_ai.types import ValidationSummary as IValidationSummary
+
+
+class ValidationSummary(IValidationSummary, ArbitraryModel):
+    @staticmethod
+    def _generate_summaries_from_validator_logs(
+        validator_logs: List[ValidatorLogs],
+    ) -> Iterator["ValidationSummary"]:
+        """Generate a list of ValidationSummary objects from a list of
+        ValidatorLogs objects.
+
+        Using an iterator to allow serializing the summaries to other
+        formats.
+        """
+        for log in validator_logs:
+            validation_result = log.validation_result
+            is_fail_result = isinstance(validation_result, FailResult)
+            failure_reason = validation_result.error_message if is_fail_result else None
+            error_spans = validation_result.error_spans if is_fail_result else []
+            outcome = validation_result.outcome if validation_result else None
+            yield ValidationSummary(
+                validatorName=log.validator_name,
+                validatorStatus=outcome,  # type: ignore
+                propertyPath=log.property_path,
+                failureReason=failure_reason,
+                errorSpans=error_spans,  # type: ignore
+            )
+
+    @staticmethod
+    def from_validator_logs(
+        validator_logs: List[ValidatorLogs],
+    ) -> List["ValidationSummary"]:
+        summaries = []
+        for summary in ValidationSummary._generate_summaries_from_validator_logs(
+            validator_logs
+        ):
+            summaries.append(summary)
+        return summaries
+
+    @staticmethod
+    def from_validator_logs_only_fails(
+        validator_logs: List[ValidatorLogs],
+    ) -> List["ValidationSummary"]:
+        summaries = []
+        for summary in ValidationSummary._generate_summaries_from_validator_logs(
+            validator_logs
+        ):
+            if summary.failure_reason:
+                summaries.append(summary)
+        return summaries

참고/guardrails-main/guardrails/classes/validation/validator_logs.py

@@ -0,0 +1,91 @@
+from datetime import datetime
+from typing import Any, Dict, Optional
+from typing_extensions import deprecated
+from pydantic import Field, field_validator, field_serializer
+from guardrails_ai.types import ValidationResult, Outcome, PassResult, FailResult
+from guardrails.classes.generic.arbitrary_model import ArbitraryModel
+
+
+class ValidatorLogs(ArbitraryModel):
+    """Logs for a single validator execution."""
+
+    validator_name: str = Field(
+        description="The class name of the validator.", alias="validatorName"
+    )
+    registered_name: str = Field(
+        description="The registry id of the validator.", alias="registeredName"
+    )
+    value_before_validation: Any = Field(alias="valueBeforeValidation")
+    validation_result: Optional[ValidationResult] = Field(
+        default=None, alias="validationResult"
+    )
+    value_after_validation: Optional[Any] = Field(
+        default=None, alias="valueAfterValidation"
+    )
+    start_time: Optional[datetime] = Field(default=None, alias="startTime")
+    end_time: Optional[datetime] = Field(default=None, alias="endTime")
+    instance_id: Optional[int] = Field(default=None, alias="instanceId")
+    property_path: str = Field(
+        description="The JSON path to the property which was validated that produced"
+        " this log.",
+        alias="propertyPath",
+    )
+
+    @field_serializer("start_time")
+    def serialize_start_time(self, start_time: datetime | None) -> str | None:
+        if start_time is None:
+            return None
+
+        return start_time.isoformat()
+
+    @field_serializer("end_time")
+    def serialize_end_time(self, end_time: datetime | None) -> str | None:
+        if end_time is None:
+            return None
+
+        return end_time.isoformat()
+
+    # NOTE: It shouldn't be necessary to add this serializer just to call model_dump,
+    #   but it is to get the correct serialized output.
+    @field_serializer("validation_result")
+    def serialize_validation_result(
+        self, validation_result: ValidationResult | None
+    ) -> dict[str, Any] | None:
+        if validation_result is None:
+            return None
+        return validation_result.model_dump(exclude_none=True, by_alias=True)
+
+    @field_validator("validation_result", mode="before")
+    @classmethod
+    def deserialize_validation_result(
+        cls, validation_result: Any
+    ) -> ValidationResult | None:
+        if validation_result is None:
+            return None
+        elif isinstance(validation_result, ValidationResult):
+            return validation_result
+        elif isinstance(validation_result, dict):
+            outcome = validation_result.get("outcome")
+            if outcome == Outcome.PASS:
+                return PassResult.model_validate(validation_result)
+            elif outcome == Outcome.FAIL:
+                return FailResult.model_validate(validation_result)
+        return ValidationResult.model_validate(validation_result)
+
+    @deprecated("Use ValidatorLogs.model_dump() instead.")
+    def to_interface(self) -> dict[str, Any]:
+        return self.model_dump(exclude_none=True, by_alias=True)
+
+    @deprecated("Use ValidatorLogs.model_dump() instead.")
+    def to_dict(self) -> Dict[str, Any]:
+        return self.model_dump(exclude_none=True, by_alias=True)
+
+    @classmethod
+    @deprecated("Use ValidatorLogs.model_validate() instead.")
+    def from_interface(cls, i_validator_log: Any) -> "ValidatorLogs":
+        return cls.model_validate(i_validator_log)
+
+    @classmethod
+    @deprecated("Use ValidatorLogs.model_validate() instead.")
+    def from_dict(cls, obj: Any) -> "ValidatorLogs":
+        return cls.model_validate(obj)