py-adtools 0.1.4__tar.gz → 0.1.8__tar.gz

{py_adtools-0.1.4 → py_adtools-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-adtools
-Version: 0.1.4
+Version: 0.1.8
 Summary: Useful tools for parsing and evaluating Python programs for LLM-based algorithm design.
 Home-page: https://github.com/RayZhhh/py-adtools
 Author: Rui Zhang
@@ -13,6 +13,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: psutil
+Requires-Dist: openai
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{py_adtools-0.1.4 → py_adtools-0.1.8}/adtools/evaluator.py

@@ -8,10 +8,12 @@ Commercial use of this software or its derivatives requires prior written permis
 import multiprocessing
 import os
 import sys
+import time
 from abc import ABC, abstractmethod
 from queue import Empty
-from typing import Any, Literal, Dict, Callable, List
+from typing import Any, Literal, Dict, Callable, List, Tuple
 import psutil
+import traceback
 
 from .py_code import PyProgram
 
@@ -21,6 +23,7 @@ class PyEvaluator(ABC):
     def __init__(
             self,
             exec_code: bool = True,
+            find_and_kill_children_evaluation_process: bool = False,
             debug_mode: bool = False,
             *,
             join_timeout_seconds: int = 10
@@ -32,11 +35,15 @@ class PyEvaluator(ABC):
                 which will be passed to 'self.evaluate_program()'. Set this parameter to 'False' if you are going to
                 evaluate a Python scripy. Note that if the parameter is set to 'False', the arguments 'callable_...'
                 in 'self.evaluate_program()' will no longer be affective.
+            find_and_kill_children_evaluation_process: If using 'self.secure_evaluate', kill children processes
+                when they are terminated. Note that it is suggested to set to 'False' if the evaluation process
+                does not start new processes.
             debug_mode: Debug mode.
             join_timeout_seconds: Timeout in seconds to wait for the process to finish. Kill the process if timeout.
         """
         self.debug_mode = debug_mode
         self.exec_code = exec_code
+        self.find_and_kill_children_evaluation_process = find_and_kill_children_evaluation_process
         self.join_timeout_seconds = join_timeout_seconds
 
     @abstractmethod
@@ -65,11 +72,14 @@ class PyEvaluator(ABC):
         )
 
     def _kill_process_and_its_children(self, process: multiprocessing.Process):
-        # Find all children processes
-        try:
-            parent = psutil.Process(process.pid)
-            children_processes = parent.children(recursive=True)
-        except psutil.NoSuchProcess:
+        if self.find_and_kill_children_evaluation_process:
+            # Find all children processes
+            try:
+                parent = psutil.Process(process.pid)
+                children_processes = parent.children(recursive=True)
+            except psutil.NoSuchProcess:
+                children_processes = []
+        else:
             children_processes = []
         # Terminate parent process
         process.terminate()
@@ -124,7 +134,7 @@ class PyEvaluator(ABC):
             return res
         except Exception as e:
             if self.debug_mode:
-                print(e)
+                print(traceback.format_exc())
             return None
 
     def _evaluate_in_safe_process(
@@ -150,8 +160,9 @@ class PyEvaluator(ABC):
             timeout_seconds: int | float = None,
             redirect_to_devnull: bool = False,
             multiprocessing_start_method: Literal['default', 'auto', 'fork', 'spawn'] = 'auto',
+            get_evaluate_time=False,
             **kwargs
-    ):
+    ) -> Any | Tuple[Any, float]:
         """Evaluate program in a new process. This enables timeout restriction and output redirection.
         Args:
             program: the program to be evaluated.
@@ -160,7 +171,11 @@ class PyEvaluator(ABC):
             multiprocessing_start_method: start a process using 'fork' or 'spawn'. If set to 'auto',
                 the process will be started using 'fork' with Linux/macOS and 'spawn' with Windows.
                 If set to 'default', there will be no changes to system default.
+            get_evaluate_time: get evaluation time for this program.
             **kwargs: additional keyword arguments to pass to 'evaluate_program'.
+        Returns:
+            Returns the evaluation results. If the 'get_evaluate_time' is True,
+            the return value will be (Results, Time).
         """
         if multiprocessing_start_method == 'auto':
             # Force macOS and Linux use 'fork' to generate new process
@@ -179,33 +194,43 @@ class PyEvaluator(ABC):
                 args=(str(program), result_queue, redirect_to_devnull),
                 kwargs=kwargs,
             )
+            evaluate_start_time = time.time()
             process.start()
 
             if timeout_seconds is not None:
                 try:
                     # Get the result in timeout seconds
                     result = result_queue.get(timeout=timeout_seconds)
+                    # Calculate the evaluate time
+                    eval_time = time.time() - evaluate_start_time
                     # After getting the result, terminate/kill the process
                     self._kill_process_and_its_children(process)
                 except Empty:  # The queue is empty indicates a timeout
+                    # Calculate the evaluate time
+                    eval_time = time.time() - evaluate_start_time
                     if self.debug_mode:
                         print(f'DEBUG: the evaluation time exceeds {timeout_seconds}s.')
                     # Terminate/kill all processes if timeout happens
                     self._kill_process_and_its_children(process)
                     result = None
                 except Exception as e:
+                    # Calculate the evaluate time
+                    eval_time = time.time() - evaluate_start_time
                     if self.debug_mode:
-                        print(f'DEBUG: evaluation failed with exception:\n{e}')
+                        print(f'DEBUG: evaluation failed with exception:\n{traceback.format_exc()}')
                     # Terminate/kill all processes if meet exceptions
                     self._kill_process_and_its_children(process)
                     result = None
             else:
                 # If there is no timeout limit, wait execution to finish
                 result = result_queue.get()
+                # Calculate the evaluate time
+                eval_time = time.time() - evaluate_start_time
                 # Terminate/kill all processes after evaluation
                 self._kill_process_and_its_children(process)
-            return result
+
+            return (result, eval_time) if get_evaluate_time else result
         except Exception as e:
             if self.debug_mode:
-                print(e)
+                print(traceback.format_exc())
             return None

{py_adtools-0.1.4 → py_adtools-0.1.8}/adtools/evaluator_pool.py

@@ -62,21 +62,23 @@ class EvaluatorExecutorPool:
             program: the program to be evaluated.
             timeout_seconds: return 'None' if the execution time exceeds 'timeout_seconds'.
             redirect_to_devnull: redirect any output to '/dev/null'.
-            multiprocessing_start_method: start a process using 'fork' or 'spawn'.
+            multiprocessing_start_method: start a process using 'fork' or 'spawn'. If set to 'auto',
+                the process will be started using 'fork' with Linux/macOS and 'spawn' with Windows.
+                If set to 'default', there will be no changes to system default.
+            return_time: get evaluation time for this program.
             **kwargs: additional keyword arguments to pass to 'evaluate_program'.
+        Returns:
+            Returns the evaluation results. If the 'get_evaluate_time' is True,
+            the return value will be (Results, Time).
         """
-        start_time = time.time()
         future = self.pool.submit(
             self.evaluator.secure_evaluate,
             program,
             timeout_seconds,
             redirect_to_devnull,
             multiprocessing_start_method,
+            return_time,
             **kwargs
         )
         res = future.result()
-        duration = time.time() - start_time
-        if return_time:
-            return res, duration
-        else:
-            return res
+        return res

py_adtools-0.1.8/adtools/lm/__init__.py

@@ -0,0 +1,6 @@
+try:
+    import openai
+except ImportError:
+    raise ImportError('Python package "openai" is not installed.')
+
+from .lm_base import LanguageModel

py_adtools-0.1.8/adtools/lm/lm_base.py

@@ -0,0 +1,39 @@
+"""
+Copyright (c) 2025 Rui Zhang <rzhang.cs@gmail.com>
+
+NOTICE: This code is under MIT license. This code is intended for academic/research purposes only.
+Commercial use of this software or its derivatives requires prior written permission.
+"""
+
+from abc import abstractmethod
+from typing import List
+
+import openai.types.chat
+
+
+class LanguageModel:
+    """Base class for language model interface."""
+
+    @abstractmethod
+    def chat_completion(
+            self,
+            message: str | List[openai.types.chat.ChatCompletionMessageParam],
+            max_tokens: int,
+            timeout_seconds: float,
+            *args,
+            **kwargs
+    ):
+        """Send a chat completion query with OpenAI format to the vLLM server. Return the response content.
+        Args:
+            message: The message in str or openai format.
+            max_tokens: The maximum number of tokens to generate.
+            timeout_seconds: The timeout seconds.
+        """
+        pass
+
+    def close(self):
+        """Release resources (if necessary)."""
+        pass
+
+    def __del__(self):
+        self.close()

py_adtools-0.1.8/adtools/lm/openai_api.py

@@ -0,0 +1,72 @@
+"""
+Copyright (c) 2025 Rui Zhang <rzhang.cs@gmail.com>
+
+NOTICE: This code is under MIT license. This code is intended for academic/research purposes only.
+Commercial use of this software or its derivatives requires prior written permission.
+"""
+
+import os
+from typing import List
+
+import openai.types.chat
+
+from .lm_base import LanguageModel
+
+
+class OpenAIAPI(LanguageModel):
+    def __init__(
+            self,
+            model: str,
+            base_url: str = None,
+            api_key: str = None,
+            **openai_init_kwargs
+    ):
+        super().__init__()
+        # If base_url is set to None, find 'OPENAI_BASE_URL' in environment variables
+        if base_url is None:
+            if 'OPENAI_BASE_URL' not in os.environ:
+                raise RuntimeError('If "base_url" is None, the environment variable OPENAI_BASE_URL must be set.')
+            else:
+                base_url = os.environ['OPENAI_BASE_URL']
+
+        # If api_key is set to None, find 'OPENAI_API_KEY' in environment variables
+        if api_key is None:
+            if 'OPENAI_API_KEY' not in os.environ:
+                raise RuntimeError('If "api_key" is None, OPENAI_API_KEY must be set.')
+            else:
+                api_key = os.environ['OPENAI_API_KEY']
+
+        self._model = model
+        self._client = openai.OpenAI(
+            api_key=api_key,
+            base_url=base_url,
+            **openai_init_kwargs
+        )
+
+    def chat_completion(
+            self,
+            message: str | List[openai.types.chat.ChatCompletionMessageParam],
+            max_tokens: int,
+            timeout_seconds: float,
+            *args,
+            **kwargs
+    ):
+        """Send a chat completion query with OpenAI format to the vLLM server. Return the response content.
+        Args:
+            message: The message in str or openai format.
+            max_tokens: The maximum number of tokens to generate.
+            timeout_seconds: The timeout seconds.
+        """
+        if isinstance(message, str):
+            message = [{'role': 'user', 'content': message.strip()}]
+
+        response = self._client.chat.completions.create(
+            model=self._model,
+            messages=message,
+            stream=False,
+            max_tokens=max_tokens,
+            timeout=timeout_seconds,
+            *args,
+            **kwargs,
+        )
+        return response.choices[0].message.content

py_adtools-0.1.4/adtools/lm_base.py → py_adtools-0.1.8/adtools/lm/vllm_server.py

@@ -5,103 +5,27 @@ NOTICE: This code is under MIT license. This code is intended for academic/resea
 Commercial use of this software or its derivatives requires prior written permission.
 """
 
-from abc import abstractmethod
+try:
+    import vllm
+except ImportError:
+    raise ImportError('Python package "vllm" is not installed.')
+
+try:
+    import requests
+except ImportError:
+    raise ImportError('Python package "requests" is not installed.')
+
 from typing import Optional, List, Literal, Dict, Any
 import os
 import subprocess
 import sys
 from pathlib import Path
 import psutil
-import requests
 import time
 
 import openai.types.chat
 
-__all__ = ['LanguageModel', 'OpenAIAPI', 'VLLMServer']
-
-
-class LanguageModel:
-    """Base class for language model interface."""
-
-    @abstractmethod
-    def chat_completion(
-            self,
-            message: str | List[openai.types.chat.ChatCompletionMessageParam],
-            max_tokens: int,
-            timeout_seconds: float,
-            *args,
-            **kwargs
-    ):
-        """Send a chat completion query with OpenAI format to the vLLM server. Return the response content.
-        Args:
-            message: The message in str or openai format.
-            max_tokens: The maximum number of tokens to generate.
-            timeout_seconds: The timeout seconds.
-        """
-        pass
-
-    def close(self):
-        """Release resources (if necessary)."""
-        pass
-
-
-class OpenAIAPI(LanguageModel):
-    def __init__(
-            self,
-            model: str,
-            base_url: str = None,
-            api_key: str = None,
-            **openai_init_kwargs
-    ):
-        super().__init__()
-        # If base_url is set to None, find 'OPENAI_BASE_URL' in environment variables
-        if base_url is None:
-            if 'OPENAI_BASE_URL' not in os.environ:
-                raise RuntimeError('If "base_url" is None, the environment variable OPENAI_BASE_URL must be set.')
-            else:
-                base_url = os.environ['OPENAI_BASE_URL']
-
-        # If api_key is set to None, find 'OPENAI_API_KEY' in environment variables
-        if api_key is None:
-            if 'OPENAI_API_KEY' not in os.environ:
-                raise RuntimeError('If "api_key" is None, OPENAI_API_KEY must be set.')
-            else:
-                api_key = os.environ['OPENAI_API_KEY']
-
-        self._model = model
-        self._client = openai.OpenAI(
-            api_key=api_key,
-            base_url=base_url,
-            **openai_init_kwargs
-        )
-
-    def chat_completion(
-            self,
-            message: str | List[openai.types.chat.ChatCompletionMessageParam],
-            max_tokens: int,
-            timeout_seconds: float,
-            *args,
-            **kwargs
-    ):
-        """Send a chat completion query with OpenAI format to the vLLM server. Return the response content.
-        Args:
-            message: The message in str or openai format.
-            max_tokens: The maximum number of tokens to generate.
-            timeout_seconds: The timeout seconds.
-        """
-        if isinstance(message, str):
-            message = [{'role': 'user', 'content': message.strip()}]
-
-        response = self._client.chat.completions.create(
-            model=self._model,
-            messages=message,
-            stream=False,
-            max_tokens=max_tokens,
-            timeout=timeout_seconds,
-            *args,
-            **kwargs,
-        )
-        return response.choices[0].message.content
+from .lm_base import LanguageModel
 
 
 def _print_cmd_list(cmd_list, gpus, host, port):
@@ -115,24 +39,26 @@ def _print_cmd_list(cmd_list, gpus, host, port):
     print('=' * 80 + '\n', flush=True)
 
 
-class VLLMServer:
-    def __init__(self,
-                 model_path: str,
-                 port: int,
-                 gpus: int | list[int],
-                 tokenizer_path: Optional[str] = None,
-                 max_model_len: int = 16384,
-                 max_lora_rank: Optional[int] = None,
-                 host: str = '0.0.0.0',
-                 mem_util: float = 0.85,
-                 deploy_timeout_seconds: int = 600,
-                 enforce_eager: bool = False,
-                 vllm_log_level: Literal['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'] = 'INFO',
-                 silent_mode: bool = False,
-                 env_variable_dict: Optional[Dict[str, str]] = None,
-                 vllm_serve_args: Optional[List[str]] = None,
-                 vllm_serve_kwargs: Optional[Dict[str, str]] = None,
-                 chat_template_kwargs: Optional[Dict[str, Any]] = None):
+class VLLMServer(LanguageModel):
+    def __init__(
+            self,
+            model_path: str,
+            port: int,
+            gpus: int | list[int],
+            tokenizer_path: Optional[str] = None,
+            max_model_len: int = 16384,
+            max_lora_rank: Optional[int] = None,
+            host: str = '0.0.0.0',
+            mem_util: float = 0.85,
+            deploy_timeout_seconds: int = 600,
+            enforce_eager: bool = False,
+            vllm_log_level: Literal['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'] = 'INFO',
+            silent_mode: bool = False,
+            env_variable_dict: Optional[Dict[str, str]] = None,
+            vllm_serve_args: Optional[List[str]] = None,
+            vllm_serve_kwargs: Optional[Dict[str, str]] = None,
+            chat_template_kwargs: Optional[Dict[str, Any]] = None
+    ):
         """Deploy an LLM on specified GPUs.
         Args:
             model_path: Path to the model to deploy.
@@ -234,8 +160,8 @@ class VLLMServer:
         env['CUDA_VISIBLE_DEVICES'] = gpus
         env['VLLM_LOGGING_LEVEL'] = self._vllm_log_level
 
-        # FIXME: These code are required for my machine :-(
-        # FIXME: This may due to the bad NCCL environment configuration :-(
+        # FIXME: These code are required for my machine :(
+        # FIXME: This may due to the bad NCCL configuration :(
         if isinstance(self._gpus, list) and len(self._gpus) > 1:
             # set NCCL environment variable
             env['NCCL_P2P_DISABLE'] = '1'
@@ -352,24 +278,26 @@ class VLLMServer:
                     print(f'[vLLM] Failed to load LoRA adapter. '
                           f'Status code: {response.status_code}, Response: {response.text}')
                 return True
-            except requests.exceptions.RequestException as e:
+            except requests.exceptions.RequestException:
                 continue
 
-        print(f'[vLLM] Error loading LoRA adapter: {str(e)}')
+        print(f'[vLLM] Error loading LoRA adapter.')
         return False
 
     def close(self):
         """Shut down vLLM server and kill all vLLM processes."""
         self._kill_vllm_process()
 
-    def chat_completion(self,
-                        message: str | List[openai.types.chat.ChatCompletionMessageParam],
-                        max_tokens: Optional[int] = None,
-                        timeout_seconds: Optional[int] = None,
-                        lora_name: Optional[str] = None,
-                        temperature: float = 0.9,
-                        top_p: float = 0.9,
-                        chat_template_kwargs: Optional[Dict[str, Any]] = None) -> str:
+    def chat_completion(
+            self,
+            message: str | List[openai.types.chat.ChatCompletionMessageParam],
+            max_tokens: Optional[int] = None,
+            timeout_seconds: Optional[int] = None,
+            lora_name: Optional[str] = None,
+            temperature: float = 0.9,
+            top_p: float = 0.9,
+            chat_template_kwargs: Optional[Dict[str, Any]] = None
+    ) -> str:
         """Send a chat completion query with OpenAI format to the vLLM server. Return the response content.
         Args:
             message: The message in str or openai format.

{py_adtools-0.1.4 → py_adtools-0.1.8}/py_adtools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-adtools
-Version: 0.1.4
+Version: 0.1.8
 Summary: Useful tools for parsing and evaluating Python programs for LLM-based algorithm design.
 Home-page: https://github.com/RayZhhh/py-adtools
 Author: Rui Zhang
@@ -13,6 +13,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: psutil
+Requires-Dist: openai
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{py_adtools-0.1.4 → py_adtools-0.1.8}/py_adtools.egg-info/SOURCES.txt

@@ -4,8 +4,11 @@ setup.py
 adtools/__init__.py
 adtools/evaluator.py
 adtools/evaluator_pool.py
-adtools/lm_base.py
 adtools/py_code.py
+adtools/lm/__init__.py
+adtools/lm/lm_base.py
+adtools/lm/openai_api.py
+adtools/lm/vllm_server.py
 py_adtools.egg-info/PKG-INFO
 py_adtools.egg-info/SOURCES.txt
 py_adtools.egg-info/dependency_links.txt

{py_adtools-0.1.4 → py_adtools-0.1.8}/py_adtools.egg-info/requires.txt

@@ -1 +1,2 @@
 psutil
+openai

{py_adtools-0.1.4 → py_adtools-0.1.8}/setup.py

@@ -5,14 +5,14 @@ with open('README.md', 'r', encoding='utf-8') as fh:
 
 setup(
     name='py-adtools',
-    version='0.1.4',
+    version='0.1.8',
     author='Rui Zhang',
     author_email='rzhang.cs@gmail.com',
     description='Useful tools for parsing and evaluating Python programs for LLM-based algorithm design.',
     long_description=long_description,
     long_description_content_type='text/markdown',
     url='https://github.com/RayZhhh/py-adtools',
-    packages=['adtools'],
+    packages=find_packages(),
     classifiers=[
         'Programming Language :: Python :: 3',
         'Operating System :: OS Independent',
@@ -20,5 +20,5 @@ setup(
         'Topic :: Scientific/Engineering',
     ],
     python_requires='>=3.10',
-    install_requires=['psutil'],
+    install_requires=['psutil', 'openai'],
 )