lexsi-sdk 0.1.16__py3-none-any.whl

lexsi_sdk/__init__.py

@@ -0,0 +1,5 @@
+#import core modules so that they can be imported directly
+from __future__ import annotations
+from lexsi_sdk.core.xai import XAI
+
+xai = XAI()

lexsi_sdk/client/client.py

@@ -0,0 +1,176 @@
+import requests
+import httpx
+from lexsi_sdk.common.xai_uris import LOGIN_URI
+import jwt
+from pydantic import BaseModel
+import json
+
+
+class APIClient(BaseModel):
+    """API client to interact with Lexsi Ai services"""
+
+    debug: bool = False
+    base_url: str = ""
+    access_token: str = ""
+    auth_token: str = ""
+    headers: dict = {}
+
+    def __init__(self, **kwargs):
+        """Initialize the API client with provided configuration."""
+        super().__init__(**kwargs)
+
+    def get_auth_token(self) -> str:
+        """get jwt auth token value
+
+        Returns:
+            str: jwt auth token
+        """
+        return self.auth_token
+
+    def set_auth_token(self, auth_token):
+        """sets jwt auth token value
+
+        :param auth_token: jwt auth token
+        """
+        self.auth_token = auth_token
+
+    def set_access_token(self, access_token):
+        """sets access token value
+
+        :param auth_token: jwt auth token
+        """
+        self.access_token = access_token
+
+    def get_url(self, uri) -> str:
+        """get url by appending uri to base url
+
+        :param uri: uri of endpoint
+        :return: url
+        """
+        return f"{self.base_url}/{uri}"
+
+    def update_headers(self, auth_token):
+        """sets jwt auth token and updates headers for all requests"""
+        self.set_auth_token(auth_token)
+        self.headers = {
+            "Authorization": f"Bearer {self.auth_token}",
+        }
+
+    def refresh_bearer_token(self):
+        """Refresh the bearer token if the current token is expired."""
+        try:
+            if self.auth_token:
+                jwt.decode(
+                    self.auth_token,
+                    options={"verify_signature": False, "verify_exp": True},
+                )
+        except jwt.exceptions.ExpiredSignatureError as e:
+            response = self.base_request(
+                "POST", LOGIN_URI, {"access_token": self.access_token}
+            ).json()
+            self.update_headers(response["access_token"])
+
+    def base_request(self, method, uri, payload={}, files=None):
+        """makes request to xai base service
+
+        :param uri: api uri
+        :param method: GET, POST, PUT, DELETE
+        :raises Exception: Request exception
+        :return: JSON response
+        """
+        url = f"{self.base_url}/{uri}"
+        try:
+            # response = requests.request(
+            #     method,
+            #     url,
+            #     headers=self.headers,
+            #     json=payload,
+            #     files=files,
+            #     stream=stream,
+            # )
+
+            with httpx.Client(http2=True, timeout=None) as client:
+                response = client.request(
+                    method=method,
+                    url=url,
+                    headers=self.headers,
+                    json=payload,
+                    files=files or None,
+                )
+                #response.raise_for_status()
+                #return response
+
+            res = None
+            try:
+                res = response.json().get("details") or response.json()
+            except Exception:
+                res = response.text
+            if 400 <= response.status_code < 500:
+                raise Exception(res)
+            elif 500 <= response.status_code < 600:
+                raise Exception(res)
+            else:
+                return response
+        except Exception as e:
+            raise e
+
+    def request(self, method, uri, payload):
+        """Refresh credentials and dispatch a base request."""
+        self.refresh_bearer_token()
+        response = self.base_request(method, uri, payload)
+        return response
+
+    def get(self, uri):
+        """makes get request to xai base service
+
+        :param uri: api uri
+        :raises Exception: Request exception
+        :return: JSON response
+        """
+
+        self.refresh_bearer_token()
+        response = self.base_request("GET", uri)
+        return response.json()
+
+    def post(self, uri, payload={}):
+        """makes post request to xai base service
+
+        :param uri: api uri
+        :param payload: api payload, defaults to {}
+        :raises Exception: Request exception
+        :return: JSON response
+        """
+
+        self.refresh_bearer_token()
+        response = self.base_request("POST", uri, payload)
+
+        return response.json()
+
+    def stream(self, uri, method, payload=None):
+        """Server-Sent Events / line-streaming endpoint."""
+        self.refresh_bearer_token()
+        url = f"{self.base_url}/{uri}"
+        # if SSE, this header helps
+        headers = {**self.headers, "Accept": "text/event-stream"}
+
+        with httpx.Client(http2=True, timeout=None) as client:
+            # streaming MUST be consumed inside the context
+            with client.stream(method, url, headers=headers, json=payload) as response:
+                response.raise_for_status()
+                for line in response.iter_lines():  # no decode_unicode arg in httpx
+                    if not line: continue
+                    if line.startswith("data: "):      # typical SSE prefix
+                        if line.strip() == "data: [DONE]":
+                            break
+                        yield json.loads(line[6:])
+
+    def file(self, uri, files):
+        """makes multipart request to send files
+
+        :param uri: api uri
+        :param file_path: file path
+        :return: JSON response
+        """
+        self.refresh_bearer_token()
+        response = self.base_request("POST", uri, files=files)
+        return response.json()

