# `Obscura.Tiktoken.Encoding`
[🔗](https://github.com/hfiguera/obscura/blob/v0.2.0/lib/obscura/tiktoken/encoding.ex#L1)

A tiktoken-compatible byte-pair encoding.

# `special_selector`

```elixir
@type special_selector() :: :all | [String.t()] | MapSet.t(String.t())
```

# `t`

```elixir
@type t() :: %Obscura.Tiktoken.Encoding{
  decoder: %{required(non_neg_integer()) => binary()},
  eot_token: non_neg_integer() | nil,
  explicit_n_vocab: non_neg_integer() | nil,
  max_token_value: non_neg_integer(),
  mergeable_ranks: %{required(binary()) => non_neg_integer()},
  name: String.t(),
  pat_str: String.t(),
  pattern: Regex.t(),
  sorted_token_bytes: [binary()],
  special_token_values: MapSet.t(non_neg_integer()),
  special_tokens: %{required(String.t()) => non_neg_integer()},
  special_tokens_decoder: %{required(non_neg_integer()) => binary()}
}
```

# `decode`

```elixir
@spec decode(t(), [non_neg_integer()], keyword()) ::
  {:ok, String.t()} | {:error, term()}
```

# `decode!`

```elixir
@spec decode!(t(), [non_neg_integer()], keyword()) :: String.t()
```

# `decode_bytes`

```elixir
@spec decode_bytes(t(), [non_neg_integer()]) :: {:ok, binary()} | {:error, term()}
```

# `decode_bytes!`

```elixir
@spec decode_bytes!(t(), [non_neg_integer()]) :: binary()
```

# `decode_single_token_bytes`

```elixir
@spec decode_single_token_bytes(t(), non_neg_integer()) ::
  {:ok, binary()} | {:error, term()}
```

# `decode_tokens_bytes`

```elixir
@spec decode_tokens_bytes(t(), [non_neg_integer()]) ::
  {:ok, [binary()]} | {:error, term()}
```

# `decode_with_offsets`

```elixir
@spec decode_with_offsets(t(), [non_neg_integer()]) ::
  {:ok, {String.t(), [non_neg_integer()]}} | {:error, term()}
```

# `encode`

```elixir
@spec encode(t(), String.t(), keyword()) ::
  {:ok, [non_neg_integer()]} | {:error, term()}
```

# `encode!`

```elixir
@spec encode!(t(), String.t(), keyword()) :: [non_neg_integer()]
```

# `encode_ordinary`

```elixir
@spec encode_ordinary(t(), String.t()) ::
  {:ok, [non_neg_integer()]} | {:error, term()}
```

# `encode_ordinary!`

```elixir
@spec encode_ordinary!(t(), String.t()) :: [non_neg_integer()]
```

# `encode_single_piece`

```elixir
@spec encode_single_piece(t(), String.t() | binary()) ::
  {:ok, [non_neg_integer()]} | {:error, term()}
```

# `encode_single_token`

```elixir
@spec encode_single_token(t(), String.t() | binary()) ::
  {:ok, non_neg_integer()} | {:error, term()}
```

# `n_vocab`

```elixir
@spec n_vocab(t()) :: non_neg_integer()
```

# `new`

```elixir
@spec new(keyword()) :: {:ok, t()} | {:error, term()}
```

# `special_token?`

```elixir
@spec special_token?(t(), non_neg_integer()) :: boolean()
```

# `token_byte_values`

```elixir
@spec token_byte_values(t()) :: [binary()]
```

---

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