src/Shared/Infrastructure/ChatGpt/ChatGptService.php line 10

Open in your IDE?
  1. <?php
  3. namespace App\Shared\Infrastructure\ChatGpt;
  5. class ChatGptService
  6. {
  7.     private $cache=[];
  9.     public function __construct(private array $apiKeys, private $cacheDir) {
  10.         $this->cache = @unserialize(@file_get_contents($this->cacheDir."/chatGpt.cache"))??[];
  11.     }
  13.     private function setCache($prompt, $response){
  14.         $md5 = md5($prompt);
  15.         $this->cache[$md5] = $response;
  17.         file_put_contents($this->cacheDir."/chatGpt.cache", serialize($this->cache));
  18.     }
  20.     private function getCache($prompt){
  21.         $md5 = md5($prompt);
  22.         if (isset($this->cache[$md5])) return $this->cache[$md5];
  24.        return false;
  25.     }
  28.     public function __invoke($prompt, $isJsonReponse = false)
  29.     {
  30.         if ($this->getCache($prompt)) {
  31.             return $this->getCache($prompt);
  32.         }
  34.         $apiKeys = $this->apiKeys;
  36.         $data = trim($prompt) ;
  37.         $dataFile = tempnam($this->cacheDir, 'data_') . '.txt';
  38.         file_put_contents($dataFile, $data);
  40.         $pythonScript = <<<EOF
  41. import sys
  42. import json
  43. import openai
  44. import traceback
  45. import time
  46. import os
  47. import tempfile
  49. # Lista de claves API pasadas desde PHP
  50. api_keys = sys.argv[4].split(',')
  51. cache_dir = sys.argv[5]
  52. index_file = os.path.join(cache_dir, 'gpt_api_key_index.txt')
  53. backoff_file = os.path.join(cache_dir, 'api_key_backoff.txt')
  55. def read_backoff_times():
  56.     if os.path.exists(backoff_file):
  57.         with open(backoff_file, 'r') as file:
  58.             return json.load(file)
  59.     return {}
  61. def write_backoff_times(backoff_data):
  62.     with open(backoff_file, 'w') as file:
  63.         json.dump(backoff_data, file)
  65. def get_next_api_key():
  66.     backoff_data = read_backoff_times()
  67.     if os.path.exists(index_file):
  68.         with open(index_file, 'r') as f:
  69.             counter = int(f.read().strip())
  70.     else:
  71.         counter = -1
  73.     while True:
  74.         counter = (counter + 1) % len(api_keys)
  75.         current_key_index = str(counter)
  76.         if current_key_index in backoff_data and time.time() < backoff_data[current_key_index]:
  77.             continue
  78.         with open(index_file, 'w') as f:
  79.             f.write(str(counter))
  80.         return api_keys[counter]
  82. def api_call(data_file, output_file="response.txt", error_file="error.txt"):
  83.     with open(data_file, 'r') as file:
  84.         content = file.read()
  86.     backoff_data = read_backoff_times()
  87.     initial_backoff = 1
  88.     print(f"Data file: {data_file}\\n")
  89.     print(f"Output file {output_file}\\n")
  90.     print(f"Error file {error_file}\\n")
  92.     while True:
  93.         try:
  94.             api_key = get_next_api_key()
  95.             openai.api_key = api_key
  96.             print(f"API Key: {api_key}")
  97.             print(f"Content: {content}")
  99.             print("Trying to generate response...\\n")
  100.             sys.executable = '/usr/bin/python3'
  101.             print(f"sys.executable: {sys.executable}\\n")
  102.             response = openai.ChatCompletion.create(
  103.                 model="gpt-3.5-turbo",
  104.                 messages=[
  105.                     {"role": "system", "content": "You are a helpful assistant."},
  106.                     {"role": "user", "content": content}
  107.                 ],
  108.                 temperature=0.7
  109.             )
  110.             print("Response success\\n")
  112.             with open(output_file, "w") as file:
  113.                 file.write(response['choices'][0]['message']['content'].strip())
  114.             print("Response written to file successfully\\n")
  115.             break
  117.         except openai.error.RateLimitError as e:
  118.             current_key_index = str(api_keys.index(api_key))
  119.             print(f"Rate limit exceeded for API key {api_key}.")
  120.             next_backoff = min(initial_backoff * 2, 3600)
  121.             backoff_data[current_key_index] = time.time() + next_backoff
  122.             write_backoff_times(backoff_data)
  123.             initial_backoff = next_backoff
  125.         except Exception as e:
  126.             print(f"Unhandled exception: {e}")
  127.             error_details = f"{str(e)}\\n{traceback.format_exc()}"
  128.             with open(error_file, "w") as file:
  129.                 file.write(error_details)
  130.             break
  131.             
  132. if __name__ == "__main__":
  133.     data_file = sys.argv[1]
  134.     output_file = sys.argv[2] if len(sys.argv) > 2 else "response.txt"
  135.     error_file = sys.argv[3] if len(sys.argv) > 3 else "error.txt"
  136.     api_call(data_file, output_file=output_file, error_file=error_file)
  138. EOF;
  139.         $response = '';
  140.         $attempt = 0;
  141.         $maxAttempts = 5;
  142.         $error = "";
  144.         while ($attempt < $maxAttempts && empty($response)) {
  145.             $outputFile = tempnam($this->cacheDir, 'gpt_response_') . '.txt';
  146.             $errorFile = tempnam($this->cacheDir, 'gpt_error_') . '.txt';
  147.             $tempName = tempnam($this->cacheDir, 'py');
  148.             file_put_contents($tempName, $pythonScript);
  150.             $apiKeysString = implode(',', $apiKeys);
  151.             $command = escapeshellcmd("python3 " . $tempName . " " . escapeshellarg($dataFile) . " " . escapeshellarg($outputFile) . " " . escapeshellarg($errorFile) . " " . escapeshellarg($apiKeysString)." " . escapeshellarg($this->cacheDir));
  152.             $output = shell_exec($command);
  154.             if (file_exists($outputFile)) {
  155.                 $response = trim(file_get_contents($outputFile));
  156.                 unlink($tempName);
  157.                 unlink($outputFile);
  158.                 unlink($errorFile);
  159.             } else {
  160.                 $error .= $output. " ".file_get_contents($errorFile).PHP_EOL;
  161.             }
  163.             unlink($errorFile);
  164.             unlink($outputFile);
  166.             if ($isJsonReponse) {
  167.                 if (json_decode($response, true)) {
  168.                     $response = json_decode($response, true);
  169.                 }
  170.                 else {
  171.                     $isMatch = preg_match("/(?<json>[\[{].*?[}\]])/ms", $response, $mt);
  173.                     if ($isMatch && isset($mt['json'])) {
  174.                         $response = json_decode($mt['json'], true);
  175.                     }
  176.                     else $response = null;
  177.                 }
  178.             }
  180.             $attempt++;
  181.         }
  183.         if (!$response) throw new \Exception("CHATGPT: ".$error);
  185.         unlink($dataFile);
  186.         $this->setCache($prompt, $response);
  188.         return $response;
  189.     }
  190. }