# `Dspy.Primitives.ReplTypes.REPLVariable`
[🔗](https://github.com/nshkrdotcom/dspex/blob/v0.11.0/lib/snakebridge_generated/dspy/primitives/repl_types/repl_variable.ex#L7)

Metadata about a variable available in the REPL environment.

# `t`

```elixir
@opaque t()
```

# `_calculate_keys`

```elixir
@spec _calculate_keys(SnakeBridge.Ref.t(), term(), term(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

REPL data types for RLM and interpreter interactions.

These types represent the state and history of REPL-based execution:
- REPLVariable: Metadata about variables available in the REPL
- REPLEntry: A single interaction (reasoning, code, output)
- REPLHistory: Container for the full interaction history

## Parameters

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

## Returns

- `term()`

# `_copy_and_set_values`

```elixir
@spec _copy_and_set_values(SnakeBridge.Ref.t(), term(), term(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

REPL data types for RLM and interpreter interactions.

These types represent the state and history of REPL-based execution:
- REPLVariable: Metadata about variables available in the REPL
- REPLEntry: A single interaction (reasoning, code, output)
- REPLHistory: Container for the full interaction history

## Parameters

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

## Returns

- `term()`

# `_get_value`

```elixir
@spec _get_value(SnakeBridge.Ref.t(), term(), term(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

REPL data types for RLM and interpreter interactions.

These types represent the state and history of REPL-based execution:
- REPLVariable: Metadata about variables available in the REPL
- REPLEntry: A single interaction (reasoning, code, output)
- REPLHistory: Container for the full interaction history

## Parameters

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

## Returns

- `term()`

# `_iter`

```elixir
@spec _iter(SnakeBridge.Ref.t(), term(), term(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

REPL data types for RLM and interpreter interactions.

These types represent the state and history of REPL-based execution:
- REPLVariable: Metadata about variables available in the REPL
- REPLEntry: A single interaction (reasoning, code, output)
- REPLHistory: Container for the full interaction history

## Parameters

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

## Returns

- `term()`

# `_setattr_handler`

```elixir
@spec _setattr_handler(SnakeBridge.Ref.t(), String.t(), term(), keyword()) ::
  {:ok, term() | nil} | {:error, Snakepit.Error.t()}
```

Get a handler for setting an attribute on the model instance.

## Parameters

- `name` (String.t())
- `value` (term())

## Returns

- `term() | nil`

# `construct`

```elixir
@spec construct(SnakeBridge.Ref.t(), [term()], keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

REPL data types for RLM and interpreter interactions.

These types represent the state and history of REPL-based execution:
- REPLVariable: Metadata about variables available in the REPL
- REPLEntry: A single interaction (reasoning, code, output)
- REPLHistory: Container for the full interaction history

## Parameters

- `fields_set` (term() default: None)
- `values` (term())

## Returns

- `term()`

# `copy`

```elixir
@spec copy(SnakeBridge.Ref.t(), term(), term(), term(), term(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

Returns a copy of the model.

!!! warning "Deprecated"
    This method is now deprecated; use `model_copy` instead.

If you need `include` or `exclude`, use:

```python {test="skip" lint="skip"}
data = self.model_dump(include=include, exclude=exclude, round_trip=True)
data = {**data, **(update or {})}
copied = self.model_validate(data)
```

## Parameters

- `include` - Optional set or mapping specifying which fields to include in the copied model.
- `exclude` - Optional set or mapping specifying which fields to exclude in the copied model.
- `update` - Optional dictionary of field-value pairs to override field values in the copied model.
- `deep` - If True, the values of fields that are Pydantic models will be deep-copied.

## Returns

- `term()`

# `dict`

```elixir
@spec dict(
  SnakeBridge.Ref.t(),
  keyword()
) :: {:ok, %{optional(String.t()) => term()}} | {:error, Snakepit.Error.t()}
```

REPL data types for RLM and interpreter interactions.

These types represent the state and history of REPL-based execution:
- REPLVariable: Metadata about variables available in the REPL
- REPLEntry: A single interaction (reasoning, code, output)
- REPLHistory: Container for the full interaction history

## Parameters

- `include` ((((MapSet.t(integer()) | MapSet.t(String.t())) | term()) | term()) | nil keyword-only default: None)
- `exclude` ((((MapSet.t(integer()) | MapSet.t(String.t())) | term()) | term()) | nil keyword-only default: None)
- `by_alias` (boolean() keyword-only default: False)
- `exclude_unset` (boolean() keyword-only default: False)
- `exclude_defaults` (boolean() keyword-only default: False)
- `exclude_none` (boolean() keyword-only default: False)

## Returns

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

# `format`

```elixir
@spec format(
  SnakeBridge.Ref.t(),
  keyword()
) :: {:ok, String.t()} | {:error, Snakepit.Error.t()}
```

Format variable metadata for prompt inclusion.

## Returns

- `String.t()`

# `from_orm`

```elixir
@spec from_orm(SnakeBridge.Ref.t(), term(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

REPL data types for RLM and interpreter interactions.

These types represent the state and history of REPL-based execution:
- REPLVariable: Metadata about variables available in the REPL
- REPLEntry: A single interaction (reasoning, code, output)
- REPLHistory: Container for the full interaction history

## Parameters

- `obj` (term())

## Returns

- `term()`

# `from_value`

```elixir
@spec from_value(SnakeBridge.Ref.t(), term(), term(), term(), term(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

Create REPLVariable from an actual value and optional field info.

## Parameters

- `name` - Variable name
- `value` - The actual value
- `field_info` - Optional pydantic FieldInfo with desc/constraints metadata
- `preview_chars` - Max characters for preview

## Returns

- `term()`

# `json`

```elixir
@spec json(
  SnakeBridge.Ref.t(),
  keyword()
) :: {:ok, String.t()} | {:error, Snakepit.Error.t()}
```

REPL data types for RLM and interpreter interactions.

These types represent the state and history of REPL-based execution:
- REPLVariable: Metadata about variables available in the REPL
- REPLEntry: A single interaction (reasoning, code, output)
- REPLHistory: Container for the full interaction history

## Parameters

- `include` ((((MapSet.t(integer()) | MapSet.t(String.t())) | term()) | term()) | nil keyword-only default: None)
- `exclude` ((((MapSet.t(integer()) | MapSet.t(String.t())) | term()) | term()) | nil keyword-only default: None)
- `by_alias` (boolean() keyword-only default: False)
- `exclude_unset` (boolean() keyword-only default: False)
- `exclude_defaults` (boolean() keyword-only default: False)
- `exclude_none` (boolean() keyword-only default: False)
- `encoder` (term() | nil keyword-only default: PydanticUndefined)
- `models_as_dict` (boolean() keyword-only default: PydanticUndefined)
- `dumps_kwargs` (term())

## Returns

- `String.t()`

# `model_computed_fields`

```elixir
@spec model_computed_fields(SnakeBridge.Ref.t()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

# `model_config`

```elixir
@spec model_config(SnakeBridge.Ref.t()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

# `model_construct`

```elixir
@spec model_construct(SnakeBridge.Ref.t(), [term()], keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

Creates a new instance of the `Model` class with validated data.

Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data.
Default values are respected, but no other validation is performed.

!!! note
    `model_construct()` generally respects the `model_config.extra` setting on the provided model.
    That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
    and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
    Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
    an error if extra values are passed, but they will be ignored.

## Parameters

- `_fields_set` - A set of field names that were originally explicitly set during instantiation. If provided, this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute. Otherwise, the field names from the `values` argument will be used.
- `values` - Trusted or pre-validated data dictionary.

## Returns

- `term()`

# `model_copy`

```elixir
@spec model_copy(
  SnakeBridge.Ref.t(),
  keyword()
) :: {:ok, term()} | {:error, Snakepit.Error.t()}
```

!!! abstract "Usage Documentation"

`model_copy`

Returns a copy of the model.

!!! note
    The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
    might have unexpected side effects if you store anything in it, on top of the model
    fields (e.g. the value of [cached properties][functools.cached_property]).

## Parameters

- `update` - Values to change/add in the new model. Note: the data is not validated before creating the new model. You should trust this data.
- `deep` - Set to `True` to make a deep copy of the model.

## Returns

- `term()`

# `model_dump`

```elixir
@spec model_dump(
  SnakeBridge.Ref.t(),
  keyword()
) :: {:ok, %{optional(String.t()) => term()}} | {:error, Snakepit.Error.t()}
```

!!! abstract "Usage Documentation"

`model_dump`

Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.

## Parameters

- `mode` - The mode in which `to_python` should run. If mode is 'json', the output will only contain JSON serializable types. If mode is 'python', the output may contain non-JSON-serializable Python objects.
- `include` - A set of fields to include in the output.
- `exclude` - A set of fields to exclude from the output.
- `context` - Additional context to pass to the serializer.
- `by_alias` - Whether to use the field's alias in the dictionary key if defined.
- `exclude_unset` - Whether to exclude fields that have not been explicitly set.
- `exclude_defaults` - Whether to exclude fields that are set to their default value.
- `exclude_none` - Whether to exclude fields that have a value of `None`.
- `exclude_computed_fields` - Whether to exclude computed fields. While this can be useful for round-tripping, it is usually recommended to use the dedicated `round_trip` parameter instead.
- `round_trip` - If True, dumped values should be valid as input for non-idempotent types such as Json[T].
- `warnings` - How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors, "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
- `fallback` - A function to call when an unknown value is encountered. If not provided, a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
- `serialize_as_any` - Whether to serialize fields with duck-typing serialization behavior.

## Returns

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

# `model_dump_json`

```elixir
@spec model_dump_json(
  SnakeBridge.Ref.t(),
  keyword()
) :: {:ok, String.t()} | {:error, Snakepit.Error.t()}
```

!!! abstract "Usage Documentation"

`model_dump_json`

Generates a JSON representation of the model using Pydantic's `to_json` method.

## Parameters

- `indent` - Indentation to use in the JSON output. If None is passed, the output will be compact.
- `ensure_ascii` - If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped. If `False` (the default), these characters will be output as-is.
- `include` - Field(s) to include in the JSON output.
- `exclude` - Field(s) to exclude from the JSON output.
- `context` - Additional context to pass to the serializer.
- `by_alias` - Whether to serialize using field aliases.
- `exclude_unset` - Whether to exclude fields that have not been explicitly set.
- `exclude_defaults` - Whether to exclude fields that are set to their default value.
- `exclude_none` - Whether to exclude fields that have a value of `None`.
- `exclude_computed_fields` - Whether to exclude computed fields. While this can be useful for round-tripping, it is usually recommended to use the dedicated `round_trip` parameter instead.
- `round_trip` - If True, dumped values should be valid as input for non-idempotent types such as Json[T].
- `warnings` - How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors, "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
- `fallback` - A function to call when an unknown value is encountered. If not provided, a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
- `serialize_as_any` - Whether to serialize fields with duck-typing serialization behavior.

## Returns

- `String.t()`

# `model_extra`

```elixir
@spec model_extra(SnakeBridge.Ref.t()) :: {:ok, term()} | {:error, Snakepit.Error.t()}
```

# `model_fields`

```elixir
@spec model_fields(SnakeBridge.Ref.t()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

# `model_fields_set`

```elixir
@spec model_fields_set(SnakeBridge.Ref.t()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

# `model_json_schema`

```elixir
@spec model_json_schema(SnakeBridge.Ref.t(), [term()], keyword()) ::
  {:ok, %{optional(String.t()) => term()}} | {:error, Snakepit.Error.t()}
```

Generates a JSON schema for a model class.

## Parameters

- `by_alias` - Whether to use attribute aliases or not.
- `ref_template` - The reference template.
- `union_format` - The format to use when combining schemas from unions together. Can be one of:
- `schema_generator` - To override the logic used to generate the JSON schema, as a subclass of `GenerateJsonSchema` with your desired modifications
- `mode` - The mode in which to generate the schema.

## Returns

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

# `model_parametrized_name`

```elixir
@spec model_parametrized_name(SnakeBridge.Ref.t(), {term(), term()}, keyword()) ::
  {:ok, String.t()} | {:error, Snakepit.Error.t()}
```

Compute the class name for parametrizations of generic classes.

This method can be overridden to achieve a custom naming scheme for generic BaseModels.

## Parameters

- `params` - Tuple of types of the class. Given a generic class `Model` with 2 type variables and a concrete model `Model[str, int]`, the value `(str, int)` would be passed to `params`.

## Raises

- `ArgumentError` - Raised when trying to generate concrete names for non-generic models.

## Returns

- `String.t()`

# `model_post_init`

```elixir
@spec model_post_init(SnakeBridge.Ref.t(), term(), keyword()) ::
  {:ok, nil} | {:error, Snakepit.Error.t()}
```

Override this method to perform additional initialization after `__init__` and `model_construct`.

This is useful if you want to do some validation that requires the entire model to be initialized.

## Parameters

- `context` (term())

## Returns

- `nil`

# `model_rebuild`

```elixir
@spec model_rebuild(SnakeBridge.Ref.t(), term(), term(), term(), term(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

Try to rebuild the pydantic-core schema for the model.

This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
the initial attempt to build the schema, and automatic rebuilding fails.

## Parameters

- `force` - Whether to force the rebuilding of the model schema, defaults to `False`.
- `raise_errors` - Whether to raise errors, defaults to `True`.
- `_parent_namespace_depth` - The depth level of the parent namespace, defaults to 2.
- `_types_namespace` - The types namespace, defaults to `None`.

## Returns

- `term()`

# `model_validate`

```elixir
@spec model_validate(SnakeBridge.Ref.t(), term(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

Validate a pydantic model instance.

## Parameters

- `obj` - The object to validate.
- `strict` - Whether to enforce types strictly.
- `extra` - Whether to ignore, allow, or forbid extra data during model validation. See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
- `from_attributes` - Whether to extract data from object attributes.
- `context` - Additional context to pass to the validator.
- `by_alias` - Whether to use the field's alias when validating against the provided input data.
- `by_name` - Whether to use the field's name when validating against the provided input data.

## Raises

- `ValidationError` - If the object could not be validated.

## Returns

- `term()`

# `model_validate_json`

```elixir
@spec model_validate_json(SnakeBridge.Ref.t(), term(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

!!! abstract "Usage Documentation"

JSON Parsing

Validate the given JSON data against the Pydantic model.

## Parameters

- `json_data` - The JSON data to validate.
- `strict` - Whether to enforce types strictly.
- `extra` - Whether to ignore, allow, or forbid extra data during model validation. See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
- `context` - Extra variables to pass to the validator.
- `by_alias` - Whether to use the field's alias when validating against the provided input data.
- `by_name` - Whether to use the field's name when validating against the provided input data.

## Raises

- `ValidationError` - If `json_data` is not a JSON string or the object could not be validated.

## Returns

- `term()`

# `model_validate_strings`

```elixir
@spec model_validate_strings(SnakeBridge.Ref.t(), term(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

Validate the given object with string data against the Pydantic model.

## Parameters

- `obj` - The object containing string data to validate.
- `strict` - Whether to enforce types strictly.
- `extra` - Whether to ignore, allow, or forbid extra data during model validation. See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
- `context` - Extra variables to pass to the validator.
- `by_alias` - Whether to use the field's alias when validating against the provided input data.
- `by_name` - Whether to use the field's name when validating against the provided input data.

## Returns

- `term()`

# `new`

```elixir
@spec new(keyword()) :: {:ok, SnakeBridge.Ref.t()} | {:error, Snakepit.Error.t()}
```

Create a new model by parsing and validating input data from keyword arguments.

Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
validated to form a valid model.

`self` is explicitly positional-only to allow `self` as a field name.

## Parameters

- `data` (term())

# `parse_file`

```elixir
@spec parse_file(
  SnakeBridge.Ref.t(),
  term(),
  term(),
  term(),
  term(),
  term(),
  keyword()
) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

REPL data types for RLM and interpreter interactions.

These types represent the state and history of REPL-based execution:
- REPLVariable: Metadata about variables available in the REPL
- REPLEntry: A single interaction (reasoning, code, output)
- REPLHistory: Container for the full interaction history

## Parameters

- `path` (term())
- `content_type` (term())
- `encoding` (term())
- `proto` (term())
- `allow_pickle` (term())

## Returns

- `term()`

# `parse_obj`

```elixir
@spec parse_obj(SnakeBridge.Ref.t(), term(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

REPL data types for RLM and interpreter interactions.

These types represent the state and history of REPL-based execution:
- REPLVariable: Metadata about variables available in the REPL
- REPLEntry: A single interaction (reasoning, code, output)
- REPLHistory: Container for the full interaction history

## Parameters

- `obj` (term())

## Returns

- `term()`

# `parse_raw`

```elixir
@spec parse_raw(
  SnakeBridge.Ref.t(),
  term(),
  term(),
  term(),
  term(),
  term(),
  keyword()
) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

REPL data types for RLM and interpreter interactions.

These types represent the state and history of REPL-based execution:
- REPLVariable: Metadata about variables available in the REPL
- REPLEntry: A single interaction (reasoning, code, output)
- REPLHistory: Container for the full interaction history

## Parameters

- `b` (term())
- `content_type` (term())
- `encoding` (term())
- `proto` (term())
- `allow_pickle` (term())

## Returns

- `term()`

# `schema`

```elixir
@spec schema(SnakeBridge.Ref.t(), [term()], keyword()) ::
  {:ok, %{optional(String.t()) => term()}} | {:error, Snakepit.Error.t()}
```

REPL data types for RLM and interpreter interactions.

These types represent the state and history of REPL-based execution:
- REPLVariable: Metadata about variables available in the REPL
- REPLEntry: A single interaction (reasoning, code, output)
- REPLHistory: Container for the full interaction history

## Parameters

- `by_alias` (boolean() default: True)
- `ref_template` (String.t() default: '#/$defs/{model}')

## Returns

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

# `schema_json`

```elixir
@spec schema_json(
  SnakeBridge.Ref.t(),
  keyword()
) :: {:ok, String.t()} | {:error, Snakepit.Error.t()}
```

REPL data types for RLM and interpreter interactions.

These types represent the state and history of REPL-based execution:
- REPLVariable: Metadata about variables available in the REPL
- REPLEntry: A single interaction (reasoning, code, output)
- REPLHistory: Container for the full interaction history

## Parameters

- `by_alias` (boolean() keyword-only default: True)
- `ref_template` (String.t() keyword-only default: '#/$defs/{model}')
- `dumps_kwargs` (term())

## Returns

- `String.t()`

# `serialize_model`

```elixir
@spec serialize_model(
  SnakeBridge.Ref.t(),
  keyword()
) :: {:ok, String.t()} | {:error, Snakepit.Error.t()}
```

REPL data types for RLM and interpreter interactions.

These types represent the state and history of REPL-based execution:
- REPLVariable: Metadata about variables available in the REPL
- REPLEntry: A single interaction (reasoning, code, output)
- REPLHistory: Container for the full interaction history

## Returns

- `String.t()`

# `update_forward_refs`

```elixir
@spec update_forward_refs(
  SnakeBridge.Ref.t(),
  keyword()
) :: {:ok, nil} | {:error, Snakepit.Error.t()}
```

REPL data types for RLM and interpreter interactions.

These types represent the state and history of REPL-based execution:
- REPLVariable: Metadata about variables available in the REPL
- REPLEntry: A single interaction (reasoning, code, output)
- REPLHistory: Container for the full interaction history

## Parameters

- `localns` (term())

## Returns

- `nil`

# `validate`

```elixir
@spec validate(SnakeBridge.Ref.t(), term(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

REPL data types for RLM and interpreter interactions.

These types represent the state and history of REPL-based execution:
- REPLVariable: Metadata about variables available in the REPL
- REPLEntry: A single interaction (reasoning, code, output)
- REPLHistory: Container for the full interaction history

## Parameters

- `value` (term())

## Returns

- `term()`

---

*Consult [api-reference.md](api-reference.md) for complete listing*