# Generated by SnakeBridge v0.12.0 - DO NOT EDIT MANUALLY
# Regenerate with: mix compile
# Library: dspy 3.1.2
# Python module: dspy.utils
# Python class: DummyLM

defmodule Dspy.Utils.DummyLM do
  def __snakebridge_python_name__, do: "dspy.utils"
  def __snakebridge_python_class__, do: "DummyLM"
  def __snakebridge_library__, do: "dspy"
  @opaque t :: SnakeBridge.Ref.t()

  @spec new(term(), list(term()), keyword()) ::
          {:ok, SnakeBridge.Ref.t()} | {:error, Snakepit.Error.t()}
  def new(answers, args, opts \\ []) do
    {args, opts} = SnakeBridge.Runtime.normalize_args_opts(args, opts)
    SnakeBridge.Runtime.call_class(__MODULE__, :__init__, [answers] ++ List.wrap(args), opts)
  end

  @spec _check_truncation(SnakeBridge.Ref.t(), term(), keyword()) ::
          {:ok, term()} | {:error, Snakepit.Error.t()}
  def _check_truncation(ref, results, opts \\ []) do
    SnakeBridge.Runtime.call_method(ref, :_check_truncation, [results], opts)
  end

  @spec _extract_citations_from_response(SnakeBridge.Ref.t(), term(), keyword()) ::
          {:ok, term()} | {:error, Snakepit.Error.t()}
  def _extract_citations_from_response(ref, choice, opts \\ []) do
    SnakeBridge.Runtime.call_method(ref, :_extract_citations_from_response, [choice], opts)
  end

  @spec _get_cached_completion_fn(SnakeBridge.Ref.t(), term(), term(), keyword()) ::
          {:ok, term()} | {:error, Snakepit.Error.t()}
  def _get_cached_completion_fn(ref, completion_fn, cache, opts \\ []) do
    SnakeBridge.Runtime.call_method(ref, :_get_cached_completion_fn, [completion_fn, cache], opts)
  end

  @spec _process_completion(SnakeBridge.Ref.t(), term(), term(), keyword()) ::
          {:ok, term()} | {:error, Snakepit.Error.t()}
  def _process_completion(ref, response, merged_kwargs, opts \\ []) do
    SnakeBridge.Runtime.call_method(ref, :_process_completion, [response, merged_kwargs], opts)
  end

  @spec _process_lm_response(SnakeBridge.Ref.t(), term(), term(), term(), keyword()) ::
          {:ok, term()} | {:error, Snakepit.Error.t()}
  def _process_lm_response(ref, response, prompt, messages, opts \\ []) do
    SnakeBridge.Runtime.call_method(
      ref,
      :_process_lm_response,
      [response, prompt, messages],
      opts
    )
  end

  @spec _process_response(SnakeBridge.Ref.t(), term(), keyword()) ::
          {:ok, term()} | {:error, Snakepit.Error.t()}
  def _process_response(ref, response, opts \\ []) do
    SnakeBridge.Runtime.call_method(ref, :_process_response, [response], opts)
  end

  @spec _run_finetune_job(SnakeBridge.Ref.t(), Dspy.Clients.Provider.TrainingJob.t(), keyword()) ::
          {:ok, term()} | {:error, Snakepit.Error.t()}
  def _run_finetune_job(ref, job, opts \\ []) do
    SnakeBridge.Runtime.call_method(ref, :_run_finetune_job, [job], opts)
  end

  @spec _use_example(SnakeBridge.Ref.t(), term(), keyword()) ::
          {:ok, term()} | {:error, Snakepit.Error.t()}
  def _use_example(ref, messages, opts \\ []) do
    SnakeBridge.Runtime.call_method(ref, :_use_example, [messages], opts)
  end

  @spec _warn_zero_temp_rollout(SnakeBridge.Ref.t(), term(), term(), keyword()) ::
          {:ok, term()} | {:error, Snakepit.Error.t()}
  def _warn_zero_temp_rollout(ref, temperature, rollout_id, opts \\ []) do
    SnakeBridge.Runtime.call_method(
      ref,
      :_warn_zero_temp_rollout,
      [temperature, rollout_id],
      opts
    )
  end

  @spec acall(SnakeBridge.Ref.t(), list(term()), keyword()) ::
          {:ok, term()} | {:error, Snakepit.Error.t()}
  def acall(ref, args, opts \\ []) do
    {args, opts} = SnakeBridge.Runtime.normalize_args_opts(args, opts)
    SnakeBridge.Runtime.call_method(ref, :acall, [] ++ List.wrap(args), opts)
  end

  @spec aforward(SnakeBridge.Ref.t(), list(term()), keyword()) ::
          {:ok, term()} | {:error, Snakepit.Error.t()}
  def aforward(ref, args, opts \\ []) do
    {args, opts} = SnakeBridge.Runtime.normalize_args_opts(args, opts)
    SnakeBridge.Runtime.call_method(ref, :aforward, [] ++ List.wrap(args), opts)
  end

  @spec copy(SnakeBridge.Ref.t(), keyword()) :: {:ok, term()} | {:error, Snakepit.Error.t()}
  def copy(ref, opts \\ []) do
    SnakeBridge.Runtime.call_method(ref, :copy, [], opts)
  end

  @spec dump_state(SnakeBridge.Ref.t(), keyword()) :: {:ok, term()} | {:error, Snakepit.Error.t()}
  def dump_state(ref, opts \\ []) do
    SnakeBridge.Runtime.call_method(ref, :dump_state, [], opts)
  end

  @spec finetune(
          SnakeBridge.Ref.t(),
          list(%{optional(String.t()) => term()}),
          term(),
          list(term()),
          keyword()
        ) :: {:ok, Dspy.Clients.Provider.TrainingJob.t()} | {:error, Snakepit.Error.t()}
  def finetune(ref, train_data, train_data_format, args, opts \\ []) do
    {args, opts} = SnakeBridge.Runtime.normalize_args_opts(args, opts)

    SnakeBridge.Runtime.call_method(
      ref,
      :finetune,
      [train_data, train_data_format] ++ List.wrap(args),
      opts
    )
  end

  @spec forward(SnakeBridge.Ref.t(), list(term()), keyword()) ::
          {:ok, term()} | {:error, Snakepit.Error.t()}
  def forward(ref, args, opts \\ []) do
    {args, opts} = SnakeBridge.Runtime.normalize_args_opts(args, opts)
    SnakeBridge.Runtime.call_method(ref, :forward, [] ++ List.wrap(args), opts)
  end

  @spec get_convo(SnakeBridge.Ref.t(), term(), keyword()) ::
          {:ok, term()} | {:error, Snakepit.Error.t()}
  def get_convo(ref, index, opts \\ []) do
    SnakeBridge.Runtime.call_method(ref, :get_convo, [index], opts)
  end

  @spec infer_provider(SnakeBridge.Ref.t(), keyword()) ::
          {:ok, Dspy.Clients.ProviderClass.t()} | {:error, Snakepit.Error.t()}
  def infer_provider(ref, opts \\ []) do
    SnakeBridge.Runtime.call_method(ref, :infer_provider, [], opts)
  end

  @spec inspect_history(SnakeBridge.Ref.t(), list(term()), keyword()) ::
          {:ok, term()} | {:error, Snakepit.Error.t()}
  def inspect_history(ref, args, opts \\ []) do
    {args, opts} = SnakeBridge.Runtime.normalize_args_opts(args, opts)
    SnakeBridge.Runtime.call_method(ref, :inspect_history, [] ++ List.wrap(args), opts)
  end

  @spec kill(SnakeBridge.Ref.t(), list(term()), keyword()) ::
          {:ok, term()} | {:error, Snakepit.Error.t()}
  def kill(ref, args, opts \\ []) do
    {args, opts} = SnakeBridge.Runtime.normalize_args_opts(args, opts)
    SnakeBridge.Runtime.call_method(ref, :kill, [] ++ List.wrap(args), opts)
  end

  @spec launch(SnakeBridge.Ref.t(), list(term()), keyword()) ::
          {:ok, term()} | {:error, Snakepit.Error.t()}
  def launch(ref, args, opts \\ []) do
    {args, opts} = SnakeBridge.Runtime.normalize_args_opts(args, opts)
    SnakeBridge.Runtime.call_method(ref, :launch, [] ++ List.wrap(args), opts)
  end

  @spec reinforce(SnakeBridge.Ref.t(), term(), keyword()) ::
          {:ok, Dspy.Clients.Provider.ReinforceJob.t()} | {:error, Snakepit.Error.t()}
  def reinforce(ref, train_kwargs, opts \\ []) do
    SnakeBridge.Runtime.call_method(ref, :reinforce, [train_kwargs], opts)
  end

  @spec update_history(SnakeBridge.Ref.t(), term(), keyword()) ::
          {:ok, term()} | {:error, Snakepit.Error.t()}
  def update_history(ref, entry, opts \\ []) do
    SnakeBridge.Runtime.call_method(ref, :update_history, [entry], opts)
  end
end