Credentials -> RC; add RC to settings

Author: CalebCourier

guardrails/classes/__init__.py

@@ -1,4 +1,5 @@
 from guardrails.classes.credentials import Credentials
+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 (
@@ -11,6 +12,7 @@
 
 __all__ = [
     "Credentials",
+    "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
+        rc = RC.load(logger)
+        return Credentials(
+            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(),
+        )

guardrails/classes/rc.py

@@ -0,0 +1,72 @@
+import logging
+import os
+from dataclasses import dataclass
+from os.path import expanduser
+from typing import Optional
+
+from guardrails.classes.generic.serializeable import Serializeable
+from guardrails.utils.casting_utils import to_bool
+
+BOOL_CONFIGS = set(["no_metrics", "enable_metrics", "use_remote_inferencing"])
+
+
+@dataclass
+class RC(Serializeable):
+    id: Optional[str] = None
+    token: Optional[str] = None
+    enable_metrics: Optional[bool] = True
+    use_remote_inferencing: Optional[bool] = True
+
+    @staticmethod
+    def exists() -> bool:
+        home = expanduser("~")
+        guardrails_rc = os.path.join(home, ".guardrailsrc")
+        return os.path.exists(guardrails_rc)
+
+    @classmethod
+    def load(cls, logger: Optional[logging.Logger] = None) -> "RC":
+        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))
+                config = {}
+                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 = to_bool(value)
+
+                        config[key] = value
+
+                rc_file.close()
+
+                # backfill no_metrics, handle defaults
+                # We missed this comment in the 0.5.0 release
+                # Making it a TODO for 0.6.0
+                # TODO: remove in 0.6.0
+                no_metrics_val = config.pop("no_metrics", None)
+                if no_metrics_val is not None and config.get("enable_metrics") is None:
+                    config["enable_metrics"] = not no_metrics_val
+                    del config["no_metrics"]
+
+                rc = cls.from_dict(config)
+                return rc
+
+        except FileNotFoundError:
+            return cls.from_dict({})  # type: ignore

guardrails/cli/configure.py

@@ -6,7 +6,7 @@
 
 import typer
 
-from guardrails.classes.credentials import Credentials
+from guardrails.settings import settings
 from guardrails.cli.guardrails import guardrails
 from guardrails.cli.logger import LEVELS, logger
 from guardrails.cli.hub.console import console