lexsi_sdk/common/config/.env.prod

@@ -0,0 +1,3 @@
+DEBUG=False
+XAI_API_URL=https://apiv1.lexsi.ai
+XAI_API_VERSION=v1

lexsi_sdk/common/constants.py

@@ -0,0 +1,143 @@
+MODEL_TYPES = ["classification", "regression"]
+
+DATA_DRIFT_DASHBOARD_REQUIRED_FIELDS = [
+    "base_line_tag",
+    "current_tag",
+    "stat_test_name",
+]
+
+DATA_DRIFT_STAT_TESTS = [
+    "chisquare",
+    "jensenshannon",
+    "ks",
+    "kl_div",
+    "psi",
+    "wasserstein",
+    "z",
+]
+
+
+TARGET_DRIFT_DASHBOARD_REQUIRED_FIELDS = [
+    "base_line_tag",
+    "current_tag",
+    "baseline_true_label",
+    "current_true_label",
+    "model_type",
+    "stat_test_name",
+]
+
+TARGET_DRIFT_STAT_TESTS = ["chisquare", "jensenshannon", "kl_div", "psi", "z"]
+
+TARGET_DRIFT_STAT_TESTS_CLASSIFICATION = [
+    "chisquare",
+    "jensenshannon",
+    "kl_div",
+    "psi",
+]
+
+TARGET_DRIFT_STAT_TESTS_REGRESSION = [
+    "jensenshannon",
+    "kl_div",
+    "ks",
+    "psi",
+    "wasserstein",
+]
+
+
+BIAS_MONITORING_DASHBOARD_REQUIRED_FIELDS = [
+    "base_line_tag",
+    "baseline_true_label",
+    "baseline_pred_label",
+    "model_type",
+]
+
+MODEL_PERF_DASHBOARD_REQUIRED_FIELDS = [
+    "base_line_tag",
+    "current_tag",
+    "baseline_true_label",
+    "baseline_pred_label",
+    "current_true_label",
+    "current_pred_label",
+    "model_type",
+]
+
+
+DATA_DRIFT_TRIGGER_REQUIRED_FIELDS = [
+    "trigger_name",
+    "trigger_type",
+    "mail_list",
+    "frequency",
+    "stat_test_name",
+    "datadrift_features_per",
+    "base_line_tag",
+    "current_tag",
+]
+
+TARGET_DRIFT_TRIGGER_REQUIRED_FIELDS = [
+    "trigger_name",
+    "trigger_type",
+    "mail_list",
+    "frequency",
+    "model_type",
+    "stat_test_name",
+    "baseline_true_label",
+    "current_true_label",
+    "base_line_tag",
+    "current_tag",
+]
+
+MODEL_PERF_TRIGGER_REQUIRED_FIELDS = [
+    "trigger_name",
+    "trigger_type",
+    "mail_list",
+    "frequency",
+    "model_type",
+    "model_performance_metric",
+    "model_performance_threshold",
+    "baseline_true_label",
+    "baseline_pred_label",
+    "base_line_tag",
+]
+
+MODEL_PERF_METRICS_CLASSIFICATION = [
+    "accuracy",
+    "f1",
+    "false_negative_rate",
+    "false_positive_rate",
+    "precision",
+    "recall",
+    "true_negative_rate",
+    "true_positive_rate",
+]
+
+MODEL_PERF_METRICS_REGRESSION = [
+    "mean_abs_perc_error",
+    "mean_abs_perc_error",
+    "mean_squared_error",
+    "r2_score",
+]
+
+MAIL_FREQUENCIES = [
+    "1 hour",
+    "3 hour",
+    "6 hour",
+    "daily",
+    "weekly",
+    "monthly",
+    "quarterly",
+    "yearly",
+]
+
+SYNTHETIC_MODELS_DEFAULT_HYPER_PARAMS = {
+    "GPT2": {
+        "batch_size": 250,
+        "early_stopping_patience": 10,
+        "early_stopping_threshold": 0.11,
+        "epochs": 100,
+        "model_type": "tabular",
+        "random_state": 1,
+        "tabular_config": "GPT2Config",
+        "train_size": 0.8,
+    },
+    "CTGAN": {"epochs": 100, "test_ratio": 0.2},
+}

