Ok, now let's take a closer look to find out why t...

Ok, now let's take a closer look to find out why this version of pP4DArgosTranslate.dpr (the older one):

text
program pP4DArgosTranslate;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  System.SysUtils,
  System.Diagnostics,
  Windows,
  PythonEngine,
  VarPyth,
  System.Classes,
  System.IOUtils, // For TDirectory, TPath
  System.Net.HttpClient, // For IHTTPResponse
  System.Net.URLClient, // For URL Client
  System.Net.HttpClientComponent, // For TNetHTTPClient
  System.Zip; // For TZipFile

var
  PythonEngine: TPythonEngine;
  PythonModule: TPythonModule; // Use TPythonModule for better structure
  PythonHome: string;
  PyFuncTranslate: PPyObject; // Keep reference to the translation function

const
  // Initialization script (initialization.py)
  EmbeddedPythonScriptInit: string = '# initialization.py' + sLineBreak +
    'import ctranslate2' + sLineBreak + 'import sentencepiece as spm' +
    sLineBreak + 'from sacremoses.normalize import MosesPunctNormalizer' +
    sLineBreak + 'import os' + sLineBreak + 'import logging' + sLineBreak + '' +
    sLineBreak + 'logging.basicConfig(level=logging.WARNING)' + sLineBreak +
    'logger = logging.getLogger(__name__)' + sLineBreak + '' + sLineBreak +
    '# --- Initialization Logic ---' + sLineBreak +
    'def init_translator(source_lang, target_lang):' + sLineBreak +
    '    global normalizer, sp_processor, translator, MODEL_DIRECTORY, SP_MODEL_FILE'
    + sLineBreak + '' + sLineBreak +
    '    MODEL_NAME = f"translate-{source_lang}_{target_lang}-1_0"' + sLineBreak
    + '    EXTRACT_FOLDER = "argos_models"' + sLineBreak + '    ' + sLineBreak +
    '    # --- Dynamically find the model directory (same as before) ---' +
    sLineBreak +
    '    extracted_folder_path = os.path.join(EXTRACT_FOLDER, f"{MODEL_NAME}_extracted")'
    + sLineBreak +
    '    subfolders = [f for f in os.listdir(extracted_folder_path) if os.path.isdir(os.path.join(extracted_folder_path, f))]'
    + sLineBreak + '    if not subfolders:' + sLineBreak +
    '        raise FileNotFoundError(f"No subfolders found in {extracted_folder_path}.")'
    + sLineBreak + '    if len(subfolders) > 1:' + sLineBreak +
    '        logger.warning(f"Multiple subfolders found in {extracted_folder_path}. Using the first one: {subfolders[0]}.")'
    + sLineBreak + '    model_subfolder_name = subfolders[0]' + sLineBreak +
    '    MODEL_DIRECTORY = os.path.join(extracted_folder_path, model_subfolder_name, "model")'
    + sLineBreak +
    '    SP_MODEL_FILE = os.path.join(extracted_folder_path, model_subfolder_name, "sentencepiece.model")'
    + sLineBreak + '    # --- End dynamic model directory finding ---' +
    sLineBreak + '' + sLineBreak +
    '    normalizer = MosesPunctNormalizer(lang=source_lang)' + sLineBreak +
    '    sp_processor = spm.SentencePieceProcessor(model_file=SP_MODEL_FILE)' +
    sLineBreak +
    '    translator = ctranslate2.Translator(MODEL_DIRECTORY, device="cpu")' +
    sLineBreak +
    '    logger.info(f"Argos Translate components initialized for {{source_lang}}->{{target_lang}}.")'
    + sLineBreak;

  // Optimized translation script (translation_optimized.py) - Now RETURNS a LIST
  EmbeddedPythonScriptTranslateOptimized: string = '# translation_optimized.py'
    + sLineBreak + 'import logging' + sLineBreak + '' + sLineBreak +
    'logger = logging.getLogger(__name__)' + sLineBreak + '' + sLineBreak +
    'def perform_translation_optimized(texts_to_translate):' + sLineBreak +
  // Accepts a LIST of texts
    '    """Translates a LIST of texts using pre-initialized Argos Translate components."""'
    + sLineBreak + '    global normalizer, sp_processor, translator' +
    sLineBreak + '    translated_texts = []' + sLineBreak +
  // Initialize a list to store results
    '    for text_to_translate in texts_to_translate:' + sLineBreak +
  // Iterate through the list
    '        try:' + sLineBreak +
    '            normalized_text = normalizer.normalize(text_to_translate)' +
    sLineBreak +
    '            tokens = sp_processor.encode(normalized_text, out_type=str)' +
    sLineBreak +
    '            translation_result = translator.translate_batch([tokens], beam_size=1)'
    + sLineBreak +
    '            translated_tokens = translation_result[0].hypotheses[0]' +
    sLineBreak +
    '            translated_text = sp_processor.decode(translated_tokens)' +
    sLineBreak + '            translated_texts.append(translated_text)' +
    sLineBreak + // Add to result list
    '        except Exception as e:' + sLineBreak +
    '            translated_texts.append(f"Translation Error: {{str(e)}}")' +
    sLineBreak + // Add error to result list
    '    return translated_texts' + sLineBreak;
  // Return the ENTIRE list of translated texts

  // --- Function to Check and Create Model Directory ---
function CheckAndCreateModelDirectory(SourceLang, TargetLang: string): Boolean;
var
  AppPath: string;
  ExtractFolder: string;
begin
  // 1. Get the application's directory.
  AppPath := ExtractFilePath(ParamStr(0));

  // 2. Check/create the "argos_models" directory.
  ExtractFolder := TPath.Combine(AppPath, 'argos_models');
  if not TDirectory.Exists(ExtractFolder) then
  begin
    try
      TDirectory.CreateDirectory(ExtractFolder);
      Result := False; // Indicate that the main folder did not exist.
    except
      on E: Exception do
      begin
        Writeln('Error creating argos_models directory: ', E.Message);
        Result := False; // Indicate failure
        Exit;
      end;
    end;
  end
  else
    Result := False; // Initially assume model is not installed

end;

// --- Function to Download a File ---
function DownloadFile(const AURL, AFilename: string): Boolean;
var
  HttpClient: TNetHTTPClient;
  Response: IHTTPResponse;
  FileStream: TFileStream;
begin
  Result := False;
  HttpClient := TNetHTTPClient.Create(nil);
  try
    // Set the User-Agent header to mimic a browser.  THIS IS CRUCIAL.
    HttpClient.UserAgent :=
      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3';
    try
      Response := HttpClient.Get(AURL);
      if Response.StatusCode = 200 then
      begin
        FileStream := TFileStream.Create(AFilename, fmCreate);
        // Use TFileStream
        try
          FileStream.CopyFrom(Response.ContentStream, 0); // Use CopyFrom
          Result := True;
        finally
          FileStream.Free;
        end;
      end
      else
      begin
        Writeln('HTTP Error: ', Response.StatusCode, ' - ',
          Response.StatusText);
        Exit; // Add exit here
      end;
    except
      on E: Exception do
      begin
        Writeln('Error downloading file: ', E.Message);
        Exit; // Add exit here also
      end;
    end;
  finally
    HttpClient.Free;
  end;
end;

// --- Function to Extract a Zip File ---
procedure ExtractZipFile(const AZipFile, ADestinationDir: string);
var
  ZipFile: TZipFile;
  ExtractPath: string;
begin
  ZipFile := TZipFile.Create;
  try
    ZipFile.Open(AZipFile, zmRead);
    try
      // Create the _extracted folder
      ExtractPath := TPath.Combine(ADestinationDir,
        TPath.GetFileNameWithoutExtension(AZipFile) + '_extracted');
      if not TDirectory.Exists(ExtractPath) then
        TDirectory.CreateDirectory(ExtractPath);

      // Extract to the _extracted folder
      ZipFile.ExtractAll(ExtractPath);
    finally
      ZipFile.Close;
    end;
  except
    on E: Exception do
    begin
      Writeln('Error extracting zip file: ', E.Message);
      // Consider deleting the partially extracted folder here in case of an error
    end;
  end;