@@ -46,7 +46,7 @@ def save_configuration_file(
 
 def _get_default_token() -> str:
     """Get the default token from the configuration file."""
-    file_token = Credentials.from_rc_file(logger).token
+    file_token = settings.rc.token
     if file_token is None:
         return ""
     return file_token

guardrails/cli/server/auth.py

@@ -9,7 +9,8 @@
 from jwt import ExpiredSignatureError, DecodeError
 
 
-from guardrails.classes.credentials import Credentials
+from guardrails.settings import settings
+from guardrails.classes.rc import RC
 from guardrails.cli.logger import logger
 from guardrails.version import GUARDRAILS_VERSION
 
@@ -86,8 +87,8 @@ def fetch_module_manifest(
     return fetch(manifest_url, token, anonymousUserId)
 
 
-def get_jwt_token(creds: Credentials) -> Optional[str]:
-    token = creds.token
+def get_jwt_token(rc: RC) -> Optional[str]:
+    token = rc.token
 
     # check for jwt expiration
     if token:
@@ -101,23 +102,21 @@ def get_jwt_token(creds: Credentials) -> Optional[str]:
 
 
 def fetch_module(module_name: str) -> Optional[Manifest]:
-    creds = Credentials.from_rc_file(logger)
-    token = get_jwt_token(creds)
+    token = get_jwt_token(settings.rc)
 
-    module_manifest_json = fetch_module_manifest(module_name, token, creds.id)
+    module_manifest_json = fetch_module_manifest(module_name, token, settings.rc.id)
     return Manifest.from_dict(module_manifest_json)
 
 
 def fetch_template(template_address: str) -> Dict[str, Any]:
-    creds = Credentials.from_rc_file(logger)
-    token = get_jwt_token(creds)
+    token = get_jwt_token(settings.rc)
 
     namespace, template_name = template_address.replace("hub:template://", "").split(
         "/", 1
     )
     template_path = f"guard-templates/{namespace}/{template_name}"
     template_url = f"{VALIDATOR_HUB_SERVICE}/{template_path}"
-    return fetch(template_url, token, creds.id)
+    return fetch(template_url, token, settings.rc.id)
 
 
 # GET /guard-templates/{namespace}/{guardTemplateName}
@@ -164,10 +163,9 @@ def get_validator_manifest(module_name: str):
 # GET /auth
 def get_auth():
     try:
-        creds = Credentials.from_rc_file(logger)
-        token = get_jwt_token(creds)
+        token = get_jwt_token(settings.rc)
         auth_url = f"{VALIDATOR_HUB_SERVICE}/auth"
-        response = fetch(auth_url, token, creds.id)
+        response = fetch(auth_url, token, settings.rc.id)
         if not response:
             raise AuthenticationError("Failed to authenticate!")
     except HttpError as http_error:
@@ -182,8 +180,7 @@ def get_auth():
 
 def post_validator_submit(package_name: str, content: str):
     try:
-        creds = Credentials.from_rc_file(logger)
-        token = get_jwt_token(creds)
+        token = get_jwt_token(settings.rc)
         submission_url = f"{VALIDATOR_HUB_SERVICE}/validator/submit"
 
         headers = {

guardrails/cli/server/hub_client.py

@@ -1,24 +1,12 @@
 import platform
-from typing import Optional
-from guardrails.classes.credentials import Credentials
+from guardrails.settings import settings
 from guardrails.utils.hub_telemetry_utils import HubTelemetry
 from guardrails.version import GUARDRAILS_VERSION
-from guardrails.cli.logger import logger
-
-config: Optional[Credentials] = None
-
-
-def load_config_file() -> Credentials:
-    global config
-    if not config:
-        config = Credentials.from_rc_file(logger)
-    return config
 
 
 def trace_if_enabled(command_name: str):
-    config = load_config_file()
-    if config.enable_metrics is True:
-        telemetry = HubTelemetry()
+    if settings.rc.enable_metrics is True:
+        telemetry = HubTelemetry(enabled=True)
         telemetry.create_new_span(
             f"guardrails-cli/{command_name}",
             [

guardrails/cli/telemetry.py

@@ -32,9 +32,9 @@
 
 from guardrails.api_client import GuardrailsApiClient
 from guardrails.classes.output_type import OT
+from guardrails.classes.rc import RC
 from guardrails.classes.validation.validation_result import ErrorSpan
 from guardrails.classes.validation_outcome import ValidationOutcome
-from guardrails.classes.credentials import Credentials
 from guardrails.classes.execution import GuardExecutionOptions
 from guardrails.classes.generic import Stack
 from guardrails.classes.history import Call
@@ -259,6 +259,7 @@ def configure(
             self._set_num_reasks(num_reasks)
         if tracer:
             self._set_tracer(tracer)
+        self._load_rc()
         self._configure_hub_telemtry(allow_metrics_collection)
 
     def _set_num_reasks(self, num_reasks: Optional[int] = None) -> None:
@@ -285,24 +286,26 @@ def _set_tracer(self, tracer: Optional[Tracer] = None) -> None:
         set_tracer_context()
         self._tracer_context = get_tracer_context()
 
+    def _load_rc(self) -> None:
+        rc = RC.load(logger)
+        settings.rc = rc
+
     def _configure_hub_telemtry(
         self, allow_metrics_collection: Optional[bool] = None
     ) -> None:
-        credentials = None
-        if allow_metrics_collection is None:
-            credentials = Credentials.from_rc_file(logger)
-            # TODO: Check credentials.enable_metrics after merge from main
-            allow_metrics_collection = credentials.enable_metrics is True
+        allow_metrics_collection = (
+            settings.rc.enable_metrics is True
+            if allow_metrics_collection is None
+            else allow_metrics_collection
+        )
 
         self._allow_metrics_collection = allow_metrics_collection
 
-        if allow_metrics_collection:
-            if not credentials:
-                credentials = Credentials.from_rc_file(logger)
-            # Get unique id of user from credentials
-            self._user_id = credentials.id or ""
+        if allow_metrics_collection is True:
+            # Get unique id of user from rc file
+            self._user_id = settings.rc.id or ""
             # Initialize Hub Telemetry singleton and get the tracer
-            self._hub_telemetry = HubTelemetry()
+            self._hub_telemetry = HubTelemetry(enabled=True)
 
     def _fill_validator_map(self):
         # dont init validators if were going to call the server
@@ -920,6 +923,7 @@ def _exec(
             call = runner(call_log=call_log, prompt_params=prompt_params)
             return ValidationOutcome[OT].from_guard_history(call)
 
+    # @trace(name="Guard.__call__")
     def __call__(
         self,
         llm_api: Optional[Callable] = None,