lexsi-sdk 0.1.16__py3-none-any.whl

lexsi_sdk/core/dashboard.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+import os
+from typing import Any
+from pydantic import BaseModel
+import json
+from IPython.display import IFrame, display, HTML
+from lexsi_sdk.common.xai_uris import XAI_APP_URI
+
+DASHBOARD_TYPES = [
+    "data_drift",
+    "target_drift",
+    "performance",
+    "biasmonitoring",
+    "image_property_drift",
+    "label_drift",
+    "property_label_correlation",
+    "image_dataset_drift",
+]
+
+
+class Dashboard(BaseModel):
+    """Client-side wrapper for visualizing generated dashboards."""
+    config: dict
+    query_params: str
+    raw_data: dict | list | str
+
+    def __init__(self, **kwargs):
+        """Print configuration then render the dashboard frame."""
+        super().__init__(**kwargs)
+
+        self.print_config()
+        self.plot()
+
+    def plot(self, width: int = "100%", height: int = 800):
+        """plot the dashboard by remote url
+
+        :param width: Width of the embedded frame.
+        :param height: Height of the embedded frame.
+        """
+        if isinstance(self.raw_data, str) and "</html>" in self.raw_data:
+            display(HTML(self.raw_data))
+        else:
+            uri = os.environ.get("XAI_APP_URL", XAI_APP_URI)
+            url = f"{uri}/sdk/dashboard{self.query_params}"
+            display(IFrame(src=f"{url}", width=width, height=height))
+
+    def get_config(self) -> dict:
+        """
+        get the dashboard config
+        """
+        config_copy = {**self.config}
+        config_copy.pop("metadata", None)
+        return config_copy
+
+    def get_raw_data(self) -> dict:
+        """
+        get the dashboard raw data
+        """
+        raw_data = {"created_at": self.config.get("created_at")}
+
+        if self.config["type"] == "data_drift":
+            data_drift_table = next(
+                filter(
+                    lambda data: data["metric"] == "DataDriftTable",
+                    self.raw_data.get("metrics"),
+                ),
+                None,
+            )
+            if data_drift_table:
+                for item in data_drift_table["result"].get("drift_by_columns"):
+                    item.pop("current_small_distribution", None)
+                    item.pop("reference_small_distribution", None)
+                    item.pop("current_big_distribution", None)
+                    item.pop("reference_big_distribution", None)
+                    item.pop("current_mean", None)
+                    item.pop("reference_std", None)
+                raw_data.update(data_drift_table["result"])
+
+        if self.config["type"] == "target_drift":
+            column_drift_metric = next(
+                filter(
+                    lambda data: data["metric"] == "ColumnDriftMetric",
+                    self.raw_data.get("metrics"),
+                ),
+                None,
+            )
+            if column_drift_metric:
+                column_drift_metric["result"].pop("data", None)
+
+                raw_data.update(column_drift_metric["result"])
+
+        if self.config["type"] == "performance":
+            classification_quality_metric = next(
+                filter(
+                    lambda data: data["metric"] == "ClassificationQualityMetric",
+                    self.raw_data.get("metrics"),
+                ),
+                None,
+            )
+            if classification_quality_metric:
+                for curr_ref in ["current", "reference"]:
+                    classification_quality_metric["result"][curr_ref].pop(
+                        "rate_plots_data", None
+                    )
+                    classification_quality_metric["result"][curr_ref].pop(
+                        "plot_data", None
+                    )
+                raw_data.update(classification_quality_metric["result"])
+
+        return raw_data
+
+    def print_config(self):
+        """
+        pretty print the cdashboard config
+        """
+        config = {k: v for k, v in self.config.items() if v is not None}
+        config.pop("metadata", None)
+        print("Using config: ", end="")
+        print(json.dumps(config, indent=4))
+
+    def __print__(self) -> str:
+        """User-friendly string representation."""
+        return f"Dashboard(config='{self.get_config()}')"
+
+    def __str__(self) -> str:
+        """Return printable representation."""
+        return self.__print__()
+
+    def __repr__(self) -> str:
+        """Return developer-friendly representation."""
+        return self.__print__()

