Add files using upload-large-folder tool

vllm/lib/python3.10/site-packages/braceexpand-0.1.7.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

vllm/lib/python3.10/site-packages/braceexpand-0.1.7.dist-info/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Stanis Trendelenburg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vllm/lib/python3.10/site-packages/braceexpand-0.1.7.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.36.2)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

vllm/lib/python3.10/site-packages/braceexpand-0.1.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+braceexpand

vllm/lib/python3.10/site-packages/gguf/tensor_mapping.py

@@ -0,0 +1,657 @@
+from __future__ import annotations
+
+from typing import Sequence
+
+from .constants import MODEL_ARCH, MODEL_TENSOR, MODEL_TENSORS, TENSOR_NAMES
+
+
+class TensorNameMap:
+    mappings_cfg: dict[MODEL_TENSOR, tuple[str, ...]] = {
+        # Token embeddings
+        MODEL_TENSOR.TOKEN_EMBD: (
+            "gpt_neox.embed_in",                         # gptneox
+            "transformer.wte",                           # gpt2 gpt-j mpt refact qwen dbrx jais exaone
+            "transformer.word_embeddings",               # falcon
+            "word_embeddings",                           # bloom
+            "model.embed_tokens",                        # llama-hf nemotron
+            "tok_embeddings",                            # llama-pth
+            "embeddings.word_embeddings",                # bert nomic-bert
+            "language_model.embedding.word_embeddings",  # persimmon
+            "wte",                                       # gpt2
+            "transformer.embd.wte",                      # phi2
+            "model.tok_embeddings",                      # internlm2
+            "model.embedding",                           # mamba-qbert
+            "backbone.embedding",                        # mamba
+            "backbone.embeddings",                       # mamba-hf
+            "transformer.in_out_embed",                  # Grok
+            "embedding.word_embeddings",                 # chatglm
+            "transformer.token_embeddings",              # openelm
+            "shared",                                    # t5
+        ),
+
+        # Token type embeddings
+        MODEL_TENSOR.TOKEN_TYPES: (
+            "embeddings.token_type_embeddings",  # bert nomic-bert
+        ),
+
+        # Normalization of token embeddings
+        MODEL_TENSOR.TOKEN_EMBD_NORM: (
+            "word_embeddings_layernorm",  # bloom
+            "embeddings.LayerNorm",       # bert
+            "emb_ln",                     # nomic-bert
+            "transformer.norm",           # openelm
+        ),
+
+        # Position embeddings
+        MODEL_TENSOR.POS_EMBD: (
+            "transformer.wpe",                 # gpt2
+            "embeddings.position_embeddings",  # bert
+            "wpe",                             # gpt2
+        ),
+
+        # Output
+        MODEL_TENSOR.OUTPUT: (
+            "embed_out",                 # gptneox
+            "lm_head",                   # gpt2 mpt falcon llama-hf baichuan qwen mamba dbrx jais nemotron exaone
+            "output",                    # llama-pth bloom internlm2
+            "word_embeddings_for_head",  # persimmon
+            "lm_head.linear",            # phi2
+            "output_layer",              # chatglm
+        ),
+
+        # Output norm
+        MODEL_TENSOR.OUTPUT_NORM: (
+            "gpt_neox.final_layer_norm",               # gptneox
+            "transformer.ln_f",                        # gpt2 gpt-j falcon jais exaone
+            "model.norm",                              # llama-hf baichuan internlm2
+            "norm",                                    # llama-pth
+            "transformer.norm_f",                      # mpt dbrx
+            "ln_f",                                    # refact bloom qwen gpt2
+            "language_model.encoder.final_layernorm",  # persimmon
+            "model.final_layernorm",                   # persimmon
+            "lm_head.ln",                              # phi2
+            "model.norm_f",                            # mamba-qbert
+            "backbone.norm_f",                         # mamba
+            "transformer.rms_norm",                    # Grok
+            "encoder.final_layernorm",                 # chatglm
+            "transformer.norm",                        # openelm
+            "model.norm",                              # nemotron
+        ),
+
+        # Rope frequencies
+        MODEL_TENSOR.ROPE_FREQS: (
+            "rope.freqs",  # llama-pth
+            "rotary_pos_emb.inv_freq",  # chatglm
+        ),
+    }
+
+    block_mappings_cfg: dict[MODEL_TENSOR, tuple[str, ...]] = {
+        # Attention norm
+        MODEL_TENSOR.ATTN_NORM: (
+            "gpt_neox.layers.{bid}.input_layernorm",                # gptneox
+            "transformer.h.{bid}.ln_1",                             # gpt2 gpt-j refact qwen jais exaone
+            "transformer.blocks.{bid}.norm_1",                      # mpt
+            "transformer.h.{bid}.input_layernorm",                  # falcon7b
+            "h.{bid}.input_layernorm",                              # bloom
+            "transformer.h.{bid}.ln_mlp",                           # falcon40b
+            "model.layers.{bid}.input_layernorm",                   # llama-hf nemotron
+            "layers.{bid}.attention_norm",                          # llama-pth
+            "language_model.encoder.layers.{bid}.input_layernorm",  # persimmon
+            "model.layers.{bid}.ln1",                               # yi
+            "h.{bid}.ln_1",                                         # gpt2
+            "transformer.h.{bid}.ln",                               # phi2
+            "model.layers.layers.{bid}.norm",                       # plamo
+            "model.layers.{bid}.attention_norm",                    # internlm2
+            "model.layers.{bid}.norm",                              # mamba-qbert
+            "backbone.layers.{bid}.norm",                           # mamba
+            "transformer.decoder_layer.{bid}.rms_norm",             # Grok
+            "transformer.blocks.{bid}.norm_attn_norm.norm_1",       # dbrx
+            "encoder.layers.{bid}.input_layernorm",                 # chatglm
+            "transformer.layers.{bid}.attn_norm",                   # openelm
+        ),
+
+        # Attention norm 2
+        MODEL_TENSOR.ATTN_NORM_2: (
+            "transformer.h.{bid}.ln_attn",  # falcon40b
+            "encoder.layer.{bid}.layer_norm_1",             # jina-v2-code
+        ),
+
+        # Attention query-key-value
+        MODEL_TENSOR.ATTN_QKV: (
+            "gpt_neox.layers.{bid}.attention.query_key_value",                     # gptneox
+            "transformer.h.{bid}.attn.c_attn",                                     # gpt2 qwen jais
+            "transformer.blocks.{bid}.attn.Wqkv",                                  # mpt
+            "transformer.blocks.{bid}.norm_attn_norm.attn.Wqkv",                   # dbrx
+            "transformer.h.{bid}.self_attention.query_key_value",                  # falcon
+            "h.{bid}.self_attention.query_key_value",                              # bloom
+            "language_model.encoder.layers.{bid}.self_attention.query_key_value",  # persimmon
+            "model.layers.{bid}.self_attn.query_key_value",                        # persimmon
+            "h.{bid}.attn.c_attn",                                                 # gpt2
+            "transformer.h.{bid}.mixer.Wqkv",                                      # phi2
+            "encoder.layers.{bid}.attn.Wqkv",                                      # nomic-bert
+            "model.layers.{bid}.self_attn.qkv_proj",                               # phi3
+            "encoder.layers.{bid}.self_attention.query_key_value",                 # chatglm
+            "transformer.layers.{bid}.attn.qkv_proj",                              # openelm
+        ),
+
+        # Attention query
+        MODEL_TENSOR.ATTN_Q: (
+            "model.layers.{bid}.self_attn.q_proj",                       # llama-hf nemotron
+            "layers.{bid}.attention.wq",                                 # llama-pth
+            "encoder.layer.{bid}.attention.self.query",                  # bert
+            "transformer.h.{bid}.attn.q_proj",                           # gpt-j
+            "model.layers.layers.{bid}.self_attn.q_proj",                # plamo
+            "model.layers.{bid}.attention.wq",                           # internlm2
+            "transformer.decoder_layer.{bid}.multi_head_attention.query",# Grok
+            "transformer.h.{bid}.attn.attention.q_proj",                 # exaone
+        ),
+
+        # Attention key
+        MODEL_TENSOR.ATTN_K: (
+            "model.layers.{bid}.self_attn.k_proj",                     # llama-hf nemotron
+            "layers.{bid}.attention.wk",                               # llama-pth
+            "encoder.layer.{bid}.attention.self.key",                  # bert
+            "transformer.h.{bid}.attn.k_proj",                         # gpt-j
+            "transformer.h.{bid}.attn.k",                              # refact
+            "model.layers.layers.{bid}.self_attn.k_proj",              # plamo
+            "model.layers.{bid}.attention.wk",                         # internlm2
+            "transformer.decoder_layer.{bid}.multi_head_attention.key",# Grok
+            "transformer.h.{bid}.attn.attention.k_proj",               # exaone
+        ),
+
+        # Attention value
+        MODEL_TENSOR.ATTN_V: (
+            "model.layers.{bid}.self_attn.v_proj",                       # llama-hf nemotron
+            "layers.{bid}.attention.wv",                                 # llama-pth
+            "encoder.layer.{bid}.attention.self.value",                  # bert
+            "transformer.h.{bid}.attn.v_proj",                           # gpt-j
+            "transformer.h.{bid}.attn.v",                                # refact
+            "model.layers.layers.{bid}.self_attn.v_proj",                # plamo
+            "model.layers.{bid}.attention.wv",                           # internlm2
+            "transformer.decoder_layer.{bid}.multi_head_attention.value",# Grok
+            "transformer.h.{bid}.attn.attention.v_proj",                 # exaone
+        ),
+
+        # Attention output
+        MODEL_TENSOR.ATTN_OUT: (
+            "gpt_neox.layers.{bid}.attention.dense",                        # gptneox
+            "transformer.h.{bid}.attn.c_proj",                              # gpt2 refact qwen jais
+            "transformer.blocks.{bid}.attn.out_proj",                       # mpt
+            "transformer.h.{bid}.self_attention.dense",                     # falcon
+            "h.{bid}.self_attention.dense",                                 # bloom
+            "model.layers.{bid}.self_attn.o_proj",                          # llama-hf nemotron
+            "layers.{bid}.attention.wo",                                    # llama-pth
+            "encoder.layer.{bid}.attention.output.dense",                   # bert
+            "transformer.h.{bid}.attn.out_proj",                            # gpt-j
+            "language_model.encoder.layers.{bid}.self_attention.dense",     # persimmon
+            "model.layers.{bid}.self_attn.dense",                           # persimmon
+            "h.{bid}.attn.c_proj",                                          # gpt2
+            "transformer.h.{bid}.mixer.out_proj",                           # phi2
+            "model.layers.layers.{bid}.self_attn.o_proj",                   # plamo
+            "model.layers.{bid}.attention.wo",                              # internlm2
+            "encoder.layers.{bid}.attn.out_proj",                           # nomic-bert
+            "transformer.decoder_layer.{bid}.multi_head_attention.linear",  # Grok
+            "transformer.blocks.{bid}.norm_attn_norm.attn.out_proj",        # dbrx
+            "encoder.layers.{bid}.self_attention.dense",                    # chatglm
+            "transformer.layers.{bid}.attn.out_proj",                       # openelm
+            "transformer.h.{bid}.attn.attention.out_proj",                  # exaone
+        ),
+
+        # Attention output norm
+        MODEL_TENSOR.ATTN_OUT_NORM: (
+            "encoder.layer.{bid}.attention.output.LayerNorm",  # bert
+            "encoder.layers.{bid}.norm1",                      # nomic-bert
+            "transformer.decoder_layer.{bid}.rms_norm_1",      # Grok
+            "transformer.blocks.{bid}.norm_attn_norm.norm_2",  # dbrx
+        ),
+
+        MODEL_TENSOR.ATTN_POST_NORM: (
+            "model.layers.{bid}.post_attention_layernorm",     # gemma2
+        ),
+
+        # Rotary embeddings
+        MODEL_TENSOR.ATTN_ROT_EMBD: (
+            "model.layers.{bid}.self_attn.rotary_emb.inv_freq",        # llama-hf
+            "layers.{bid}.attention.inner_attention.rope.freqs",       # llama-pth
+            "model.layers.layers.{bid}.self_attn.rotary_emb.inv_freq", # plamo
+            "transformer.h.{bid}.attn.rotary_emb.inv_freq",            # codeshell
+        ),
+
+        # Feed-forward norm
+        MODEL_TENSOR.FFN_NORM: (
+            "gpt_neox.layers.{bid}.post_attention_layernorm",                # gptneox
+            "transformer.h.{bid}.ln_2",                                      # gpt2 refact qwen jais exaone
+            "h.{bid}.post_attention_layernorm",                              # bloom
+            "transformer.blocks.{bid}.norm_2",                               # mpt
+            "model.layers.{bid}.post_attention_layernorm",                   # llama-hf nemotron
+            "layers.{bid}.ffn_norm",                                         # llama-pth
+            "language_model.encoder.layers.{bid}.post_attention_layernorm",  # persimmon
+            "model.layers.{bid}.ln2",                                        # yi
+            "h.{bid}.ln_2",                                                  # gpt2
+            "model.layers.{bid}.ffn_norm",                                   # internlm2
+            "transformer.decoder_layer.{bid}.rms_norm_2",                    # Grok
+            "encoder.layers.{bid}.post_attention_layernorm",                 # chatglm
+            "transformer.layers.{bid}.ffn_norm",                             # openelm
+        ),
+
+        # Post feed-forward norm
+        MODEL_TENSOR.FFN_PRE_NORM: (
+            "model.layers.{bid}.pre_feedforward_layernorm", # gemma2
+        ),
+
+        # Post feed-forward norm
+        MODEL_TENSOR.FFN_POST_NORM: (
+            "model.layers.{bid}.post_feedforward_layernorm", # gemma2
+        ),
+
+        MODEL_TENSOR.FFN_GATE_INP: (
+            "layers.{bid}.feed_forward.gate",             # mixtral
+            "model.layers.{bid}.block_sparse_moe.gate",   # mixtral
+            "model.layers.{bid}.mlp.gate",                # qwen2moe
+            "transformer.decoder_layer.{bid}.router",     # Grok
+            "transformer.blocks.{bid}.ffn.router.layer",  # dbrx
+        ),
+
+        MODEL_TENSOR.FFN_GATE_INP_SHEXP: (
+            "model.layers.{bid}.mlp.shared_expert_gate", # qwen2moe
+        ),
+
+        # Feed-forward up
+        MODEL_TENSOR.FFN_UP: (
+            "gpt_neox.layers.{bid}.mlp.dense_h_to_4h",                # gptneox
+            "transformer.h.{bid}.mlp.c_fc",                           # gpt2 jais
+            "transformer.blocks.{bid}.ffn.up_proj",                   # mpt
+            "transformer.h.{bid}.mlp.dense_h_to_4h",                  # falcon
+            "h.{bid}.mlp.dense_h_to_4h",                              # bloom
+            "model.layers.{bid}.mlp.up_proj",                         # llama-hf refact nemotron
+            "layers.{bid}.feed_forward.w3",                           # llama-pth
+            "encoder.layer.{bid}.intermediate.dense",                 # bert
+            "transformer.h.{bid}.mlp.fc_in",                          # gpt-j
+            "transformer.h.{bid}.mlp.linear_3",                       # refact
+            "language_model.encoder.layers.{bid}.mlp.dense_h_to_4h",  # persimmon
+            "model.layers.{bid}.mlp.dense_h_to_4h",                   # persimmon
+            "transformer.h.{bid}.mlp.w1",                             # qwen
+            "h.{bid}.mlp.c_fc",                                       # gpt2
+            "transformer.h.{bid}.mlp.fc1",                            # phi2
+            "model.layers.{bid}.mlp.fc1",                             # phi2
+            "model.layers.{bid}.mlp.gate_up_proj",                    # phi3
+            "model.layers.layers.{bid}.mlp.up_proj",                  # plamo
+            "model.layers.{bid}.feed_forward.w3",                     # internlm2
+            "encoder.layers.{bid}.mlp.fc11",                          # nomic-bert
+            "model.layers.{bid}.mlp.c_fc",                            # starcoder2
+            "encoder.layer.{bid}.mlp.gated_layers_v",                 # jina-bert-v2
+            "model.layers.{bid}.residual_mlp.w3",                     # arctic
+            "encoder.layers.{bid}.mlp.dense_h_to_4h",                 # chatglm
+            "transformer.h.{bid}.mlp.c_fc_1",                         # exaone
+        ),
+
+        MODEL_TENSOR.FFN_UP_EXP: (
+            "layers.{bid}.feed_forward.experts.w3",          # mixtral (merged)
+            "transformer.decoder_layer.{bid}.moe.linear_v",  # Grok (merged)
+            "transformer.blocks.{bid}.ffn.experts.mlp.v1",   # dbrx
+            "model.layers.{bid}.mlp.experts.up_proj",        # qwen2moe (merged)
+        ),
+
+        MODEL_TENSOR.FFN_UP_SHEXP: (
+            "model.layers.{bid}.mlp.shared_expert.up_proj",  # qwen2moe
+            "model.layers.{bid}.mlp.shared_experts.up_proj", # deepseek2
+        ),
+
+        # AWQ-activation gate
+        MODEL_TENSOR.FFN_ACT: (
+            "transformer.blocks.{bid}.ffn.act",  # mpt
+        ),
+
+        # Feed-forward gate
+        MODEL_TENSOR.FFN_GATE: (
+            "model.layers.{bid}.mlp.gate_proj",           # llama-hf refact
+            "layers.{bid}.feed_forward.w1",               # llama-pth
+            "transformer.h.{bid}.mlp.w2",                 # qwen
+            "transformer.h.{bid}.mlp.c_fc2",              # jais
+            "model.layers.layers.{bid}.mlp.gate_proj",    # plamo
+            "model.layers.{bid}.feed_forward.w1",         # internlm2
+            "encoder.layers.{bid}.mlp.fc12",              # nomic-bert
+            "encoder.layer.{bid}.mlp.gated_layers_w",     # jina-bert-v2
+            "transformer.h.{bid}.mlp.linear_1",           # refact
+            "model.layers.{bid}.residual_mlp.w1",         # arctic
+            "transformer.h.{bid}.mlp.c_fc_0",             # exaone
+        ),
+
+        MODEL_TENSOR.FFN_GATE_EXP: (
+            "layers.{bid}.feed_forward.experts.w1",         # mixtral (merged)
+            "transformer.decoder_layer.{bid}.moe.linear",   # Grok (merged)
+            "transformer.blocks.{bid}.ffn.experts.mlp.w1",  # dbrx
+            "model.layers.{bid}.mlp.experts.gate_proj",     # qwen2moe (merged)
+        ),
+
+        MODEL_TENSOR.FFN_GATE_SHEXP: (
+            "model.layers.{bid}.mlp.shared_expert.gate_proj",  # qwen2moe
+            "model.layers.{bid}.mlp.shared_experts.gate_proj", # deepseek2
+        ),
+
+        # Feed-forward down
+        MODEL_TENSOR.FFN_DOWN: (
+            "gpt_neox.layers.{bid}.mlp.dense_4h_to_h",                # gptneox
+            "transformer.h.{bid}.mlp.c_proj",                         # gpt2 refact qwen jais
+            "transformer.blocks.{bid}.ffn.down_proj",                 # mpt
+            "transformer.h.{bid}.mlp.dense_4h_to_h",                  # falcon
+            "h.{bid}.mlp.dense_4h_to_h",                              # bloom
+            "model.layers.{bid}.mlp.down_proj",                       # llama-hf nemotron
+            "layers.{bid}.feed_forward.w2",                           # llama-pth
+            "encoder.layer.{bid}.output.dense",                       # bert
+            "transformer.h.{bid}.mlp.fc_out",                         # gpt-j
+            "language_model.encoder.layers.{bid}.mlp.dense_4h_to_h",  # persimmon
+            "model.layers.{bid}.mlp.dense_4h_to_h",                   # persimmon
+            "h.{bid}.mlp.c_proj",                                     # gpt2
+            "transformer.h.{bid}.mlp.fc2",                            # phi2
+            "model.layers.{bid}.mlp.fc2",                             # phi2
+            "model.layers.layers.{bid}.mlp.down_proj",                # plamo
+            "model.layers.{bid}.feed_forward.w2",                     # internlm2
+            "encoder.layers.{bid}.mlp.fc2",                           # nomic-bert
+            "model.layers.{bid}.mlp.c_proj",                          # starcoder2
+            "encoder.layer.{bid}.mlp.wo",                             # jina-bert-v2
+            "transformer.layers.{bid}.ffn.proj_2",                    # openelm
+            "model.layers.{bid}.residual_mlp.w2",                     # arctic
+            "encoder.layer.{bid}.mlp.down_layer",                     # jina-bert-v2
+            "encoder.layers.{bid}.mlp.dense_4h_to_h",                 # chatglm
+            "model.layers.h.{bid}.mlp.c_proj",                        # exaone
+        ),
+
+        MODEL_TENSOR.FFN_DOWN_EXP: (
+            "layers.{bid}.feed_forward.experts.w2",          # mixtral (merged)
+            "transformer.decoder_layer.{bid}.moe.linear_1",  # Grok (merged)
+            "transformer.blocks.{bid}.ffn.experts.mlp.w2",   # dbrx
+            "model.layers.{bid}.mlp.experts.down_proj",      # qwen2moe (merged)
+        ),
+
+        MODEL_TENSOR.FFN_DOWN_SHEXP: (
+            "model.layers.{bid}.mlp.shared_expert.down_proj",  # qwen2moe
+            "model.layers.{bid}.mlp.shared_experts.down_proj", # deepseek2
+        ),
+
+        MODEL_TENSOR.ATTN_Q_NORM: (
+            "language_model.encoder.layers.{bid}.self_attention.q_layernorm",
+            "model.layers.{bid}.self_attn.q_layernorm",                       # persimmon
+            "model.layers.{bid}.self_attn.q_norm",                            # cohere
+            "transformer.blocks.{bid}.attn.q_ln",                             # sea-lion
+            "encoder.layer.{bid}.attention.self.layer_norm_q",                # jina-bert-v2
+            "transformer.layers.{bid}.attn.q_norm",                           # openelm
+        ),
+
+        MODEL_TENSOR.ATTN_K_NORM: (
+            "language_model.encoder.layers.{bid}.self_attention.k_layernorm",
+            "model.layers.{bid}.self_attn.k_layernorm",                       # persimmon
+            "model.layers.{bid}.self_attn.k_norm",                            # cohere
+            "transformer.blocks.{bid}.attn.k_ln",                             # sea-lion
+            "encoder.layer.{bid}.attention.self.layer_norm_k",                # jina-bert-v2
+            "transformer.layers.{bid}.attn.k_norm",                           # openelm
+        ),
+
+        MODEL_TENSOR.ROPE_FREQS: (
+            "language_model.encoder.layers.{bid}.self_attention.rotary_emb.inv_freq",  # persimmon
+        ),
+
+        MODEL_TENSOR.LAYER_OUT_NORM: (
+            "encoder.layer.{bid}.output.LayerNorm",         # bert
+            "encoder.layers.{bid}.norm2",                   # nomic-bert
+            "transformer.decoder_layer.{bid}.rms_norm_3",   # Grok
+            "encoder.layer.{bid}.mlp.layernorm",            # jina-bert-v2
+            "encoder.layer.{bid}.layer_norm_2"              # jina-v2-code
+        ),
+
+        MODEL_TENSOR.SSM_IN: (
+            "model.layers.{bid}.in_proj",
+            "backbone.layers.{bid}.mixer.in_proj",
+        ),
+
+        MODEL_TENSOR.SSM_CONV1D: (
+            "model.layers.{bid}.conv1d",
+            "backbone.layers.{bid}.mixer.conv1d",
+        ),
+
+        MODEL_TENSOR.SSM_X: (
+            "model.layers.{bid}.x_proj",
+            "backbone.layers.{bid}.mixer.x_proj",
+        ),
+
+        MODEL_TENSOR.SSM_DT: (
+            "model.layers.{bid}.dt_proj",
+            "backbone.layers.{bid}.mixer.dt_proj",
+        ),
+
+        MODEL_TENSOR.SSM_A: (
+            "model.layers.{bid}.A_log",
+            "backbone.layers.{bid}.mixer.A_log",
+        ),
+
+        MODEL_TENSOR.SSM_D: (
+            "model.layers.{bid}.D",
+            "backbone.layers.{bid}.mixer.D",
+        ),
+
+        MODEL_TENSOR.SSM_OUT: (
+            "model.layers.{bid}.out_proj",
+            "backbone.layers.{bid}.mixer.out_proj",
+        ),
+
+        MODEL_TENSOR.ATTN_Q_A: (
+            "model.layers.{bid}.self_attn.q_a_proj", # deepseek2
+        ),
+
+        MODEL_TENSOR.ATTN_Q_B: (
+            "model.layers.{bid}.self_attn.q_b_proj", # deepseek2
+        ),
+
+        MODEL_TENSOR.ATTN_KV_A_MQA: (
+            "model.layers.{bid}.self_attn.kv_a_proj_with_mqa", # deepseek2
+        ),
+
+        MODEL_TENSOR.ATTN_KV_B: (
+            "model.layers.{bid}.self_attn.kv_b_proj", # deepseek2
+        ),
+
+        MODEL_TENSOR.ATTN_Q_A_NORM: (
+            "model.layers.{bid}.self_attn.q_a_layernorm", # deepseek2
+        ),
+
+        MODEL_TENSOR.ATTN_KV_A_NORM: (
+            "model.layers.{bid}.self_attn.kv_a_layernorm", # deepseek2
+        ),
+
+        MODEL_TENSOR.ATTN_SUB_NORM: (
+            "model.layers.{bid}.self_attn.inner_attn_ln",  # bitnet
+        ),
+
+        MODEL_TENSOR.FFN_SUB_NORM: (
+            "model.layers.{bid}.mlp.ffn_layernorm",  # bitnet
+        ),
+
+        MODEL_TENSOR.DEC_ATTN_NORM: (
+            "decoder.block.{bid}.layer.0.layer_norm", # t5
+        ),
+
+        MODEL_TENSOR.DEC_ATTN_Q: (
+            "decoder.block.{bid}.layer.0.SelfAttention.q", # t5
+        ),
+
+        MODEL_TENSOR.DEC_ATTN_K: (
+            "decoder.block.{bid}.layer.0.SelfAttention.k", # t5
+        ),
+
+        MODEL_TENSOR.DEC_ATTN_V: (
+            "decoder.block.{bid}.layer.0.SelfAttention.v", # t5
+        ),
+
+        MODEL_TENSOR.DEC_ATTN_OUT: (
+            "decoder.block.{bid}.layer.0.SelfAttention.o", # t5
+        ),
+
+        MODEL_TENSOR.DEC_ATTN_REL_B: (
+            "decoder.block.{bid}.layer.0.SelfAttention.relative_attention_bias", # t5
+        ),
+
+        MODEL_TENSOR.DEC_CROSS_ATTN_NORM: (
+            "decoder.block.{bid}.layer.1.layer_norm", # t5
+        ),
+
+        MODEL_TENSOR.DEC_CROSS_ATTN_Q: (
+            "decoder.block.{bid}.layer.1.EncDecAttention.q", # t5
+        ),
+
+        MODEL_TENSOR.DEC_CROSS_ATTN_K: (
+            "decoder.block.{bid}.layer.1.EncDecAttention.k", # t5
+        ),
+
+        MODEL_TENSOR.DEC_CROSS_ATTN_V: (
+            "decoder.block.{bid}.layer.1.EncDecAttention.v", # t5
+        ),
+
+        MODEL_TENSOR.DEC_CROSS_ATTN_OUT: (
+            "decoder.block.{bid}.layer.1.EncDecAttention.o", # t5
+        ),
+
+        MODEL_TENSOR.DEC_CROSS_ATTN_REL_B: (
+            "decoder.block.{bid}.layer.1.EncDecAttention.relative_attention_bias", # t5
+        ),
+
+        MODEL_TENSOR.DEC_FFN_NORM: (
+            "decoder.block.{bid}.layer.2.layer_norm", # t5
+        ),
+
+        MODEL_TENSOR.DEC_FFN_GATE: (
+            "decoder.block.{bid}.layer.2.DenseReluDense.wi_0", # flan-t5
+        ),
+
+        MODEL_TENSOR.DEC_FFN_UP: (
+            "decoder.block.{bid}.layer.2.DenseReluDense.wi",   # t5
+            "decoder.block.{bid}.layer.2.DenseReluDense.wi_1", # flan-t5
+        ),
+
+        MODEL_TENSOR.DEC_FFN_DOWN: (
+            "decoder.block.{bid}.layer.2.DenseReluDense.wo", # t5
+        ),
+
+        MODEL_TENSOR.DEC_OUTPUT_NORM: (
+            "decoder.final_layer_norm", # t5
+        ),
+
+        MODEL_TENSOR.ENC_ATTN_NORM: (
+            "encoder.block.{bid}.layer.0.layer_norm", # t5
+        ),
+
+        MODEL_TENSOR.ENC_ATTN_Q: (
+            "encoder.block.{bid}.layer.0.SelfAttention.q", # t5
+        ),
+
+        MODEL_TENSOR.ENC_ATTN_K: (
+            "encoder.block.{bid}.layer.0.SelfAttention.k", # t5
+        ),
+
+        MODEL_TENSOR.ENC_ATTN_V: (
+            "encoder.block.{bid}.layer.0.SelfAttention.v", # t5
+        ),
+
+        MODEL_TENSOR.ENC_ATTN_OUT: (
+            "encoder.block.{bid}.layer.0.SelfAttention.o", # t5
+        ),
+
+        MODEL_TENSOR.ENC_ATTN_REL_B: (
+            "encoder.block.{bid}.layer.0.SelfAttention.relative_attention_bias", # t5
+        ),
+
+        MODEL_TENSOR.ENC_FFN_NORM: (
+            "encoder.block.{bid}.layer.1.layer_norm", # t5
+        ),
+
+        MODEL_TENSOR.ENC_FFN_GATE: (
+            "encoder.block.{bid}.layer.1.DenseReluDense.wi_0", # flan-t5
+        ),
+
+        MODEL_TENSOR.ENC_FFN_UP: (
+            "encoder.block.{bid}.layer.1.DenseReluDense.wi",   # t5
+            "encoder.block.{bid}.layer.1.DenseReluDense.wi_1", # flan-t5
+        ),
+
+        MODEL_TENSOR.ENC_FFN_DOWN: (
+            "encoder.block.{bid}.layer.1.DenseReluDense.wo", # t5
+        ),
+
+        MODEL_TENSOR.ENC_OUTPUT_NORM: (
+            "encoder.final_layer_norm", # t5
+        ),
+    }
+
+    # architecture-specific block mappings
+    arch_block_mappings_cfg: dict[MODEL_ARCH, dict[MODEL_TENSOR, tuple[str, ...]]] = {
+        MODEL_ARCH.ARCTIC: {
+            MODEL_TENSOR.FFN_NORM: (
+                "model.layers.{bid}.residual_layernorm",
+            ),
+            MODEL_TENSOR.FFN_NORM_EXP: (
+                "model.layers.{bid}.post_attention_layernorm",
+            ),
+        },
+    }
+
+    mapping: dict[str, tuple[MODEL_TENSOR, str]]
+
+    def __init__(self, arch: MODEL_ARCH, n_blocks: int):
+        self.mapping = {}
+        for tensor, keys in self.mappings_cfg.items():
+            if tensor not in MODEL_TENSORS[arch]:
+                continue
+            tensor_name = TENSOR_NAMES[tensor]
+            self.mapping[tensor_name] = (tensor, tensor_name)
+            for key in keys:
+                self.mapping[key] = (tensor, tensor_name)
+        if arch in self.arch_block_mappings_cfg:
+            self.block_mappings_cfg.update(self.arch_block_mappings_cfg[arch])
+        for bid in range(n_blocks):
+            for tensor, keys in self.block_mappings_cfg.items():
+                if tensor not in MODEL_TENSORS[arch]:
+                    continue
+
+                tensor_name = TENSOR_NAMES[tensor].format(bid = bid)
+                self.mapping[tensor_name] = (tensor, tensor_name)
+                for key in keys:
+                    key = key.format(bid = bid)
+                    self.mapping[key] = (tensor, tensor_name)
+
+    def get_type_and_name(self, key: str, try_suffixes: Sequence[str] = ()) -> tuple[MODEL_TENSOR, str] | None:
+        result = self.mapping.get(key)
+        if result is not None:
+            return result
+        for suffix in try_suffixes:
+            if key.endswith(suffix):
+                result = self.mapping.get(key[:-len(suffix)])
+                if result is not None:
+                    return result[0], result[1] + suffix
+        return None
+
+    def get_name(self, key: str, try_suffixes: Sequence[str] = ()) -> str | None:
+        result = self.get_type_and_name(key, try_suffixes = try_suffixes)
+        if result is None:
+            return None
+        return result[1]
+
+    def get_type(self, key: str, try_suffixes: Sequence[str] = ()) -> MODEL_TENSOR | None:
+        result = self.get_type_and_name(key, try_suffixes = try_suffixes)
+        if result is None:
+            return None
+        return result[0]
+
+    def __getitem__(self, key: str) -> str:
+        try:
+            return self.mapping[key][1]
+        except KeyError:
+            raise KeyError(key)
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.mapping
+
+    def __repr__(self) -> str:
+        return repr(self.mapping)
+
+
+def get_tensor_name_map(arch: MODEL_ARCH, n_blocks: int) -> TensorNameMap:
+    return TensorNameMap(arch, n_blocks)

