lexsi-sdk 0.1.12__tar.gz

lexsi_sdk-0.1.12/.github/scripts/release.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+import subprocess
+
+default_version = "0.1.0"
+
+def get_last_version() -> str:
+    """Return the version number of the last release."""
+    result = subprocess.run(
+        ["gh", "release", "list", "--limit", "1", "--json", "tagName", "--jq", ".[0].tagName"],
+        check=False,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    )
+    tag = result.stdout.strip()
+    if not tag:
+        return default_version
+    return tag
+
+
+def bump_patch_number(version_number: str) -> str:
+    """Return a copy of `version_number` with the patch number incremented."""
+    major, minor, patch = version_number.split(".")
+    return f"{major}.{minor}.{int(patch) + 1}"
+
+
+def create_new_patch_release():
+    """Create a new patch release on GitHub."""
+    try:
+        last_version_number = get_last_version()
+    except subprocess.CalledProcessError as err: 
+        # The project doesn't have any releases yet.
+        new_version_number = default_version
+        print(err)
+        print(f'taking default version: {new_version_number}')
+    else:
+        new_version_number = bump_patch_number(last_version_number)
+
+    subprocess.run(
+        ["gh", "release", "create", "--generate-notes", f"{new_version_number}"],
+        check=True,
+    )
+
+
+if __name__ == "__main__":
+    create_new_patch_release()

