scitex 2.0.0__py2.py3-none-any.whl

scitex/ai/_gen_ai/_Perplexity.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-11 04:11:10 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/ai/_gen_ai/_Perplexity.py
+
+"""
+Functionality:
+    - Implements Perplexity AI interface using OpenAI-compatible API
+    - Provides access to Llama and Mixtral models
+Input:
+    - User prompts and chat history
+    - Model configurations and API credentials
+Output:
+    - Generated text responses from Perplexity models
+    - Token usage statistics
+Prerequisites:
+    - Perplexity API key
+    - openai package
+"""
+
+"""Imports"""
+import os
+import sys
+from pprint import pprint
+from typing import Dict, Generator, List, Optional
+
+import matplotlib.pyplot as plt
+from openai import OpenAI
+
+from ._BaseGenAI import BaseGenAI
+
+"""Functions & Classes"""
+
+
+class Perplexity(BaseGenAI):
+    def __init__(
+        self,
+        system_setting: str = "",
+        model: str = "",
+        api_key: str = "",
+        stream: bool = False,
+        seed: Optional[int] = None,
+        n_keep: int = 1,
+        temperature: float = 1.0,
+        chat_history: Optional[List[Dict[str, str]]] = None,
+        max_tokens: Optional[int] = None,  # Added parameter
+    ) -> None:
+        # Set max_tokens based on model if not provided
+        if max_tokens is None:
+            max_tokens = 128_000 if "128k" in model else 32_000
+
+        super().__init__(
+            system_setting=system_setting,
+            model=model,
+            api_key=api_key,
+            stream=stream,
+            n_keep=n_keep,
+            temperature=temperature,
+            provider="Perplexity",
+            chat_history=chat_history,
+            max_tokens=max_tokens,
+        )
+
+    def _init_client(self) -> OpenAI:
+        return OpenAI(api_key=self.api_key, base_url="https://api.perplexity.ai")
+        # return OpenAI(
+        #     api_key=self.api_key, base_url="https://api.perplexity.ai/chat/completions"
+        # )
+
+    def _api_call_static(self) -> str:
+        output = self.client.chat.completions.create(
+            model=self.model,
+            messages=self.history,
+            max_tokens=self.max_tokens,
+            stream=False,
+            temperature=self.temperature,
+        )
+
+        print(output)
+
+        out_text = output.choices[0].message.content
+        self.input_tokens += output.usage.prompt_tokens
+        self.output_tokens += output.usage.completion_tokens
+
+        return out_text
+
+    def _api_call_stream(self) -> Generator[str, None, None]:
+        stream = self.client.chat.completions.create(
+            model=self.model,
+            messages=self.history,
+            max_tokens=self.max_tokens,
+            n=1,
+            stream=self.stream,
+            temperature=self.temperature,
+        )
+
+        for chunk in stream:
+            if chunk and chunk.choices[0].finish_reason == "stop":
+                print(chunk.choices)
+                try:
+                    self.input_tokens += chunk.usage.prompt_tokens
+                    self.output_tokens += chunk.usage.completion_tokens
+                except AttributeError:
+                    pass
+
+            if chunk.choices:
+                current_text = chunk.choices[0].delta.content
+                if current_text:
+                    yield current_text
+
+    def _get_available_models(self) -> List[str]:
+        return [
+            "llama-3.1-sonar-small-128k-online",
+            "llama-3.1-sonar-large-128k-online",
+            "llama-3.1-sonar-huge-128k-online",
+            "llama-3.1-sonar-small-128k-chat",
+            "llama-3.1-sonar-large-128k-chat",
+            "llama-3-sonar-small-32k-chat",
+            "llama-3-sonar-small-32k-online",
+            "llama-3-sonar-large-32k-chat",
+            "llama-3-sonar-large-32k-online",
+            "llama-3-8b-instruct",
+            "llama-3-70b-instruct",
+            "mixtral-8x7b-instruct",
+        ]
+
+
+def main() -> None:
+    from ._genai_factory import genai_factory as GenAI
+
+    models = [
+        "llama-3.1-sonar-small-128k-online",
+        "llama-3.1-sonar-large-128k-online",
+        "llama-3.1-sonar-huge-128k-online",
+    ]
+    ai = GenAI(model=models[0], api_key=os.getenv("PERPLEXITY_API_KEY"), stream=False)
+    out = ai("tell me about important citations for epilepsy prediction with citations")
+    print(out)
+
+
+def main():
+    import requests
+
+    url = "https://api.perplexity.ai/chat/completions"
+
+    payload = {
+        "model": "llama-3.1-sonar-small-128k-online",
+        "messages": [
+            {"role": "system", "content": "Be precise and concise."},
+            {
+                "role": "user",
+                "content": "tell me useful citations (scientific peer-reviewed papers) for epilepsy seizure prediction.",
+            },
+        ],
+        "max_tokens": 4096,
+        "temperature": 0.2,
+        "top_p": 0.9,
+        "search_domain_filter": ["perplexity.ai"],
+        "return_images": False,
+        "return_related_questions": False,
+        "search_recency_filter": "month",
+        "top_k": 0,
+        "stream": False,
+        "presence_penalty": 0,
+        "frequency_penalty": 1,
+    }
+    api_key = os.getenv("PERPLEXITY_API_KEY")
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+
+    response = requests.request("POST", url, json=payload, headers=headers)
+
+    pprint(response.json()["citations"])
+    # pprint(response["citations"])
+
+    # print(response.url)
+    # print(response.links)
+    # print(dir(response))
+    # print(response.text["citations"])
+
+
+if __name__ == "__main__":
+    import scitex
+
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(sys, plt, verbose=False)
+    main()
+    scitex.gen.close(CONFIG, verbose=False, notify=False)
+
+# EOF