end;

// --- CUDA Setup (Ideally, do this only ONCE per application run) ---
procedure SetupCUDAEnvironment;
var
  OldPath: string;
begin
  SetEnvironmentVariable('CUDA_PATH',
    'C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.4');
  OldPath := GetEnvironmentVariable('PATH');
  SetEnvironmentVariable('PATH',
    PChar(OldPath +
    ';C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.4\bin' +
    ';C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.4\libnvvp'));

  // These loads might not be necessary, depending on how ctranslate2 is set up.
  // They *are* necessary if you want to force loading of specific DLLs.
  LoadLibrary
    (PChar('C:\Users\user\AppData\Local\Programs\Python\Python39\lib\site-packages\torch\lib\cudnn_graph64_9.dll')
    );
  LoadLibrary
    (PChar('C:\Users\user\AppData\Local\Programs\Python\Python39\lib\site-packages\ctranslate2\ctranslate2.dll')
    );
  LoadLibrary
    (PChar('C:\Windows\system32\DriverStore\FileRepository\nvdmui.inf_amd64_fdc98cdf10f69918\nvcuda64.dll')
    );
end;

procedure InitializeCUDAContext(PythonEngine: TPythonEngine);
begin
  PythonEngine.ExecString(AnsiString('import torch;' + sLineBreak +
    'torch.cuda.init();' + sLineBreak +
    'print("CUDA Device:", torch.cuda.get_device_name(0))' + sLineBreak));
  PythonEngine.CheckError; // Always check for errors after Python calls
end;

// Dummy function, just to demonstrate the pattern.  Not actually used.
function DoNothing(Self, Args: PPyObject): PPyObject; cdecl;
begin
  Result := GetPythonEngine.ReturnNone;
end;

procedure CreatePyEngine(SourceLang, TargetLang: string);
var
  PyArgs: PPyObject;
  PyInitFunc: PPyObject;
  PyMainModule: PPyObject; // Hold a reference to __main__
  ModelName: string; // Store Model Name
  DownloadURL: string; // Store the download URL
  DownloadPath: string; // Store the download Path
begin
  PythonEngine := TPythonEngine.Create(nil);
  PythonEngine.Name := 'PythonEngine';
  PythonEngine.DllName :=
    'C:\Users\user\AppData\Local\Programs\Python\Python39\python39.dll';
  // Your path here
  PythonHome := 'C:\Users\user\AppData\Local\Programs\Python\Python39';
  // Your path here
  PythonEngine.SetPythonHome(PWideChar(PythonHome));
  PythonEngine.LoadDll;

  // Create the module *before* running any scripts
  PythonModule := TPythonModule.Create(nil);
  PythonModule.Engine := PythonEngine;
  PythonModule.ModuleName := 'delphi_module'; // Good practice

  // Add a dummy method (optional, but good for consistency)
  // PythonModule.AddMethod('do_nothing', @DoNothing, 'A dummy method.');

  // --- 1. Execute Initialization Script ---
  PythonEngine.ExecString(PAnsiChar(AnsiString(EmbeddedPythonScriptInit)));
  PythonEngine.CheckError;

  // Get the __main__ module
  PyMainModule := PythonEngine.GetMainModule;
  if not Assigned(PyMainModule) then
    raise Exception.Create('Could not get __main__ module.');
  PythonEngine.CheckError;

  // Get the init_translator function from __main__
  PyInitFunc := PythonEngine.PyObject_GetAttrString(PyMainModule,
    'init_translator');
  if not Assigned(PyInitFunc) then
  begin
    PythonEngine.Py_XDECREF(PyMainModule); // Decref __main__
    raise Exception.Create('init_translator function not found');
  end;
  PythonEngine.CheckError;

  // Prepare arguments for init_translator
  PyArgs := PythonEngine.PyTuple_New(2);
  PythonEngine.CheckError;
  try
    PythonEngine.PyTuple_SetItem(PyArgs, 0,
      PythonEngine.PyUnicode_FromString(PAnsiChar(UTF8String(SourceLang))));
    PythonEngine.CheckError;
    PythonEngine.PyTuple_SetItem(PyArgs, 1,
      PythonEngine.PyUnicode_FromString(PAnsiChar(UTF8String(TargetLang))));
    PythonEngine.CheckError;

    // Call init_translator.  It returns None, so we don't need to manage the result.
    PythonEngine.PyObject_CallObject(PyInitFunc, PyArgs);
    PythonEngine.CheckError;
  finally
    PythonEngine.Py_XDECREF(PyArgs); // Clean up the arguments tuple
    PythonEngine.Py_XDECREF(PyInitFunc);
    // Clean up reference to the init function
  end;

  // --- 2. Load Translation Script (for later use) ---
  PythonEngine.ExecString
    (PAnsiChar(AnsiString(EmbeddedPythonScriptTranslateOptimized)));
  PythonEngine.CheckError;

  // Get a reference to the translation function.  GOOD: More descriptive name.
  PyFuncTranslate := PythonEngine.PyObject_GetAttrString(PyMainModule,
    'perform_translation_optimized'); // from __main__
  PythonEngine.Py_XDECREF(PyMainModule); // Done with __main__ module now

  if not Assigned(PyFuncTranslate) then
  begin
    raise Exception.Create
      ('Could not find perform_translation_optimized function in __main__.');
  end;
  PythonEngine.CheckError;

  // No need to initialize PythonModule here, it's done above.
end;

procedure DestroyEngine;
begin
  if Assigned(PyFuncTranslate) then
    PythonEngine.Py_XDECREF(PyFuncTranslate);
  // Clean up the function reference. ESSENTIAL.

  PythonModule.Free; // Free the module *before* the engine
  PythonEngine.Free;
end;

function CallOptimizedTranslate(const TextToTranslate: string): string;
var
  PyArgsTuple: PPyObject;
  PyTextList: PPyObject;
  PyResultList: PPyObject;
  PySingleTranslation: PPyObject;
begin
  // 1. Create a Python list containing the single text to translate
  PyTextList := PythonEngine.PyList_New(1);
  PythonEngine.CheckError;
  try
    PythonEngine.PyList_SetItem(PyTextList, 0,
      PythonEngine.PyUnicode_FromString
      (PAnsiChar(UTF8String(TextToTranslate))));
    PythonEngine.CheckError;

    // 2. Prepare arguments - now pass the list
    PyArgsTuple := PythonEngine.PyTuple_New(1);
    PythonEngine.CheckError;
    try
      PythonEngine.PyTuple_SetItem(PyArgsTuple, 0, PyTextList);
      // Pass the Python list as argument.  STEALS a reference.
      PythonEngine.CheckError;

      // 3. Call Python function.  GOOD: More descriptive name.
      PyResultList := PythonEngine.PyObject_CallObject(PyFuncTranslate,
        PyArgsTuple);
      PythonEngine.CheckError; // Check for errors *immediately* after the call
    finally
      PythonEngine.Py_XDECREF(PyArgsTuple);
      // Clean up the arguments tuple.  ESSENTIAL.
      // DO NOT DECREF PyTextList here! It was STOLEN by PyTuple_SetItem
    end;

    if not Assigned(PyResultList) then
    begin
      // Handle the case where the Python function returned None (an error occurred)
      Result := 'Error: No result returned from Python.';
      Exit; // Exit the function
    end;

    try // Add try finally for PyResultList cleanup

      // 4. Expect a Python LIST back (even if it contains only one translation)
      if not PythonEngine.PyList_Check(PyResultList) then
      begin
        Result := 'Error: Unexpected result from Python - not a list.';
        Exit; // Exit the function
      end;

      if PythonEngine.PyList_Size(PyResultList) = 0 then
      begin
        Result := 'Error: Empty result list from Python.';
        Exit; // Exit the function
      end;

      // 5. Get the string out.
      PySingleTranslation := PythonEngine.PyList_GetItem(PyResultList, 0);
      // Get the first item. NO INCREF NEEDED (borrowed reference)
      if not Assigned(PySingleTranslation) then
      begin
        Result := 'Error: could not extract translated item.';
        Exit;
      end;

      // No need to Py_INCREF PySingleTranslation - it's a BORROWED reference
      Result := UTF8ToString(PythonEngine.PyUnicode_AsUTF8(PySingleTranslation)
        ); // Extract string.  No need to DECREF the result of PyUnicode_AsUTF8
      PythonEngine.CheckError;

    finally
      PythonEngine.Py_XDECREF(PyResultList);
      // Clean up the result list. ESSENTIAL.
    end;

  finally
    // No need to clean PyTextList, reference was stolen by PyTuple_SetItem
  end;