lexsi_sdk/core/guardrails/guard_template.py

@@ -0,0 +1,299 @@
+from typing import Any, Callable, Dict, List, Optional, Tuple, TypedDict, Union 
+
+class Guard:
+    """Predefined guardrail configurations for common use cases"""
+    
+    @staticmethod
+    def detect_pii(entities: List[str] = None) -> Dict[str, Any]:
+        """Template for PII detection guardrail
+        
+        :param entities: List of PII entity types to detect.
+        """
+        if entities is None:
+            entities = ["EMAIL_ADDRESS", "PHONE_NUMBER", "PERSON", "ADDRESS"]
+        
+        return {
+            "name": "Detect PII",
+            "config": {
+                "pii_entities": entities
+            }
+        }
+    
+    @staticmethod
+    def nsfw_text(threshold: float = 0.8, validation_method: str = "sentence") -> Dict[str, Any]:
+        """Template for NSFW text detection guardrail
+        
+        :param threshold: Confidence threshold for detection (0.0-1.0).
+        :param validation_method: Validation scope: "sentence", "paragraph", or "document".
+        """
+        return {
+            "name": "NSFW Text",
+            "config": {
+                "threshold": threshold,
+                "validation_method": validation_method
+            }
+        }
+    @staticmethod
+    def ban_list(banned_words: List[str]) -> Dict[str, Any]:
+        """Template for banned words guardrail"""
+        return {
+            "name": "Ban List",
+            "config": {
+                "banned_words": banned_words
+            }
+        }
+    @staticmethod
+    def bias_check(threshold: float = 0.9) -> Dict[str, Any]:
+        """Template for bias check guardrail"""
+        return {
+            "name": "Bias Check",
+            "config": {
+                "threshold": threshold
+            }
+        }
+    
+    @staticmethod
+    def competitor_check(competitors: List[str]) -> Dict[str, Any]:
+        """Template for competitor guardrail"""
+        return {
+            "name": "Competitor Check",
+            "config": {
+                "competitors": competitors
+            }
+        }
+    
+    @staticmethod
+    def correct_language(expected_language_iso: str = "en", threshold: float = 0.75) -> Dict[str, Any]:
+        """Template for correct language guardrail"""
+        return {
+            "name": "Correct Language",
+            "config": {
+                "expected_language_iso": expected_language_iso,
+                "threshold": threshold
+            }
+        }
+    
+    @staticmethod
+    def gibberish_text(threshold: float = 0.5, validation_method: str = "sentence") -> Dict[str, Any]:
+        """Template for gibberish text guardrail"""
+        return {
+            "name": "Gibberish Text",
+            "config": {
+                "threshold": threshold,
+                "validation_method": validation_method
+            }
+        }
+    
+    @staticmethod
+    def profanity_free() -> Dict[str, Any]:
+        """Template for profanity free guardrail"""
+        return {
+            "name": "Profanity Free",
+            "config": {}
+        }
+    
+    @staticmethod
+    def secrets_present() -> Dict[str, Any]:
+        """Template for secrets present guardrail"""
+        return {
+            "name": "Secrets Present",
+            "config": {}
+        }
+    
+    @staticmethod
+    def toxic_language(threshold: float = 0.5, validation_method: str = "sentence") -> Dict[str, Any]:
+        """Template for toxic language guardrail"""
+        return {
+            "name": "Toxic Language",
+            "config": {
+                "threshold": threshold,
+                "validation_method": validation_method
+            }
+        }
+
+    @staticmethod
+    def contains_string(substring: str) -> Dict[str, Any]:
+        """Template for contains string guardrail"""
+        return {
+            "name": "Contains String",
+            "config": {
+                "substring": substring
+            }
+        }
+
+    @staticmethod
+    def detect_jailbreak(threshold: float = 0.0) -> Dict[str, Any]:
+        """Template for detect jailbreak guardrail"""
+        return {
+            "name": "Detect Jailbreak",
+            "config": {
+                "threshold": threshold
+            }
+        }
+
+    @staticmethod
+    def endpoint_is_reachable() -> Dict[str, Any]:
+        """Template for endpoint is reachable guardrail"""
+        return {
+            "name": "Endpoint Is Reachable",
+            "config": {}
+        }
+    
+    @staticmethod
+    def ends_with(end: str) -> Dict[str, Any]:
+        """Template for ends with guardrail"""
+        return {
+            "name": "Ends With",
+            "config": {
+                "end": end
+            }
+        }
+
+    @staticmethod
+    def has_url() -> Dict[str, Any]:
+        """Template for has url guardrail"""
+        return {
+            "name": "Has Url",
+            "config": {}
+        }
+
+    @staticmethod
+    def lower_case() -> Dict[str, Any]:
+        """Template for lower case guardrail"""
+        return {
+            "name": "Lower Case",
+            "config": {}
+        }
+
+    @staticmethod
+    def mentions_drugs() -> Dict[str, Any]:
+        """Template for mentions drugs guardrail"""
+        return {
+            "name": "Mentions Drugs",
+            "config": {}
+        }
+
+    @staticmethod
+    def one_line() -> Dict[str, Any]:
+        """Template for one line guardrail"""
+        return {
+            "name": "One Line",
+            "config": {}
+        }
+
+    @staticmethod
+    def reading_time(reading_time: float) -> Dict[str, Any]:
+        """Template for reading time guardrail"""
+        return {
+            "name": "Reading Time",
+            "config": {
+                "reading_time": reading_time
+            }
+        }
+
+    @staticmethod
+    def redundant_sentences(threshold: int = 70) -> Dict[str, Any]:
+        """Template for redundant sentences guardrail"""
+        return {
+            "name": "Redundant Sentences",
+            "config": {
+                "threshold": threshold
+            }
+        }
+
+    @staticmethod
+    def regex_match(regex: str, match_type: str = "search") -> Dict[str, Any]:
+        """Template for regex match guardrail"""
+        return {
+            "name": "Regex Match",
+            "config": {
+                "regex": regex,
+                "match_type": match_type
+            }
+        }
+
+    @staticmethod
+    def sql_column_presence(cols: List[str]) -> Dict[str, Any]:
+        """Template for SQL column presence guardrail"""
+        return {
+            "name": "Sql Column Presence",
+            "config": {
+                "cols": cols
+            }
+        }
+
+    @staticmethod
+    def two_words() -> Dict[str, Any]:
+        """Template for two words guardrail"""
+        return {
+            "name": "Two Words",
+            "config": {}
+        }
+
+    @staticmethod
+    def upper_case() -> Dict[str, Any]:
+        """Template for upper case guardrail"""
+        return {
+            "name": "Upper Case",
+            "config": {}
+        }
+
+    @staticmethod
+    def valid_choices(choices: List[str]) -> Dict[str, Any]:
+        """Template for valid choices guardrail"""
+        return {
+            "name": "Valid Choices",
+            "config": {
+                "choices": choices
+            }
+        }
+
+    @staticmethod
+    def valid_json() -> Dict[str, Any]:
+        """Template for valid json guardrail"""
+        return {
+            "name": "Valid Json",
+            "config": {}
+        }
+
+    @staticmethod
+    def valid_length(min: Optional[int] = None, max: Optional[int] = None) -> Dict[str, Any]:
+        """Template for valid length guardrail"""
+        config = {}
+        if min is not None:
+            config['min'] = min
+        if max is not None:
+            config['max'] = max
+        return {
+            "name": "Valid Length",
+            "config": config
+        }
+
+    @staticmethod
+    def valid_range(min: Optional[int] = None, max: Optional[int] = None) -> Dict[str, Any]:
+        """Template for valid range guardrail"""
+        config = {}
+        if min is not None:
+            config['min'] = min
+        if max is not None:
+            config['max'] = max
+        return {
+            "name": "Valid Range",
+            "config": config
+        }
+
+    @staticmethod
+    def valid_url() -> Dict[str, Any]:
+        """Template for valid url guardrail"""
+        return {
+            "name": "Valid URL",
+            "config": {}
+        }
+    
+    @staticmethod
+    def web_sanitization() -> Dict[str, Any]:
+        """Template for web sanitization guardrail"""
+        return {
+            "name": "Web Sanitization",
+            "config": {}
+        }