scitex 2.0.0__py2.py3-none-any.whl

scitex/ai/_gen_ai/_DeepSeek.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-08 20:33:49 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/ai/_gen_ai/_DeepSeek.py
+
+"""
+1. Functionality:
+   - Implements DeepSeek Code LLM API interface
+2. Input:
+   - Text prompts for code generation
+3. Output:
+   - Generated code responses (streaming or static)
+4. Prerequisites:
+   - DEEPSEEK_API_KEY environment variable
+   - requests library
+"""
+
+"""Imports"""
+import json
+import os
+import sys
+from typing import Dict, Generator, List, Optional
+
+import scitex
+import requests
+
+from ._BaseGenAI import BaseGenAI
+
+"""Warnings"""
+# scitex.pd.ignore_SettingWithCopyWarning()
+# warnings.simplefilter("ignore", UserWarning)
+# with warnings.catch_warnings():
+#     warnings.simplefilter("ignore", UserWarning)
+
+"""Parameters"""
+# from scitex.io import load_configs
+# CONFIG = load_configs()
+
+"""Functions & Classes"""
+from openai import OpenAI as _OpenAI
+
+"""Functions & Classes"""
+
+
+class DeepSeek(BaseGenAI):
+    def __init__(
+        self,
+        system_setting="",
+        model="deepseek-chat",
+        api_key="",
+        stream=False,
+        seed=None,
+        n_keep=1,
+        temperature=1.0,
+        chat_history=None,
+        max_tokens=4096,
+    ):
+        super().__init__(
+            system_setting=system_setting,
+            model=model,
+            api_key=api_key,
+            stream=stream,
+            n_keep=n_keep,
+            temperature=temperature,
+            provider="DeepSeek",
+            chat_history=chat_history,
+            max_tokens=max_tokens,
+        )
+
+    def _init_client(self):
+        # client = _OpenAI(api_key=self.api_key, base_url="https://api.deepseek.com")
+        client = _OpenAI(api_key=self.api_key, base_url="https://api.deepseek.com/beta")
+
+        return client
+
+    def _api_call_static(self):
+        kwargs = dict(
+            model=self.model,
+            messages=self.history,
+            seed=self.seed,
+            stream=False,
+            temperature=self.temperature,
+            max_tokens=self.max_tokens,
+        )
+
+        output = self.client.chat.completions.create(**kwargs)
+        self.input_tokens += output.usage.prompt_tokens
+        self.output_tokens += output.usage.completion_tokens
+
+        out_text = output.choices[0].message.content
+
+        return out_text
+
+    def _api_call_stream(self):
+        kwargs = dict(
+            model=self.model,
+            messages=self.history,
+            max_tokens=self.max_tokens,
+            n=1,
+            stream=self.stream,
+            seed=self.seed,
+            temperature=self.temperature,
+        )
+
+        stream = self.client.chat.completions.create(**kwargs)
+        buffer = ""
+
+        for chunk in stream:
+            if chunk:
+                try:
+                    self.input_tokens += chunk.usage.prompt_tokens
+                except:
+                    pass
+                try:
+                    self.output_tokens += chunk.usage.completion_tokens
+                except:
+                    pass
+
+                try:
+                    current_text = chunk.choices[0].delta.content
+                    if current_text:
+                        buffer += current_text
+                        if any(char in ".!?\n " for char in current_text):
+                            yield buffer
+                            buffer = ""
+                except Exception as e:
+                    pass
+
+        if buffer:
+            yield buffer
+
+
+if __name__ == "__main__":
+    # -----------------------------------
+    # Initiatialization of scitex format
+    # -----------------------------------
+    import sys
+
+    import matplotlib.pyplot as plt
+
+    # Configurations
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(
+        sys,
+        plt,
+        verbose=False,
+        agg=True,
+        # sdir_suffix="",
+    )
+
+    # # Argument parser
+    # script_mode = scitex.gen.is_script()
+    # import argparse
+    # parser = argparse.ArgumentParser(description='')
+    # parser.add_argument('--var', '-v', type=int, choices=None, default=1, help='(default: %%(default)s)')
+    # parser.add_argument('--flag', '-f', action='store_true', default=False, help='(default: %%(default)s)')
+    # args = parser.parse_args()
+    # scitex.gen.print_block(args, c='yellow')
+
+    # -----------------------------------
+    # Main
+    # -----------------------------------
+    exit_status = main()
+
+    # -----------------------------------
+    # Cleanup scitex format
+    # -----------------------------------
+    scitex.gen.close(
+        CONFIG,
+        verbose=False,
+        notify=False,
+        message="",
+        exit_status=exit_status,
+    )
+
+# EOF