lexsi_sdk/common/enums.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class UserRole(Enum):
+    """Enumeration of supported user roles within Lexsi."""
+
+    ADMIN = 'admin'
+    USER = 'user'

lexsi_sdk/common/environment.py

@@ -0,0 +1,49 @@
+import os
+from pydantic import BaseModel
+from dotenv import load_dotenv
+
+
+class Environment(BaseModel):
+    """
+    Environment class to load current environment
+    """
+
+    debug: bool = False
+    XAI_ENV: str = os.getenv("XAI_ENV", "prod")
+
+    def __init__(self):
+        """Load environment configuration on instantiation."""
+        super().__init__()
+
+        self.load_environment()
+
+    def load_environment(self):
+        """
+        load current environment config
+
+        :return: None
+        """
+        env_file = f".env.{self.XAI_ENV}"
+
+        BASEDIR = os.path.abspath(os.path.dirname(__file__))
+        load_dotenv(os.path.join(BASEDIR, "config", env_file))
+
+        logger_on = self.get_debug()
+
+        if logger_on:
+            self.debug = logger_on
+            print(f"Connected to: {self.XAI_ENV} environment")
+
+    def get_base_url(self) -> str:
+        """get base url of XAI platform
+
+        :return: base url
+        """
+        return os.getenv("XAI_API_URL", "https://apiv1.lexsi.ai")
+
+    def get_debug(self) -> bool:
+        """get debug flag
+
+        :return: debug flag
+        """
+        return bool(os.getenv("DEBUG", False))

lexsi_sdk/common/monitoring.py

@@ -0,0 +1,81 @@
+from typing import List, Optional, TypedDict
+
+
+class ImageDashboardPayload(TypedDict):
+    """Payload schema for image monitoring dashboards."""
+
+    base_line_tag: List[str]
+    current_tag: List[str]
+
+
+class DataDriftPayload(TypedDict):
+    """Payload schema for data drift dashboards."""
+
+    project_name: Optional[str]
+    base_line_tag: List[str]
+    current_tag: List[str]
+
+    date_feature: Optional[str]
+    baseline_date: Optional[dict]
+    current_date: Optional[dict]
+
+    features_to_use: List[str]
+
+    stat_test_name: str
+    stat_test_threshold: str
+
+
+class TargetDriftPayload(TypedDict):
+    """Payload schema for target drift dashboards."""
+
+    project_name: str
+    base_line_tag: List[str]
+    current_tag: List[str]
+
+    date_feature: Optional[str]
+    baseline_date: Optional[dict]
+    current_date: Optional[dict]
+
+    model_type: str
+
+    baseline_true_label: str
+    current_true_label: str
+
+    stat_test_name: str
+    stat_test_threshold: float
+
+
+class BiasMonitoringPayload(TypedDict):
+    """Payload schema for bias monitoring dashboards."""
+
+    project_name: str
+    base_line_tag: List[str]
+
+    date_feature: Optional[str]
+    baseline_date: Optional[dict]
+    current_date: Optional[dict]
+
+    baseline_true_label: str
+    baseline_pred_label: str
+
+    features_to_use: List[str]
+    model_type: str
+
+
+class ModelPerformancePayload(TypedDict):
+    """Payload schema for model performance dashboards."""
+
+    project_name: str
+    base_line_tag: List[str]
+    current_tag: List[str]
+
+    date_feature: Optional[str]
+    baseline_date: Optional[dict]
+    current_date: Optional[dict]
+
+    baseline_true_label: str
+    baseline_pred_label: str
+    current_true_label: str
+    current_pred_label: str
+
+    model_type: str

lexsi_sdk/common/trigger.py