scitex/ai/_gen_ai/__init__.py

@@ -0,0 +1,32 @@
+#!./env/bin/python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-07-29 14:55:00 (ywatanabe)"
+# /home/ywatanabe/proj/scitex/src/scitex/ml/_gen_ai/__init__.py
+
+from ._PARAMS import MODELS
+from ._BaseGenAI import BaseGenAI
+from ._Anthropic import Anthropic
+from ._DeepSeek import DeepSeek
+from ._Google import Google
+from ._Groq import Groq
+from ._Llama import Llama
+from ._OpenAI import OpenAI
+from ._Perplexity import Perplexity
+from ._calc_cost import calc_cost
+from ._format_output_func import format_output_func
+from ._genai_factory import genai_factory
+
+__all__ = [
+    "MODELS",
+    "BaseGenAI",
+    "Anthropic",
+    "DeepSeek", 
+    "Google",
+    "Groq",
+    "Llama",
+    "OpenAI",
+    "Perplexity",
+    "calc_cost",
+    "format_output_func",
+    "genai_factory",
+]

scitex/ai/_gen_ai/_calc_cost.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-04 01:37:36 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/ai/_gen_ai/_calc_cost.py
+
+"""
+Functionality:
+    - Calculates usage costs for AI model API calls
+    - Handles token-based pricing for different models
+Input:
+    - Model name
+    - Number of input and output tokens used
+Output:
+    - Total cost in USD based on token usage
+Prerequisites:
+    - MODELS parameter dictionary with pricing information
+    - pandas package
+"""
+
+from typing import Union, Any
+import pandas as pd
+
+from ._PARAMS import MODELS
+
+
+def calc_cost(model: str, input_tokens: int, output_tokens: int) -> float:
+    """Calculates API usage cost based on token count.
+
+    Example
+    -------
+    >>> cost = calc_cost("gpt-4", 100, 50)
+    >>> print(f"${cost:.4f}")
+    $0.0030
+
+    Parameters
+    ----------
+    model : str
+        Name of the AI model
+    input_tokens : int
+        Number of input tokens used
+    output_tokens : int
+        Number of output tokens used
+
+    Returns
+    -------
+    float
+        Total cost in USD
+
+    Raises
+    ------
+    ValueError
+        If model is not found in MODELS
+    """
+    models_df = pd.DataFrame(MODELS)
+    indi = models_df["name"] == model
+
+    if not indi.any():
+        raise ValueError(f"Model '{model}' not found in pricing table")
+
+    costs = models_df[["input_cost", "output_cost"]][indi]
+    cost = (
+        input_tokens * costs["input_cost"] + output_tokens * costs["output_cost"]
+    ) / 1_000_000
+
+    return cost.iloc[0]
+
+
+# def calc_cost(model, input_tokens, output_tokens):
+#     indi = MODELS["name"] == model
+#     costs = MODELS[["input_cost", "output_cost"]][indi]
+#     cost = (
+#         input_tokens * costs["input_cost"]
+#         + output_tokens * costs["output_cost"]
+#     ) / 1_000_000
+#     return cost.iloc[0]
+
+
+# EOF

