Merge branch 'main' into feat/validation-summary

Author: AlejandroEsquivel

docs/faq.md

@@ -1,5 +1,21 @@
 # Frequently Asked Questions
 
+## I get an "Unauthorized" error when installing validators from the Guardrails Hub. What should I do?
+
+If you see an "Unauthorized" error when installing validators from the Guardrails hub, it means that the API key you are using is not authorized to access the Guardrails hub. It may be unset or expired. 
+
+To fix this, first generate a new API key from the [Guardrails Hub](https://hub.guardrailsai.com/keys). Then, configure the Guardrails CLI with the new API key.
+
+```bash
+guardrails configure
+```
+
+There is also a headless option to configure the CLI with the token.
+
+```bash
+guardrails configure --token <your_token>
+```
+
 ## I'm seeing a PromptCallableException when invoking my Guard. What should I do?
 
 If you see an exception that looks like this

docs/getting_started/guardrails_server.md

@@ -13,6 +13,13 @@ This document will overview a few of the key features of the Guardrails Server,
 
 # Walkthrough
 
+## 0. Configure Guardrails
+First, get a free auth key from [Guardrails Hub](https://hub.guardrailsai.com/keys). Then, configure the Guardrails CLI with the auth key.
+
+```bash
+guardrails configure
+```
+
 ## 1. Install the Guardrails Server
 This is done by simply installing the `guardrails-ai` package. See the [installation guide](./quickstart.md) for more information.
 

docs/getting_started/quickstart.md

@@ -17,6 +17,8 @@ pip install guardrails-ai
 ```
 
 ### Configure the Guardrails CLI (required)
+
+First, get a free auth key from [Guardrails Hub](https://hub.guardrailsai.com/keys). Then, configure the Guardrails CLI with the auth key.
 
 ```bash
 guardrails configure

docs/how_to_guides/deploying_aws.md

@@ -1,3 +1,3 @@
 # AWS - Deploying Guardrails Server
 
-This doc has moved to [continuous integration and deployment - aws](docs/how_to_guides/continuous_integration_continuous_deployment).
+This doc has moved to [continuous integration and deployment - aws](/docs/how_to_guides/continuous_integration_continuous_deployment).

docs/how_to_guides/using_llms.md

@@ -289,3 +289,49 @@ for chunk in stream_chunk_generator
 ## Other LLMs
 
 See LiteLLM’s documentation [here](https://docs.litellm.ai/docs/providers) for details on many other llms.
+
+## Custom LLM Wrappers
+In case you're using an LLM that isn't natively supported by Guardrails and you don't want to use LiteLLM, you can build a custom LLM API wrapper. In order to use a custom LLM, create a function that accepts a positional argument for the prompt as a string and any other arguments that you want to pass to the LLM API as keyword args. The function should return the output of the LLM API as a string.
+
+```python
+from guardrails import Guard
+from guardrails.hub import ProfanityFree
+
+# Create a Guard class
+guard = Guard().use(ProfanityFree())
+
+# Function that takes the prompt as a string and returns the LLM output as string
+def my_llm_api(
+    prompt: Optional[str] = None,
+    *,
+    instructions: Optional[str] = None,
+    msg_history: Optional[list[dict]] = None,
+    **kwargs
+) -> str:
+    """Custom LLM API wrapper.
+
+    At least one of prompt, instruction or msg_history should be provided.
+
+    Args:
+        prompt (str): The prompt to be passed to the LLM API
+        instruction (str): The instruction to be passed to the LLM API
+        msg_history (list[dict]): The message history to be passed to the LLM API
+        **kwargs: Any additional arguments to be passed to the LLM API
+
+    Returns:
+        str: The output of the LLM API
+    """
+
+    # Call your LLM API here
+    # What you pass to the llm will depend on what arguments it accepts.
+    llm_output = some_llm(prompt, instructions, msg_history, **kwargs)
+
+    return llm_output
+
+# Wrap your LLM API call
+validated_response = guard(
+    my_llm_api,
+    prompt="Can you generate a list of 10 things that are not food?",
+    **kwargs,
+)
+```

guardrails/api_client.py

@@ -1,6 +1,6 @@
 import json
 import os
-from typing import Any, Iterable, Optional
+from typing import Any, Iterator, Optional
 
 import requests
 from guardrails_api_client.configuration import Configuration
@@ -80,7 +80,7 @@ def stream_validate(
         guard: Guard,
         payload: ValidatePayload,
         openai_api_key: Optional[str] = None,
-    ) -> Iterable[Any]:
+    ) -> Iterator[Any]:
         _openai_api_key = (
             openai_api_key
             if openai_api_key is not None

guardrails/applications/text2sql.py

@@ -1,14 +1,14 @@
 import asyncio
 import json
 import os
+import openai
 from string import Template
 from typing import Callable, Dict, Optional, Type, cast
 
 from guardrails.classes import ValidationOutcome
 from guardrails.document_store import DocumentStoreBase, EphemeralDocumentStore
 from guardrails.embedding import EmbeddingBase, OpenAIEmbedding
 from guardrails.guard import Guard
-from guardrails.utils.openai_utils import get_static_openai_create_func
 from guardrails.utils.sql_utils import create_sql_driver
 from guardrails.vectordb import Faiss, VectorDBBase
 
@@ -89,7 +89,7 @@ def __init__(
             reask_prompt: Prompt to use for reasking. Defaults to REASK_PROMPT.
         """
         if llm_api is None:
-            llm_api = get_static_openai_create_func()
+            llm_api = openai.completions.create
 
         self.example_formatter = example_formatter
         self.llm_api = llm_api

guardrails/async_guard.py

@@ -4,7 +4,7 @@
 from opentelemetry import context as otel_context
 from typing import (
     Any,
-    AsyncIterable,
+    AsyncIterator,
     Awaitable,
     Callable,
     Dict,
@@ -37,6 +37,7 @@
     set_tracer,
     set_tracer_context,
 )
+from guardrails.hub_telemetry.hub_tracing import async_trace
 from guardrails.types.pydantic import ModelOrListOfModels
 from guardrails.types.validator import UseManyValidatorSpec, UseValidatorSpec
 from guardrails.telemetry import trace_async_guard_execution, wrap_with_otel_context
@@ -187,7 +188,7 @@ async def _execute(
     ) -> Union[
         ValidationOutcome[OT],
         Awaitable[ValidationOutcome[OT]],
-        AsyncIterable[ValidationOutcome[OT]],
+        AsyncIterator[ValidationOutcome[OT]],
     ]:
         self._fill_validator_map()
         self._fill_validators()
@@ -219,49 +220,13 @@ async def __exec(
         ) -> Union[
             ValidationOutcome[OT],
             Awaitable[ValidationOutcome[OT]],
-            AsyncIterable[ValidationOutcome[OT]],
+            AsyncIterator[ValidationOutcome[OT]],
         ]:
             prompt_params = prompt_params or {}
             metadata = metadata or {}
             if full_schema_reask is None:
                 full_schema_reask = self._base_model is not None
 
-            if self._allow_metrics_collection:
-                llm_api_str = ""
-                if llm_api:
-                    llm_api_module_name = (
-                        llm_api.__module__ if hasattr(llm_api, "__module__") else ""
-                    )
-                    llm_api_name = (
-                        llm_api.__name__
-                        if hasattr(llm_api, "__name__")
-                        else type(llm_api).__name__
-                    )
-                    llm_api_str = f"{llm_api_module_name}.{llm_api_name}"
-                # Create a new span for this guard call
-                self._hub_telemetry.create_new_span(
-                    span_name="/guard_call",
-                    attributes=[
-                        ("guard_id", self.id),
-                        ("user_id", self._user_id),
-                        ("llm_api", llm_api_str),
-                        (
-                            "custom_reask_prompt",
-                            self._exec_opts.reask_prompt is not None,
-                        ),
-                        (
-                            "custom_reask_instructions",
-                            self._exec_opts.reask_instructions is not None,
-                        ),
-                        (
-                            "custom_reask_messages",
-                            self._exec_opts.reask_messages is not None,
-                        ),
-                    ],
-                    is_parent=True,  # It will have children
-                    has_parent=False,  # Has no parents
-                )
-
             set_call_kwargs(kwargs)
             set_tracer(self._tracer)
             set_tracer_context(self._tracer_context)
@@ -369,7 +334,7 @@ async def _exec(
     ) -> Union[
         ValidationOutcome[OT],
         Awaitable[ValidationOutcome[OT]],
-        AsyncIterable[ValidationOutcome[OT]],
+        AsyncIterator[ValidationOutcome[OT]],
     ]:
         """Call the LLM asynchronously and validate the output.
 
@@ -435,6 +400,7 @@ async def _exec(
             )
             return ValidationOutcome[OT].from_guard_history(call)
 
+    @async_trace(name="/guard_call", origin="AsyncGuard.__call__")
     async def __call__(
         self,
         llm_api: Optional[Callable[..., Awaitable[Any]]] = None,
@@ -450,7 +416,7 @@ async def __call__(
     ) -> Union[
         ValidationOutcome[OT],
         Awaitable[ValidationOutcome[OT]],
-        AsyncIterable[ValidationOutcome[OT]],
+        AsyncIterator[ValidationOutcome[OT]],
     ]:
         """Call the LLM and validate the output. Pass an async LLM API to
         return a coroutine.
@@ -501,6 +467,7 @@ async def __call__(
             **kwargs,
         )
 
+    @async_trace(name="/guard_call", origin="AsyncGuard.parse")
     async def parse(
         self,
         llm_output: str,
@@ -567,7 +534,7 @@ async def parse(
 
     async def _stream_server_call(
         self, *, payload: Dict[str, Any]
-    ) -> AsyncIterable[ValidationOutcome[OT]]:
+    ) -> AsyncIterator[ValidationOutcome[OT]]:
         # TODO: Once server side supports async streaming, this function will need to
         # yield async generators, not generators
         if self._api_client:
@@ -609,6 +576,7 @@ async def _stream_server_call(
         else:
             raise ValueError("AsyncGuard does not have an api client!")
 
+    @async_trace(name="/guard_call", origin="AsyncGuard.validate")
     async def validate(
         self, llm_output: str, *args, **kwargs
     ) -> Awaitable[ValidationOutcome[OT]]:

guardrails/classes/__init__.py

@@ -1,4 +1,5 @@
-from guardrails.classes.credentials import Credentials
+from guardrails.classes.credentials import Credentials  # type: ignore
+from guardrails.classes.rc import RC
 from guardrails.classes.input_type import InputType
 from guardrails.classes.output_type import OT
 from guardrails.classes.validation.validation_result import (
@@ -10,7 +11,8 @@
 from guardrails.classes.validation_outcome import ValidationOutcome
 
 __all__ = [
-    "Credentials",
+    "Credentials",  # type: ignore
+    "RC",
     "ErrorSpan",
     "InputType",
     "OT",

guardrails/classes/credentials.py

@@ -1,21 +1,24 @@
 import logging
-import os
 from dataclasses import dataclass
-from os.path import expanduser
 from typing import Optional
+from typing_extensions import deprecated
 
-from guardrails.classes.generic.serializeable import Serializeable
+from guardrails.classes.generic.serializeable import SerializeableJSONEncoder
+from guardrails.classes.rc import RC
 
 BOOL_CONFIGS = set(["no_metrics", "enable_metrics", "use_remote_inferencing"])
 
 
+@deprecated(
+    (
+        "The `Credentials` class is deprecated and will be removed in version 0.6.x."
+        " Use the `RC` class instead."
+    ),
+    category=DeprecationWarning,
+)
 @dataclass
-class Credentials(Serializeable):
-    id: Optional[str] = None
-    token: Optional[str] = None
+class Credentials(RC):
     no_metrics: Optional[bool] = False
-    enable_metrics: Optional[bool] = True
-    use_remote_inferencing: Optional[bool] = True
 
     @staticmethod
     def _to_bool(value: str) -> Optional[bool]:
@@ -27,51 +30,16 @@ def _to_bool(value: str) -> Optional[bool]:
 
     @staticmethod
     def has_rc_file() -> bool:
-        home = expanduser("~")
-        guardrails_rc = os.path.join(home, ".guardrailsrc")
-        return os.path.exists(guardrails_rc)
+        return RC.exists()
 
     @staticmethod
-    def from_rc_file(logger: Optional[logging.Logger] = None) -> "Credentials":
-        try:
-            if not logger:
-                logger = logging.getLogger()
-            home = expanduser("~")
-            guardrails_rc = os.path.join(home, ".guardrailsrc")
-            with open(guardrails_rc, encoding="utf-8") as rc_file:
-                lines = rc_file.readlines()
-                filtered_lines = list(filter(lambda l: l.strip(), lines))
-                creds = {}
-                for line in filtered_lines:
-                    line_content = line.split("=", 1)
-                    if len(line_content) != 2:
-                        logger.warning(
-                            """
-                            Invalid line found in .guardrailsrc file!
-                            All lines in this file should follow the format: key=value
-                            Ignoring line contents...
-                            """
-                        )
-                        logger.debug(f".guardrailsrc file location: {guardrails_rc}")
-                    else:
-                        key, value = line_content
-                        key = key.strip()
-                        value = value.strip()
-                        if key in BOOL_CONFIGS:
-                            value = Credentials._to_bool(value)
-
-                        creds[key] = value
-
-                rc_file.close()
-
-                # backfill no_metrics, handle defaults
-                # remove in 0.5.0
-                no_metrics_val = creds.pop("no_metrics", None)
-                if no_metrics_val is not None and creds.get("enable_metrics") is None:
-                    creds["enable_metrics"] = not no_metrics_val
-
-                creds_dict = Credentials.from_dict(creds)
-                return creds_dict
-
-        except FileNotFoundError:
-            return Credentials.from_dict({})  # type: ignore
+    def from_rc_file(logger: Optional[logging.Logger] = None) -> "Credentials":  # type: ignore
+        rc = RC.load(logger)
+        return Credentials(  # type: ignore
+            id=rc.id,
+            token=rc.token,
+            enable_metrics=rc.enable_metrics,
+            use_remote_inferencing=rc.use_remote_inferencing,
+            no_metrics=(not rc.enable_metrics),
+            encoder=SerializeableJSONEncoder(),
+        )