@@ -0,0 +1,75 @@
+from typing import List, Optional, TypedDict
+    
+class DataDriftTriggerPayload(TypedDict):
+    """Payload schema for creating data drift alert triggers."""
+
+    project_name: str
+    trigger_name: str
+    trigger_type: str
+
+    mail_list: List[str]
+    frequency: str
+
+    stat_test_name: str
+    stat_test_threshold: Optional[float]
+
+    datadrift_features_per: float
+
+    features_to_use: List[str]
+
+    date_feature: Optional[str]
+    baseline_date: Optional[dict]
+    current_date: Optional[dict]
+
+    base_line_tag: List[str]
+    current_tag: List[str]
+    
+    
+class TargetDriftTriggerPayload(TypedDict):
+    """Payload schema for creating target drift alert triggers."""
+
+    project_name: str
+    trigger_name: str
+    trigger_type: str
+
+    mail_list: List[str]
+    frequency: str
+
+    model_type: str
+
+    stat_test_name: str
+    stat_test_threshold: Optional[float]
+
+    baseline_true_label: str
+    current_true_label: str
+
+    date_feature: Optional[str]
+    baseline_date: Optional[dict]
+    current_date: Optional[dict]
+
+    base_line_tag: List[str]
+    current_tag: List[str]
+
+    
+class ModelPerfTriggerPayload(TypedDict):
+    """Payload schema for creating model performance alert triggers."""
+
+    project_name: str
+    trigger_name: str
+    trigger_type: str
+
+    mail_list: List[str]
+    frequency: str
+
+    model_type: str
+    model_performance_metric: float
+    model_performance_threshold: float
+
+    baseline_true_label: str
+    baseline_pred_label: str
+
+    date_feature: Optional[str]
+    baseline_date: Optional[dict]
+    current_date: Optional[dict]
+
+    base_line_tag: List[str]

lexsi_sdk/common/types.py

@@ -0,0 +1,122 @@
+from datetime import datetime
+from typing import List, Optional, TypedDict, Dict
+
+
+class ProjectConfig(TypedDict):
+    """Configuration keys required to describe a project."""
+
+    project_type: str
+    model_name: Optional[str] = None
+    unique_identifier: str
+    true_label: str
+    tag: str
+    pred_label: Optional[str]
+    feature_exclude: Optional[List[str]]
+    drop_duplicate_uid: Optional[bool]
+    handle_errors: Optional[bool]
+    feature_encodings: Optional[dict]
+    handle_data_imbalance: Optional[bool]
+    explainability_method: Optional[List[str]] = None
+
+class DataConfig(TypedDict):
+    """Training data configuration for tabular workloads."""
+
+    tags: List[str]
+    test_tags: Optional[List[str]]
+    use_optuna: Optional[bool] = False
+    feature_exclude: List[str]
+    feature_encodings: Dict[str, str]
+    drop_duplicate_uid: bool
+    sample_percentage: float
+    explainability_sample_percentage: float
+    lime_explainability_iterations: int
+    explainability_method: List[str]
+    handle_data_imbalance: Optional[bool]
+
+class SyntheticDataConfig(TypedDict):
+    """Configuration required when generating synthetic data."""
+
+    model_name: str
+    tags: List[str]
+    feature_exclude: List[str]
+    feature_include: List[str]
+    feature_actual_used: List[str]
+    drop_duplicate_uid: bool
+
+
+class SyntheticModelHyperParams(TypedDict):
+    """Common hyperparameter keys for supported synthetic models."""
+
+    # GPT2 hyper params
+    batch_size: Optional[int]
+    early_stopping_patience: Optional[int]
+    early_stopping_threshold: Optional[float]
+    epochs: Optional[int]
+    model_type: Optional[str]
+    random_state: Optional[int]
+    tabular_config: Optional[str]
+    train_size: Optional[float]
+
+    # CTGAN hyper params
+    epochs: Optional[int]
+    test_ratio: Optional[float]
+
+class GCSConfig(TypedDict):
+    """Google Cloud Storage connector configuration."""
+
+    project_id: str
+    gcp_project_name: str
+    type: str
+    private_key_id: str
+    private_key: str
+    client_email: str
+    client_id: str
+    auth_uri: str
+    token_uri: str
+
+class S3Config(TypedDict):
+    """Amazon S3 connector configuration."""
+
+    region: Optional[str] = None
+    access_key: str
+    secret_key: str
+
+class GDriveConfig(TypedDict):
+    """Google Drive connector configuration."""
+
+    project_id: str
+    type: str
+    private_key_id: str
+    private_key: str
+    client_email: str
+    client_id: str
+    auth_uri: str
+    token_uri: str
+
+class SFTPConfig(TypedDict):
+    """SFTP connector configuration."""
+
+    hostname: str
+    port: str
+    username: str
+    password: str
+
+class CustomServerConfig(TypedDict):
+    """Scheduling options when requesting dedicated inference compute."""
+
+    start: Optional[datetime] = None
+    stop: Optional[datetime] = None
+    shutdown_after: Optional[int] = 1
+    op_hours: Optional[bool] = None
+    auto_start: bool = False
+
+class InferenceCompute(TypedDict):
+    """Inference compute selection payload."""
+
+    instance_type: str
+    custom_server_config: Optional[CustomServerConfig] = CustomServerConfig()
+
+class InferenceSettings(TypedDict):
+    """Inference settings that can be applied to text models."""
+
+    inference_engine: str