0.6.0 update

Author: CalebCourier

guardrails/guard.py

@@ -380,7 +380,7 @@ def _for_rail_schema(
         name: Optional[str] = None,
         description: Optional[str] = None,
     ):
-        guard = cls(
+        guard = cls._init_guard_for_cls_method(
             name=name,
             description=description,
             output_schema=schema.json_schema,
@@ -526,6 +526,25 @@ def for_rail_string(
     def from_pydantic(cls, output_class: ModelOrListOfModels, *args, **kwargs):
         return cls.for_pydantic(output_class, **kwargs)
 
+    @classmethod
+    def _init_guard_for_cls_method(
+        cls,
+        *,
+        id: Optional[str] = None,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        validators: Optional[List[ValidatorReference]] = None,
+        output_schema: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ):
+        return cls(
+            id=id,
+            name=name,
+            description=description,
+            output_schema=output_schema,
+            validators=validators,
+        )
+
     @classmethod
     def for_pydantic(
         cls,
@@ -538,6 +557,7 @@ def for_pydantic(
         name: Optional[str] = None,
         description: Optional[str] = None,
         output_formatter: Optional[Union[str, BaseFormatter]] = None,
+        **kwargs,
     ):
         """Create a Guard instance using a Pydantic model to specify the output
         schema.
@@ -574,11 +594,12 @@ def for_pydantic(
             reask_messages=reask_messages,
             messages=messages,
         )
-        guard = cls(
+        guard = cls._init_guard_for_cls_method(
             name=name,
             description=description,
             output_schema=schema.json_schema,
             validators=schema.validators,
+            **kwargs,
         )
         if schema.output_type == OutputTypes.LIST:
             guard = cast(Guard[List], guard)
@@ -1306,7 +1327,7 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional["Guard"]:
             i_guard.output_schema.to_dict() if i_guard.output_schema else None
         )
 
-        guard = cls(
+        guard = cls._init_guard_for_cls_method(
             id=i_guard.id,
             name=i_guard.name,
             description=i_guard.description,

guardrails/integrations/nemoguardrails/nemoguardrails_guard.py

@@ -1,25 +1,27 @@
-from typing import Callable, Dict, Iterable, List, Optional, Union, cast
-import warnings
+from typing import Any, Callable, Dict, Generic, Iterable, List, Optional, Union, cast
 from typing_extensions import deprecated
 
-from guardrails.classes.execution.guard_execution_options import GuardExecutionOptions
 from guardrails.classes.output_type import OT, OutputTypes
 from guardrails.classes.validation_outcome import ValidationOutcome
+from guardrails.classes.validation.validator_reference import ValidatorReference
 
 from guardrails import Guard
-from nemoguardrails import LLMRails
 
-from guardrails.formatters import get_formatter
 from guardrails.formatters.base_formatter import BaseFormatter
-from guardrails.schema.pydantic_schema import pydantic_model_to_schema
 from guardrails.types.pydantic import ModelOrListOfModels
 
-from guardrails.stores.context import (
-    Tracer
-)
+from guardrails.stores.context import Tracer
+
+try:
+    from nemoguardrails import LLMRails
+except ImportError:
+    raise ImportError(
+        "Could not import nemoguardrails, please install it with "
+        "`pip install nemoguardrails`."
+    )
 
 
-class NemoguardrailsGuard(Guard):
+class NemoguardrailsGuard(Guard, Generic[OT]):
     def __init__(
         self,
         nemorails: LLMRails,
@@ -30,7 +32,11 @@ def __init__(
         self._nemorails = nemorails
 
     def __call__(
-        self, llm_api: Optional[Callable] = None, generate_kwargs: Optional[Dict] = None, *args, **kwargs
+        self,
+        llm_api: Optional[Callable] = None,
+        generate_kwargs: Optional[Dict] = None,
+        *args,
+        **kwargs,
     ) -> Union[ValidationOutcome[OT], Iterable[ValidationOutcome[OT]]]:
         # peel llm_api off of kwargs
         llm_api = kwargs.pop("llm_api", None)
@@ -54,114 +60,61 @@ def __call__(
             )
 
         def _custom_nemo_callable(*args, **kwargs):
-            return self._custom_nemo_callable(*args, generate_kwargs=generate_kwargs, **kwargs)
+            return self._custom_nemo_callable(
+                *args, generate_kwargs=generate_kwargs, **kwargs
+            )
 
         return super().__call__(llm_api=_custom_nemo_callable, *args, **kwargs)
 
     @classmethod
-    def from_pydantic(
+    def _init_guard_for_cls_method(
         cls,
+        *,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        validators: Optional[List[ValidatorReference]] = None,
+        output_schema: Optional[Dict[str, Any]] = None,
         nemorails: LLMRails,
+        **kwargs,
+    ):
+        return cls(
+            nemorails,
+            name=name,
+            description=description,
+            output_schema=output_schema,
+            validators=validators,
+        )
+
+    @classmethod
+    def for_pydantic(
+        cls,
         output_class: ModelOrListOfModels,
+        nemorails: LLMRails,
         *,
-        prompt: Optional[str] = None,
-        instructions: Optional[str] = None,
         num_reasks: Optional[int] = None,
-        reask_prompt: Optional[str] = None,
-        reask_instructions: Optional[str] = None,
         reask_messages: Optional[List[Dict]] = None,
         messages: Optional[List[Dict]] = None,
         tracer: Optional[Tracer] = None,
         name: Optional[str] = None,
         description: Optional[str] = None,
         output_formatter: Optional[Union[str, BaseFormatter]] = None,
+        **kwargs,
     ):
-        """Create a Guard instance using a Pydantic model to specify the output
-        schema.
-
-        Args:
-            output_class: (Union[Type[BaseModel], List[Type[BaseModel]]]): The pydantic model that describes
-            the desired structure of the output.
-            prompt (str, optional): The prompt used to generate the string. Defaults to None.
-            instructions (str, optional): Instructions for chat models. Defaults to None.
-            reask_prompt (str, optional): An alternative prompt to use during reasks. Defaults to None.
-            reask_instructions (str, optional): Alternative instructions to use during reasks. Defaults to None.
-            reask_messages (List[Dict], optional): A list of messages to use during reasks. Defaults to None.
-            num_reasks (int, optional): The max times to re-ask the LLM if validation fails. Deprecated
-            tracer (Tracer, optional): An OpenTelemetry tracer to use for metrics and traces. Defaults to None.
-            name (str, optional): A unique name for this Guard. Defaults to `gr-` + the object id.
-            description (str, optional): A description for this Guard. Defaults to None.
-            output_formatter (str | Formatter, optional): 'none' (default), 'jsonformer', or a Guardrails Formatter.
-        """  # noqa
-
-        if num_reasks:
-            warnings.warn(
-                "Setting num_reasks during initialization is deprecated"
-                " and will be removed in 0.6.x!"
-                "We recommend setting num_reasks when calling guard()"
-                " or guard.parse() instead."
-                "If you insist on setting it at the Guard level,"
-                " use 'Guard.configure()'.",
-                DeprecationWarning,
-            )
-
-        if reask_instructions:
-            warnings.warn(
-                "reask_instructions is deprecated and will be removed in 0.6.x!"
-                "Please be prepared to set reask_messages instead.",
-                DeprecationWarning,
-            )
-        if reask_prompt:
-            warnings.warn(
-                "reask_prompt is deprecated and will be removed in 0.6.x!"
-                "Please be prepared to set reask_messages instead.",
-                DeprecationWarning,
-            )
-
-        # We have to set the tracer in the ContextStore before the Rail,
-        #   and therefore the Validators, are initialized
-        cls._set_tracer(cls, tracer)  # type: ignore
-
-        schema = pydantic_model_to_schema(output_class)
-        exec_opts = GuardExecutionOptions(
-            prompt=prompt,
-            instructions=instructions,
-            reask_prompt=reask_prompt,
-            reask_instructions=reask_instructions,
-            reask_messages=reask_messages,
+        guard = super().for_pydantic(
+            output_class,
+            num_reasks=num_reasks,
             messages=messages,
-        )
-
-        # TODO: This is the only line that's changed vs the parent Guard class
-        # Find a way to refactor this
-        guard = cls(
-            nemorails=nemorails,
+            reask_messages=reask_messages,
+            tracer=tracer,
             name=name,
             description=description,
-            output_schema=schema.json_schema,
-            validators=schema.validators,
+            output_formatter=output_formatter,
+            nemorails=nemorails,
         )
-        if schema.output_type == OutputTypes.LIST:
-            guard = cast(Guard[List], guard)
+        if guard._output_type == OutputTypes.LIST:
+            return cast(NemoguardrailsGuard[List], guard)
         else:
-            guard = cast(Guard[Dict], guard)
-        guard.configure(num_reasks=num_reasks, tracer=tracer)
-        guard._validator_map = schema.validator_map
-        guard._exec_opts = exec_opts
-        guard._output_type = schema.output_type
-        guard._base_model = output_class
-        if isinstance(output_formatter, str):
-            if isinstance(output_class, list):
-                raise Exception("""Root-level arrays are not supported with the 
-                jsonformer argument, but can be used with other json generation methods.
-                Omit the output_formatter argument to use the other methods.""")
-            output_formatter = get_formatter(
-                output_formatter,
-                schema=output_class.model_json_schema(),  # type: ignore
-            )
-        guard._output_formatter = output_formatter
-        guard._fill_validators()
-        return guard
+            return cast(NemoguardrailsGuard[Dict], guard)
 
     # create the callable
     def _custom_nemo_callable(self, *args, generate_kwargs, **kwargs):
@@ -171,13 +124,13 @@ def _custom_nemo_callable(self, *args, generate_kwargs, **kwargs):
         # msg_history, messages, prompt, and instruction all may or may not be present.
         # if none of them are present, raise an error
         # if messages is present, use that
-        # if msg_history is present, use 
+        # if msg_history is present, use
 
         msg_history = kwargs.pop("msg_history", None)
         messages = kwargs.pop("messages", None)
         prompt = kwargs.pop("prompt", None)
         instructions = kwargs.pop("instructions", None)
-        
+
         if msg_history is not None and messages is None:
             messages = msg_history
 
@@ -188,30 +141,52 @@ def _custom_nemo_callable(self, *args, generate_kwargs, **kwargs):
             if prompt is not None:
                 messages.append({"role": "system", "content": prompt})
 
-        if messages is [] or messages is None:
-            raise ValueError("messages, prompt, or instructions should be passed during a call.")
-        
+        if messages == [] or messages is None:
+            raise ValueError(
+                "messages, prompt, or instructions should be passed during a call."
+            )
+
         # kwargs["messages"] = messages
 
         # return (self._nemorails.generate(**kwargs))["content"]  # type: ignore
         if not generate_kwargs:
             generate_kwargs = {}
-        return (self._nemorails.generate(messages=messages, **generate_kwargs))["content"]  # type: ignore
+        return (self._nemorails.generate(messages=messages, **generate_kwargs))[  # type: ignore
+            "content"
+        ]
 
     @deprecated(
-        "This method has been deprecated. Please use the main constructor `NemoGuardrailsGuard(nemorails=nemorails)` or the `from_pydantic` method.",
+        "Use `for_rail_string` instead. This method will be removed in 0.6.x.",
+        category=None,
     )
+    @classmethod
     def from_rail_string(cls, *args, **kwargs):
         raise NotImplementedError("""\
 `from_rail_string` is not implemented for NemoguardrailsGuard.
 We recommend using the main constructor `NemoGuardrailsGuard(nemorails=nemorails)`
+or the `from_pydantic` method.""")
+
+    @classmethod
+    def for_rail_string(cls, *args, **kwargs):
+        raise NotImplementedError("""\
+`for_rail_string` is not implemented for NemoguardrailsGuard.
+We recommend using the main constructor `NemoGuardrailsGuard(nemorails=nemorails)`
 or the `from_pydantic` method.""")
 
     @deprecated(
-        "This method has been deprecated. Please use the main constructor `NemoGuardrailsGuard(nemorails=nemorails)` or the `from_pydantic` method.",
+        "Use `for_rail` instead. This method will be removed in 0.6.x.",
+        category=None,
     )
+    @classmethod
     def from_rail(cls, *args, **kwargs):
         raise NotImplementedError("""\
 `from_rail` is not implemented for NemoguardrailsGuard.
 We recommend using the main constructor `NemoGuardrailsGuard(nemorails=nemorails)`
+or the `from_pydantic` method.""")
+
+    @classmethod
+    def for_rail(cls, *args, **kwargs):
+        raise NotImplementedError("""\
+`for_rail` is not implemented for NemoguardrailsGuard.
+We recommend using the main constructor `NemoGuardrailsGuard(nemorails=nemorails)`
 or the `from_pydantic` method.""")