gpt-batch 0.1.6__tar.gz → 0.1.9__tar.gz

{gpt_batch-0.1.6 → gpt_batch-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gpt_batch
-Version: 0.1.6
+Version: 0.1.9
 Summary: A package for batch processing with OpenAI API.
 Home-page: https://github.com/fengsxy/gpt_batch
 Author: Ted Yu
@@ -9,7 +9,6 @@ License: UNKNOWN
 Platform: UNKNOWN
 Description-Content-Type: text/markdown
 
-Certainly! Here's a clean and comprehensive README for your `GPTBatcher` tool, formatted in Markdown:
 
 ```markdown
 # GPT Batcher
@@ -60,6 +59,22 @@ print(result)
 # Expected output: ["embedding_1", "embedding_2", "embedding_3", "embedding_4"]
 ```
 
+### Handling Message Lists with different API
+
+This example demonstrates how to send a list of questions and receive answers with different api:
+
+```python
+from gpt_batch.batcher import GPTBatcher
+
+# Initialize the batcher
+batcher = GPTBatcher(api_key='sk-', model_name='deepseek-chat',api_base_url="https://api.deepseek.com/v1")
+
+
+# Send a list of messages and receive answers
+result = batcher.handle_message_list(['question_1', 'question_2', 'question_3', 'question_4'])
+
+# Expected output: ["answer_1", "answer_2", "answer_3", "answer_4"]
+```
 ## Configuration
 
 The `GPTBatcher` class can be customized with several parameters to adjust its performance and behavior:

{gpt_batch-0.1.6 → gpt_batch-0.1.9}/README.md

@@ -1,4 +1,3 @@
-Certainly! Here's a clean and comprehensive README for your `GPTBatcher` tool, formatted in Markdown:
 
 ```markdown
 # GPT Batcher
@@ -49,6 +48,22 @@ print(result)
 # Expected output: ["embedding_1", "embedding_2", "embedding_3", "embedding_4"]
 ```
 
+### Handling Message Lists with different API
+
+This example demonstrates how to send a list of questions and receive answers with different api:
+
+```python
+from gpt_batch.batcher import GPTBatcher
+
+# Initialize the batcher
+batcher = GPTBatcher(api_key='sk-', model_name='deepseek-chat',api_base_url="https://api.deepseek.com/v1")
+
+
+# Send a list of messages and receive answers
+result = batcher.handle_message_list(['question_1', 'question_2', 'question_3', 'question_4'])
+
+# Expected output: ["answer_1", "answer_2", "answer_3", "answer_4"]
+```
 ## Configuration
 
 The `GPTBatcher` class can be customized with several parameters to adjust its performance and behavior:

gpt_batch-0.1.9/gpt_batch/batcher.py

@@ -0,0 +1,203 @@
+from openai import OpenAI
+import anthropic
+from concurrent.futures import ThreadPoolExecutor, wait
+from functools import partial
+from tqdm import tqdm
+import re
+
+class GPTBatcher:
+    """
+    A class to handle batching and sending requests to the OpenAI GPT model and Anthropic Claude models efficiently.
+
+    Attributes:
+        client: The client instance to communicate with the API (OpenAI or Anthropic).
+        is_claude (bool): Flag to indicate if using a Claude model.
+        model_name (str): The name of the model to be used. Default is 'gpt-3.5-turbo-0125'.
+        system_prompt (str): Initial prompt or context to be used with the model. Default is an empty string.
+        temperature (float): Controls the randomness of the model's responses. Higher values lead to more diverse outputs. Default is 1.
+        num_workers (int): Number of worker threads used for handling concurrent requests. Default is 64.
+        timeout_duration (int): Maximum time (in seconds) to wait for a response from the API before timing out. Default is 60 seconds.
+        retry_attempts (int): Number of retries if a request fails. Default is 2.
+        miss_index (list): Tracks the indices of requests that failed to process correctly.
+    """
+    def __init__(self, api_key, model_name="gpt-3.5-turbo-0125", system_prompt="",temperature=1,num_workers=64,timeout_duration=60,retry_attempts=2,api_base_url=None,**kwargs):
+        
+        self.is_claude = bool(re.search(r'claude', model_name, re.IGNORECASE))
+        
+        if self.is_claude:
+            self.client = anthropic.Anthropic(api_key=api_key)
+            # Anthropic doesn't support custom base URL the same way
+            # If needed, this could be implemented differently
+        else:
+            self.client = OpenAI(api_key=api_key)
+            if api_base_url:
+                self.client.base_url = api_base_url
+        
+        self.model_name = model_name
+        self.system_prompt = system_prompt
+        self.temperature = temperature
+        self.num_workers = num_workers
+        self.timeout_duration = timeout_duration
+        self.retry_attempts = retry_attempts
+        self.miss_index = []
+        self.extra_params = kwargs 
+
+    def get_attitude(self, ask_text):
+        index, ask_text = ask_text
+        try:
+            if self.is_claude:
+                # Use the Anthropic Claude API
+                message = self.client.messages.create(
+                    model=self.model_name,
+                    max_tokens=1024,  # You can make this configurable if needed
+                    messages=[
+                        {"role": "user", "content": ask_text}
+                    ],
+                    system=self.system_prompt if self.system_prompt else None,
+                    temperature=self.temperature,
+                    **self.extra_params
+                )
+                return (index, message.content[0].text)
+            else:
+                # Use the OpenAI API as before
+                completion = self.client.chat.completions.create(
+                    model=self.model_name,
+                    messages=[
+                        {"role": "system", "content": self.system_prompt},
+                        {"role": "user", "content": ask_text}
+                    ],
+                    temperature=self.temperature,
+                    **self.extra_params
+                )
+                return (index, completion.choices[0].message.content)
+        except Exception as e:
+            print(f"Error occurred: {e}")
+            self.miss_index.append(index)
+            return (index, None)
+
+    def process_attitude(self, message_list):
+        new_list = []
+        num_workers = self.num_workers
+        timeout_duration = self.timeout_duration
+        retry_attempts = self.retry_attempts
+    
+        executor = ThreadPoolExecutor(max_workers=num_workers)
+        message_chunks = list(self.chunk_list(message_list, num_workers))
+        try:
+            for chunk in tqdm(message_chunks, desc="Processing messages"):
+                future_to_message = {executor.submit(self.get_attitude, message): message for message in chunk}
+                for _ in range(retry_attempts):
+                    done, not_done = wait(future_to_message.keys(), timeout=timeout_duration)
+                    for future in not_done:
+                        future.cancel()
+                    new_list.extend(future.result() for future in done if future.done())
+                    if len(not_done) == 0:
+                        break
+                    future_to_message = {executor.submit(self.get_attitude, future_to_message[future]): future_to_message[future] for future in not_done}
+        except Exception as e:
+            print(f"Error occurred: {e}")
+        finally:
+            executor.shutdown(wait=False)
+            return new_list
+
+    def complete_attitude_list(self, attitude_list, max_length):
+        completed_list = []
+        current_index = 0
+        for item in attitude_list:
+            index, value = item
+            # Fill in missing indices
+            while current_index < index:
+                completed_list.append((current_index, None))
+                current_index += 1
+            # Add the current element from the list
+            completed_list.append(item)
+            current_index = index + 1
+        while current_index < max_length:
+            print("Filling in missing index", current_index)
+            self.miss_index.append(current_index)
+            completed_list.append((current_index, None))
+            current_index += 1
+        return completed_list
+
+    def chunk_list(self, lst, n):
+        """Yield successive n-sized chunks from lst."""
+        for i in range(0, len(lst), n):
+            yield lst[i:i + n]
+
+    def handle_message_list(self, message_list):
+        indexed_list = [(index, data) for index, data in enumerate(message_list)]
+        max_length = len(indexed_list)
+        attitude_list = self.process_attitude(indexed_list)
+        attitude_list.sort(key=lambda x: x[0])
+        attitude_list = self.complete_attitude_list(attitude_list, max_length)
+        attitude_list = [x[1] for x in attitude_list]
+        return attitude_list
+    
+    def get_embedding(self, text):
+        index, text = text
+        try:
+            if self.is_claude:
+                # Use Anthropic's embedding API if available
+                # Note: As of March 2025, make sure to check Anthropic's latest API
+                # for embeddings, as the format might have changed
+                response = self.client.embeddings.create(
+                    model=self.model_name,
+                    input=text
+                )
+                return (index, response.embedding)
+            else:
+                # Use OpenAI's embedding API
+                response = self.client.embeddings.create(
+                    input=text,
+                    model=self.model_name
+                )
+                return (index, response.data[0].embedding)
+        except Exception as e:
+            print(f"Error getting embedding: {e}")
+            self.miss_index.append(index)
+            return (index, None)
+    
+    def process_embedding(self, message_list):
+        new_list = []
+        executor = ThreadPoolExecutor(max_workers=self.num_workers)
+        # Split message_list into chunks
+        message_chunks = list(self.chunk_list(message_list, self.num_workers))
+        fixed_get_embedding = partial(self.get_embedding)
+        for chunk in tqdm(message_chunks, desc="Processing messages"):
+            future_to_message = {executor.submit(fixed_get_embedding, message): message for message in chunk}
+            for i in range(self.retry_attempts):
+                done, not_done = wait(future_to_message.keys(), timeout=self.timeout_duration)
+                for future in not_done:
+                    future.cancel()
+                new_list.extend(future.result() for future in done if future.done())
+                if len(not_done) == 0:
+                    break
+                future_to_message = {executor.submit(fixed_get_embedding, future_to_message[future]): future_to_message[future] for future in not_done}
+        executor.shutdown(wait=False)
+        return new_list
+
+    def handle_embedding_list(self, message_list):
+        indexed_list = [(index, data) for index, data in enumerate(message_list)]
+        max_length = len(indexed_list)
+        attitude_list = self.process_embedding(indexed_list)
+        attitude_list.sort(key=lambda x: x[0])
+        attitude_list = self.complete_attitude_list(attitude_list, max_length)
+        attitude_list = [x[1] for x in attitude_list]
+        return attitude_list
+    
+    def get_miss_index(self):
+        return self.miss_index
+
+# Example usage:
+if __name__ == "__main__":
+    # For OpenAI
+    openai_batcher = GPTBatcher(
+        api_key="your_openai_api_key",
+        model_name="gpt-4-turbo"
+    )
+    
+    # For Claude
+    claude_batcher = GPTBatcher(
+        api_key="your_anthropic_api_key",
+        model_name="claude-3-7-sonnet-20250219"
+    )

{gpt_batch-0.1.6 → gpt_batch-0.1.9}/gpt_batch.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gpt-batch
-Version: 0.1.6
+Version: 0.1.9
 Summary: A package for batch processing with OpenAI API.
 Home-page: https://github.com/fengsxy/gpt_batch
 Author: Ted Yu
@@ -9,7 +9,6 @@ License: UNKNOWN
 Platform: UNKNOWN
 Description-Content-Type: text/markdown
 
-Certainly! Here's a clean and comprehensive README for your `GPTBatcher` tool, formatted in Markdown:
 
 ```markdown
 # GPT Batcher
@@ -60,6 +59,22 @@ print(result)
 # Expected output: ["embedding_1", "embedding_2", "embedding_3", "embedding_4"]
 ```
 
+### Handling Message Lists with different API
+
+This example demonstrates how to send a list of questions and receive answers with different api:
+
+```python
+from gpt_batch.batcher import GPTBatcher
+
+# Initialize the batcher
+batcher = GPTBatcher(api_key='sk-', model_name='deepseek-chat',api_base_url="https://api.deepseek.com/v1")
+
+
+# Send a list of messages and receive answers
+result = batcher.handle_message_list(['question_1', 'question_2', 'question_3', 'question_4'])
+
+# Expected output: ["answer_1", "answer_2", "answer_3", "answer_4"]
+```
 ## Configuration
 
 The `GPTBatcher` class can be customized with several parameters to adjust its performance and behavior:

{gpt_batch-0.1.6 → gpt_batch-0.1.9}/gpt_batch.egg-info/requires.txt

@@ -1,2 +1,3 @@
 openai
 tqdm
+anthropic

{gpt_batch-0.1.6 → gpt_batch-0.1.9}/setup.py

@@ -2,10 +2,10 @@ from setuptools import setup, find_packages
 
 setup(
     name='gpt_batch',
-    version='0.1.6',
+    version='0.1.9',
     packages=find_packages(),
     install_requires=[
-        'openai', 'tqdm'
+        'openai', 'tqdm','anthropic'
     ],
     author='Ted Yu',
     author_email='liddlerain@gmail.com',

{gpt_batch-0.1.6 → gpt_batch-0.1.9}/tests/test_batcher.py

@@ -18,6 +18,27 @@ def test_handle_message_list():
     assert len(results) == 2, "There should be two results, one for each message"
     assert all(len(result) >= 2 for result in results), "Each result should be at least two elements"
 
+
+def test_json_format():
+    import json
+    # Initialize the GPTBatcher with hypothetical valid credentials
+    #api_key = #get from system environment
+    api_key = os.getenv('TEST_KEY')
+    if not api_key:
+        raise ValueError("API key must be set in the environment variables")
+    batcher = GPTBatcher(api_key=api_key, model_name='gpt-3.5-turbo-1106', system_prompt="Your task is to discuss privacy questions and provide persuasive answers with supporting reasons.",response_format={ "type": "json_object" })
+    message_list = ["return me a random json object", "return me a random json object"]
+
+    # Call the method under test
+    results = batcher.handle_message_list(message_list)
+    # Assertions to verify the length of the results and the structure of each item
+    assert len(results) == 2, "There should be two results, one for each message"
+    assert all(len(result) >= 2 for result in results), "Each result should be at least two elements"
+    #assert all(isinstance(result, dict) and 'json' in result for result in results), "Each result should be a JSON object with 'json' key"
+    assert all(isinstance(json.loads(result), dict) for result in results), "Each result should be a JSON object with 'json' key"
+
+
+
 def test_handle_embedding_list():
     # Initialize the GPTBatcher with hypothetical valid credentials
     #api_key = #get from system environment
@@ -51,5 +72,27 @@ def test_get_miss_index():
     miss_index = batcher.get_miss_index()
     assert miss_index == [], "The miss index should be empty"
 # Optionally, you can add a test configuration if you have specific needs
+
+
+def test_claude_handle_message_list():
+    # Initialize the GPTBatcher with Claude model
+    api_key = os.getenv('ANTHROPIC_API_KEY')
+    if not api_key:
+        raise ValueError("Anthropic API key must be set in the environment variables as ANTHROPIC_API_KEY")
+    
+    batcher = GPTBatcher(
+        api_key=api_key, 
+        model_name='claude-3-7-sonnet-20250219', 
+        system_prompt="Your task is to discuss privacy questions and provide persuasive answers with supporting reasons."
+    )
+    message_list = ["I think privacy is important", "I don't think privacy is important"]
+
+    # Call the method under test
+    results = batcher.handle_message_list(message_list)
+
+    # Assertions to verify the length of the results and the structure of each item
+    assert len(results) == 2, "There should be two results, one for each message"
+    assert all(isinstance(result, str) and len(result) > 0 for result in results if result is not None), "Each result should be a non-empty string if not None"
+    assert batcher.is_claude, "Should recognize model as Claude"
 if __name__ == "__main__":
     pytest.main()

gpt_batch-0.1.6/gpt_batch/batcher.py

@@ -1,156 +0,0 @@
-from openai import OpenAI
-from concurrent.futures import ThreadPoolExecutor, wait
-from functools import partial
-from tqdm import tqdm
-
-class GPTBatcher:
-    """
-    A class to handle batching and sending requests to the OpenAI GPT model efficiently.
-
-    Attributes:
-        client (OpenAI): The client instance to communicate with the OpenAI API using the provided API key.
-        model_name (str): The name of the GPT model to be used. Default is 'gpt-3.5-turbo-0125'.
-        system_prompt (str): Initial prompt or context to be used with the model. Default is an empty string.
-        temperature (float): Controls the randomness of the model's responses. Higher values lead to more diverse outputs. Default is 1.
-        num_workers (int): Number of worker threads used for handling concurrent requests. Default is 64.
-        timeout_duration (int): Maximum time (in seconds) to wait for a response from the API before timing out. Default is 60 seconds.
-        retry_attempts (int): Number of retries if a request fails. Default is 2.
-        miss_index (list): Tracks the indices of requests that failed to process correctly.
-
-    Parameters:
-        api_key (str): API key for authenticating requests to the OpenAI API.
-        model_name (str, optional): Specifies the GPT model version. Default is 'gpt-3.5-turbo-0125'.
-        system_prompt (str, optional): Initial text or question to seed the model with. Default is empty.
-        temperature (float, optional): Sets the creativity of the responses. Default is 1.
-        num_workers (int, optional): Number of parallel workers for request handling. Default is 64.
-        timeout_duration (int, optional): Timeout for API responses in seconds. Default is 60.
-        retry_attempts (int, optional): How many times to retry a failed request. Default is 2.
-    """
-
-    def __init__(self, api_key, model_name="gpt-3.5-turbo-0125", system_prompt="",temperature=1,num_workers=64,timeout_duration=60,retry_attempts=2,api_base_url=None):
-        
-        self.client = OpenAI(api_key=api_key)
-        self.model_name = model_name
-        self.system_prompt = system_prompt
-        self.temperature = temperature
-        self.num_workers = num_workers
-        self.timeout_duration = timeout_duration
-        self.retry_attempts = retry_attempts
-        self.miss_index =[]
-        if api_base_url:
-            self.client.base_url = api_base_url
-
-    def get_attitude(self, ask_text):
-        index, ask_text = ask_text
-        try:
-            completion = self.client.chat.completions.create(
-                model=self.model_name,
-                messages=[
-                    {"role": "system", "content": self.system_prompt},
-                    {"role": "user", "content": ask_text}
-                ],
-                temperature=self.temperature,
-            )
-            return (index, completion.choices[0].message.content)
-        except Exception as e:
-            print(f"Error occurred: {e}")
-            self.miss_index.append(index)
-            return (index, None)
-
-    def process_attitude(self, message_list):
-        new_list = []
-        num_workers = self.num_workers
-        timeout_duration = self.timeout_duration
-        retry_attempts = 2
-    
-        executor = ThreadPoolExecutor(max_workers=num_workers)
-        message_chunks = list(self.chunk_list(message_list, num_workers))
-        try:
-            for chunk in tqdm(message_chunks, desc="Processing messages"):
-                future_to_message = {executor.submit(self.get_attitude, message): message for message in chunk}
-                for _ in range(retry_attempts):
-                    done, not_done = wait(future_to_message.keys(), timeout=timeout_duration)
-                    for future in not_done:
-                        future.cancel()
-                    new_list.extend(future.result() for future in done if future.done())
-                    if len(not_done) == 0:
-                        break
-                    future_to_message = {executor.submit(self.get_attitude, future_to_message[future]): future for future in not_done}
-        except Exception as e:
-            print(f"Error occurred: {e}")
-        finally:
-            executor.shutdown(wait=False)
-            return new_list
-
-    def complete_attitude_list(self,attitude_list, max_length):
-        completed_list = []
-        current_index = 0
-        for item in attitude_list:
-            index, value = item
-            # Fill in missing indices
-            while current_index < index:
-                completed_list.append((current_index, None))
-                current_index += 1
-            # Add the current element from the list
-            completed_list.append(item)
-            current_index = index + 1
-        while current_index < max_length:
-            print("Filling in missing index", current_index)
-            self.miss_index.append(current_index)
-            completed_list.append((current_index, None))
-            current_index += 1
-        return completed_list
-
-    def chunk_list(self, lst, n):
-        """Yield successive n-sized chunks from lst."""
-        for i in range(0, len(lst), n):
-            yield lst[i:i + n]
-
-    def handle_message_list(self,message_list):
-        indexed_list = [(index, data) for index, data in enumerate(message_list)]
-        max_length = len(indexed_list)
-        attitude_list = self.process_attitude(indexed_list)
-        attitude_list.sort(key=lambda x: x[0])
-        attitude_list = self.complete_attitude_list(attitude_list, max_length)
-        attitude_list = [x[1] for x in attitude_list]
-        return attitude_list
-    
-    def process_embedding(self,message_list):
-            new_list = []
-            executor = ThreadPoolExecutor(max_workers=self.num_workers)
-            # Split message_list into chunks
-            message_chunks = list(self.chunk_list(message_list, self.num_workers))
-            fixed_get_embedding = partial(self.get_embedding)
-            for chunk in tqdm(message_chunks, desc="Processing messages"):
-                future_to_message = {executor.submit(fixed_get_embedding, message): message for message in chunk}
-                for i in range(self.retry_attempts):
-                    done, not_done = wait(future_to_message.keys(), timeout=self.timeout_duration)
-                    for future in not_done:
-                        future.cancel()
-                    new_list.extend(future.result() for future in done if future.done())
-                    if len(not_done) == 0:
-                        break
-                    future_to_message = {executor.submit(fixed_get_embedding, future_to_message[future]): future_to_message[future] for future in not_done}
-            executor.shutdown(wait=False)
-            return new_list
-    def get_embedding(self,text):
-        index,text = text
-        response = self.client.embeddings.create(
-        input=text,
-        model=self.model_name)
-        return (index,response.data[0].embedding)
-
-    def handle_embedding_list(self,message_list):
-        indexed_list = [(index, data) for index, data in enumerate(message_list)]
-        max_length = len(indexed_list)
-        attitude_list = self.process_embedding(indexed_list)
-        attitude_list.sort(key=lambda x: x[0])
-        attitude_list = self.complete_attitude_list(attitude_list, max_length)
-        attitude_list = [x[1] for x in attitude_list]
-        return attitude_list
-    
-    def get_miss_index(self):
-        return self.miss_index
-
-    # Add other necessary methods similar to the above, refactored to fit within this class structure.
-