end;

// --- Function to find the translation path (direct or pivoted) ---
function FindTranslationPath(const SourceLang, TargetLang: string;
  const ModelList: TArray < TArray < string >> ): TStringList;
var
  i, j: Integer;
begin
  Result := TStringList.Create;
  try
    // Check for direct translation
    for i := Low(ModelList) to High(ModelList) do
    begin
      if (Length(ModelList[i]) > 3) and (ModelList[i][2] = SourceLang) and
        (ModelList[i][3] = TargetLang) then
      begin
        Result.Add(Format('(%s,%s)', [SourceLang, TargetLang]));
        Exit; // Direct path found
      end;
    end;

    // Check for English pivot
    for i := Low(ModelList) to High(ModelList) do
    begin
      if (Length(ModelList[i]) > 3) and (ModelList[i][2] = SourceLang) and
        (ModelList[i][3] = 'en') then
      begin
        for j := Low(ModelList) to High(ModelList) do
        begin
          if (Length(ModelList[j]) > 3) and (ModelList[j][2] = 'en') and
            (ModelList[j][3] = TargetLang) then
          begin
            Result.Add(Format('(%s,%s)', [SourceLang, 'en']));
            Result.Add(Format('(%s,%s)', ['en', TargetLang]));
            Exit; // Indirect path found
          end;
        end;
      end;
    end;
  except
    Result.Free;
    raise;
  end;
end;

const
  ModelList: TArray < TArray < string >> = [
  // Block 1 (lines 0 to 11)
    ['Albanian', 'English', 'sq', 'en'], ['Arabic', 'English', 'ar', 'en'],
    ['Azerbaijani', 'English', 'az', 'en'], ['Basque', 'English', 'eu', 'en'],
    ['Bengali', 'English', 'bn', 'en'], ['Bulgarian', 'English', 'bg', 'en'],
    ['Catalan', 'English', 'ca', 'en'], ['Chinese (traditional)', 'English', 'zt', 'en'],
    ['Chinese', 'English', 'zh', 'en'], ['Czech', 'English', 'cs', 'en'],
    ['Danish', 'English', 'da', 'en'], ['Dutch', 'English', 'nl', 'en'],
  // Block 2 (lines 12 to 56): translations where English is the source language
    ['English', 'Albanian', 'en', 'sq'], ['English', 'Arabic', 'en', 'ar'],
    ['English', 'Azerbaijani', 'en', 'az'], ['English', 'Basque', 'en', 'eu'],
    ['English', 'Bengali', 'en', 'bn'], ['English', 'Bulgarian', 'en', 'bg'],
    ['English', 'Catalan', 'en', 'ca'], ['English', 'Chinese', 'en', 'zh'],
    ['English', 'Chinese (traditional)', 'en', 'zt'],
    ['English', 'Czech', 'en', 'cs'], ['English', 'Danish', 'en', 'da'],
    ['English', 'Dutch', 'en', 'nl'], ['English', 'Esperanto', 'en', 'eo'],
    ['English', 'Estonian', 'en', 'et'], ['English', 'Finnish', 'en', 'fi'],
    ['English', 'French', 'en', 'fr'], ['English', 'Galician', 'en', 'gl'],
    ['English', 'German', 'en', 'de'], ['English', 'Greek', 'en', 'el'],
    ['English', 'Hebrew', 'en', 'he'], ['English', 'Hindi', 'en', 'hi'],
    ['English', 'Hungarian', 'en', 'hu'], ['English', 'Indonesian', 'en', 'id'],
    ['English', 'Irish', 'en', 'ga'], ['English', 'Italian', 'en', 'it'],
    ['English', 'Japanese', 'en', 'ja'], ['English', 'Korean', 'en', 'ko'],
    ['English', 'Latvian', 'en', 'lv'], ['English', 'Lithuanian', 'en', 'lt'],
    ['English', 'Malay', 'en', 'ms'], ['English', 'Norwegian', 'en', 'nb'],
    ['English', 'Persian', 'en', 'fa'], ['English', 'Polish', 'en', 'pl'],
    ['English', 'Portuguese', 'en', 'pt'], ['English', 'Romanian', 'en', 'ro'],
    ['English', 'Russian', 'en', 'ru'], ['English', 'Slovak', 'en', 'sk'],
    ['English', 'Slovenian', 'en', 'sl'], ['English', 'Spanish', 'en', 'es'],
    ['English', 'Swedish', 'en', 'sv'], ['English', 'Tagalog', 'en', 'tl'],
    ['English', 'Thai', 'en', 'th'], ['English', 'Turkish', 'en', 'tr'],
    ['English', 'Ukranian', 'en', 'uk'], ['English', 'Urdu', 'en', 'ur'],
  // Block 3 (lines 57 to 91): translations from other languages ​​to English
    ['Esperanto', 'English', 'eo', 'en'], ['Estonian', 'English', 'et', 'en'],
    ['Finnish', 'English', 'fi', 'en'], ['French', 'English', 'fr', 'en'],
    ['Galician', 'English', 'gl', 'en'], ['German', 'English', 'de', 'en'],
    ['Greek', 'English', 'el', 'en'], ['Hebrew', 'English', 'he', 'en'],
    ['Hindi', 'English', 'hi', 'en'], ['Hungarian', 'English', 'hu', 'en'],
    ['Indonesian', 'English', 'id', 'en'], ['Irish', 'English', 'ga', 'en'],
    ['Italian', 'English', 'it', 'en'], ['Japanese', 'English', 'ja', 'en'],
    ['Korean', 'English', 'ko', 'en'], ['Latvian', 'English', 'lv', 'en'],
    ['Lithuanian', 'English', 'lt', 'en'], ['Malay', 'English', 'ms', 'en'],
    ['Norwegian', 'English', 'nb', 'en'], ['Persian', 'English', 'fa', 'en'],
    ['Polish', 'English', 'pl', 'en'], ['Portuguese', 'English', 'pt', 'en'],
    ['Portuguese', 'Spanish', 'pt', 'es'], ['Romanian', 'English', 'ro', 'en'],
    ['Russian', 'English', 'ru', 'en'], ['Slovak', 'English', 'sk', 'en'],
    ['Slovenian', 'English', 'sl', 'en'], ['Spanish', 'English', 'es', 'en'],
    ['Spanish', 'Portuguese', 'es', 'pt'], ['Swedish', 'English', 'sv', 'en'],
    ['Tagalog', 'English', 'tl', 'en'], ['Thai', 'English', 'th', 'en'],
    ['Turkish', 'English', 'tr', 'en'], ['Ukrainian', 'English', 'uk', 'en'],
    ['Urdu', 'English', 'ur', 'en']];

var
  TranslatedText: string;
  TotalStopwatch: TStopwatch;
  CreateEngineTime, TranslationTime, DestroyEngineTime: Int64;
  SourceLanguage, TargetLanguage: string;
  OriginalText: string;
  UserInputText: string;
  UserSourceLang, UserSourceLang1, UserSourceLang2: string;
  UserTargetLang, UserTargetLang1, UserTargetLang2: string;
  ModelInstalled: Boolean;
  ModelName: string; // Store Model Name
  DownloadURL: string; // Store the download URL
  DownloadPath: string; // Store the download Path
  AppPath: string;
  ExtractFolder: string;
  ChosenModels: TStringList;
  PathParts: TArray<string>;