scitex/ai/_gen_ai/_Google.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-02-06 13:47:23 (ywatanabe)"
+# File: _Google.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/ai/_gen_ai/_Google.py"
+
+
+"""
+Functionality:
+    - Implements Google's Generative AI (Gemini) interface
+    - Handles both streaming and static text generation
+Input:
+    - User prompts and chat history
+    - Model configurations and API credentials
+Output:
+    - Generated text responses from Gemini models
+    - Token usage statistics
+Prerequisites:
+    - Google API key (GOOGLE_API_KEY environment variable)
+    - google.generativeai package
+"""
+
+"""Imports"""
+import os
+import sys
+from pprint import pprint
+from typing import Any, Dict, Generator, List, Optional
+
+import matplotlib.pyplot as plt
+import scitex
+
+try:
+    from google import genai
+except ImportError:
+    genai = None
+
+from ._BaseGenAI import BaseGenAI
+
+"""Functions & Classes"""
+
+
+class Google(BaseGenAI):
+    def __init__(
+        self,
+        system_setting: str = "",
+        api_key: Optional[str] = os.getenv("GOOGLE_API_KEY"),
+        model: str = "gemini-1.5-pro-latest",
+        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: int = 32_768,
+    ) -> None:
+
+        api_key = api_key or os.getenv("GOOGLE_API_KEY")
+
+        if not api_key:
+            raise ValueError("GOOGLE_API_KEY environment variable not set")
+
+        super().__init__(
+            system_setting=system_setting,
+            model=model,
+            api_key=api_key,
+            stream=stream,
+            seed=seed,
+            n_keep=n_keep,
+            temperature=temperature,
+            provider="Google",
+            chat_history=chat_history,
+            max_tokens=max_tokens,
+        )
+
+    def _init_client(self) -> Any:
+        return genai.Client(api_key=self.api_key)
+
+    def _api_call_static(self) -> str:
+        response = self.client.models.generate_content(
+            model=self.model, contents=self.history
+        )
+
+        try:
+            self.input_tokens += response.usage_metadata.prompt_token_count
+            self.output_tokens += response.usage_metadata.candidates_token_count
+        except:
+            pass
+
+        return response.text
+
+    def _api_call_stream(self) -> Generator[str, None, None]:
+        # print("========================================")
+        # pprint(self.history)
+        # print("========================================")
+
+        # return self.client.models.generate_content_stream(
+        #     model=self.model, contents=self.history
+        # )
+
+        for chunk in self.client.models.generate_content_stream(
+            model=self.model, contents=self.history
+        ):
+            if chunk:
+                try:
+                    self.input_tokens += chunk.usage_metadata.prompt_token_count
+                    self.output_tokens += chunk.usage_metadata.candidates_token_count
+                except:
+                    pass
+
+                yield chunk.text
+
+    def _api_format_history(
+        self, history: List[Dict[str, str]]
+    ) -> List[Dict[str, str]]:
+        """Formats the chat history for the Google Generative AI API."""
+        formatted_history = []
+        for item in history:
+            if isinstance(item.get("parts"), list):
+                # Rename role from assistant to model
+                if item.get("role") == "assistant":
+                    item["role"] = "model"
+                formatted_history.append(item)
+            else:
+                formatted_history.append(
+                    {
+                        "role": item["role"],
+                        "parts": [{"text": item["content"]}],
+                    }
+                )
+        # print(formatted_history)
+        return formatted_history
+
+
+def main() -> None:
+    ai = scitex.ai.GenAI(
+        # "gemini-2.0-flash-exp",
+        # "gemini-2.0-flash",
+        # "gemini-2.0-flash-lite-preview-02-05",
+        # "gemini-2.0-pro-exp-02-05",
+        "gemini-2.0-flash-thinking-exp-01-21",
+        stream=True,
+        n_keep=10,
+    )
+    print(ai("hi"))
+    print(ai("My name is Yusuke"))
+    print(ai("do you remember my name?"))
+
+
+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)
+
+
+"""
+python src/scitex/ai/_gen_ai/_Google.py
+python -m src.scitex.ai._gen_ai._Google
+"""
+
+
+# EOF

scitex/ai/_gen_ai/_Groq.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-28 02:47:54 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/ai/_gen_ai/_Groq.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/ai/_gen_ai/_Groq.py"
+
+"""
+Functionality:
+    - Implements GLOQ AI interface
+    - Handles both streaming and static text generation
+Input:
+    - User prompts and chat history
+    - Model configurations and API credentials
+Output:
+    - Generated text responses
+    - Token usage statistics
+Prerequisites:
+    - GLOQ API key (GLOQ_API_KEY environment variable)
+    - gloq package
+"""
+
+"""Imports"""
+import os
+import sys
+from typing import Any, Dict, Generator, List, Optional, Union
+
+from groq import Groq as _Groq
+import matplotlib.pyplot as plt
+
+from ._BaseGenAI import BaseGenAI
+
+"""Functions & Classes"""
+
+
+class Groq(BaseGenAI):
+    def __init__(
+        self,
+        system_setting: str = "",
+        api_key: Optional[str] = os.getenv("GROQ_API_KEY"),
+        model: str = "llama3-8b-8192",
+        stream: bool = False,
+        seed: Optional[int] = None,
+        n_keep: int = 1,
+        temperature: float = 0.5,
+        chat_history: Optional[List[Dict[str, str]]] = None,
+        max_tokens: int = 8000,
+    ) -> None:
+        max_tokens = min(max_tokens, 8000)
+        if not api_key:
+            raise ValueError("GROQ_API_KEY environment variable not set")
+
+        super().__init__(
+            system_setting=system_setting,
+            model=model,
+            api_key=api_key,
+            stream=stream,
+            n_keep=n_keep,
+            temperature=temperature,
+            provider="Groq",
+            chat_history=chat_history,
+            max_tokens=max_tokens,
+        )
+
+    def _init_client(self) -> Any:
+        return _Groq(api_key=self.api_key)
+
+    def _api_call_static(self) -> str:
+        output = self.client.chat.completions.create(
+            model=self.model,
+            messages=self.history,
+            temperature=self.temperature,
+            max_tokens=self.max_tokens,
+            stream=False,
+        )
+        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,
+            temperature=self.temperature,
+            max_tokens=self.max_tokens,
+            stream=True,
+        )
+
+        for chunk in stream:
+            if chunk.choices[0].delta.content:
+                yield chunk.choices[0].delta.content
+
+
+# EOF