scitex/ai/_gen_ai/_format_output_func.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-04 01:39:25 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/ai/_gen_ai/_format_output_func.py
+
+"""
+Functionality:
+    - Formats AI model output text
+    - Wraps URLs in HTML anchor tags
+    - Converts markdown to HTML
+    - Handles DOI links specially
+Input:
+    - Raw text output from AI models
+    - Optional API key for masking
+Output:
+    - Formatted HTML text with proper link handling
+Prerequisites:
+    - markdown2 package
+    - Regular expressions support
+"""
+
+"""Imports"""
+import re
+import sys
+from typing import List, Optional
+
+import markdown2
+import matplotlib.pyplot as plt
+import scitex
+
+"""Functions & Classes"""
+
+
+def format_output_func(out_text: str) -> str:
+    """Formats AI output text with proper link handling and markdown conversion.
+
+    Example
+    -------
+    >>> text = "Check https://example.com or doi:10.1234/abc"
+    >>> print(format_output_func(text))
+    Check <a href="https://example.com">https://example.com</a> or <a href="https://doi.org/10.1234/abc">https://doi.org/10.1234/abc</a>
+
+    Parameters
+    ----------
+    out_text : str
+        Raw text output from AI model
+
+    Returns
+    -------
+    str
+        HTML formatted text with proper link handling
+    """
+
+    def find_unwrapped_urls(text: str) -> List[str]:
+        url_pattern = r'(?<!<a href=")(https?://|doi:|http://doi.org/)[^\s,<>"]+'
+        return re.findall(url_pattern, text)
+
+    def add_a_href_tag(text: str) -> str:
+        def replace_url(match) -> str:
+            url = match.group(0)
+            if url.startswith("doi:"):
+                url = "https://doi.org/" + url[4:]
+            return f'<a href="{url}">{url}</a>'
+
+        url_pattern = r'(?<!<a href=")(https?://|doi:|http://doi.org/)[^\s,<>"]+'
+        return re.sub(url_pattern, replace_url, text)
+
+    def add_masked_api_key(text: str, api_key: str) -> str:
+        masked_key = f"{api_key[:4]}****{api_key[-4:]}"
+        return text + f"\n(API Key: {masked_key}"
+
+    formatted_text = markdown2.markdown(out_text)
+    formatted_text = add_a_href_tag(formatted_text)
+    formatted_text = re.sub(r"^<p>(.*)</p>$", r"\1", formatted_text, flags=re.DOTALL)
+    return formatted_text
+
+
+def main() -> None:
+    pass
+
+
+if __name__ == "__main__":
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(sys, plt, verbose=False)
+    main()
+    scitex.gen.close(CONFIG, verbose=False, notify=False)
+
+# EOF
+# #!/usr/bin/env python3
+# # -*- coding: utf-8 -*-
+# # Time-stamp: "2024-11-04 01:32:10 (ywatanabe)"
+# # File: ./scitex_repo/src/scitex/ai/_gen_ai/_format_output_func.py
+
+# """This script does XYZ."""
+
+
+# """Imports"""
+# import re
+# import sys
+
+# import markdown2
+# import matplotlib.pyplot as plt
+# import scitex
+
+# """
+# Warnings
+# """
+# # warnings.simplefilter("ignore", UserWarning)
+
+
+# """
+# Config
+# """
+# # CONFIG = scitex.gen.load_configs()
+
+
+# """
+# Functions & Classes
+# """
+
+
+# def format_output_func(out_text):
+#     def find_unwrapped_urls(text):
+#         # Regex to find URLs that are not already within <a href> tags
+#         url_pattern = (
+#             r'(?<!<a href=")(https?://|doi:|http://doi.org/)[^\s,<>"]+'
+#         )
+
+#         # Find all matches that are not already wrapped
+#         unwrapped_urls = re.findall(url_pattern, text)
+
+#         return unwrapped_urls
+
+#     def add_a_href_tag(text):
+#         # Function to replace each URL with its wrapped version
+#         def replace_url(match):
+#             url = match.group(0)
+#             # Normalize DOI URLs
+#             if url.startswith("doi:"):
+#                 url = "https://doi.org/" + url[4:]
+#             return f'<a href="{url}">{url}</a>'
+
+#         # Regex pattern to match URLs not already wrapped in <a> tags
+#         url_pattern = (
+#             r'(?<!<a href=")(https?://|doi:|http://doi.org/)[^\s,<>"]+'
+#         )
+
+#         # Replace all occurrences of unwrapped URLs in the text
+#         updated_text = re.sub(url_pattern, replace_url, text)
+
+#         return updated_text
+
+#     def add_masked_api_key(text, api_key):
+#         masked_api_key = f"{api_key[:4]}****{api_key[-4:]}"
+#         return text + f"\n(API Key: {masked_api_key}"
+
+#     out_text = markdown2.markdown(out_text)
+#     out_text = add_a_href_tag(out_text)
+#     out_text = re.sub(r"^<p>(.*)</p>$", r"\1", out_text, flags=re.DOTALL)
+#     return out_text
+
+
+# def main():
+#     pass
+
+
+# if __name__ == "__main__":
+#     # # Argument Parser
+#     # import argparse
+#     # parser = argparse.ArgumentParser(description='')
+#     # parser.add_argument('--var', '-v', type=int, default=1, help='')
+#     # parser.add_argument('--flag', '-f', action='store_true', default=False, help='')
+#     # args = parser.parse_args()
+
+#     # Main
+#     CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(
+#         sys, plt, verbose=False
+#     )
+#     main()
+#     scitex.gen.close(CONFIG, verbose=False, notify=False)
+
+#
+
+# EOF