lexsi_sdk-0.1.12/.github/scripts/test-release.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+import subprocess
+
+default_version = "0.0.dev1"
+
+def get_last_version() -> str:
+    """Return the version number of the last release."""
+    tag_info = (
+        subprocess.run(
+            "gh release list | grep -E '^.+\\.dev\\d*' | head -n 1",
+            shell=True,
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+        .stdout.decode("utf8")
+        .strip()
+    )
+    tag_fields = tag_info.split('\t')
+    tag = tag_fields[2] if len(tag_fields) > 2 else default_version
+
+    return tag
+
+def bump_patch_number(version_number: str) -> str:
+    """Return a copy of `version_number` with the patch number incremented."""
+    major, minor, patch = version_number.split(".")
+    
+    new_patch_version = int(patch[3:]) + 1
+
+    return f"{major}.{minor}.dev{new_patch_version}"
+
+
+def create_new_patch_release():
+    """Create a new patch release on GitHub."""
+    try:
+        last_version_number = get_last_version()
+    except subprocess.CalledProcessError as err: 
+        # The project doesn't have any releases yet.
+        new_version_number = default_version
+        print(err)
+        print(f'taking default version: {new_version_number}')
+    else:
+        new_version_number = bump_patch_number(last_version_number)
+
+    subprocess.run(
+        ["gh", "release", "create", "--generate-notes", f"{new_version_number}"],
+        check=True,
+    )
+
+
+if __name__ == "__main__":
+    create_new_patch_release()

lexsi_sdk-0.1.12/.github/workflows/publish.yml

@@ -0,0 +1,83 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  pypi:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    env:
+      SETUPTOOLS_SCM_PRETEND_VERSION: ${{ github.event.release.tag_name }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          ref: ${{ github.event.release.tag_name }}
+
+      - name: Clean build artefacts
+        run: rm -rf dist build ./*.egg-info
+
+      - name: Install dependencies and run tests
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+          pip install .
+          pip install pytest
+          pytest tests/
+        continue-on-error: false
+
+      - name: Build package
+        run: python3 -m pip install --upgrade build && python3 -m build
+
+      - name: Check version is non-dev
+        run: |
+          python -m pip install setuptools_scm
+          python - << 'PY'
+          from setuptools_scm import get_version
+          v = get_version()
+          print("Computed version:", v)
+          if ".dev" in v:
+              raise SystemExit(f"Refusing to publish dev version: {v}")
+          PY
+
+      - name: Publish package to PyPI
+        if: success()
+        run: |
+          python -m pip install --upgrade twine
+          python -m pip install -U packaging
+          python -m twine upload dist/*
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+
+      - name: Send release notes to Slack
+        id: slack
+        uses: slackapi/slack-github-action@v1.24.0
+        with:
+          channel-id: "lexsi-sdk-prod-release"
+          payload: |
+            {
+              "text": "Lexsi SDK release",
+              "blocks": [
+                {
+                  "type": "section",
+                  "text": {
+                    "type": "mrkdwn",
+                    "text": "*Version:* ${{ github.event.release.tag_name }}"
+                  }
+                },
+                {
+                  "type": "section",
+                  "text": {
+                    "type": "mrkdwn",
+                    "text": "*PyPI URL:* https://pypi.org/project/lexsi_sdk/${{ github.event.release.tag_name }}"
+                  }
+                }
+              ]
+            }
+        env:
+          SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}

lexsi_sdk-0.1.12/.github/workflows/release.yml

@@ -0,0 +1,28 @@
+name: Create release
+
+on:
+  push:
+    branches:
+      - main        # when you push to main, this runs
+
+jobs:
+  github:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write       # needed so gh can create tags/releases
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0    # full history so setuptools_scm & gh see all tags
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Create new patch release
+        run: .github/scripts/release.py
+        env:
+          GH_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}

lexsi_sdk-0.1.12/.github/workflows/test-publish.yml

@@ -0,0 +1,93 @@
+name: Publish to test PyPI
+
+on:
+  workflow_dispatch:
+    inputs:
+      branch:
+        description: "Branch to release from"
+        required: true
+        default: "main"
+
+jobs:
+  pypi:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          ref: ${{ github.event.inputs.branch }}
+
+      - name: Fetch all tags
+        run: git fetch --tags --force
+
+      - name: Detect latest stable version
+        run: |
+          latest_tag=$(git tag --list --sort=-v:refname | grep -E '^[0-9]+\.[0-9]+\.[0-9]+$' | head -n 1)
+
+          if [ -z "$latest_tag" ]; then
+            echo "No stable tags found. Using fallback 0.1.0"
+            base="0.1.0"
+          else
+            echo "Latest stable tag detected: $latest_tag"
+            base="$latest_tag"
+          fi
+
+          echo "BASE_VERSION=$base" >> $GITHUB_ENV
+          echo "Using base version: $base"
+
+      - name: Upgrade packaging stack
+        run: |
+          python -m pip install --upgrade pip
+          pip install --upgrade setuptools wheel setuptools_scm build twine pkginfo readme-renderer requests
+
+      - name: Compute next dev version
+        run: |
+          python <<'EOF'
+          import os, re, requests
+
+          base = os.environ["BASE_VERSION"]
+          pkg = "lexsi-sdk"
+
+          url = f"https://test.pypi.org/pypi/{pkg}/json"
+
+          try:
+              data = requests.get(url, timeout=10).json()
+              versions = data.get("releases", {}).keys()
+          except Exception:
+              print("No existing TestPyPI project found. Starting dev counter at 1.")
+              versions = []
+
+          pattern = re.compile(rf"^{re.escape(base)}\.dev(\d+)$")
+
+          dev_nums = [
+              int(m.group(1))
+              for v in versions
+              if (m := pattern.match(v))
+          ]
+
+          next_dev = max(dev_nums, default=0) + 1
+          final_version = f"{base}.dev{next_dev}"
+
+          print("Next dev version:", final_version)
+
+          with open(os.environ["GITHUB_ENV"], "a") as f:
+              f.write(f"SETUPTOOLS_SCM_PRETEND_VERSION={final_version}\n")
+
+          EOF
+
+      - name: Build package
+        env:
+          XAI_ENV: testing
+        run: |
+          rm -rf build dist *.egg-info
+          python -m build
+          twine check dist/*
+
+      - name: Publish package to Test PyPI
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.TEST_PYPI_API_TOKEN }}
+        run: |
+          python -m twine upload --repository-url https://test.pypi.org/legacy/ dist/*

lexsi_sdk-0.1.12/.github/workflows/test-release.yml

@@ -0,0 +1,20 @@
+name: Create test release
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - testing-main
+
+jobs:
+  github:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Create new test release
+        run: .github/scripts/test-release.py
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN  }}

lexsi_sdk-0.1.12/.gitignore

@@ -0,0 +1,29 @@
+.vscode
+
+# Compiled python modules.
+*.pyc
+__pycache__
+
+# Setuptools distribution folder.
+/dist/
+build
+
+# Python egg metadata, regenerated from source files by setuptools.
+*.egg-info
+.eggs
+
+# Documentation files
+_build
+_static
+_templates
+
+# Venv
+*venv
+
+# env file
+.env.local
+.env.testing
+
+# package version file
+lexsi_sdk/version.py
+/workingtest/

lexsi_sdk-0.1.12/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Lexsi.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lexsi_sdk-0.1.12/MANIFEST.in

@@ -0,0 +1,8 @@
+include LICENSE
+include README.md
+include requirements.txt
+recursive-include lexsi_sdk *.pickle
+recursive-exclude * __pycache__
+recursive-exclude * *.py[co]
+recursive-include docs *.md
+recursive-include tests *.py

lexsi_sdk-0.1.12/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: lexsi-sdk
+Version: 0.1.12
+Summary: Full stack ML Observability with Lexsi.ai
+Author-email: Lexsi Labs <support@lexsi.ai>
+License: Lexsi Labs Source Available License (LSAL) v1.0
+Keywords: lexsi,lexsi-sdk,lexsi_sdk,ML observability,observability,machine learning
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=1.10.13
+Requires-Dist: httpx
+Requires-Dist: pyjwt>=2.3.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: pandas>=1.5.3
+Requires-Dist: plotly>=5.15.0
+Requires-Dist: ipython>=7.34.0
+Requires-Dist: Pillow>=10.4.0
+Requires-Dist: google-genai>=1.24.0
+Requires-Dist: anthropic>=0.57.1
+Requires-Dist: openai>=1.93.1
+Requires-Dist: groq>=0.29.0
+Requires-Dist: xai-sdk>=1.0.0
+Requires-Dist: together>=1.3.14
+Requires-Dist: replicate>=1.0.7
+Requires-Dist: huggingface-hub>=0.33.2
+Requires-Dist: mistralai>=1.9.1
+Requires-Dist: boto3>=1.39.4
+Requires-Dist: opentelemetry-sdk>=1.36.0
+Requires-Dist: opentelemetry-exporter-otlp>=1.36.0
+Requires-Dist: openinference-instrumentation-langchain>=0.1.50
+Requires-Dist: openinference-instrumentation-autogen-agentchat>=0.1.4
+Requires-Dist: openinference-instrumentation-crewai>=0.1.11
+Requires-Dist: openinference-instrumentation-dspy>=0.1.28
+Requires-Dist: openinference-instrumentation-llama-index>=4.3.4
+Requires-Dist: openinference-instrumentation-openai-agents>=1.2.0
+Requires-Dist: openinference-instrumentation-smolagents>=0.1.16
+
+## [Lexsi ai](https://lexsi.ai): ML Observability for mission-critical ‘AI’
+
+Lexsi Ai is a full-stack ML Observability platform that integrates with your MLOPs platform to Explain, Monitor, Audit and Improve your ML models.
+
+Lexsi Ai has multiple components to address the complex observability required for mission-critical ‘AI’. 
+
+1. **ML Explainability:** Lexsi Ai offers diverse explainability options like- Bactrace(Specialized for deep learning models), SHAPE, Decision View, Observations (New way to correlate expert functioning vs model functioning) and Similar Cases (reference as explanations).
+2. **ML Monitoring:** Monitor your models for drifts, performance & bias. The tool offers diverse options for drift (data/model) like - PSI, KL Divergence, Chi-square test, 
+3. **Synthetic ‘AI’:** Deploy advanced synthetic ‘AI’ techniques like GPT-2 & GANs on your tabular data to generate high-quality synthetic datasets. Test the quality and privacy of these data sets using our Anonymity tests, column tests etc. 
+4. **ML Risk policies:** Define advanced risk policies on your models. 
+5. **AutoML:** Lexsi Ai also provides fully low-code and no-code options to build ML models on your data. For advanced users, it also provides more options to fine-tune it. 
+
+Lexsi Ai also acts as a common workflow and provides insights acceptable by all stakeholders - Data Science, IT, Risk, Operations and compliance teams, making the rollout and maintenance of AI/ML models seamless and clutter-free.
+
+### Quickstart:
+Get started with Lexsi Ai with a few easy steps:
+
+1. Sign up and log in to your new Lexsi Ai account.
+2. After logging in, generate an Access Token for your user account.
+3. Set the environment variable **XAI_ACCESS_TOKEN** with the generated value. 
+
+Once you've completed these steps, you're all set! Now, you can easily log in and start using the Lexsi Ai SDK:
+
+1. Log in by importing the "xai" object instance from the "lexsi_sdk" package.
+2. Call the "login" method. This method automatically takes the access token value from the "XAI_ACCESS_TOKEN" environment variable and stores the JWT in the object instance. This means that all your future SDK operations will be authorized automatically, making it simple and hassle-free!
+
+
+```
+from lexsi_sdk import xai as lexsi
+
+## login() function authenticates user using token that can be generated in app.lexsi_sdk.com/sdk
+
+
+lexsi.login()
+
+
+Enter your Lexsi ai Access Token: ··········
+Authenticated successfully.
+```
+
+### Cookbook: 
+In this section, you can review the examples of implementation of Lexsi Ai-SDK. 
+
+1. [Full features overview of Lexsi Ai](https://colab.research.google.com/drive/1Dy5eL-FJVnFV0K5yOfGGVoAmiS_Icaz3?usp=sharing)
+2. Using Lexsi Ai in Loan Underwriting (Coming Soon)
+
+
+### Contribution guidelines:
+At Lexsi Ai, we're passionate about open source and value community contributions! Explore our contribution guide for insights into the development workflow and Lexsi Ai library internals. For bug reports or feature requests, head to GitHub Issues or reach out to us at [support@Lexsi Ai.com](support@Lexsi Ai.com).

lexsi_sdk-0.1.12/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-0.1.12/lexsi_sdk/client/client.py

@@ -0,0 +1,194 @@
+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):
+    #     """makes streaming 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("GET", uri, stream=True)
+    #     for res in response.iter_lines(decode_unicode=True):
+    #         if res:
+    #             if res.startswith("data: "):
+    #                 res = res.split("data: ")[1]
+    #             yield json.loads(res)
+
+    def stream(self, uri):
+        """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("GET", url, headers=headers) as response:
+                response.raise_for_status()
+                for line in response.iter_lines():  # no decode_unicode arg in httpx
+                    if not line:
+                        continue
+                    # httpx.iter_lines() yields str lines
+                    if line.startswith("data: "):      # typical SSE prefix
+                        line = line[6:]
+                    yield json.loads(line)
+
+    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()