# `Vllm.Config.SchedulerConfig`
[🔗](https://github.com/nshkrdotcom/vllm/blob/v0.3.0/lib/snakebridge_generated/vllm/config/scheduler_config.ex#L7)

Scheduler configuration.

# `t`

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

# `_skip_none_validation`

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

Skip validation if the value is `None` when initialisation is delayed.

## Parameters

- `value` (term())
- `handler` (term())

## Returns

- `term()`

# `async_scheduling`

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

# `compute_hash`

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

WARNING: Whenever a new field is added to this config,

ensure that it is included in the factors list if
it affects the computation graph.

Provide a hash that uniquely identifies all the configs
that affect the structure of the computation
graph from input ids/embeddings to the final hidden states,
excluding anything before input ids/embeddings and after
the final hidden states.

## Returns

- `String.t()`

# `default_factory`

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

Factory method to create `SchedulerConfig` with default values for `InitVar`s.

## Parameters

- `kwargs` (term())

## Returns

- `term()`

# `default_max_num_batched_tokens`

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

# `default_max_num_seqs`

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

# `disable_chunked_mm_input`

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

# `disable_hybrid_kv_cache_manager`

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

# `enable_chunked_prefill`

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

# `encoder_cache_size`

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

# `get_scheduler_cls`

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

Python method `SchedulerConfig.get_scheduler_cls`.

## Returns

- `term()`

# `is_multimodal_model`

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

# `long_prefill_token_threshold`

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

# `max_long_partial_prefills`

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

# `max_num_batched_tokens`

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

# `max_num_encoder_input_tokens`

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

# `max_num_partial_prefills`

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

# `max_num_seqs`

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

# `new`

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

Constructs `SchedulerConfig`.

## Parameters

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

# `policy`

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

# `runner_type`

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

# `scheduler_cls`

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

# `stream_interval`

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

# `verify_max_model_len`

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

Python method `SchedulerConfig.verify_max_model_len`.

## Parameters

- `max_model_len` (integer())

## Returns

- `term()`

---

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