File size: 4,321 Bytes
6c50d1f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 | import os
import threading
import time
from dataclasses import dataclass
from dotenv import load_dotenv
from openai import OpenAI
from autoresttest.config import get_config
from autoresttest.prompts.system_prompts import DEFAULT_SYSTEM_MESSAGE
from autoresttest.utils import encode_dictionary
CONFIG = get_config()
load_dotenv()
@dataclass
class TokenCounter:
input_tokens: int = 0
output_tokens: int = 0
class LanguageModel:
input_tokens = 0
output_tokens = 0
cache = {}
# Thread-safety locks for parallel value generation
_cache_lock = threading.RLock()
_token_lock = threading.RLock()
@staticmethod
def get_tokens() -> TokenCounter:
return TokenCounter(
input_tokens=LanguageModel.input_tokens,
output_tokens=LanguageModel.output_tokens,
)
def __init__(
self,
engine=CONFIG.openai_llm_engine,
temperature=CONFIG.creative_temperature,
max_tokens=CONFIG.llm_max_tokens,
):
self.api_key = os.getenv("API_KEY")
if self.api_key is None or self.api_key.strip() == "":
raise ValueError(
"API key is required for OpenAI language model, found None or empty string."
)
self.client = OpenAI(api_key=self.api_key, base_url=CONFIG.llm_api_base)
self.engine = engine
self.temperature = temperature
self.max_tokens = max_tokens
def _generate_cache_key(self, user_message, system_message, json_mode):
key_data = {
"user_message": user_message,
"system_message": system_message,
"json_mode": json_mode,
"engine": self.engine,
"temperature": self.temperature,
"max_tokens": self.max_tokens,
}
return encode_dictionary(key_data)
def query(
self, user_message, system_message=DEFAULT_SYSTEM_MESSAGE, json_mode=False
) -> str:
cache_key = self._generate_cache_key(user_message, system_message, json_mode)
# Thread-safe cache read
with LanguageModel._cache_lock:
if cache_key in LanguageModel.cache:
return LanguageModel.cache[cache_key]
messages = [
{"role": "system", "content": system_message},
{"role": "user", "content": user_message},
]
kwargs = {
"model": self.engine,
"messages": messages,
"temperature": self.temperature,
}
if self.max_tokens != -1:
kwargs["max_tokens"] = self.max_tokens
if json_mode:
kwargs["response_format"] = {"type": "json_object"}
max_retries = 3
base_delay = 1.0
for attempt in range(max_retries):
try:
response = self.client.chat.completions.create(**kwargs)
break
except Exception:
if attempt < max_retries - 1:
delay = base_delay * (2**attempt)
# print(
# f"[LLM] API call failed (attempt {attempt + 1}/{max_retries}): {type(e).__name__}: {e}"
# )
# print(f"[LLM] Retrying in {delay}s...")
time.sleep(delay)
else:
# print(
# f"[LLM] API call failed after {max_retries} attempts: {type(e).__name__}: {e}"
# )
return ""
input_tokens = 0
output_tokens = 0
if response.usage is not None:
input_tokens = getattr(response.usage, "prompt_tokens", 0) or 0
output_tokens = getattr(response.usage, "completion_tokens", 0) or 0
# print(f"[LLM] Input tokens: {input_tokens}, Output tokens: {output_tokens}")
# Thread-safe token updates
with LanguageModel._token_lock:
LanguageModel.input_tokens += input_tokens
LanguageModel.output_tokens += output_tokens
if not response.choices:
return ""
content = response.choices[0].message.content
result = content.strip() if content else ""
# Thread-safe cache write
with LanguageModel._cache_lock:
LanguageModel.cache[cache_key] = result
return result
|