# `Vllm.Multimodal.Inputs.MultiModalKwargsItems`
[🔗](https://github.com/nshkrdotcom/vllm/blob/v0.3.0/lib/snakebridge_generated/vllm/multimodal/inputs/multi_modal_kwargs_items.ex#L7)

A dictionary of

[`MultiModalKwargsItem`][vllm.multimodal.inputs.MultiModalKwargsItem]s
by modality.

# `t`

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

# `clear`

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

D.clear() -> None.  Remove all items from D.

## Returns

- `term()`

# `copy`

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

Python method `MultiModalKwargsItems.copy`.

## Returns

- `term()`

# `from_hf_inputs`

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

Python method `MultiModalKwargsItems.from_hf_inputs`.

## Parameters

- `hf_inputs` (term())
- `config_by_key` (term())

## Returns

- `term()`

# `from_seq`

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

Python method `MultiModalKwargsItems.from_seq`.

## Parameters

- `items` (term())

## Returns

- `term()`

# `fromkeys`

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

Python method `MultiModalKwargsItems.fromkeys`.

## Parameters

- `iterable` (term())
- `value` (term() default: None)

## Returns

- `term()`

# `get`

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

D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.

## Parameters

- `key` (term())
- `default` (term() default: None)

## Returns

- `term()`

# `get_data`

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

Construct a dictionary of keyword arguments to pass to the model.

## Parameters

- `device` (((term() | String.t()) | integer()) | nil keyword-only default: None)
- `pin_memory` (boolean() keyword-only default: False)

## Returns

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

# `items`

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

D.items() -> a set-like object providing a view on D's items

## Returns

- `term()`

# `keys`

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

D.keys() -> a set-like object providing a view on D's keys

## Returns

- `term()`

# `new`

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

Initialize self.  See help(type(self)) for accurate signature.

## Parameters

- `dict` (term() default: None)
- `kwargs` (term())

# `pop`

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

D.pop(k[,d]) -> v, remove specified key and return the corresponding value.

If key is not found, d is returned if given, otherwise KeyError is raised.

## Parameters

- `key` (term())
- `default` (term() default: <object object at 0x7272d76e01c0>)

## Returns

- `term()`

# `popitem`

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

D.popitem() -> (k, v), remove and return some (key, value) pair

as a 2-tuple; but raise KeyError if D is empty.

## Returns

- `term()`

# `require_data`

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

Python method `MultiModalKwargsItems.require_data`.

## Returns

- `term()`

# `setdefault`

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

D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D

## Parameters

- `key` (term())
- `default` (term() default: None)

## Returns

- `term()`

# `update`

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

D.update([E, ]**F) -> None.  Update D from mapping/iterable E and F.

If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
In either case, this is followed by: for k, v in F.items(): D[k] = v

## Parameters

- `other` (term() default: ())
- `kwds` (term())

## Returns

- `term()`

# `values`

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

D.values() -> an object providing a view on D's values

## Returns

- `term()`

---

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