begin
  try
    MaskFPUExceptions(True); // Do this very early!
    TotalStopwatch := TStopwatch.StartNew;

    // Ideally, CUDA setup should be done only ONCE for the entire application.
    // If you create multiple PythonEngine instances, you only need to do this once.
    SetupCUDAEnvironment;

    CreateEngineTime := 0;
    var
    EngineTimer := TStopwatch.StartNew;

    Writeln('=== Interactive Translation ===');
    Writeln('Enter source language code (e.g., ''en'', ''pt'', ''es''):');
    Readln(UserSourceLang);
    Writeln('Enter target language code (e.g., ''en'', ''pt'', ''es''):');
    Readln(UserTargetLang);

    ChosenModels := TStringList.Create;
    ChosenModels := FindTranslationPath(UserSourceLang, UserTargetLang,
      ModelList);

    case ChosenModels.Count of
      0: // Direct translation
      begin
        raise Exception.Create('No translation path found for ' + UserSourceLang + ' -> ' + UserTargetLang);
      end;
      2:
      begin
        // Extract source and target from the path string "(source,target)"
        PathParts := ChosenModels[0].Split([',', '(', ')']);
        SourceLanguage := Trim(PathParts[1]);
        TargetLanguage := Trim(PathParts[2]);
        UserSourceLang1 := SourceLanguage;
        UserTargetLang1 := TargetLanguage;
        // Construct the model name and paths
        AppPath := ExtractFilePath(ParamStr(0));
        ModelName := Format('translate-%s_%s-1_0', [UserSourceLang1, UserTargetLang1]);
        ExtractFolder := TPath.Combine(AppPath, 'argos_models');
        DownloadPath := TPath.Combine(ExtractFolder, ModelName + '.argosmodel');

        // --- Check if the model directory exists BEFORE creating the Python engine ---
        // Only check if argos_models main folder exists
        ModelInstalled := CheckAndCreateModelDirectory(UserSourceLang1, UserTargetLang1);

        if not ModelInstalled then
        begin
          Writeln('Model directory does not exist.');

          // --- Download and Install Model (Delphi Implementation) ---
          DownloadURL := Format('https://argos-net.com/v1/%s.argosmodel', [ModelName]); // Corrected URL

          if DownloadFile(DownloadURL, DownloadPath) then
          begin
            Writeln('Model downloaded successfully.');
            ExtractZipFile(DownloadPath, ExtractFolder);
            // Extract to argos_models
            Writeln('Model installed successfully.');
            // Now check that the model exists, after downloading and extracting.
            ModelInstalled := TDirectory.Exists(TPath.Combine(ExtractFolder,
              ModelName + '_extracted'));
            if not ModelInstalled then
            begin
              Writeln('Error: Model installation check failed. Exiting.');
              Writeln('Press Enter to exit...');
              Readln;
              Exit;
            end
            else
            begin
              // --- Delete the .argosmodel file ---
              try
                TFile.Delete(DownloadPath);
                Writeln('Model file deleted successfully.');
              except
                on E: Exception do
                  Writeln('Warning: Could not delete model file: ',
                    E.Message);
              end;
            end;
          end
          else
          begin
            Writeln('Error: Model download failed.  Exiting.');
            Writeln('Press Enter to exit...');
            Readln;
            Exit; // Exit if download failed.
          end;
        end;


        // Extract source and target from the path string "(source,target)"
        PathParts := ChosenModels[1].Split([',', '(', ')']);
        SourceLanguage := Trim(PathParts[1]);
        TargetLanguage := Trim(PathParts[2]);
        UserSourceLang2 := SourceLanguage;
        UserTargetLang2 := TargetLanguage;

        // Construct the model name and paths
        AppPath := ExtractFilePath(ParamStr(0));
        ModelName := Format('translate-%s_%s-1_0', [UserSourceLang2, UserTargetLang2]);
        ExtractFolder := TPath.Combine(AppPath, 'argos_models');
        DownloadPath := TPath.Combine(ExtractFolder, ModelName + '.argosmodel');

        // --- Check if the model directory exists BEFORE creating the Python engine ---
        // Only check if argos_models main folder exists
        ModelInstalled := CheckAndCreateModelDirectory(UserSourceLang2, UserTargetLang2);

        if not ModelInstalled then
        begin
          Writeln('Model directory does not exist.');

          // --- Download and Install Model (Delphi Implementation) ---
          DownloadURL := Format('https://argos-net.com/v1/%s.argosmodel', [ModelName]); // Corrected URL

          if DownloadFile(DownloadURL, DownloadPath) then
          begin
            Writeln('Model downloaded successfully.');
            ExtractZipFile(DownloadPath, ExtractFolder);
            // Extract to argos_models
            Writeln('Model installed successfully.');
            // Now check that the model exists, after downloading and extracting.
            ModelInstalled := TDirectory.Exists(TPath.Combine(ExtractFolder,
              ModelName + '_extracted'));
            if not ModelInstalled then
            begin
              Writeln('Error: Model installation check failed. Exiting.');
              Writeln('Press Enter to exit...');
              Readln;
              Exit;
            end
            else
            begin
              // --- Delete the .argosmodel file ---
              try
                TFile.Delete(DownloadPath);
                Writeln('Model file deleted successfully.');
              except
                on E: Exception do
                  Writeln('Warning: Could not delete model file: ',
                    E.Message);
              end;
            end;
          end
          else
          begin
            Writeln('Error: Model download failed.  Exiting.');
            Writeln('Press Enter to exit...');
            Readln;
            Exit; // Exit if download failed.
          end;
        end;
      end
      else
      begin
        // Construct the model name and paths
        AppPath := ExtractFilePath(ParamStr(0));
        ModelName := Format('translate-%s_%s-1_0',
          [UserSourceLang, UserTargetLang]);
        ExtractFolder := TPath.Combine(AppPath, 'argos_models');
        DownloadPath := TPath.Combine(ExtractFolder, ModelName + '.argosmodel');

        // --- Check if the model directory exists BEFORE creating the Python engine ---
        // Only check if argos_models main folder exists
        ModelInstalled := CheckAndCreateModelDirectory(UserSourceLang,
          UserTargetLang);

        if not ModelInstalled then
        begin
          Writeln('Model directory does not exist.');

          // --- Download and Install Model (Delphi Implementation) ---
          DownloadURL := Format('https://argos-net.com/v1/%s.argosmodel',
            [ModelName]); // Corrected URL

          if DownloadFile(DownloadURL, DownloadPath) then
          begin
            Writeln('Model downloaded successfully.');
            ExtractZipFile(DownloadPath, ExtractFolder); // Extract to argos_models
            Writeln('Model installed successfully.');
            // Now check that the model exists, after downloading and extracting.
            ModelInstalled := TDirectory.Exists(TPath.Combine(ExtractFolder,
              ModelName + '_extracted'));
            if not ModelInstalled then
            begin
              Writeln('Error: Model installation check failed. Exiting.');
              Writeln('Press Enter to exit...');
              Readln;
              Exit;
            end
            else
            begin
              // --- Delete the .argosmodel file ---
              try
                TFile.Delete(DownloadPath);
                Writeln('Model file deleted successfully.');
              except
                on E: Exception do
                  Writeln('Warning: Could not delete model file: ', E.Message);
              end;
            end;
          end
          else
          begin
            Writeln('Error: Model download failed.  Exiting.');
            Writeln('Press Enter to exit...');
            Readln;
            Exit; // Exit if download failed.
          end;
        end;
      end;
    end;

    case ChosenModels.Count of
      0: // Direct translation
      begin
        raise Exception.Create('No translation path found for ' + UserSourceLang + ' -> ' + UserTargetLang);
      end;
      2:
      begin
        CreatePyEngine(UserSourceLang1, UserTargetLang1);
        EngineTimer.Stop;
        CreateEngineTime := EngineTimer.ElapsedMilliseconds;

        try
          SourceLanguage := UserSourceLang1;
          TargetLanguage := UserTargetLang1;

          InitializeCUDAContext(PythonEngine);

          Writeln('Please enter text to translate (' + SourceLanguage + ' to ' +
            TargetLanguage + '):');
          Readln(UserInputText);
          OriginalText := UserInputText;

          var
            TranslationTimer: TStopwatch := TStopwatch.StartNew;
          TranslatedText := CallOptimizedTranslate(OriginalText);
          TranslationTimer.Stop;
          TranslationTime := TranslationTimer.ElapsedMilliseconds;

          Writeln('=== Translation Result (Optimized) ===');
          Writeln('Original (' + SourceLanguage + '): ', OriginalText);
          Writeln('Translated Text (' + TargetLanguage + '): ', TranslatedText);

          Writeln('');
          Writeln('=== Performance Metrics (ms) ===');
          Writeln('Create Python Engine (including init): ', CreateEngineTime);
          Writeln('Translation Time (Delphi Call): ', TranslationTime);

        finally
          // Moved DestroyEngine here, so it's called *after* timing
          DestroyEngineTime := 0;
          var
          DestroyEngineTimer := TStopwatch.StartNew;
          DestroyEngine; // GOOD:  Clean up in a finally block
          DestroyEngineTimer.Stop;
          DestroyEngineTime := DestroyEngineTimer.ElapsedMilliseconds;
        end;



        CreatePyEngine(UserSourceLang2, UserTargetLang2);
        EngineTimer.Stop;
        CreateEngineTime := EngineTimer.ElapsedMilliseconds;

        try
          SourceLanguage := UserSourceLang2;
          TargetLanguage := UserTargetLang2;

          OriginalText := TranslatedText;

          var
            TranslationTimer: TStopwatch := TStopwatch.StartNew;
          TranslatedText := CallOptimizedTranslate(OriginalText);
          TranslationTimer.Stop;
          TranslationTime := TranslationTimer.ElapsedMilliseconds;

          Writeln('=== Translation Result (Optimized) ===');
          Writeln('Original (' + SourceLanguage + '): ', OriginalText);
          Writeln('Translated Text (' + TargetLanguage + '): ', TranslatedText);

          Writeln('');
          Writeln('=== Performance Metrics (ms) ===');
          Writeln('Create Python Engine (including init): ', CreateEngineTime);
          Writeln('Translation Time (Delphi Call): ', TranslationTime);

        finally
          // Moved DestroyEngine here, so it's called *after* timing
          DestroyEngineTime := 0;
          var
          DestroyEngineTimer := TStopwatch.StartNew;
          DestroyEngine; // GOOD:  Clean up in a finally block
          DestroyEngineTimer.Stop;
          DestroyEngineTime := DestroyEngineTimer.ElapsedMilliseconds;
        end;
      end
      else
      begin
        CreatePyEngine(UserSourceLang, UserTargetLang);
        EngineTimer.Stop;
        CreateEngineTime := EngineTimer.ElapsedMilliseconds;

        try
          SourceLanguage := UserSourceLang;
          TargetLanguage := UserTargetLang;

          InitializeCUDAContext(PythonEngine);

          Writeln('Please enter text to translate (' + SourceLanguage + ' to ' +
            TargetLanguage + '):');
          Readln(UserInputText);
          OriginalText := UserInputText;

          var
            TranslationTimer: TStopwatch := TStopwatch.StartNew;
          TranslatedText := CallOptimizedTranslate(OriginalText);
          TranslationTimer.Stop;
          TranslationTime := TranslationTimer.ElapsedMilliseconds;

          Writeln('=== Translation Result (Optimized) ===');
          Writeln('Original (' + SourceLanguage + '): ', OriginalText);
          Writeln('Translated Text (' + TargetLanguage + '): ', TranslatedText);

          Writeln('');
          Writeln('=== Performance Metrics (ms) ===');
          Writeln('Create Python Engine (including init): ', CreateEngineTime);
          Writeln('Translation Time (Delphi Call): ', TranslationTime);

        finally
          // Moved DestroyEngine here, so it's called *after* timing
          DestroyEngineTime := 0;
          var
          DestroyEngineTimer := TStopwatch.StartNew;
          DestroyEngine; // GOOD:  Clean up in a finally block
          DestroyEngineTimer.Stop;
          DestroyEngineTime := DestroyEngineTimer.ElapsedMilliseconds;
        end;
      end;
    end;



    TotalStopwatch.Stop; // Stop the total timer
    Writeln('Destroy Python Engine: ', DestroyEngineTime);
    Writeln('Total Delphi Execution Time: ',
      TotalStopwatch.ElapsedMilliseconds);
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
  Writeln('Press Enter to exit...');
  Readln;