scitex/ai/_gen_ai/_Llama.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-05 21:11:08 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/ai/_gen_ai/_Llama.py
+
+"""Imports"""
+import os
+import sys
+from typing import List, Optional
+
+import matplotlib.pyplot as plt
+import scitex
+
+try:
+    from llama import Dialog
+    from llama import Llama as _Llama
+except:
+    pass
+
+from ._BaseGenAI import BaseGenAI
+
+"""Functions & Classes"""
+
+
+def print_envs():
+    settings = {
+        "MASTER_ADDR": os.getenv("MASTER_ADDR", "localhost"),
+        "MASTER_PORT": os.getenv("MASTER_PORT", "12355"),
+        "WORLD_SIZE": os.getenv("WORLD_SIZE", "1"),
+        "RANK": os.getenv("RANK", "0"),
+    }
+
+    print("Environment Variable Settings:")
+    for key, value in settings.items():
+        print(f"{key}: {value}")
+    print()
+
+
+class Llama(BaseGenAI):
+    def __init__(
+        self,
+        ckpt_dir: str = "",
+        tokenizer_path: str = "",
+        system_setting: str = "",
+        model: str = "Meta-Llama-3-8B",
+        max_seq_len: int = 32_768,
+        max_batch_size: int = 4,
+        max_gen_len: Optional[int] = None,
+        stream: bool = False,
+        seed: Optional[int] = None,
+        n_keep: int = 1,
+        temperature: float = 1.0,
+        provider="Llama",
+        chat_history=None,
+        **kwargs,
+    ):
+
+        # Configure environment variables
+        os.environ["MASTER_ADDR"] = os.getenv("MASTER_ADDR", "localhost")
+        os.environ["MASTER_PORT"] = os.getenv("MASTER_PORT", "12355")
+        os.environ["WORLD_SIZE"] = os.getenv("WORLD_SIZE", "1")
+        os.environ["RANK"] = os.getenv("RANK", "0")
+        print_envs()
+
+        self.ckpt_dir = ckpt_dir if ckpt_dir else f"Meta-{model}/"
+        self.tokenizer_path = (
+            tokenizer_path if tokenizer_path else f"./Meta-{model}/tokenizer.model"
+        )
+        self.max_seq_len = max_seq_len
+        self.max_batch_size = max_batch_size
+        self.max_gen_len = max_gen_len
+
+        super().__init__(
+            system_setting=system_setting,
+            model=model,
+            api_key="",
+            stream=stream,
+            seed=seed,
+            n_keep=n_keep,
+            temperature=temperature,
+            chat_history=chat_history,
+        )
+
+    def __str__(self):
+        return "Llama"
+
+    def _init_client(self):
+        generator = _Llama.build(
+            ckpt_dir=self.ckpt_dir,
+            tokenizer_path=self.tokenizer_path,
+            max_seq_len=self.max_seq_len,
+            max_batch_size=self.max_batch_size,
+        )
+        return generator
+
+    def _api_call_static(self):
+        dialogs: List[Dialog] = [self.history]
+        results = self.client.chat_completion(
+            dialogs,
+            max_gen_len=self.max_gen_len,
+            temperature=self.temperature,
+            top_p=0.9,
+        )
+        out_text = results[0]["generation"]["content"]
+        return out_text
+
+    def _api_call_stream(self):
+        # Llama3 doesn't have built-in streaming, so we'll simulate it
+        full_response = self._api_call_static()
+        for char in full_response:
+            yield char
+
+    # def _get_available_models(self):
+    #     # Llama3 doesn't have a list of available models, so we'll return a placeholder
+    #     return ["llama3"]
+
+    def verify_model(self):
+        # Llama3 doesn't require model verification, so we'll skip it
+        pass
+
+
+def main():
+    m = Llama(
+        ckpt_dir="/path/to/checkpoint",
+        tokenizer_path="/path/to/tokenizer",
+        system_setting="You are a helpful assistant.",
+        max_seq_len=512,
+        max_batch_size=4,
+        stream=True,
+        temperature=0.7,
+    )
+    m("Hi")
+    pass
+
+
+if __name__ == "__main__":
+    # 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