dspex

# Generated by SnakeBridge v0.16.0 - DO NOT EDIT MANUALLY
# Regenerate with: mix compile
# Library: dspy 3.2.0
# Python module: dspy.predict
# Python class: Refine

defmodule Dspy.Predict.Refine do
  @moduledoc """
  Base class for all DSPy modules (programs).

  A Module is a building block for DSPy programs that can contain predictors,
  sub-modules, and custom logic. Modules can be composed together to create
  complex pipelines and can be optimized using DSPy's teleprompters.

  All DSPy programs should inherit from this class and implement a ``forward``
  method that defines the program's logic.

  ## Parameters

  - `callbacks` - Optional list of callback handlers for instrumentation and monitoring.

  ## Examples

      iex> import dspy
      iex> class MyProgram(dspy.Module):
      ...> def __init__(self):
      ...> super().__init__()
      ...> self.predictor = dspy.Predict("question -> answer")
      ...> 
      ...> def forward(self, question):
      ...> return self.predictor(question=question)
  """
  def __snakebridge_python_name__, do: "dspy.predict"
  def __snakebridge_python_class__, do: "Refine"
  def __snakebridge_library__, do: "dspy"
  @opaque t :: SnakeBridge.Ref.t()

  @doc """
  Refines a module by running it up to N times with different rollout IDs at `temperature=1.0`

  and returns the best prediction.

  This module runs the provided module multiple times with varying rollout identifiers and selects
  either the first prediction that exceeds the specified threshold or the one with the highest reward.
  If no prediction meets the threshold, it automatically generates feedback to improve future predictions.

  ## Parameters

  - `module` - The module to refine. (type: `Module`)
  - `N` - The number of times to run the module. must (type: `integer()`)
  - `reward_fn` - The reward function. (type: `Callable`)
  - `threshold` - The threshold for the reward function. (type: `float()`)
  - `fail_count` - The number of times the module can fail before raising an error (type: `integer() | nil`)

  ## Examples

      ```python
      import dspy

      dspy.configure(lm=dspy.LM("openai/gpt-4o-mini"))

      # Define a QA module with chain of thought
      qa = dspy.ChainOfThought("question -> answer")

      # Define a reward function that checks for one-word answers
      def one_word_answer(args, pred):
      return 1.0 if len(pred.answer.split()) == 1 else 0.0

      # Create a refined module that tries up to 3 times
      best_of_3 = dspy.Refine(module=qa, N=3, reward_fn=one_word_answer, threshold=1.0)

      # Use the refined module
      result = best_of_3(question="What is the capital of Belgium?").answer
      # Returns: Brussels
      ```
  """
  @spec new(term(), integer(), term(), float(), list(term()), keyword()) ::
          {:ok, SnakeBridge.Ref.t()} | {:error, Snakepit.Error.t()}
  def new(module, n, reward_fn, threshold, args, opts \\ []) do
    {args, opts} = SnakeBridge.Runtime.normalize_args_opts(args, opts)

    SnakeBridge.Runtime.call_class(
      __MODULE__,
      :__init__,
      [module, n, reward_fn, threshold] ++ List.wrap(args),
      opts
    )
  end

  @doc """
  Python method `Refine._base_init`.

  ## Returns

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

  @doc """
  Python method `Refine._set_lm_usage`.

  ## Parameters

  - `tokens` (%{optional(String.t()) => term()})
  - `output` (term())

  ## Returns

  - `term()`
  """
  @spec _set_lm_usage(SnakeBridge.Ref.t(), %{optional(String.t()) => term()}, term(), keyword()) ::
          {:ok, term()} | {:error, Snakepit.Error.t()}
  def _set_lm_usage(ref, tokens, output, opts \\ []) do
    SnakeBridge.Runtime.call_method(ref, :_set_lm_usage, [tokens, output], opts)
  end

  @doc """
  Python method `Refine.acall`.

  ## Parameters

  - `args` (term())
  - `kwargs` (term())

  ## Returns

  - `term()`
  """
  @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

  @doc """
  Processes a list of dspy.Example instances in parallel using the Parallel module.



  ## Parameters

  - `examples` - List of dspy.Example instances to process.
  - `num_threads` - Number of threads to use for parallel processing.
  - `max_errors` - Maximum number of errors allowed before stopping execution. If ``None``, inherits from ``dspy.settings.max_errors``.
  - `return_failed_examples` - Whether to return failed examples and exceptions.
  - `provide_traceback` - Whether to include traceback information in error logs.
  - `disable_progress_bar` - Whether to display the progress bar.
  - `timeout` - Seconds before a straggler task is resubmitted. Set to 0 to disable.
  - `straggler_limit` - Only check for stragglers when this many or fewer tasks remain.

  ## Returns

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

  @doc """
  Deep copy the module.

  This is a tweak to the default python deepcopy that only deep copies `self.parameters()`, and for other
  attributes, we just do the shallow copy.

  ## Returns

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

  @doc """
  Python method `Refine.dump_state`.

  ## Parameters

  - `json_mode` (term() default: True)

  ## Returns

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

  @doc """
  Python method `Refine.forward`.

  ## Parameters

  - `kwargs` (term())

  ## Returns

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

  @doc """
  Get the language model used by this module's predictors.

  Returns the language model if all predictors use the same LM.
  Raises an error if multiple different LMs are in use.

  ## Raises

  - `ArgumentError` - If multiple different language models are being used by the predictors in this module.

  ## Returns

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

  @doc """
  Display the LM call history for this module.

  Prints a formatted view of the most recent language model calls
  made by this module, useful for debugging and understanding
  the module's behavior.

  ## Parameters

  - `n` - The number of recent history entries to display. Defaults to 1.
  - `file` - An optional file-like object to write output to. When provided, ANSI color codes are automatically disabled. Defaults to `None` (prints to stdout).

  ## Returns

  - `nil`
  """
  @spec inspect_history(SnakeBridge.Ref.t(), list(term()), keyword()) ::
          {:ok, nil} | {: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

  @doc """
  Load the saved module. You may also want to check out dspy.load, if you want to

  load an entire program, not just the state for an existing program.

  ## Parameters

  - `path` - Path to the saved state file, which should be a .json or a .pkl file (type: `String.t()`)
  - `allow_pickle` - If True, allow loading .pkl files, which can run arbitrary code. This is dangerous and should only be used if you are sure about the source of the file and in a trusted environment. (type: `boolean()`)
  - `allow_unsafe_lm_state` - If True, preserves unsafe LM endpoint keys (e.g., `api_base`, `base_url`, and `model_list`) from loaded state. Enable only for trusted files. (type: `boolean()`)

  ## Returns

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

  @doc """
  Python method `Refine.load_state`.

  ## Parameters

  - `state` (term())
  - `allow_unsafe_lm_state` (term() keyword-only default: False)

  ## Returns

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

  @doc """
  Apply a function to all named predictors in this module.

  This method iterates through all Predict instances in the module
  and applies the given function to each, replacing the original
  predictor with the function's return value.

  ## Parameters

  - `func` - A callable that takes a Predict instance and returns a new Predict instance (or compatible object).

  ## Returns

  Returns `Module`. Returns self for method chaining.

  ## Examples

      iex> import dspy
      iex> class MyProgram(dspy.Module):
      ...> def __init__(self):
      ...> super().__init__()
      ...> self.qa = dspy.Predict("question -> answer")
      ...> 
      iex> program = MyProgram()
      iex> program.map_named_predictors(lambda p: p)
  """
  @spec map_named_predictors(SnakeBridge.Ref.t(), term(), keyword()) ::
          {:ok, term()} | {:error, Snakepit.Error.t()}
  def map_named_predictors(ref, func, opts \\ []) do
    SnakeBridge.Runtime.call_method(ref, :map_named_predictors, [func], opts)
  end

  @doc """
  Unlike PyTorch, handles (non-recursive) lists of parameters too.

  ## Returns

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

  @doc """
  Return all named Predict modules in this module.

  Iterates through all parameters and returns those that are instances
  of ``dspy.Predict``, along with their names.

  ## Examples

      iex> import dspy
      iex> class MyProgram(dspy.Module):
      ...> def __init__(self):
      ...> super().__init__()
      ...> self.qa = dspy.Predict("question -> answer")
      ...> self.summarize = dspy.Predict("text -> summary")
      ...> 
      iex> program = MyProgram()
      iex> for name, p in program.named_predictors():
      ...> print(name)
      qa
      summarize

  ## Returns

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

  @doc """
  Find all sub-modules in the module, as well as their names.

  Say `self.children[4]['key'].sub_module` is a sub-module. Then the name will be
  `children[4]['key'].sub_module`. But if the sub-module is accessible at different
  paths, only one of the paths will be returned.

  ## Parameters

  - `type_` (term() default: None)
  - `skip_compiled` (term() default: False)

  ## Returns

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

  @doc """
  Python method `Refine.parameters`.

  ## Returns

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

  @doc """
  Return all Predict modules in this module.



  ## Examples

      iex> import dspy
      iex> class MyProgram(dspy.Module):
      ...> def __init__(self):
      ...> super().__init__()
      ...> self.qa = dspy.Predict("question -> answer")
      ...> 
      iex> program = MyProgram()
      iex> len(program.predictors())
      1

  ## Returns

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

  @doc """
  Deep copy the module and reset all parameters.

  ## Returns

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

  @doc """
  Save the module.

  Save the module to a directory or a file. There are two modes:
  - `save_program=False`: Save only the state of the module to a json or pickle file, based on the value of
      the file extension.
  - `save_program=True`: Save the whole module to a directory via cloudpickle, which contains both the state and
      architecture of the model.

  If `save_program=True` and `modules_to_serialize` are provided, it will register those modules for serialization
  with cloudpickle's `register_pickle_by_value`. This causes cloudpickle to serialize the module by value rather
  than by reference, ensuring the module is fully preserved along with the saved program. This is useful
  when you have custom modules that need to be serialized alongside your program. If None, then no modules
  will be registered for serialization.

  We also save the dependency versions, so that the loaded model can check if there is a version mismatch on
  critical dependencies or DSPy version.

  ## Parameters

  - `path` - Path to the saved state file, which should be a .json or .pkl file when `save_program=False`, and a directory when `save_program=True`. (type: `String.t()`)
  - `save_program` - If True, save the whole module to a directory via cloudpickle, otherwise only save the state. (type: `boolean()`)
  - `modules_to_serialize` - A list of modules to serialize with cloudpickle's `register_pickle_by_value`. If None, then no modules will be registered for serialization. (type: `list()`)

  ## Returns

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

  @doc """
  Set the language model for all predictors in this module.

  This method recursively sets the language model for all Predict
  instances contained within this module.

  ## Parameters

  - `lm` - The language model instance to use for all predictors.

  ## Examples

      iex> import dspy
      iex> lm = dspy.LM("openai/gpt-4o-mini")
      iex> program = dspy.Predict("question -> answer")
      iex> program.set_lm(lm)

  ## Returns

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