end.

is faster (takes 200 milliseconds) to translate.

While this version of pP4DArgosTranslate.dpr (the one we're working on now):

text
program pP4DArgosTranslate;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,
  System.Diagnostics,
  Windows,
  PythonEngine,
  VarPyth,
  System.Classes;

var
  PythonEngine: TPythonEngine;
  PythonModule: TPythonModule; // Use TPythonModule for better structure
  PythonHome: string;
  PyFuncTranslate: PPyObject; // Keep reference to the translation function

const
	// Initialization script (initialization.py) - INITIALIZE GLOBALLY
    EmbeddedPythonScriptInit: string =
        '# initialization.py' + sLineBreak +
        'import ctranslate2' + sLineBreak +
        'import sentencepiece as spm' + sLineBreak +
        'from sacremoses.normalize import MosesPunctNormalizer' + sLineBreak +
        'import os' + sLineBreak +
        'import logging' + sLineBreak +
        '' + sLineBreak +
        'logging.basicConfig(level=logging.WARNING)' + sLineBreak +
        'logger = logging.getLogger(__name__)' + sLineBreak +
		'' + sLineBreak +
        '# --- Global Variables (initialized to None) ---' + sLineBreak +
        'normalizer = None' + sLineBreak +
        'sp_processor = None' + sLineBreak +
        'translator = None' + sLineBreak +
        'MODEL_DIRECTORY = None' + sLineBreak +  // Good practice, even if not *strictly* needed here
        'SP_MODEL_FILE = None' + sLineBreak +      // Good practice
        '' + sLineBreak +
        '# --- Initialization Logic ---' + sLineBreak +
        'def init_translator(source_lang, target_lang):' + sLineBreak +
        '    global normalizer, sp_processor, translator, MODEL_DIRECTORY, SP_MODEL_FILE' + sLineBreak +  // Declare as global
        '    MODEL_NAME = f"translate-{source_lang}_{target_lang}-1_0"' + sLineBreak +
        '    EXTRACT_FOLDER = "argos_models"' + sLineBreak +
        '    ' + sLineBreak +
        '    # --- Dynamically find the model directory (same as before) ---' + sLineBreak +
        '    extracted_folder_path = os.path.join(EXTRACT_FOLDER, f"{MODEL_NAME}_extracted")' + sLineBreak +
        '    subfolders = [f for f in os.listdir(extracted_folder_path) if os.path.isdir(os.path.join(extracted_folder_path, f))]' + sLineBreak +
        '    if not subfolders:' + sLineBreak +
        '        raise FileNotFoundError(f"No subfolders found in {extracted_folder_path}.")' + sLineBreak +
        '    if len(subfolders) > 1:' + sLineBreak +
        '        logger.warning(f"Multiple subfolders found in {extracted_folder_path}. Using the first one: {subfolders[0]}.")' + sLineBreak +
        '    model_subfolder_name = subfolders[0]' + sLineBreak +
        '    MODEL_DIRECTORY = os.path.join(extracted_folder_path, model_subfolder_name, "model")' + sLineBreak +
        '    SP_MODEL_FILE = os.path.join(extracted_folder_path, model_subfolder_name, "sentencepiece.model")' + sLineBreak +
        '    # --- End dynamic model directory finding ---' + sLineBreak +
        '' + sLineBreak +
        '    normalizer = MosesPunctNormalizer(lang=source_lang)' + sLineBreak +
        '    sp_processor = spm.SentencePieceProcessor(model_file=SP_MODEL_FILE)' + sLineBreak +
        '    translator = ctranslate2.Translator(MODEL_DIRECTORY, device="cpu")' + sLineBreak +
        '    logger.info(f"Argos Translate components initialized for {{source_lang}}->{{target_lang}}.")' + sLineBreak;

    // Optimized translation script (translation_optimized.py) - Now RETURNS a LIST
    EmbeddedPythonScriptTranslateOptimized: string =
        '# translation_optimized.py' + sLineBreak +
        'import logging' + sLineBreak +
        '' + sLineBreak +
        'logger = logging.getLogger(__name__)' + sLineBreak +
        '' + sLineBreak +
        'def perform_translation_optimized(texts_to_translate):' + sLineBreak + // Accepts a LIST of texts
        '    """Translates a LIST of texts using pre-initialized Argos Translate components."""' + sLineBreak +
        '    translated_texts = []' + sLineBreak +  // Initialize a list to store results
        '    for text_to_translate in texts_to_translate:' + sLineBreak +  // Iterate through the list
        '        try:' + sLineBreak +
        '            normalized_text = normalizer.normalize(text_to_translate)' + sLineBreak +
        '            tokens = sp_processor.encode(normalized_text, out_type=str)' + sLineBreak +
        '            translation_result = translator.translate_batch([tokens], beam_size=1)' + sLineBreak +
        '            translated_tokens = translation_result[0].hypotheses[0]' + sLineBreak +
        '            translated_text = sp_processor.decode(translated_tokens)' + sLineBreak +
        '            translated_texts.append(translated_text)' + sLineBreak +  // Add to result list
        '        except Exception as e:' + sLineBreak +
        '            translated_texts.append(f"Translation Error: {str(e)}")' + sLineBreak +  // Add error to result list
        '    return translated_texts' + sLineBreak;  // Return the ENTIRE list of translated texts

procedure SetupCUDAEnvironment;
var
    OldPath: string;
begin
    SetEnvironmentVariable('CUDA_PATH',
        'C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.4');
    OldPath := GetEnvironmentVariable('PATH');
    SetEnvironmentVariable('PATH', PChar(OldPath +
        ';C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.4\bin' +
        ';C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.4\libnvvp'));

     // These loads might not be necessary, depending on how ctranslate2 is set up.
     // They *are* necessary if you want to force loading of specific DLLs.
    LoadLibrary(PChar('C:\Users\user\AppData\Local\Programs\Python\Python39\lib\site-packages\torch\lib\cudnn_graph64_9.dll'));
    LoadLibrary(PChar('C:\Users\user\AppData\Local\Programs\Python\Python39\lib\site-packages\ctranslate2\ctranslate2.dll'));
    LoadLibrary(PChar('C:\Windows\system32\DriverStore\FileRepository\nvdmui.inf_amd64_fdc98cdf10f69918\nvcuda64.dll'));
end;

procedure InitializeCUDAContext(PythonEngine: TPythonEngine);
begin
    PythonEngine.ExecString(AnsiString(
        'import torch;' + sLineBreak +
        'torch.cuda.init();' + sLineBreak +
        'print("CUDA Device:", torch.cuda.get_device_name(0))' + sLineBreak
        ));
    PythonEngine.CheckError; // Always check for errors after Python calls
end;

// Dummy function, just to demonstrate the pattern.  Not actually used.
function DoNothing( Self, Args : PPyObject ) : PPyObject; cdecl;
begin
  Result := GetPythonEngine.ReturnNone;
end;

procedure InitializePythonEngine;
begin
  PythonEngine := TPythonEngine.Create(nil);
  PythonEngine.Name := 'PythonEngine';
  PythonEngine.DllName := 'C:\Users\user\AppData\Local\Programs\Python\Python39\python39.dll'; // Your path here
  PythonHome := 'C:\Users\user\AppData\Local\Programs\Python\Python39'; // Your path here
  PythonEngine.SetPythonHome(PWideChar(PythonHome));
  PythonEngine.LoadDll;

  // Create the module *before* running any scripts
  PythonModule := TPythonModule.Create(nil);
  PythonModule.Engine := PythonEngine;
  PythonModule.ModuleName := 'delphi_module'; // Good practice

  // Add a dummy method (optional, but good for consistency)
  PythonModule.AddMethod('do_nothing', @DoNothing, 'A dummy method.');
end;

procedure InitializeArgosTranslate(SourceLang, TargetLang: string);
var
  PyArgs: PPyObject;
  PyInitFunc: PPyObject;
  PyMainModule: PPyObject;
  ExcType, ExcValue, ExcTraceback: PPyObject; // For detailed error reporting
begin
    // --- 1. Execute Initialization Script ---
    PythonEngine.ExecString(PAnsiChar(AnsiString(EmbeddedPythonScriptInit)));
    if PythonEngine.PyErr_Occurred <> nil then
    begin
        // Get error information
        PythonEngine.PyErr_Fetch(ExcType, ExcValue, ExcTraceback);
        try
          if Assigned(ExcType) then
          begin
            // Format and raise the exception in Delphi, including traceback THIS TIME
            raise Exception.Create(Format('Error running EmbeddedPythonScriptInit: %s - %s - Traceback: %s',  // ADDED TRACEBACK HERE
              [string(PythonEngine.PyObjectAsString(ExcType)),
               string(PythonEngine.PyObjectAsString(ExcValue)),
               string(PythonEngine.PyObjectAsString(ExcTraceback))])); // INCLUDE TRACEBACK
          end
          else
            raise Exception.Create('Error running EmbeddedPythonScriptInit: Unknown Python Error');
        finally
            // VERY IMPORTANT: Clear the error and DECREF the objects
            PythonEngine.PyErr_Clear;
            PythonEngine.Py_XDECREF(ExcType);
            PythonEngine.Py_XDECREF(ExcValue);
            PythonEngine.Py_XDECREF(ExcTraceback);
        end;
    end;

    // Get the __main__ module
    PyMainModule := PythonEngine.GetMainModule;
    if not Assigned(PyMainModule) then
        raise Exception.Create('Could not get __main__ module.');
    PythonEngine.CheckError;

    // Get the init_translator function from __main__
    PyInitFunc := PythonEngine.PyObject_GetAttrString(PyMainModule, 'init_translator');
    if not Assigned(PyInitFunc) then
    begin
        PythonEngine.Py_XDECREF(PyMainModule); // Decref __main__
        raise Exception.Create('init_translator function not found');
    end;
    PythonEngine.CheckError;

    // Prepare arguments for init_translator
    PyArgs := PythonEngine.PyTuple_New(2);
    if not Assigned(PyArgs) then
    begin
        PythonEngine.Py_XDECREF(PyInitFunc);
        PythonEngine.Py_XDECREF(PyMainModule);
        raise Exception.Create('Could not create argument tuple.');
    end;
    PythonEngine.CheckError;

    try
      PythonEngine.PyTuple_SetItem(PyArgs, 0, PythonEngine.PyUnicode_FromString(PAnsiChar(UTF8String(SourceLang))));
      PythonEngine.CheckError;
      PythonEngine.PyTuple_SetItem(PyArgs, 1, PythonEngine.PyUnicode_FromString(PAnsiChar(UTF8String(TargetLang))));
      PythonEngine.CheckError;

      // Call init_translator.  It returns None, so we don't need to manage the result.
      PythonEngine.PyObject_CallObject(PyInitFunc, PyArgs);
      if PythonEngine.PyErr_Occurred <> nil then
      begin
          // Get and format error information
          PythonEngine.PyErr_Fetch(ExcType, ExcValue, ExcTraceback);
            try
              if Assigned(ExcType) then
              begin
                raise Exception.Create(Format('Error calling init_translator(%s, %s): %s - %s - Traceback: %s', // ADDED TRACEBACK HERE
                  [SourceLang, TargetLang, string(PythonEngine.PyObjectAsString(ExcType)),
                   string(PythonEngine.PyObjectAsString(ExcValue)),
                   string(PythonEngine.PyObjectAsString(ExcTraceback))])); // INCLUDE TRACEBACK
              end
              else
                raise Exception.Create(Format('Error calling init_translator(%s, %s): Unknown Python Error', [SourceLang, TargetLang]));
            finally
                PythonEngine.PyErr_Clear; // VERY IMPORTANT
                PythonEngine.Py_XDECREF(ExcType);
                PythonEngine.Py_XDECREF(ExcValue);
                PythonEngine.Py_XDECREF(ExcTraceback);
            end;
      end;

    finally
      PythonEngine.Py_XDECREF(PyArgs);  // Clean up the arguments tuple
      PythonEngine.Py_XDECREF(PyInitFunc); // Clean up reference to the init function
    end;

    // --- 2. Load Translation Script (for later use) ---
    PythonEngine.ExecString(PAnsiChar(AnsiString(EmbeddedPythonScriptTranslateOptimized)));
    if PythonEngine.PyErr_Occurred <> nil then
    begin
        // Get and display error information
        PythonEngine.PyErr_Fetch(ExcType, ExcValue, ExcTraceback);
        try
          if Assigned(ExcType) then
          begin
            raise Exception.Create(Format('Error running EmbeddedPythonScriptTranslateOptimized: %s - %s - Traceback: %s', // ADDED TRACEBACK HERE
                [string(PythonEngine.PyObjectAsString(ExcType)),
                 string(PythonEngine.PyObjectAsString(ExcValue)),
                 string(PythonEngine.PyObjectAsString(ExcTraceback))])); // INCLUDE TRACEBACK
          end
          else
            raise Exception.Create('Error running EmbeddedPythonScriptTranslateOptimized: Unknown Python Error');

        finally
            PythonEngine.PyErr_Clear;
            PythonEngine.Py_XDECREF(ExcType);
            PythonEngine.Py_XDECREF(ExcValue);
            PythonEngine.Py_XDECREF(ExcTraceback);
        end;
    end;


    // Get a reference to the translation function.
    PyFuncTranslate := PythonEngine.PyObject_GetAttrString(PyMainModule, 'perform_translation_optimized'); //from __main__
    PythonEngine.Py_XDECREF(PyMainModule); // Done with __main__ module now

    if not Assigned(PyFuncTranslate) then
    begin
        raise Exception.Create('Could not find perform_translation_optimized function in __main__.');
    end;
    PythonEngine.CheckError;

end;

procedure DestroyEngine;
begin
  if Assigned(PyFuncTranslate) then
    PythonEngine.Py_XDECREF(PyFuncTranslate);  // Clean up the function reference. ESSENTIAL.

  PythonModule.Free; // Free the module *before* the engine
  PythonEngine.Free;
end;

function CallOptimizedTranslate(const TextToTranslate: string): string;
var
  PyArgsTuple: PPyObject;
  PyTextList: PPyObject;
  PyResultList: PPyObject;
  PySingleTranslation: PPyObject;
  ExcType, ExcValue, ExcTraceback: PPyObject; // For error handling
  Size: NativeInt;
  PyObj: PPyObject;
  PyStr: PAnsiChar; // For use with PyUnicode_AsUTF8AndSize
begin
  // --- Input Validation ---
  if not Assigned(PyFuncTranslate) then
  begin
    Result := 'Error: Translation function not initialized.';
    Exit;
  end;
  if TextToTranslate = '' then
  begin
    Result := ''; // Or some other default value, or raise a Delphi exception
    Exit;
  end;


  // 1. Create a Python list containing the single text to translate.
  //    Using PyList_New(1) is correct for a list of size 1.
  PyTextList := PythonEngine.PyList_New(1);
  if not Assigned(PyTextList) then
  begin
    // Use a more specific exception class, if available.
    raise EPythonError.Create('CallOptimizedTranslate: Failed to create Python list.');
  end;

  // --- String Handling Optimization (CRITICAL)---
  // Avoid unnecessary conversions. Directly create a UTF-8 encoded Python string.
  // No need to use the String type for UTF8String, use a straight PAnsiChar
  PyObj := PythonEngine.PyUnicode_FromString(PAnsiChar(UTF8String(TextToTranslate)));
  PyStr := PAnsiChar(PyObj);
  if not Assigned(PyStr) then
  begin
    PythonEngine.Py_XDECREF(PyTextList); // Clean up list on error.
    raise EPythonError.Create('CallOptimizedTranslate: Failed to create Python string.');
  end;
  // PyList_SetItem *steals* a reference, so we don't Py_DECREF PyStr here.
  PythonEngine.PyList_SetItem(PyTextList, 0, PyObj);


  // 2. Prepare arguments:  A tuple containing the list.
  PyArgsTuple := PythonEngine.PyTuple_New(1);
  if not Assigned(PyArgsTuple) then
  begin
    PythonEngine.Py_XDECREF(PyTextList);  // Clean up the list!
    raise EPythonError.Create('CallOptimizedTranslate: Failed to create argument tuple.');
  end;
  // PyTuple_SetItem *steals* a reference to PyTextList.  This is VERY important.
  PythonEngine.PyTuple_SetItem(PyArgsTuple, 0, PyTextList);


  // 3. Call the Python function.
  PyResultList := PythonEngine.PyObject_CallObject(PyFuncTranslate, PyArgsTuple);
  PythonEngine.Py_XDECREF(PyArgsTuple); // PyObject_CallObject used the tuple, so we DECREF now.

  if not Assigned(PyResultList) then
  begin
    // If PyObject_CallObject fails, it returns NULL *and* sets an exception.
    // We check for both a NULL return and an active exception.
    if PythonEngine.PyErr_Occurred <> nil then
        PythonEngine.PyErr_Fetch(ExcType, ExcValue, ExcTraceback)
    else
    begin  // No Python error, but a NULL return
      ExcType := nil;
      ExcValue := PythonEngine.PyUnicode_FromString('Python function returned NULL.');
      ExcTraceback := nil;
    end;

    try
      if Assigned(ExcType) then //Check if an error actually occurred
      begin
          // --- Improved Error Reporting ---
          // Get type and value of exception
          Result := Format('Python error during translation: %s - %s',
          [string(PythonEngine.PyObjectAsString(ExcType)),
           string(PythonEngine.PyObjectAsString(ExcValue))]);

          //Add traceback if available
          if Assigned(ExcTraceback) then
            Result := Result + sLineBreak + 'Traceback: ' +
                      string(PythonEngine.PyObjectAsString(ExcTraceback));
      end
      else
        Result := 'Python error during translation: Unknown error';

    finally
      //Clear error and release references
      PythonEngine.PyErr_Clear;
      PythonEngine.Py_XDECREF(ExcType);
      PythonEngine.Py_XDECREF(ExcValue);
      PythonEngine.Py_XDECREF(ExcTraceback);
    end;
    Exit; // Exit after handling the error.
  end;



  // 4. Process the result (expecting a list of strings).
  try
    if not PythonEngine.PyList_Check(PyResultList) then
    begin
      Result := 'Error: Python function did not return a list.';
      Exit;
    end;

    if PythonEngine.PyList_Size(PyResultList) = 0 then
    begin
      Result := '';  // Return empty string if list is empty
      Exit;
    end;

    // 5. Get the translated string from the list (borrowed reference).
    PySingleTranslation := PythonEngine.PyList_GetItem(PyResultList, 0);  // Borrowed reference!
    if not Assigned(PySingleTranslation) then
    begin
      Result := 'Error: Could not extract translated item from list.';
      Exit;
    end;

    // --- Optimized String Extraction ---
    PyStr := PythonEngine.PyUnicode_AsUTF8AndSize(PySingleTranslation, @Size);
    if not Assigned(PyStr) then
    begin
      Result := 'Error: Could not convert Python string to UTF-8.';
      Exit;
    end;

    // Safest way to get a Delphi string.
    SetString(Result, PAnsiChar(PyStr), Size);


  finally
    // Always clean up the result list.
    PythonEngine.Py_XDECREF(PyResultList);
  end;
end;

var
  TranslatedText: string;
  TotalStopwatch: TStopwatch;
  CreateEngineTime, TranslationTime, DestroyEngineTime: Int64;
  SourceLanguage, TargetLanguage: string;
  OriginalText: string;
  UserInputText: string;
  UserSourceLang: string;
  UserTargetLang: string;
  ExcType, ExcValue, ExcTraceback: PPyObject; // For detailed error reporting - declared here to be accessible in the outer EXCEPT block
begin
  try
    MaskFPUExceptions(True); // Do this very early!
    TotalStopwatch := TStopwatch.StartNew;

    // Ideally, CUDA setup should be done only ONCE for the entire application.
    // If you create multiple PythonEngine instances, you only need to do this once.
    SetupCUDAEnvironment;

    CreateEngineTime := 0;
    var EngineTimer := TStopwatch.StartNew;

    Writeln('=== Interactive Translation ===');
    Writeln('Enter source language code (e.g., ''en'', ''pt'', ''es''):');
    Readln(UserSourceLang);
    Writeln('Enter target language code (e.g., ''en'', ''pt'', ''es''):');
    Readln(UserTargetLang);

    InitializePythonEngine;
    InitializeArgosTranslate(UserSourceLang, UserTargetLang);
    EngineTimer.Stop;
    CreateEngineTime := EngineTimer.ElapsedMilliseconds;

    try
      SourceLanguage := UserSourceLang;
      TargetLanguage := UserTargetLang;

      InitializeCUDAContext(PythonEngine);

      Writeln('Please enter text to translate (' + SourceLanguage + ' to ' + TargetLanguage + '):');
      Readln(UserInputText);
      OriginalText := UserInputText;


      var TranslationTimer: TStopwatch := TStopwatch.StartNew;
      TranslatedText := CallOptimizedTranslate(OriginalText);
      TranslationTimer.Stop;
      TranslationTime := TranslationTimer.ElapsedMilliseconds;

      Writeln('=== Translation Result (Optimized) ===');
      Writeln('Original (' + SourceLanguage + '): ', OriginalText);
      Writeln('Translated Text (' + TargetLanguage + '): ', TranslatedText);

      Writeln('');
      Writeln('=== Performance Metrics (ms) ===');
      Writeln('Create Python Engine (including init): ', CreateEngineTime);
      Writeln('Translation Time (Delphi Call): ', TranslationTime);

    finally
      // Moved DestroyEngine here, so it's called *after* timing
      DestroyEngineTime := 0;
      var DestroyEngineTimer := TStopwatch.StartNew;
      DestroyEngine;  // GOOD:  Clean up in a finally block
      DestroyEngineTimer.Stop;
      DestroyEngineTime := DestroyEngineTimer.ElapsedMilliseconds;
    end;

    TotalStopwatch.Stop; // Stop the total timer
    Writeln('Destroy Python Engine: ', DestroyEngineTime);
    Writeln('Total Delphi Execution Time: ', TotalStopwatch.ElapsedMilliseconds);
  except
    on E: Exception do
    begin
      Writeln(E.ClassName, ': ', E.Message);
      // Get and display Delphi exception AND Python traceback if available
      PythonEngine.PyErr_Fetch(ExcType, ExcValue, ExcTraceback);  // Fetch Python error info
      try
        if Assigned(ExcTraceback) then  // Check if there's a Python traceback
        begin
          Writeln('Python Traceback (most recent call last):');
          Writeln(UTF8ToString(PythonEngine.PyObjectAsString(ExcTraceback))); // Print Python traceback to console
        end;
      finally
        PythonEngine.PyErr_Clear; // Clear Python error status
        PythonEngine.Py_XDECREF(ExcType);
        PythonEngine.Py_XDECREF(ExcValue);
        PythonEngine.Py_XDECREF(ExcTraceback);
      end;
    end;
  end;
  Writeln('Press Enter to exit...');
  Readln;
end. 

which despite all the optimization we're doing still takes 400 milliseconds to translate.

Ok, let's redo the analysis, but now focusing on the CallOptimizedTranslate function. Why is it faster in the old version? What should I do to make the version we are working on now closer to the speed of the old version?

After much thought, write the definitive Delphi code for optimization (maximum translation speed) for our best version of pP4DArgosTranslate.dpr. Review everything and always improve the ideas and possibilities you develop, ensure complete and perfect functionality for a highly optimized algorithm using P4D to run Python in Delphi, taking advantage of the Argos-Translate translation library, maintaining pre-caching strategies (preloading the Python Engine "core", preloading the Argos libraries, and their dependencies such as CTranslate2 and others, and preloading the translation model).

Remember that you are a very experienced P4D (Python4Delphi) expert, the code you write is of the highest degree of professionalism.

Be careful to ensure that the names of functions, types, tipecastings, are really from P4D, Delphi (Modern) and Python (algorithms on the Python side, using Argos-Translate Library), ensure that everything works perfectly while remaining as optimized as possible (which is our main goal).

--

I've heard (some guesses) that:

• The cause of this slow latency issue with the latest version of our pP4DArgosTranslate.dpr, regarding the translation task, was because the new version uses PyUnicode_AsUTF8AndSize followed by SetString(Result, PAnsiChar(PyStr), Size), instead of the old version using Result := UTF8ToString(PythonEngine.PyUnicode_AsUTF8(PySingleTranslation)); which was much faster. I was then told to Revert to the Faster String Conversion.

• There is also the suspicion that, the old version simply creates the Python objects, calls the function, and extracts the result with minimal conditional checks. While the new version of pP4DArgosTranslate.dpr adds extra input validations, checks for every object’s assignment, and extra error reporting (e.g. fetching and formatting exception details). While these improve robustness, they introduce additional branches and function calls that add overhead. Medisseram que era preciso então Reduce Unnecessary Checks in the Hot Path.

• They also advised me to Streamline Error Handling (When Appropriate). While detailed error reporting is great for debugging, you might consider having a "fast path" version that skips the detailed PyErr_Fetch and traceback formatting when performance is critical.

• The older version of CallOptimizedTranslate is faster because the corresponding Python function processes the entire list of texts in a single batch, leveraging efficient batch processing in the translation model. The current Python code processes each text individually in a loop, resulting in multiple smaller batches and increased overhead.

But the tips given above are quick guesses from some people I spoke to, but the professional is you, if they are coherent use them, if you see that it really is better.

There are also some generic tips that are always said out there for algorithmic speed optimization regarding the best use of P4D:

• Reduce the number of calls between Delphi and Python, as these transitions can introduce overhead.

• Batch operations whenever possible.

• Choose appropriate data structures in Delphi and Python to optimize performance:

• When possible, work directly with raw data pointers or memory buffers to avoid unnecessary type conversions during the translation task.

• For numeric data, use types that are compatible between Delphi and Python (e.g., Integer in Delphi and int in Python) to minimize conversion overhead.

• Be aware of string encoding differences (e.g., UTF-8 in Python and UTF-16 in Delphi) and handle them appropriately.

• For large arrays or lists, consider using shared memory or memory-mapped files for efficient data exchange.

Please note that these are just quick guesses and general tips. But you, as an experienced developer, know exactly what to improve as much as possible while keeping everything fully functional. Perhaps these tips can be an addition to your ideas for improving translation execution speed using the Python Argos Translate library in the Delphi environment with maximum performance and optimization possible. Implement all forms of optimization, analyzing each line of the pP4DArgosTranslate.dpr code to rewrite it all and completely improve it into perfect translation functionality at the fastest possible speed that optimization can achieve. Note: Use all optimization strategies except multi-threading (this is the only exception, understand?).