vllm/lib/python3.10/site-packages/mdurl-0.1.2.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

vllm/lib/python3.10/site-packages/mdurl-0.1.2.dist-info/LICENSE

@@ -0,0 +1,46 @@
+Copyright (c) 2015 Vitaly Puzrin, Alex Kocharin.
+Copyright (c) 2021 Taneli Hukkinen
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+--------------------------------------------------------------------------------
+
+.parse() is based on Joyent's node.js `url` code:
+
+Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

vllm/lib/python3.10/site-packages/mdurl-0.1.2.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.1
+Name: mdurl
+Version: 0.1.2
+Summary: Markdown URL utilities
+Keywords: markdown,commonmark
+Author-email: Taneli Hukkinen <hukkin@users.noreply.github.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Project-URL: Homepage, https://github.com/executablebooks/mdurl
+
+# mdurl
+
+[![Build Status](https://github.com/executablebooks/mdurl/workflows/Tests/badge.svg?branch=master)](https://github.com/executablebooks/mdurl/actions?query=workflow%3ATests+branch%3Amaster+event%3Apush)
+[![codecov.io](https://codecov.io/gh/executablebooks/mdurl/branch/master/graph/badge.svg)](https://codecov.io/gh/executablebooks/mdurl)
+[![PyPI version](https://img.shields.io/pypi/v/mdurl)](https://pypi.org/project/mdurl)
+
+This is a Python port of the JavaScript [mdurl](https://www.npmjs.com/package/mdurl) package.
+See the [upstream README.md file](https://github.com/markdown-it/mdurl/blob/master/README.md) for API documentation.
+

vllm/lib/python3.10/site-packages/mdurl-0.1.2.dist-info/RECORD

@@ -0,0 +1,19 @@
+mdurl-0.1.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+mdurl-0.1.2.dist-info/LICENSE,sha256=fGBd9uKGZ6lgMRjpgnT2SknOPu0NJvzM6VNKNF4O-VU,2338
+mdurl-0.1.2.dist-info/METADATA,sha256=tTsp1I9Jk2cFP9o8gefOJ9JVg4Drv4PmYCOwLrfd0l0,1638
+mdurl-0.1.2.dist-info/RECORD,,
+mdurl-0.1.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mdurl-0.1.2.dist-info/WHEEL,sha256=4TfKIB_xu-04bc2iKz6_zFt-gEFEEDU_31HGhqzOCE8,81
+mdurl/__init__.py,sha256=1vpE89NyXniIRZNC_4f6BPm3Ub4bPntjfyyhLRR7opU,547
+mdurl/__pycache__/__init__.cpython-310.pyc,,
+mdurl/__pycache__/_decode.cpython-310.pyc,,
+mdurl/__pycache__/_encode.cpython-310.pyc,,
+mdurl/__pycache__/_format.cpython-310.pyc,,
+mdurl/__pycache__/_parse.cpython-310.pyc,,
+mdurl/__pycache__/_url.cpython-310.pyc,,
+mdurl/_decode.py,sha256=3Q_gDQqU__TvDbu7x-b9LjbVl4QWy5g_qFwljcuvN_Y,3004
+mdurl/_encode.py,sha256=goJLUFt1h4rVZNqqm9t15Nw2W-bFXYQEy3aR01ImWvs,2602
+mdurl/_format.py,sha256=xZct0mdePXA0H3kAqxjGtlB5O86G35DAYMGkA44CmB4,626
+mdurl/_parse.py,sha256=ezZSkM2_4NQ2Zx047sEdcJG7NYQRFHiZK7Y8INHFzwY,11374
+mdurl/_url.py,sha256=5kQnRQN2A_G4svLnRzZcG0bfoD9AbBrYDXousDHZ3z0,284
+mdurl/py.typed,sha256=8PjyZ1aVoQpRVvt71muvuq5qE-jTFZkK-GLHkhdebmc,26

vllm/lib/python3.10/site-packages/mdurl-0.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.7.1
+Root-Is-Purelib: true
+Tag: py3-none-any

vllm/lib/python3.10/site-packages/outlines/__init__.py

@@ -0,0 +1,20 @@
+"""Outlines is a Generative Model Programming Framework."""
+import outlines.generate
+import outlines.grammars
+import outlines.models
+import outlines.processors
+import outlines.types
+from outlines.base import vectorize
+from outlines.caching import clear_cache, disable_cache, get_cache
+from outlines.function import Function
+from outlines.prompts import prompt
+
+__all__ = [
+    "clear_cache",
+    "disable_cache",
+    "get_cache",
+    "Function",
+    "prompt",
+    "vectorize",
+    "grammars",
+]

vllm/lib/python3.10/site-packages/outlines/caching.py

@@ -0,0 +1,179 @@
+import asyncio
+import contextlib
+import functools
+import os
+from typing import Callable, Optional
+
+import cloudpickle
+from diskcache import Cache, Disk
+from diskcache.core import ENOVAL, UNKNOWN, args_to_key, full_name
+
+_caching_enabled = True
+
+
+class CloudpickleDisk(Disk):
+    def __init__(self, directory, compress_level=1, **kwargs):
+        self.compress_level = compress_level
+        super().__init__(directory, **kwargs)
+
+    def put(self, key):
+        data = cloudpickle.dumps(key)
+        return super().put(data)
+
+    def get(self, key, raw):
+        data = super().get(key, raw)
+        return cloudpickle.loads(data)
+
+    def store(self, value, read, key=UNKNOWN):
+        if not read:
+            value = cloudpickle.dumps(value)
+        return super().store(value, read, key=key)
+
+    def fetch(self, mode, filename, value, read):
+        data = super().fetch(mode, filename, value, read)
+        if not read:
+            data = cloudpickle.loads(data)
+        return data
+
+
+@functools.lru_cache(1)
+def get_cache():
+    """Get the context object that contains previously-computed return values.
+
+    The cache is used to avoid unnecessary computations and API calls, which can
+    be long and expensive for large models.
+
+    The cache directory defaults to `HOMEDIR/.cache/outlines`, but this choice
+    can be overridden by the user by setting the value of the `OUTLINES_CACHE_DIR`
+    environment variable.
+
+    """
+    from outlines._version import __version__ as outlines_version  # type: ignore
+
+    home_dir = os.path.expanduser("~")
+    cache_dir = os.environ.get("OUTLINES_CACHE_DIR", f"{home_dir}/.cache/outlines")
+    memory = Cache(
+        cache_dir,
+        eviction_policy="none",
+        cull_limit=0,
+        disk=CloudpickleDisk,
+    )
+
+    # ensure if version upgrade occurs, old cache is pruned
+    if outlines_version != memory.get("__version__"):
+        memory.clear()
+    memory["__version__"] = outlines_version
+
+    return memory
+
+
+def cache(expire: Optional[float] = None, typed=False, ignore=()):
+    """Caching decorator for memoizing function calls.
+
+    The cache key is created based on the values returned by the key_function callable
+    if provided or based on the arguments of the decorated function directly otherwise
+
+    This is based on `diskcache`'s `memoize`.
+
+    Parameters
+    ----------
+    expire
+        Seconds until arguments expire.
+    typed
+        Cache different types separately.
+    ignore
+        Positional or keyword arguments to ignore.
+
+    Returns
+    -------
+        A decorator function that can be applied to other functions.
+    """
+
+    def decorator(cached_function: Callable):
+        memory = get_cache()
+
+        base = (full_name(cached_function),)
+
+        if asyncio.iscoroutinefunction(cached_function):
+
+            async def wrapper(*args, **kwargs):
+                if not _caching_enabled:
+                    return await cached_function(*args, **kwargs)
+
+                cache_key = wrapper.__cache_key__(*args, **kwargs)
+                result = wrapper.__memory__.get(cache_key, default=ENOVAL, retry=True)
+
+                if result is ENOVAL:
+                    result = await cached_function(*args, **kwargs)
+                    wrapper.__memory__.set(cache_key, result, expire, retry=True)
+
+                return result
+
+        else:
+
+            def wrapper(*args, **kwargs):
+                if not _caching_enabled:
+                    return cached_function(*args, **kwargs)
+
+                cache_key = wrapper.__cache_key__(*args, **kwargs)
+                result = wrapper.__memory__.get(cache_key, default=ENOVAL, retry=True)
+
+                if result is ENOVAL:
+                    result = cached_function(*args, **kwargs)
+                    wrapper.__memory__.set(cache_key, result, expire, retry=True)
+
+                return result
+
+        def __cache_key__(*args, **kwargs):
+            """Make key for cache given function arguments."""
+            return args_to_key(base, args, kwargs, typed, ignore)
+
+        wrapper.__cache_key__ = __cache_key__  # type: ignore
+        wrapper.__memory__ = memory  # type: ignore
+        wrapper.__wrapped__ = cached_function  # type: ignore
+
+        return wrapper
+
+    return decorator
+
+
+def disable_cache():
+    """Disable the cache for this session.
+
+    Generative models output different results each time they are called when
+    sampling. This can be a desirable property for some workflows, in which case
+    one can call `outlines.call.disable` to disable the cache for the session.
+
+    This function does not delete the cache, call `outlines.cache.clear`
+    instead. It also does not overwrite the cache with the values returned
+    during the session.
+
+    Example
+    -------
+
+    `outlines.cache.disable` should be called right after importing outlines:
+
+    >>> import outlines.caching as cache
+    >>> cache.disable_cache()
+
+    """
+    global _caching_enabled
+    _caching_enabled = False
+
+
+def clear_cache():
+    """Erase the cache completely."""
+    memory = get_cache()
+    memory.clear()
+
+
+@contextlib.contextmanager
+def cache_disabled():
+    # outlines.caching._caching_enabled
+    global _caching_enabled
+    original_state = _caching_enabled
+    _caching_enabled = False
+    try:
+        yield
+    finally:
+        _caching_enabled = original_state

vllm/lib/python3.10/site-packages/outlines/fsm/guide.py

@@ -0,0 +1,276 @@
+import collections
+import copy
+import warnings
+from typing import TYPE_CHECKING, Any, Generator, Union
+
+import torch
+from lark.indenter import DedentError
+from lark.lexer import UnexpectedCharacters, UnexpectedToken
+from outlines_core.fsm.guide import Generate
+from outlines_core.fsm.guide import Guide as CoreGuide
+from outlines_core.fsm.guide import RegexGuide as CoreRegexGuide
+from outlines_core.fsm.guide import Write
+from outlines_core.fsm.guide import (
+    create_states_mapping as uncached_create_states_mapping,
+)
+
+from outlines import grammars
+from outlines.fsm.parsing import PartialLark, PartialParserState
+
+if TYPE_CHECKING:
+    from outlines.models.tokenizer import Tokenizer
+
+
+Instruction = Union[Write, Generate]
+
+
+class Guide(CoreGuide):
+    """Base definition of a generation guide.
+
+    A generation guide defines the behavior of a finite-state machine that guides
+    a text generation procedure. Unlike the DFAs built from regular expressions
+    guides can also emit a `Write` instructions which tells the model that it can
+    append a sequence of tokens (or token word) instead of generating it.
+
+    """
+
+    initial_state: Any
+
+
+class StopAtEOSGuide(Guide):
+    """Guide to generate tokens until the EOS token has been generated."""
+
+    final_state = 1
+    start_state = 0  # TODO: remove start_state, use only initial_state
+    initial_state = 0
+
+    def __init__(self, tokenizer: "Tokenizer"):
+        """Initialize the generation guide.
+
+        model
+            The logit generator used to generate the next token.
+
+        """
+        self.eos_token_id = tokenizer.eos_token_id
+        self.vocabulary = tokenizer.vocabulary.values()
+
+    def get_next_instruction(self, state: int) -> Instruction:
+        if self.is_final_state(state):
+            return Write([self.eos_token_id])
+        return Generate(None)
+
+    def get_next_state(self, state: int, token_id: int) -> int:
+        if token_id == self.eos_token_id or state == self.final_state:
+            return self.final_state
+
+        return self.initial_state
+
+    def is_final_state(self, state: int):
+        return state == self.final_state
+
+    def copy(self):
+        return self
+
+
+def cached_create_states_mapping(regex_string, tokenizer, *args, **kwargs):
+    return uncached_create_states_mapping(regex_string, tokenizer, *args, **kwargs)
+
+
+class RegexGuide(CoreRegexGuide):
+    """
+    Guide to generate text in the language of a regular expression.
+    CoreRegexGuide with outlines cache
+    """
+
+    @classmethod
+    def from_regex(
+        cls,
+        regex_string: str,
+        tokenizer,
+        **kwargs,
+    ):
+        return super().from_regex(
+            regex_string,
+            tokenizer,
+            _create_states_mapping=cached_create_states_mapping,
+            **kwargs,
+        )
+
+
+CFGState = collections.namedtuple("CFGState", ["parser_state", "prev_token"])
+
+
+class CFGGuide(Guide):
+    """Guide to generate text that is in the language of a context-free Lark grammar."""
+
+    def __init__(self, cfg_string: str, tokenizer):
+        """
+        Construct the PartialLark parser and set the empty initial_state (PartialParserState)
+        """
+        warnings.warn(
+            "Outlines' public *community-contributed* CFG structured generation is experimental. "
+            "Please review https://dottxt-ai.github.io/outlines/latest/reference/generation/cfg#disclaimer"
+        )
+
+        self.cfg_string = cfg_string
+        self.tokenizer = tokenizer
+        self.eos_token_id = self.tokenizer.eos_token_id
+        self.parser = PartialLark(
+            cfg_string,
+            parser="lalr",
+            import_paths=[grammars.GRAMMAR_PATH],
+        )
+        self.initial_state = CFGState(
+            parser_state=self.parser.parse(""), prev_token=None
+        )
+
+    def get_next_instruction(self, state: CFGState) -> Instruction:
+        """Return the next instruction for guided generation.
+
+        Current lazy approach:
+        - For each token in the vocabulary
+          - create a copy of the parsers state
+          - add the tokens to the parsers input text
+          - if valid, add token to returned tokens
+
+        Further refinements are necessary for performant text processing.
+
+        Parameters
+        ----------
+        state
+            The guides current PartialParserState, or None if complete
+
+        Returns
+        -------
+        A `Generate` instance that contains the model and the allowed token ids.
+
+        """
+
+        if state.parser_state is None:
+            return Write(torch.tensor([self.eos_token_id]))
+
+        valid_tokens = list(
+            self.iter_valid_token_ids(state, self.tokenizer.vocabulary.values())
+        )
+        if len(valid_tokens) == 1:
+            return Write(torch.tensor(valid_tokens))
+        return Generate(torch.tensor(valid_tokens))
+
+    def iter_valid_token_ids(
+        self, state: CFGState, candidate_token_ids: list
+    ) -> Generator[int, None, None]:
+        """
+        Iterate over the given token_ids and yield those that are valid for the current parser state.
+
+        Parameters
+        ----------
+        parser_state
+            The current state of the parser, or None if complete.
+        token_ids
+            The list of token ids to check for validity.
+
+        Yields
+        ------
+        int
+            Valid token ids.
+        """
+        if state.parser_state is None:
+            yield self.eos_token_id
+            return
+
+        for token_id in candidate_token_ids:
+            if token_id == self.eos_token_id:
+                if self.can_terminate_state(state):
+                    yield token_id
+            else:
+                try:
+                    self._get_parser_state_token_applied(state, int(token_id))
+                    yield token_id
+                except (
+                    ValueError,
+                    EOFError,
+                    UnexpectedToken,
+                    UnexpectedCharacters,
+                    DedentError,
+                ):
+                    pass
+
+    def get_next_state(self, state: CFGState, token_id: int) -> CFGState:
+        """
+        Update the state of the guide.
+        Decode the token_id, and calculate the new parser_state with the token applied.
+
+        Parameters
+        ----------
+        state
+            The guides current PartialParserState, or None if complete
+        token_id
+            The id of the token that was just generated.
+
+        Returns
+        -------
+        The guides new PartialParserState
+
+        """
+        if state.parser_state is None or token_id == self.eos_token_id:
+            parser_state = None
+        else:
+            parser_state = self._get_parser_state_token_applied(state, int(token_id))
+        return CFGState(parser_state=parser_state, prev_token=token_id)
+
+    def _get_parser_state_token_applied(
+        self, state: CFGState, token_id: int
+    ) -> PartialParserState:
+        """
+        Don't mutate `parser_state`, copy to protect
+
+        Get the token string
+          - if first token in generation: tokenizer.decode (no leading whitespace)
+          - else: normalized (with possibly leading whitespace)
+
+        Don't allow empty ("") tokens, raise ValueError
+        """
+        parser_state = copy.copy(state.parser_state)  # prevent side effects
+
+        # normalize
+        if state.prev_token is None:
+            new_token_str = self.tokenizer.decode([token_id])[0]
+        else:
+            prev_token_str = self.tokenizer.decode([[state.prev_token]])[0]
+            combined_token_str = self.tokenizer.decode([[state.prev_token, token_id]])[
+                0
+            ]
+            new_token_str = combined_token_str[len(prev_token_str) :]
+
+        if new_token_str == "":
+            raise ValueError("empty next token")
+
+        # update parser with new token
+        parser_state.lexer.state.text += new_token_str
+        self.parser.parse_from_state(parser_state, is_end=False)
+
+        return parser_state
+
+    def is_final_state(self, state: CFGState) -> bool:
+        # TODO: remove this method, use can_terminate_state and must_terminate_state
+        # here and in RegexGuide per https://github.com/dottxt-ai/outlines/issues/885
+        return self.can_terminate_state(state)
+
+    def can_terminate_state(self, state: CFGState) -> bool:
+        """Generation is allowed to terminate"""
+        if state.parser_state is not None:
+            try:
+                copy.copy(state.parser_state).feed_eof()
+            except UnexpectedToken:
+                return False
+        return True
+
+    def must_terminate_state(self, state: CFGState) -> bool:
+        """Generation must terminate, no legal continuations"""
+        return state.parser_state is None or set(state.parser_state.accepts()).issubset(
+            {"$END"}
+        )
+
+    def copy(self) -> "CFGGuide":
+        """Create a copy of the Guide."""
+        return CFGGuide(self.cfg_string, self.tokenizer)

vllm/lib/python3.10/site-packages/outlines/fsm/json_schema.py

@@ -0,0 +1,83 @@
+import inspect
+import json
+import warnings
+from enum import Enum
+from typing import Callable, Type, Union
+
+from pydantic import BaseModel, create_model
+
+
+def convert_json_schema_to_str(json_schema: Union[dict, str, Type[BaseModel]]) -> str:
+    """Convert a JSON schema to a string.
+
+    Parameters
+    ----------
+    json_schema
+        The JSON schema.
+
+    Returns
+    -------
+    str
+        The JSON schema converted to a string.
+
+    Raises
+    ------
+    ValueError
+        If the schema is not a dictionary, a string or a Pydantic class.
+    """
+    if isinstance(json_schema, dict):
+        schema_str = json.dumps(json_schema)
+    elif isinstance(json_schema, str):
+        schema_str = json_schema
+    elif issubclass(json_schema, BaseModel):
+        schema_str = json.dumps(json_schema.model_json_schema())
+    else:
+        raise ValueError(
+            f"Cannot parse schema {json_schema}. The schema must be either "
+            + "a Pydantic class, a dictionary or a string that contains the JSON "
+            + "schema specification"
+        )
+    return schema_str
+
+
+def get_schema_from_signature(fn: Callable) -> dict:
+    """Turn a function signature into a JSON schema.
+
+    Every JSON object valid to the output JSON Schema can be passed
+    to `fn` using the ** unpacking syntax.
+
+    """
+    signature = inspect.signature(fn)
+    arguments = {}
+    for name, arg in signature.parameters.items():
+        if arg.annotation == inspect._empty:
+            raise ValueError("Each argument must have a type annotation")
+        else:
+            arguments[name] = (arg.annotation, ...)
+
+    try:
+        fn_name = fn.__name__
+    except Exception as e:
+        fn_name = "Arguments"
+        warnings.warn(
+            f"The function name could not be determined. Using default name 'Arguments' instead. For debugging, here is exact error:\n{e}",
+            category=UserWarning,
+        )
+    model = create_model(fn_name, **arguments)
+
+    return model.model_json_schema()
+
+
+def get_schema_from_enum(myenum: type[Enum]) -> dict:
+    if len(myenum) == 0:
+        raise ValueError(
+            f"Your enum class {myenum.__name__} has 0 members. If you are working with an enum of functions, do not forget to register them as callable (using `partial` for instance)"
+        )
+    choices = [
+        get_schema_from_signature(elt.value.func)
+        if callable(elt.value)
+        else {"const": elt.value}
+        for elt in myenum
+    ]
+    schema = {"title": myenum.__name__, "oneOf": choices}
+    return schema

vllm/lib/python3.10/site-packages/outlines/fsm/parsing.py

@@ -0,0 +1,1127 @@
+from copy import copy, deepcopy
+from dataclasses import dataclass
+from functools import lru_cache
+from typing import (
+    Any,
+    Dict,
+    FrozenSet,
+    Generator,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Union,
+)
+
+import interegular
+from interegular.fsm import FSM, Alphabet, OblivionError
+from interegular.patterns import Unsupported
+from lark import Lark, Token
+from lark.common import LexerConf, ParserConf
+from lark.exceptions import LexError, UnexpectedInput
+from lark.indenter import Indenter
+from lark.lexer import (
+    BasicLexer,
+    ContextualLexer,
+    LexerState,
+    LexerThread,
+    Scanner,
+    UnexpectedCharacters,
+    UnexpectedToken,
+    _create_unless,
+)
+from lark.parser_frontends import (
+    ParsingFrontend,
+    PostLexConnector,
+    _validate_frontend_args,
+)
+from lark.parsers.lalr_analysis import (
+    Action,
+    IntParseTable,
+    LALR_Analyzer,
+    ParseTable,
+    Shift,
+)
+from lark.parsers.lalr_interactive_parser import InteractiveParser
+from lark.parsers.lalr_parser import LALR_Parser, ParseConf, ParserState, _Parser
+from outlines_core.fsm.regex import (
+    BetterFSM,
+    get_token_transition_keys,
+    make_deterministic_fsm,
+)
+
+PartialParseState = Tuple[str, int]
+ParseStateType = Union[int, FrozenSet]
+
+
+@dataclass
+class PartialTerminalInfo:
+    priority: int
+    terminal_name: str
+    can_transition: bool
+    is_final: bool
+
+
+@dataclass
+class PartialTokensInfo:
+    fsm_state_seq: Tuple[int, ...]
+    is_not_finished: bool
+    terminals_and_info: Tuple[PartialTerminalInfo, ...]
+    final_terminals_and_info: Tuple[PartialTerminalInfo, ...]
+
+
+class PartialParserConf(ParserConf):
+    __serialize_fields__ = (
+        "rules",
+        "start",
+        "parser_type",
+        "deterministic",
+        "use_value_stack",
+    )
+
+    def __init__(self, rules, callbacks, start, deterministic, use_value_stack):
+        super().__init__(rules, callbacks, start)
+        self.deterministic = deterministic
+        self.use_value_stack = use_value_stack
+
+
+class PartialLark(Lark):
+    __serialize_fields__ = (
+        "parser",
+        "rules",
+        "options",
+        "deterministic",
+        "use_value_stack",
+    )
+
+    def __init__(self, grammar, **options):
+        # TODO: Could've extended `LarkOptions`, but all these extensions are
+        # already way too much (and brittle).  This library really needs a
+        # complete refactoring.
+        self.deterministic = options.pop("deterministic", False)
+        self.use_value_stack = options.pop("use_value_stack", False)
+        options["regex"] = True
+        super().__init__(grammar, **options)
+        assert self.options.parser == "lalr"
+
+    def _build_lexer(self, dont_ignore: bool = False) -> "PartialBasicLexer":
+        lexer_conf = self.lexer_conf
+        if dont_ignore:
+            from copy import copy
+
+            lexer_conf = copy(lexer_conf)
+            lexer_conf.ignore = ()
+
+        return PartialBasicLexer(lexer_conf)
+
+    def _build_parser(self) -> "PartialParsingFrontend":
+        self._prepare_callbacks()
+        _validate_frontend_args(self.options.parser, self.options.lexer)
+        parser_conf = PartialParserConf(
+            self.rules,
+            self._callbacks,
+            self.options.start,
+            self.deterministic,
+            self.use_value_stack,
+        )
+
+        # This is `_construct_parsing_frontend` expanded/inlined
+        parser_type = self.options.parser
+        lexer_type = self.options.lexer
+        lexer_conf = self.lexer_conf
+
+        assert isinstance(lexer_conf, LexerConf)
+        assert isinstance(parser_conf, ParserConf)
+        parser_conf.parser_type = parser_type
+        self.lexer_conf.lexer_type = lexer_type
+        return PartialParsingFrontend(lexer_conf, parser_conf, self.options)
+
+    def __repr__(self):
+        return "{}(open({!r}), parser={!r}, lexer={!r}, ...)".format(
+            type(self).__name__,
+            self.source_path,
+            self.options.parser,
+            self.options.lexer,
+        )
+
+    def parse_from_state(self, parse_state: "PartialParseState", is_end=False):
+        return self.parser.parser.parser.parse_from_state(parse_state, is_end=is_end)
+
+
+class PartialLexerThread(LexerThread):
+    def __copy__(self):
+        return type(self)(copy(self.lexer), copy(self.state))
+
+    def __repr__(self):
+        return f"{type(self).__name__}(lexer={self.lexer!r}, state={self.state!r})"
+
+
+class PartialPostLexConnector(PostLexConnector):
+    def __copy__(self):
+        return type(self)(self.lexer, copy(self.postlexer))
+
+    def __repr__(self):
+        return (
+            f"{type(self).__name__}(lexer={self.lexer!r}, postlexer={self.postlexer!r})"
+        )
+
+
+class PartialParsingFrontend(ParsingFrontend):
+    def __init__(self, lexer_conf, parser_conf, options, parser=None):
+        assert parser_conf.parser_type == "lalr"
+
+        options._plugins["LALR_Parser"] = PartialLALRParser
+        options._plugins["BasicLexer"] = PartialBasicLexer
+        options._plugins["ContextualLexer"] = PartialContextualLexer
+        options._plugins["LexerThread"] = PartialLexerThread
+
+        super().__init__(lexer_conf, parser_conf, options, parser=parser)
+
+        if lexer_conf.postlex:
+            self.lexer = PartialPostLexConnector(self.lexer.lexer, lexer_conf.postlex)
+
+        self._termset_fsm_info = None
+        self._symbols_to_states: Optional[
+            Dict[str, Set[Tuple[ParseStateType, Action]]]
+        ] = None
+        self._reverse_shifts: Optional[
+            Dict[ParseStateType, Dict[str, Set[ParseStateType]]]
+        ] = None
+        # self._state_transition_map: Optional[
+        #     Dict[Tuple[ParseStateType, str], Set[ParseStateType]]
+        # ] = None
+
+    def _compute_maps(
+        self,
+    ):
+        """Compute state transition and symbols-to-states maps."""
+        self._reverse_shifts = {}
+        self._symbols_to_states = {}
+
+        parse_table = self.parser.parser.parse_table
+
+        for from_state, symbols_to_ops in parse_table.states.items():
+            for symbol, op in symbols_to_ops.items():
+                if op[0] == Shift:
+                    symbols_to_from_states = self._reverse_shifts.setdefault(op[1], {})
+                    symbols_to_from_states.setdefault(symbol, set()).add(from_state)
+                self._symbols_to_states.setdefault(symbol, set()).add((from_state, op))
+
+        # # TODO: This approach is very wasteful.
+        # context_lexer = get_contextual_lexer(self)
+        # self._state_transition_map = {}
+        #
+        # for from_state, transitions in parse_table.states.items():
+        #     for symbol, action in transitions.items():
+        #         # TODO: Filter non-terminals
+        #         if symbol not in context_lexer.root_lexer.terminals_by_name:
+        #             continue
+        #
+        #         if action[0] is Shift:
+        #             self._state_transition_map.setdefault(
+        #                 (from_state, symbol), set()
+        #             ).add(action[1])
+        #             continue
+        #
+        #         antecedent_state_seqs = parse_to_terminal(self, [(from_state,)], symbol)
+        #
+        #         for antecedent_state_seq in antecedent_state_seqs:
+        #             antecedent_state = antecedent_state_seq[-1]
+        #             self._state_transition_map.setdefault(
+        #                 (from_state, symbol), set()
+        #             ).add(antecedent_state)
+
+    def _compute_termset_fsm_info(self):
+        """Collect and return information about terminal symbol sets and their FSMs.
+
+        Terminal symbol sets (or "termsets") are ordered sequences of terminal
+        symbols that are used by each parser state.  Associated with each is a
+        collection of FSMs for each terminal and a single parse state FSM that is
+        the union of each terminal's FSM.
+
+        This constructs a list of tuples containing the termset, the set of
+        parse states that use the termsets, parse state FSMs, and information
+        mapping the components of the parse state FSMs to their terminal symbol
+        FSMs.
+
+        """
+        context_lexer = get_contextual_lexer(self)
+        termsets_to_fsms = {}
+        termsets_to_parse_states: Dict[Tuple[str, ...], Set[ParseStateType]] = {}
+        for parse_state, lexer in context_lexer.lexers.items():
+            scanner = lexer.scanner
+            key = tuple(term.name for term in scanner.terminals)
+            termsets_to_fsms[key] = (scanner.fsm, scanner.fsms_to_trans_finals)
+            termsets_to_parse_states.setdefault(key, set()).add(parse_state)
+
+        self._termset_fsm_info = [
+            (
+                termset,
+                frozenset(termsets_to_parse_states[termset]),
+                fsm,
+                fsms_to_trans_finals,
+            )
+            for termset, (fsm, fsms_to_trans_finals) in termsets_to_fsms.items()
+        ]
+
+    @property
+    def termset_fsm_info(self):
+        if self._termset_fsm_info is None:
+            self._compute_termset_fsm_info()
+        return self._termset_fsm_info
+
+    @property
+    def symbols_to_states(self):
+        if self._symbols_to_states is None:
+            self._compute_maps()
+        return self._symbols_to_states
+
+    @property
+    def reverse_shifts(self):
+        if self._reverse_shifts is None:
+            self._compute_maps()
+        return self._reverse_shifts
+
+    # @property
+    # def state_transition_map(self):
+    #     if self._state_transition_map is None:
+    #         self._compute_maps()
+    #     return self._state_transition_map
+
+
+class PartialLALRParser(LALR_Parser):
+    def __init__(self, parser_conf, debug=False, strict=False):
+        analysis = LALR_Analyzer(
+            parser_conf, debug=debug if not parser_conf.deterministic else True
+        )
+        analysis.compute_lalr()
+        callbacks = parser_conf.callbacks
+
+        self.parser_conf = parser_conf
+        self._parse_table = analysis.parse_table
+
+        if parser_conf.deterministic:
+            old_to_new = {}
+
+            def to_tuple(v):
+                new = old_to_new.get(v)
+                if new is None:
+                    new = tuple(sorted(v, key=lambda y: str(y)))
+                    old_to_new[v] = new
+                return new
+
+            enum = sorted(
+                self._parse_table.states.keys(),
+                key=lambda x: str(sorted(x, key=lambda y: str(y))),
+            )
+
+            new_states = {}
+            for s in enum:
+                transitions = {
+                    term: op if op[0] is not Shift else (op[0], to_tuple(op[1]))
+                    for term, op in self._parse_table.states[s].items()
+                }
+                new_states[to_tuple(s)] = transitions
+
+            self._parse_table = type(self._parse_table)(
+                new_states,
+                {k: to_tuple(v) for k, v in self._parse_table.start_states.items()},
+                {k: to_tuple(v) for k, v in self._parse_table.end_states.items()},
+            )
+
+            if not debug:
+                self._parse_table = IntParseTable.from_ParseTable(self._parse_table)
+                self.states_to_rulesets = dict(
+                    zip(self._parse_table.states.keys(), new_states.keys())
+                )
+
+        self.parser = PartialParser(
+            self._parse_table,
+            callbacks,
+            debug,
+            use_value_stack=parser_conf.use_value_stack,
+        )
+
+    @classmethod
+    def deserialize(cls, data, memo, callbacks, debug=False):
+        inst = cls.__new__(cls)
+        inst._parse_table = ParseTable.deserialize(data, memo)
+        inst.parser = PartialParser(inst._parse_table, callbacks, debug)
+        return inst
+
+
+class PartialParserState(ParserState):
+    __slots__ = "use_value_stack"
+
+    def __init__(
+        self,
+        parse_conf,
+        lexer,
+        state_stack=None,
+        value_stack=None,
+        use_value_stack=False,
+    ):
+        super().__init__(
+            parse_conf, lexer, state_stack=state_stack, value_stack=value_stack
+        )
+        self.use_value_stack = use_value_stack
+
+    def feed_token(self, token, is_end=False):
+        if token.type == "partial":
+            # If none of the potential terminals can transition, we need to know now
+            current_state = self.state_stack[-1]
+            current_lexer = get_contextual_lexer(self.lexer).lexers[current_state]
+
+            # We have to feed the token and determine whether or not at least
+            # one terminal is consistent with the stack; otherwise, we'll miss
+            # invalid REDUCE cases.
+            # TODO: We should track separate parses conditional on possible
+            # token/symbol types, then we can coherently reuse the following
+            # results instead of recomputing it later.
+            can_transition = False
+            for terminal_info in token.value.terminals_and_info:
+                if terminal_info.terminal_name not in current_lexer.ignore_types:
+                    test_token = Token.new_borrow_pos(
+                        terminal_info.terminal_name, "", token
+                    )
+
+                    stack = copy(self.state_stack)
+                    try:
+                        self.feed_token_no_stack(test_token, is_end=is_end)
+                        can_transition = True
+                        break
+                    except UnexpectedToken:
+                        continue
+                    finally:
+                        self.state_stack = stack
+                else:
+                    can_transition = True
+
+            if not can_transition:
+                expected = {
+                    s
+                    for s in self.parse_conf.states[current_state].keys()
+                    if s.isupper()
+                }
+                raise UnexpectedToken(
+                    token, expected, state=self, interactive_parser=None
+                )
+
+        elif self.use_value_stack:
+            super().feed_token(token, is_end=is_end)
+        else:
+            self.feed_token_no_stack(token, is_end=is_end)
+
+    def feed_token_no_stack(self, token, is_end=False):
+        """
+        This is a copy of `ParserState.feed_token` with all the value stack
+        steps removed.  Since we're not exactly parsing in order to obtain a
+        CST or anything similar, we can avoid the growing expense of tracking
+        the parse tree.
+        """
+        state_stack = self.state_stack
+        states = self.parse_conf.states
+        end_state = self.parse_conf.end_state
+
+        while True:
+            state = state_stack[-1]
+            try:
+                action, arg = states[state][token.type]
+            except KeyError:
+                expected = {s for s in states[state].keys() if s.isupper()}
+                raise UnexpectedToken(
+                    token, expected, state=self, interactive_parser=None
+                )
+
+            assert arg != end_state
+
+            if action is Shift:
+                # shift once and return
+                assert not is_end
+                state_stack.append(arg)
+                return
+            else:
+                # reduce+shift as many times as necessary
+                rule = arg
+                size = len(rule.expansion)
+                if size:
+                    del state_stack[-size:]
+
+                _action, new_state = states[state_stack[-1]][rule.origin.name]
+                assert _action is Shift
+                state_stack.append(new_state)
+
+                if is_end and state_stack[-1] == end_state:
+                    return
+
+    def feed_eof(self):
+        last_token = self.lexer.state.last_token
+
+        if last_token is None:
+            eof_token = self.lexer._Token("$END", "", 0, 1, 1)
+        else:
+            eof_token = Token.new_borrow_pos("$END", "", last_token)
+
+        new_token_is_legal = (
+            last_token is None
+            or last_token.type != "partial"
+            or any(ti.is_final for ti in last_token.value.terminals_and_info)
+        )
+        if new_token_is_legal:
+            self.feed_token(eof_token, is_end=True)
+        else:
+            raise UnexpectedToken(eof_token, [], state=self, interactive_parser=None)
+
+    def choices(self):
+        return self.parse_conf.parse_table.states[self.position]
+
+    def accepts(self):
+        """
+        Adapted from https://github.com/lark-parser/lark/blob/be542c2ff6d968817df019b8bf03f37b3111c08c/lark/parsers/lalr_interactive_parser.py#L95
+        Returns the set of possible tokens that will advance the parser into a new valid state.
+        """
+        accepts = set()
+        conf_no_callbacks = copy(self.parse_conf)
+        # We don't want to call callbacks here since those might have arbitrary side effects
+        # and are unnecessarily slow.
+        conf_no_callbacks.callbacks = {}
+        for t in self.choices():
+            if t.isupper():  # is terminal?
+                new_state = copy(self)
+                new_state.parse_conf = conf_no_callbacks
+                try:
+                    new_state.feed_token(new_state.lexer._Token(t, ""))
+                except UnexpectedToken:
+                    pass
+                else:
+                    accepts.add(t)
+        return accepts
+
+    def __copy__(self):
+        return type(self)(
+            self.parse_conf,
+            copy(self.lexer),
+            copy(self.state_stack),
+            deepcopy(self.value_stack),
+            use_value_stack=self.use_value_stack,
+        )
+
+    def __repr__(self):
+        return f"{type(self).__name__}(lexer={self.lexer!r}, state_stack={self.state_stack!r})"
+
+
+class PartialParser(_Parser):
+    def __init__(self, parse_table, callbacks, debug=False, use_value_stack=False):
+        super().__init__(parse_table, callbacks, debug=debug)
+        self.use_value_stack = use_value_stack
+
+    def parse(
+        self, lexer, start, value_stack=None, state_stack=None, start_interactive=False
+    ):
+        parse_conf = ParseConf(self.parse_table, self.callbacks, start)
+        parser_state = PartialParserState(
+            parse_conf, copy(lexer), state_stack, value_stack, self.use_value_stack
+        )
+        if start_interactive:
+            return InteractiveParser(self, parser_state, parser_state.lexer)
+        return self.parse_from_state(parser_state)
+
+    def parse_from_state(self, state, last_token=None, is_end=False):
+        try:
+            token = last_token
+            for token in state.lexer.lex(state):
+                state.feed_token(token)
+
+            if is_end and (not token or token.type != "partial"):
+                state.feed_eof()
+
+            return state
+        except UnexpectedInput as e:
+            try:
+                e.interactive_parser = InteractiveParser(self, state, state.lexer)
+            except NameError:
+                pass
+            raise e
+        except Exception:
+            if self.debug:
+                print("")
+                print("STATE STACK DUMP")
+                print("----------------")
+                for i, s in enumerate(state.state_stack):
+                    print("%d)" % i, s)
+                print("")
+
+            raise
+
+
+class PartialScanner(Scanner):
+    @classmethod
+    @lru_cache
+    def construct_terminal_fsm(cls, terminal):
+        # TODO: This should really be done at the lexer/parser level so that
+        # the lifetime of these objects is tied to the parser itself.
+        regex_str = terminal.pattern.to_regexp()
+        pattern = interegular.parse_pattern(regex_str)
+        fsm, _ = make_deterministic_fsm(pattern.to_fsm().reduce())
+        return fsm, pattern.prefix_postfix
+
+    def __init__(self, terminals, g_regex_flags, re_, use_bytes, match_whole=False):
+        self.terminals = terminals
+        self.g_regex_flags = g_regex_flags
+        self.use_bytes = use_bytes
+        self.match_whole = match_whole
+        self.allowed_types = {t.name for t in self.terminals}
+        self._mres = None
+
+        fsms = []
+        for t in self.terminals:
+            fsm, prefix_postfix = self.construct_terminal_fsm(t)
+
+            # TODO FIXME: We don't support this right now.
+            assert prefix_postfix == (0, 0)
+
+            fsms.append(fsm)
+
+        self.fsm, self.fsms_to_trans_finals = fsm_union(fsms)
+
+    def get_terminals_info(
+        self, fsm_state_seq
+    ) -> Tuple[Tuple[PartialTerminalInfo, ...], Tuple[PartialTerminalInfo, ...]]:
+        """Get the possible terminal symbols for an FSM state sequence."""
+        terminals_and_info: Tuple[PartialTerminalInfo, ...] = ()
+        final_terminals_and_info: Tuple[PartialTerminalInfo, ...] = ()
+        for i, (fsm_id, fsm_reads_more, in_final) in enumerate(
+            get_sub_fsms_from_seq(fsm_state_seq, self.fsms_to_trans_finals)
+        ):
+            terminal_name = self.terminals[fsm_id].name
+            info = PartialTerminalInfo(i, terminal_name, fsm_reads_more, in_final)
+            terminals_and_info += (info,)
+            if in_final:
+                final_terminals_and_info += (info,)
+
+        return terminals_and_info, final_terminals_and_info
+
+    def match(self, text, pos, last_fsm_state_seq: Optional[Tuple[int, ...]] = None):
+        """Determine an FSM match over `text` starting at `pos` and continuing `last_fsm_state_seq`."""
+
+        start_pos = pos
+
+        if last_fsm_state_seq:
+            assert len(last_fsm_state_seq) > 1
+            start_pos += len(last_fsm_state_seq) - 1
+            start_state = last_fsm_state_seq[-1]
+        else:
+            start_state = self.fsm.initial
+
+        text_part = text[start_pos:]
+
+        text_transitions = get_token_transition_keys(
+            self.fsm.fsm_info.alphabet_symbol_mapping,
+            self.fsm.fsm_info.alphabet_anything_value,
+            text_part,
+        )
+
+        state_seq = walk_fsm(
+            self.fsm,
+            text_transitions,
+            start_state,
+            full_match=self.match_whole,
+        )
+
+        if not state_seq:
+            return None
+
+        if last_fsm_state_seq:
+            res = last_fsm_state_seq + tuple(state_seq)
+        else:
+            res = (start_state,) + tuple(state_seq)
+
+        return res
+
+
+class PartialContextualLexer(ContextualLexer):
+    def __init__(self, conf: "LexerConf", states, always_accept=()):
+        terminals = list(conf.terminals)
+        terminals_by_name = conf.terminals_by_name
+
+        trad_conf = copy(conf)
+        trad_conf.terminals = terminals
+
+        lexer_by_symbols: Dict = {}
+        self.lexers = {}
+        for state, accepts in states.items():
+            key = frozenset(accepts)
+            try:
+                lexer = lexer_by_symbols[key]
+            except KeyError:
+                accepts = set(accepts) | set(conf.ignore) | set(always_accept)
+                lexer_conf = copy(trad_conf)
+                lexer_conf.terminals = [
+                    terminals_by_name[n] for n in accepts if n in terminals_by_name
+                ]
+                if not lexer_conf.terminals:
+                    continue
+                lexer = PartialBasicLexer(lexer_conf)
+                lexer_by_symbols[key] = lexer
+
+            self.lexers[state] = lexer
+
+        assert trad_conf.terminals is terminals
+        self.root_lexer = PartialBasicLexer(trad_conf)
+
+    def lex(self, lexer_state: LexerState, parser_state: Any) -> Iterator[Token]:
+        try:
+            while True:
+                lexer = self.lexers[parser_state.position]
+                next_tok = lexer.next_token(lexer_state, parser_state)
+                yield next_tok
+        except EOFError:
+            pass
+        except KeyError:
+            if len(lexer_state.text) > lexer_state.line_ctr.char_pos:
+                raise UnexpectedCharacters(
+                    lexer_state.text,
+                    lexer_state.line_ctr.char_pos,
+                    lexer_state.line_ctr.line,
+                    lexer_state.line_ctr.column,
+                    allowed=False,
+                    token_history=lexer_state.last_token and [lexer_state.last_token],
+                    state=parser_state,
+                    terminals_by_name=self.root_lexer.terminals,
+                )
+
+
+class PartialBasicLexer(BasicLexer):
+    def __init__(self, conf: "LexerConf"):
+        super().__init__(conf)
+        # Eagerly construct the scanner
+        self._build_scanner()
+
+    def _build_scanner(self):
+        # This seems incredibly convoluted: `lark` creates callback-triggered
+        # nested scanners for regex-defined terminals that overlap with
+        # string-defined terminals when both types of terminals have the same
+        # priority.  Unless I'm missing something important, why not simply
+        # reorder the terminals so that the string-defined ones come before the
+        # regex-defined ones?
+        terminals, self.callback = _create_unless(
+            self.terminals, self.g_regex_flags, self.re, self.use_bytes
+        )
+
+        # We can't let people arbitrarily mess with the scanning process.
+        assert not self.user_callbacks
+        # for type_, f in self.user_callbacks.items():
+        #     if type_ in self.callback:
+        #         # Already a callback there, probably UnlessCallback
+        #         self.callback[type_] = CallChain(
+        #             self.callback[type_], f, lambda t: t.type == type_
+        #         )
+        #     else:
+        #         self.callback[type_] = f
+
+        # We used the "callback" results to reorder the terminals (see the
+        # comments above).
+        for terminal_name, callback in self.callback.items():
+            terminal = self.terminals_by_name[terminal_name]
+            for sub_terminal in callback.scanner.terminals:
+                self.terminals.remove(sub_terminal)
+                idx = self.terminals.index(terminal)
+                self.terminals.insert(idx, sub_terminal)
+
+        self._scanner = PartialScanner(
+            self.terminals, self.g_regex_flags, self.re, self.use_bytes
+        )
+
+    def match(self, text, pos, last_fsm_state_seq=None):
+        return self.scanner.match(text, pos, last_fsm_state_seq)
+
+    def next_token(self, lex_state: LexerState, parser_state: Any = None) -> Token:
+        last_token = lex_state.last_token
+
+        last_fsm_state_seq = None
+        if last_token and last_token.type == "partial":
+            # Continue from last partial lexer state
+            last_fsm_state_seq = last_token.value.fsm_state_seq
+
+        line_ctr = lex_state.line_ctr
+        end_pos = line_ctr.char_pos + (
+            len(last_fsm_state_seq) - 1 if last_fsm_state_seq else 0
+        )
+        while end_pos < len(lex_state.text):
+            res = self.match(lex_state.text, line_ctr.char_pos, last_fsm_state_seq)
+
+            if not res:
+                if (
+                    not last_fsm_state_seq
+                    or last_fsm_state_seq[-1] not in self.scanner.fsm.finals
+                ):
+                    allowed = self.scanner.allowed_types - self.ignore_types
+                    if not allowed:
+                        allowed = {"<END-OF-FILE>"}
+                    raise UnexpectedCharacters(
+                        lex_state.text,
+                        line_ctr.char_pos,
+                        line_ctr.line,
+                        line_ctr.column,
+                        allowed=allowed,
+                        token_history=lex_state.last_token and [lex_state.last_token],
+                        state=parser_state,
+                        terminals_by_name=self.terminals_by_name,
+                    )
+
+                # The partial match might be complete now
+                fsm_state_seq = last_token.value.fsm_state_seq
+                terminals_and_info = last_token.value.terminals_and_info
+                final_terminals_and_info = last_token.value.final_terminals_and_info
+            else:
+                fsm_state_seq = res
+                (
+                    terminals_and_info,
+                    final_terminals_and_info,
+                ) = self.scanner.get_terminals_info(fsm_state_seq)
+
+            priority_terminal_info = (
+                final_terminals_and_info[0]
+                if final_terminals_and_info
+                else terminals_and_info[0]
+            )
+
+            is_not_finished = (
+                not priority_terminal_info.is_final
+                or priority_terminal_info.can_transition
+                or len(terminals_and_info) > 1
+            )
+
+            start_pos = line_ctr.char_pos
+            end_pos = start_pos + len(fsm_state_seq) - 1
+
+            if end_pos >= len(lex_state.text) and is_not_finished:
+                type_name = "partial"
+                token_value = PartialTokensInfo(
+                    fsm_state_seq,
+                    is_not_finished,
+                    terminals_and_info,
+                    final_terminals_and_info,
+                )
+                # Don't update the line counter states until we've finished
+                value = ""
+            else:
+                type_name = priority_terminal_info.terminal_name
+                # The token value should contain all partial scan parts in this
+                # case
+                value = token_value = lex_state.text[start_pos:end_pos]
+
+            assert isinstance(self.callback, Dict)
+
+            if type_name not in self.ignore_types:
+                t = Token(
+                    type_name,
+                    token_value,
+                    line_ctr.char_pos,
+                    line_ctr.line,
+                    line_ctr.column,
+                )
+
+                line_ctr.feed(value, type_name in self.newline_types)
+
+                t.end_line = line_ctr.line
+                t.end_column = line_ctr.column
+                t.end_pos = line_ctr.char_pos
+                if t.type in self.callback:
+                    t = self.callback[t.type](t)
+                    if not isinstance(t, Token):
+                        raise LexError(
+                            "Callbacks must return a token (returned %r)" % t
+                        )
+                lex_state.last_token = t
+                return t
+
+            if type_name in self.callback:
+                t2 = Token(
+                    type_name, value, line_ctr.char_pos, line_ctr.line, line_ctr.column
+                )
+                self.callback[type_name](t2)
+
+            line_ctr.feed(value, type_name in self.newline_types)
+
+            last_fsm_state_seq = None
+
+        raise EOFError(self)
+
+
+class PartialIndenter(Indenter):
+    """An `Indenter` that doesn't reset its state every time `process` is called."""
+
+    def process(self, stream):
+        return self._process(stream)
+
+    def _process(self, stream):
+        for token in stream:
+            # These were previously *after* the `yield`, but that makes the
+            # state tracking unnecessarily convoluted.
+            if token.type in self.OPEN_PAREN_types:
+                self.paren_level += 1
+            elif token.type in self.CLOSE_PAREN_types:
+                self.paren_level -= 1
+                if self.paren_level < 0:
+                    raise UnexpectedToken(token, [])
+
+            if token.type == self.NL_type:
+                yield from self.handle_NL(token)
+            else:
+                yield token
+
+        # TODO: What do we want to do here?
+        # while len(self.indent_level) > 1:
+        #     self.indent_level.pop()
+        #     yield Token(self.DEDENT_type, "")
+
+    def accepts_token_type(self, token_type):
+        if token_type in self.CLOSE_PAREN_types and self.paren_level - 1 < 0:
+            return False
+
+        # TODO:
+        # if token_type == self.NL_type and self.paren_level == 0:
+        #     ...
+        #     return False
+
+        return True
+
+    def __copy__(self):
+        res = type(self)()
+        res.paren_level = self.paren_level
+        res.indent_level = copy(self.indent_level)
+        return res
+
+    def __repr__(self):
+        return f"{type(self).__name__}(paren_level={self.paren_level!r}, indent_level={self.indent_level!r})"
+
+
+class PartialPythonIndenter(PartialIndenter):
+    NL_type = "_NEWLINE"
+    OPEN_PAREN_types = ["LPAR", "LSQB", "LBRACE"]
+    CLOSE_PAREN_types = ["RPAR", "RSQB", "RBRACE"]
+    INDENT_type = "_INDENT"
+    DEDENT_type = "_DEDENT"
+    tab_len = 8
+
+
+def get_contextual_lexer(x: Union[PartialLexerThread, PartialParsingFrontend]):
+    if isinstance(x.lexer, ContextualLexer):
+        return x.lexer
+    else:
+        return x.lexer.lexer
+
+
+def terminals_to_fsms(lp: PartialLark) -> Dict[str, FSM]:
+    """Construct a ``dict`` mapping terminal symbol names to their finite state machines."""
+
+    symbol_names_and_fsms = {}
+    for terminal in lp.terminals:
+        pattern = interegular.parse_pattern(terminal.pattern.to_regexp())
+        # TODO: Use `pyparser.terminals[0].pattern.flags`?
+        try:
+            fsm, _ = make_deterministic_fsm(pattern.to_fsm().reduce())
+        except Unsupported:
+            fsm = None
+
+        symbol_names_and_fsms[terminal.name] = fsm
+
+    return symbol_names_and_fsms
+
+
+def fsm_union(
+    fsms: Sequence[FSM],
+) -> Tuple[FSM, Dict[int, Tuple[Set[Tuple[int, int]], Set[int], Dict[int, Set[int]]]]]:
+    """Construct an FSM representing the union of the FSMs in `fsms`.
+
+    This is an updated version of `interegular.fsm.FSM.union` made to return an
+    extra map of component FSMs to the sets of state transitions that
+    correspond to them in the new FSM.
+
+    """
+
+    alphabet, new_to_old = Alphabet.union(*[fsm.alphabet for fsm in fsms])
+
+    indexed_fsms = tuple(enumerate(fsms))
+
+    initial = {i: fsm.initial for (i, fsm) in indexed_fsms}
+
+    # Dedicated function accepting a "superset" and returning the next
+    # "superset" obtained by following this transition in the new FSM
+    def follow(current_state, new_transition: int):
+        next = {}
+        for i, f in indexed_fsms:
+            old_transition = new_to_old[i][new_transition]
+            if (
+                i in current_state
+                and current_state[i] in f.map
+                and old_transition in f.map[current_state[i]]
+            ):
+                next[i] = f.map[current_state[i]][old_transition]
+        if not next:
+            raise OblivionError
+        return next
+
+    states = [initial]
+    finals: Set[int] = set()
+    map: Dict[int, Dict[int, int]] = {}
+
+    # Map component FSMs to their new state-to-state transitions, finals, and a
+    # map translating component FSM states to aggregate FSM states
+    fsms_to_trans_finals: Dict[
+        int, Tuple[Set[Tuple[int, int]], Set[int], Dict[int, Set[int]]]
+    ] = {}
+
+    i = 0
+    while i < len(states):
+        state = states[i]
+
+        # Add to the finals of the aggregate FSM whenever we hit a final in a
+        # component FSM
+        if any(state.get(j, -1) in fsm.finals for (j, fsm) in indexed_fsms):
+            finals.add(i)
+
+        # Compute the map for this state
+        map[i] = {}
+        for transition in alphabet.by_transition:
+            try:
+                next = follow(state, transition)
+            except OblivionError:
+                # Reached an oblivion state; don't list it
+                continue
+            else:
+                try:
+                    # TODO: Seems like this could--and should--be avoided
+                    j = states.index(next)
+                except ValueError:
+                    j = len(states)
+                    states.append(next)
+
+                map[i][transition] = j
+
+                for fsm_id, fsm_state in next.items():
+                    (
+                        fsm_transitions,
+                        fsm_finals,
+                        fsm_old_to_new,
+                    ) = fsms_to_trans_finals.setdefault(fsm_id, (set(), set(), {}))
+                    old_from = state[fsm_id]
+                    old_to = fsm_state
+                    fsm_old_to_new.setdefault(old_from, set()).add(i)
+                    fsm_old_to_new.setdefault(old_to, set()).add(j)
+                    fsm_transitions.add((i, j))
+                    if fsm_state in fsms[fsm_id].finals:
+                        fsm_finals.add(j)
+
+        i += 1
+
+    fsm = FSM(
+        alphabet=alphabet,
+        states=range(len(states)),
+        initial=0,
+        finals=finals,
+        map=map,
+        __no_validation__=True,
+    )
+
+    fsm, old_to_new_states = make_deterministic_fsm(fsm)
+    _fsms_to_trans_finals = {
+        fsm_id: (
+            {(old_to_new_states[s1], old_to_new_states[s2]) for s1, s2 in transitions},
+            {old_to_new_states[s] for s in finals},
+            {
+                old_state: {old_to_new_states[new_state] for new_state in new_states}
+                for old_state, new_states in old_to_new.items()
+            },
+        )
+        for fsm_id, (transitions, finals, old_to_new) in sorted(
+            fsms_to_trans_finals.items(), key=lambda x: x[0]
+        )
+    }
+
+    return (
+        fsm,
+        _fsms_to_trans_finals,
+    )
+
+
+def get_sub_fsms_from_seq(
+    state_seq: Sequence[int],
+    fsms_to_trans_finals: Dict[
+        int, Tuple[Set[Tuple[int, int]], Set[int], Dict[int, Set[int]]]
+    ],
+) -> Generator[Tuple[int, bool, bool], None, None]:
+    """Get the indices of the sub-FSMs in `fsm` that could have matched the state sequence `state_seq`.
+
+    Parameters
+    ----------
+    state_seq
+        A state sequence.
+    fsms_to_trans_finals
+        A map from FSM indices to tuples containing sets of their state transitions
+        and sets of the final/accept states.
+
+    Returns
+    -------
+    A generator returning tuples containing each sub-FSM index (in the order
+    they were union-ed to construct `fsm`) and booleans indicating whether or
+    not there is another valid transition from the last state in the sequence
+    for the associated sub-FSM (i.e. if the FSM can continue
+    accepting/matching) and whether or not the sequence ends in a final state
+    of the sub-FSM.
+    """
+    state_seq_transitions = set(zip(state_seq[:-1], state_seq[1:]))
+    last_fsm_state = state_seq[-1]
+    yield from (
+        (
+            # The sub-FMS index
+            fsm_idx,
+            # Is there another possible transition in this sub-FSM?
+            any(last_fsm_state == from_s for (from_s, to_s) in transitions),
+            # Is this sub-FSM in a final state?
+            state_seq[-1] in finals,
+        )
+        for fsm_idx, (transitions, finals, _) in fsms_to_trans_finals.items()
+        if state_seq_transitions.issubset(transitions)
+    )
+
+
+def walk_fsm(
+    fsm: BetterFSM,
+    token_transition_keys: Sequence[int],
+    start_state: int,
+    full_match: bool = True,
+) -> List[int]:
+    fsm_finals = fsm.finals
+
+    state = start_state
+    accepted_states: List[int] = []
+    last_final_idx: int = 0
+
+    fsm_transitions = fsm.flat_transition_map
+
+    # Iterate over token transition key sequence. The transition key
+    # sequence represents the FSM traversal rules of the tokens symbols.
+    for i, trans_key in enumerate(token_transition_keys):
+        new_state = fsm_transitions.get((state, trans_key))
+
+        if new_state is None:
+            if not full_match and last_final_idx > 0:
+                return accepted_states[:last_final_idx]
+
+            return []
+
+        state = new_state
+
+        if state in fsm_finals:
+            last_final_idx = i + 1
+
+        accepted_states.append(state)
+
+    if full_match and last_final_idx - 1 != i:
+        return []
+
+    return accepted_states

vllm/lib/python3.10/site-packages/outlines/fsm/types.py

@@ -0,0 +1,81 @@
+import datetime
+from enum import EnumMeta
+from typing import Any, Protocol, Tuple, Type
+
+from typing_extensions import _AnnotatedAlias, get_args
+
+INTEGER = r"[+-]?(0|[1-9][0-9]*)"
+BOOLEAN = "(True|False)"
+FLOAT = rf"{INTEGER}(\.[0-9]+)?([eE][+-][0-9]+)?"
+DATE = r"(\d{4})-(0[1-9]|1[0-2])-([0-2][0-9]|3[0-1])"
+TIME = r"([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])"
+DATETIME = rf"({DATE})(\s)({TIME})"
+
+
+class FormatFunction(Protocol):
+    def __call__(self, sequence: str) -> Any:
+        ...
+
+
+def python_types_to_regex(python_type: Type) -> Tuple[str, FormatFunction]:
+    # If it is a custom type
+    if isinstance(python_type, _AnnotatedAlias):
+        json_schema = get_args(python_type)[1].json_schema
+        type_class = get_args(python_type)[0]
+
+        custom_regex_str = json_schema["pattern"]
+
+        def custom_format_fn(sequence: str) -> Any:
+            return type_class(sequence)
+
+        return custom_regex_str, custom_format_fn
+
+    if isinstance(python_type, EnumMeta):
+        values = python_type.__members__.keys()
+        enum_regex_str: str = "(" + "|".join(values) + ")"
+
+        def enum_format_fn(sequence: str) -> str:
+            return str(sequence)
+
+        return enum_regex_str, enum_format_fn
+
+    if python_type == float:
+
+        def float_format_fn(sequence: str) -> float:
+            return float(sequence)
+
+        return FLOAT, float_format_fn
+    elif python_type == int:
+
+        def int_format_fn(sequence: str) -> int:
+            return int(sequence)
+
+        return INTEGER, int_format_fn
+    elif python_type == bool:
+
+        def bool_format_fn(sequence: str) -> bool:
+            return bool(sequence)
+
+        return BOOLEAN, bool_format_fn
+    elif python_type == datetime.date:
+
+        def date_format_fn(sequence: str) -> datetime.date:
+            return datetime.datetime.strptime(sequence, "%Y-%m-%d").date()
+
+        return DATE, date_format_fn
+    elif python_type == datetime.time:
+
+        def time_format_fn(sequence: str) -> datetime.time:
+            return datetime.datetime.strptime(sequence, "%H:%M:%S").time()
+
+        return TIME, time_format_fn
+    elif python_type == datetime.datetime:
+
+        def datetime_format_fn(sequence: str) -> datetime.datetime:
+            return datetime.datetime.strptime(sequence, "%Y-%m-%d %H:%M:%S")
+
+        return DATETIME, datetime_format_fn
+    else:
+        raise NotImplementedError(
+            f"The Python type {python_type} is not supported. Please open an issue."
+        )

vllm/lib/python3.10/site-packages/outlines/function.py

@@ -0,0 +1,117 @@
+import importlib.util
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Callable, Optional, Tuple, Union
+
+import requests
+
+from outlines import generate, models
+
+if TYPE_CHECKING:
+    from outlines.generate.api import SequenceGenerator
+    from outlines.prompts import Prompt
+
+
+@dataclass
+class Function:
+    """Represents an Outlines function.
+
+    Functions are a convenient way to encapsulate a prompt template, a language
+    model and a Pydantic model that define the output structure. Once defined,
+    the function can be called with arguments that will be used to render the
+    prompt template.
+
+    """
+
+    prompt_template: "Prompt"
+    schema: Union[str, Callable, object]
+    model_name: str
+    generator: Optional["SequenceGenerator"] = None
+
+    @classmethod
+    def from_github(cls, program_path: str, function_name: str = "fn"):
+        """Load a function stored on GitHub"""
+        program_content = download_from_github(program_path)
+        function = extract_function_from_file(program_content, function_name)
+
+        return function
+
+    def init_generator(self):
+        """Load the model and initialize the generator."""
+        model = models.transformers(self.model_name)
+        self.generator = generate.json(model, self.schema)
+
+    def __call__(self, *args, **kwargs):
+        """Call the function.
+
+        .. warning::
+
+           This currently does not support batching.
+
+        Parameters
+        ----------
+        args
+            Values to pass to the prompt template as positional arguments.
+        kwargs
+            Values to pass to the prompt template as keyword arguments.
+
+        """
+        if self.generator is None:
+            self.init_generator()
+
+        prompt = self.prompt_template(*args, **kwargs)
+        return self.generator(prompt)
+
+
+def download_from_github(short_path: str):
+    """Download the file in which the function is stored on GitHub."""
+    GITHUB_BASE_URL = "https://raw.githubusercontent.com"
+    BRANCH = "main"
+
+    path = short_path.split("/")
+    if len(path) < 3:
+        raise ValueError(
+            "Please provide a valid path in the form {USERNAME}/{REPO_NAME}/{PATH_TO_FILE}."
+        )
+    elif short_path[-3:] == ".py":
+        raise ValueError("Do not append the `.py` extension to the program name.")
+
+    username = path[0]
+    repo = path[1]
+    path_to_file = path[2:]
+
+    url = "/".join([GITHUB_BASE_URL, username, repo, BRANCH] + path_to_file) + ".py"
+    result = requests.get(url)
+
+    if result.status_code == 200:
+        return result.text
+    elif result.status_code == 404:
+        raise ValueError(
+            f"Program could not be found at {url}. Please make sure you entered the GitHub username, repository name and path to the program correctly."
+        )
+    else:
+        result.raise_for_status()
+
+
+def extract_function_from_file(content: str, function_name: str) -> Tuple[Callable]:
+    """Extract a function object from a downloaded file."""
+
+    spec = importlib.util.spec_from_loader(
+        "outlines_function", loader=None, origin="github"
+    )
+    if spec is not None:
+        module = importlib.util.module_from_spec(spec)
+        exec(content, module.__dict__)
+
+        try:
+            fn = getattr(module, function_name)
+        except AttributeError:
+            raise AttributeError(
+                "Could not find an `outlines.Function` instance in the remote file. Make sure that the path you specified is correct."
+            )
+
+        if not isinstance(fn, module.outlines.Function):
+            raise TypeError(
+                f"The `{function_name}` variable in the program must be an instance of `outlines.Function`"
+            )
+
+    return fn

vllm/lib/python3.10/site-packages/outlines/generate/choice.py

@@ -0,0 +1,59 @@
+import json as pyjson
+import re
+from enum import Enum
+from functools import singledispatch
+from typing import Callable, List, Union
+
+from outlines_core.fsm.json_schema import build_regex_from_schema
+
+from outlines.fsm.json_schema import get_schema_from_enum
+from outlines.generate.api import SequenceGeneratorAdapter
+from outlines.models import OpenAI
+from outlines.samplers import Sampler, multinomial
+
+from .json import json
+from .regex import regex
+
+
+@singledispatch
+def choice(
+    model, choices: Union[List[str], type[Enum]], sampler: Sampler = multinomial()
+) -> SequenceGeneratorAdapter:
+    if isinstance(choices, type(Enum)):
+        regex_str = build_regex_from_schema(pyjson.dumps(get_schema_from_enum(choices)))
+    else:
+        choices = [re.escape(choice) for choice in choices]  # type: ignore
+        regex_str = r"(" + r"|".join(choices) + r")"
+
+    generator = regex(model, regex_str, sampler)
+    if isinstance(choices, type(Enum)):
+        generator.format_sequence = lambda x: pyjson.loads(x)
+    else:
+        generator.format_sequence = lambda x: x
+
+    return generator
+
+
+@choice.register(OpenAI)
+def choice_openai(
+    model: OpenAI, choices: List[str], sampler: Sampler = multinomial()
+) -> Callable:
+    """
+    Call OpenAI API with response_format of a dict:
+    {"result": <one of choices>}
+    """
+
+    choices_schema = pyjson.dumps(
+        {
+            "type": "object",
+            "properties": {"result": {"type": "string", "enum": choices}},
+            "additionalProperties": False,
+            "required": ["result"],
+        }
+    )
+    generator = json(model, choices_schema, sampler)
+
+    def generate_choice(*args, **kwargs):
+        return generator(*args, **kwargs)["result"]
+
+    return generate_choice

vllm/lib/python3.10/site-packages/outlines/generate/text.py

@@ -0,0 +1,50 @@
+from functools import singledispatch
+
+from outlines.generate.api import (
+    SequenceGeneratorAdapter,
+    VisionSequenceGeneratorAdapter,
+)
+from outlines.models import OpenAI, TransformersVision
+from outlines.samplers import Sampler, multinomial
+
+
+@singledispatch
+def text(model, sampler: Sampler = multinomial()) -> SequenceGeneratorAdapter:
+    """Generate text with a `Transformer` model.
+
+    Note
+    ----
+    Python 3.11 allows dispatching on Union types and
+    this should greatly simplify the code.
+
+    Arguments
+    ---------
+    model:
+        An instance of `Transformer` that represents a model from the
+        `transformers` library.
+    sampler:
+        The sampling algorithm to use to generate token ids from the logits
+        distribution.
+
+    Returns
+    -------
+    A `SequenceGeneratorAdapter` instance that generates text.
+
+    """
+    return SequenceGeneratorAdapter(model, None, sampler)
+
+
+@text.register(TransformersVision)
+def text_vision(model, sampler: Sampler = multinomial()):
+    return VisionSequenceGeneratorAdapter(model, None, sampler)
+
+
+@text.register(OpenAI)
+def text_openai(model: OpenAI, sampler: Sampler = multinomial()) -> OpenAI:
+    if not isinstance(sampler, multinomial):
+        raise NotImplementedError(
+            r"The OpenAI API does not support any other sampling algorithm "
+            + "than the multinomial sampler."
+        )
+
+    return model

vllm/lib/python3.10/site-packages/outlines/grammars.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+GRAMMAR_PATH = Path(__file__).parent / "grammars"
+
+
+def read_grammar(grammar_file_name, base_grammar_path=GRAMMAR_PATH):
+    """Read grammar file from default grammar path"""
+    full_path = base_grammar_path / grammar_file_name
+    with open(full_path) as file:
+        return file.read()
+
+
+arithmetic = read_grammar("arithmetic.lark")
+json = read_grammar("json.lark")

vllm/lib/python3.10/site-packages/outlines/grammars/arithmetic.lark

@@ -0,0 +1,18 @@
+?start: sum
+
+?sum: product
+| sum "+" product   -> add
+| sum "-" product   -> sub
+
+?product: atom
+| product "*" atom  -> mul
+| product "/" atom  -> div
+
+?atom: NUMBER           -> number
+| "-" atom         -> neg
+| "(" sum ")"
+
+%import common.NUMBER
+%import common.WS_INLINE
+
+%ignore WS_INLINE

vllm/lib/python3.10/site-packages/outlines/grammars/common.lark

@@ -0,0 +1,83 @@
+// Adapted from https://github.com/lark-parser/lark/blob/master/lark/grammars/common.lark
+
+// Lark License:
+// Copyright © 2017 Erez Shinan
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+// Basic terminals for common use
+
+
+//
+// Numbers
+//
+
+DIGIT: "0".."9"
+HEXDIGIT: "a".."f"|"A".."F"|DIGIT
+
+INT: DIGIT+
+SIGNED_INT: ["+"|"-"] INT
+DECIMAL: INT "." INT? | "." INT
+
+// float = /-?\d+(\.\d+)?([eE][+-]?\d+)?/
+_EXP: ("e"|"E") SIGNED_INT
+FLOAT: INT _EXP | DECIMAL _EXP?
+SIGNED_FLOAT: ["+"|"-"] FLOAT
+
+NUMBER: FLOAT | INT
+SIGNED_NUMBER: ["+"|"-"] NUMBER
+
+UNESCAPED_STRING: /\"[^"]*\"/
+
+// based on `outlines/fsm/json_schema.py`
+_NON_CONTROL_CHAR: /([^"\\\x00-\x1F\x7F-\x9F])/
+_ESCAPED_CHAR: /\\/ (_NON_CONTROL_CHAR | /\\/ | /"/)
+ESCAPED_STRING_INNER: _NON_CONTROL_CHAR | _ESCAPED_CHAR
+ESCAPED_STRING: /"/ ESCAPED_STRING_INNER* /"/
+
+
+
+//
+// Names (Variables)
+//
+LCASE_LETTER: "a".."z"
+UCASE_LETTER: "A".."Z"
+
+LETTER: UCASE_LETTER | LCASE_LETTER
+WORD: LETTER+
+
+CNAME: ("_"|LETTER) ("_"|LETTER|DIGIT)*
+
+
+//
+// Whitespace
+//
+WS_INLINE: (" "|/\t/)+
+WS: /[ \t\f\r\n]/+
+
+CR : /\r/
+LF : /\n/
+NEWLINE: (CR? LF)+
+
+
+// Comments
+SH_COMMENT: /#[^\n]*/
+CPP_COMMENT: /\/\/[^\n]*/
+C_COMMENT: "/*" /(.|\n)*?/ "*/"
+SQL_COMMENT: /--[^\n]*/

vllm/lib/python3.10/site-packages/outlines/models/__init__.py

@@ -0,0 +1,19 @@
+"""Module that contains all the models integrated in outlines.
+
+We group the models in submodules by provider instead of theme (completion, chat
+completion, diffusers, etc.) and use routing functions everywhere else in the
+codebase.
+
+"""
+
+from typing import Union
+
+from .exllamav2 import ExLlamaV2Model, exl2
+from .llamacpp import LlamaCpp, llamacpp
+from .mlxlm import MLXLM, mlxlm
+from .openai import OpenAI, azure_openai, openai
+from .transformers import Transformers, TransformerTokenizer, mamba, transformers
+from .transformers_vision import TransformersVision, transformers_vision
+from .vllm import VLLM, vllm
+
+LogitsGenerator = Union[Transformers, LlamaCpp, OpenAI, ExLlamaV2Model, MLXLM, VLLM]