scitex/ai/_gen_ai/_genai_factory.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-03 11:57:10 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/ai/_gen_ai/_genai_factory.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/ai/_gen_ai/_genai_factory.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import random
+
+from ._Anthropic import Anthropic
+from ._DeepSeek import DeepSeek
+from ._Google import Google
+from ._Groq import Groq
+from ._Llama import Llama
+from ._OpenAI import OpenAI
+from ._PARAMS import MODELS
+from ._Perplexity import Perplexity
+
+
+def genai_factory(
+    model="gpt-3.5-turbo",
+    stream=False,
+    api_key=None,
+    seed=None,
+    temperature=1.0,
+    n_keep=1,
+    chat_history=None,
+    max_tokens=4096,
+):
+    """Factory function to create an instance of an AI model handler."""
+    AVAILABLE_MODELS = MODELS.name.tolist()
+
+    if model not in AVAILABLE_MODELS:
+        raise ValueError(
+            f'Model "{model}" is not available. Please choose from:{MODELS.name.tolist()}'
+        )
+
+    provider = MODELS[MODELS.name == model].provider.iloc[0]
+
+    # model_class = globals()[provider]
+    model_class = {
+        "OpenAI": OpenAI,
+        "Anthropic": Anthropic,
+        "Google": Google,
+        "Llama": Llama,
+        "Perplexity": Perplexity,
+        "DeepSeek": DeepSeek,
+        "Groq": Groq,
+    }[provider]
+
+    # Select a random API key from the list
+    if isinstance(api_key, (list, tuple)):
+        api_key = random.choice(api_key)
+
+    return model_class(
+        model=model,
+        stream=stream,
+        api_key=api_key,
+        seed=seed,
+        temperature=temperature,
+        n_keep=n_keep,
+        chat_history=chat_history,
+        max_tokens=max_tokens,
+    )
+
+
+# EOF

scitex/ai/act/__init__.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env python3
+"""Scitex act module."""
+
+from ._define import define
+
+__all__ = [
+    "define",
+]

scitex/ai/act/_define.py

@@ -0,0 +1,11 @@
+import torch.nn as nn
+
+
+def define(act_str):
+    acts_dict = {
+        "relu": nn.ReLU(),
+        "swish": nn.SiLU(),
+        "mish": nn.Mish(),
+        "lrelu": nn.LeakyReLU(0.1),
+    }
+    return acts_dict[act_str]

scitex/ai/classification/__init__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+"""Classification utilities."""
+
+from .classification_reporter import ClassificationReporter
+from .classifier_server import ClassifierServer
+
+__all__ = ["ClassificationReporter", "ClassifierServer"]