Add files using upload-large-folder tool

.gitattributes

@@ -676,3 +676,4 @@ evalkit_tf437/lib/python3.10/site-packages/scipy/optimize/_highs/_highs_wrapper.
 deepseekvl2/lib/python3.10/site-packages/transformers/models/seamless_m4t_v2/__pycache__/modeling_seamless_m4t_v2.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 deepseekvl2/lib/python3.10/site-packages/transformers/__pycache__/__init__.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 deepseekvl2/lib/python3.10/site-packages/transformers/__pycache__/modeling_outputs.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+deepseek/lib/python3.10/site-packages/setuptools/_vendor/__pycache__/typing_extensions.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

deepseek/lib/python3.10/site-packages/httpx/_transports/base.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import typing
+from types import TracebackType
+
+from .._models import Request, Response
+
+T = typing.TypeVar("T", bound="BaseTransport")
+A = typing.TypeVar("A", bound="AsyncBaseTransport")
+
+__all__ = ["AsyncBaseTransport", "BaseTransport"]
+
+
+class BaseTransport:
+    def __enter__(self: T) -> T:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
+    ) -> None:
+        self.close()
+
+    def handle_request(self, request: Request) -> Response:
+        """
+        Send a single HTTP request and return a response.
+
+        Developers shouldn't typically ever need to call into this API directly,
+        since the Client class provides all the higher level user-facing API
+        niceties.
+
+        In order to properly release any network resources, the response
+        stream should *either* be consumed immediately, with a call to
+        `response.stream.read()`, or else the `handle_request` call should
+        be followed with a try/finally block to ensuring the stream is
+        always closed.
+
+        Example usage:
+
+            with httpx.HTTPTransport() as transport:
+                req = httpx.Request(
+                    method=b"GET",
+                    url=(b"https", b"www.example.com", 443, b"/"),
+                    headers=[(b"Host", b"www.example.com")],
+                )
+                resp = transport.handle_request(req)
+                body = resp.stream.read()
+                print(resp.status_code, resp.headers, body)
+
+
+        Takes a `Request` instance as the only argument.
+
+        Returns a `Response` instance.
+        """
+        raise NotImplementedError(
+            "The 'handle_request' method must be implemented."
+        )  # pragma: no cover
+
+    def close(self) -> None:
+        pass
+
+
+class AsyncBaseTransport:
+    async def __aenter__(self: A) -> A:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
+    ) -> None:
+        await self.aclose()
+
+    async def handle_async_request(
+        self,
+        request: Request,
+    ) -> Response:
+        raise NotImplementedError(
+            "The 'handle_async_request' method must be implemented."
+        )  # pragma: no cover
+
+    async def aclose(self) -> None:
+        pass

deepseek/lib/python3.10/site-packages/importlib_metadata-8.5.0.dist-info/INSTALLER

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

deepseek/lib/python3.10/site-packages/importlib_metadata-8.5.0.dist-info/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

deepseek/lib/python3.10/site-packages/importlib_metadata-8.5.0.dist-info/METADATA

@@ -0,0 +1,133 @@
+Metadata-Version: 2.1
+Name: importlib_metadata
+Version: 8.5.0
+Summary: Read metadata from Python packages
+Author-email: "Jason R. Coombs" <jaraco@jaraco.com>
+Project-URL: Source, https://github.com/python/importlib_metadata
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: zipp >=3.20
+Requires-Dist: typing-extensions >=3.6.4 ; python_version < "3.8"
+Provides-Extra: check
+Requires-Dist: pytest-checkdocs >=2.4 ; extra == 'check'
+Requires-Dist: pytest-ruff >=0.2.1 ; (sys_platform != "cygwin") and extra == 'check'
+Provides-Extra: cover
+Requires-Dist: pytest-cov ; extra == 'cover'
+Provides-Extra: doc
+Requires-Dist: sphinx >=3.5 ; extra == 'doc'
+Requires-Dist: jaraco.packaging >=9.3 ; extra == 'doc'
+Requires-Dist: rst.linker >=1.9 ; extra == 'doc'
+Requires-Dist: furo ; extra == 'doc'
+Requires-Dist: sphinx-lint ; extra == 'doc'
+Requires-Dist: jaraco.tidelift >=1.4 ; extra == 'doc'
+Provides-Extra: enabler
+Requires-Dist: pytest-enabler >=2.2 ; extra == 'enabler'
+Provides-Extra: perf
+Requires-Dist: ipython ; extra == 'perf'
+Provides-Extra: test
+Requires-Dist: pytest !=8.1.*,>=6 ; extra == 'test'
+Requires-Dist: packaging ; extra == 'test'
+Requires-Dist: pyfakefs ; extra == 'test'
+Requires-Dist: flufl.flake8 ; extra == 'test'
+Requires-Dist: pytest-perf >=0.9.2 ; extra == 'test'
+Requires-Dist: jaraco.test >=5.4 ; extra == 'test'
+Requires-Dist: importlib-resources >=1.3 ; (python_version < "3.9") and extra == 'test'
+Provides-Extra: type
+Requires-Dist: pytest-mypy ; extra == 'type'
+
+.. image:: https://img.shields.io/pypi/v/importlib_metadata.svg
+   :target: https://pypi.org/project/importlib_metadata
+
+.. image:: https://img.shields.io/pypi/pyversions/importlib_metadata.svg
+
+.. image:: https://github.com/python/importlib_metadata/actions/workflows/main.yml/badge.svg
+   :target: https://github.com/python/importlib_metadata/actions?query=workflow%3A%22tests%22
+   :alt: tests
+
+.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json
+    :target: https://github.com/astral-sh/ruff
+    :alt: Ruff
+
+.. image:: https://readthedocs.org/projects/importlib-metadata/badge/?version=latest
+   :target: https://importlib-metadata.readthedocs.io/en/latest/?badge=latest
+
+.. image:: https://img.shields.io/badge/skeleton-2024-informational
+   :target: https://blog.jaraco.com/skeleton
+
+.. image:: https://tidelift.com/badges/package/pypi/importlib-metadata
+   :target: https://tidelift.com/subscription/pkg/pypi-importlib-metadata?utm_source=pypi-importlib-metadata&utm_medium=readme
+
+Library to access the metadata for a Python package.
+
+This package supplies third-party access to the functionality of
+`importlib.metadata <https://docs.python.org/3/library/importlib.metadata.html>`_
+including improvements added to subsequent Python versions.
+
+
+Compatibility
+=============
+
+New features are introduced in this third-party library and later merged
+into CPython. The following table indicates which versions of this library
+were contributed to different versions in the standard library:
+
+.. list-table::
+   :header-rows: 1
+
+   * - importlib_metadata
+     - stdlib
+   * - 7.0
+     - 3.13
+   * - 6.5
+     - 3.12
+   * - 4.13
+     - 3.11
+   * - 4.6
+     - 3.10
+   * - 1.4
+     - 3.8
+
+
+Usage
+=====
+
+See the `online documentation <https://importlib-metadata.readthedocs.io/>`_
+for usage details.
+
+`Finder authors
+<https://docs.python.org/3/reference/import.html#finders-and-loaders>`_ can
+also add support for custom package installers.  See the above documentation
+for details.
+
+
+Caveats
+=======
+
+This project primarily supports third-party packages installed by PyPA
+tools (or other conforming packages). It does not support:
+
+- Packages in the stdlib.
+- Packages installed without metadata.
+
+Project details
+===============
+
+ * Project home: https://github.com/python/importlib_metadata
+ * Report bugs at: https://github.com/python/importlib_metadata/issues
+ * Code hosting: https://github.com/python/importlib_metadata
+ * Documentation: https://importlib-metadata.readthedocs.io/
+
+For Enterprise
+==============
+
+Available as part of the Tidelift Subscription.
+
+This project and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use.
+
+`Learn more <https://tidelift.com/subscription/pkg/pypi-importlib-metadata?utm_source=pypi-importlib-metadata&utm_medium=referral&utm_campaign=github>`_.

deepseek/lib/python3.10/site-packages/importlib_metadata-8.5.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (74.1.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

deepseek/lib/python3.10/site-packages/importlib_metadata-8.5.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+importlib_metadata

deepseek/lib/python3.10/site-packages/lmformatenforcer/analyzer.py

@@ -0,0 +1,77 @@
+from typing import Dict, Hashable, List
+try:
+    import numpy as np
+    import numpy.typing as npt
+except ImportError as e:
+    class FormatEnforcerAnalyzer: # type: ignore
+        def __init__(self, *args, **kwargs):
+            pass
+        def report_raw_logits(self, *args, **kwargs):
+            pass
+        def generate_report_dict(self, *args, **kwargs):
+            return {}
+    raise ImportError('FormatEnforcerAnalyzer not available because numpy is not installed. Please install it with "pip install numpy"') from e
+
+from . import TokenEnforcer
+
+class FormatEnforcerAnalyzer:
+    """A helper class to help analyze the format enforcer's behavior."""
+    def __init__(self, token_enforcer: TokenEnforcer):
+        self.token_enforcer = token_enforcer
+        self.raw_logits: Dict[Hashable, npt.ArrayLike] = {}
+
+    def report_raw_logits(self, output_tokens: List[int], logits: npt.ArrayLike):
+        """Report what logits were generated for a specific token sequence. The logits must be before any processing / filtering."""
+        self.raw_logits[tuple(output_tokens)] = logits
+
+    def generate_report_dict(self, output_tokens: List[int]) -> dict:
+        """Generate a report dict containing the analysis results for a specific output token sequence."""
+        scores_matrix: List[npt.ArrayLike] = []
+        allowed_tokens_matrix: List[List[int]] = []
+        for idx in range(len(output_tokens)):
+            prefix = output_tokens[:idx]
+            prefix_tuple = tuple(prefix)
+            if prefix_tuple in self.raw_logits:
+                scores_matrix.append(self.raw_logits[prefix_tuple])
+                allowed_tokens_matrix.append(self.token_enforcer.get_allowed_tokens(prefix))
+
+        logits = np.array(scores_matrix) # n_tokens * vocab_size
+        softmax_logits = _softmax(logits) # n_tokens * vocab_size
+        original_indices = softmax_logits.argmax(axis=1) # n_tokens
+        original_scores = _select_array(softmax_logits, original_indices) # n_tokens
+        
+        single_token_dict: Dict[int, str] = {token_id: token_str for token_id, token_str, _ in self.token_enforcer.regular_tokens}
+        def single_token_decoder(token_id: int) -> str:
+            if token_id in single_token_dict:
+                return single_token_dict[token_id]
+            return self.token_enforcer.decoder([token_id])
+        
+        original_tokens = [single_token_decoder(idx) for idx in original_indices]
+        
+        penalty_matrix = np.full_like(softmax_logits, -np.inf)
+        for row in range(penalty_matrix.shape[0]):
+            penalty_matrix[row][allowed_tokens_matrix[row]] = 0
+        enfored_softmax_logits = softmax_logits + penalty_matrix
+
+        enforced_indices = enfored_softmax_logits.argmax(axis=1)
+        enforced_scores = _select_array(enfored_softmax_logits, enforced_indices)
+
+        enforced_tokens = [single_token_decoder(idx) for idx in enforced_indices]
+        df_dict = {}  # In order to minimize the package's dependencies, we don't create a dataframe, but create a dataframe-like dictionary instead.
+        df_dict['generated_token'] = enforced_tokens
+        df_dict['generated_token_idx'] = enforced_indices.tolist()
+        df_dict['generated_score'] = enforced_scores.tolist()
+        df_dict['leading_token'] = original_tokens
+        df_dict['leading_token_idx'] = original_indices.tolist()
+        df_dict['leading_score'] = original_scores.tolist()
+
+        return df_dict
+    
+def _softmax(arr: np.ndarray) -> np.ndarray:
+    """Compute softmax values for each sets of scores in arr."""
+    e_arr = np.exp(arr)
+    return e_arr / np.sum(e_arr, axis=1, keepdims=True)
+
+def _select_array(arr: np.ndarray, index_array: np.ndarray) -> np.ndarray:
+    # https://numpy.org/doc/stable/reference/generated/numpy.argmax.html
+    return np.take_along_axis(arr, np.expand_dims(index_array, axis=-1), axis=-1).squeeze(axis=-1)

deepseek/lib/python3.10/site-packages/lmformatenforcer/characterlevelparser.py

@@ -0,0 +1,187 @@
+import abc
+import os
+from dataclasses import dataclass, field
+from typing import Hashable, List, Optional, TypeVar
+from .consts import (COMPLETE_ALPHABET, WHITESPACE_CHARACTERS, DEFAULT_MAX_CONSECUTIVE_WHITESPACES, 
+                     DEFAULT_FORCE_JSON_FIELD_ORDER, CONFIG_ENV_VAR_MAX_CONSECUTIVE_WHITESPACES, 
+                     CONFIG_ENV_VAR_STRICT_JSON_FIELD_ORDER, CONFIG_ENV_VAR_MAX_JSON_ARRAY_LENGTH,
+                     DEFAULT_MAX_JSON_ARRAY_LENGTH)
+
+
+def _parse_bool(s: str) -> bool:
+    return s and (s.strip().lower() in ['true', '1'])
+
+
+def _env_or_default_field(env_var: str, default_val):
+    default_val_type = type(default_val)
+    parser_func = _parse_bool if default_val_type == bool else default_val_type
+    def factory_func():
+        return parser_func(os.environ.get(env_var, str(default_val)))
+    return field(default_factory=factory_func)
+
+
+@dataclass
+class CharacterLevelParserConfig:
+    alphabet: str = COMPLETE_ALPHABET
+    max_consecutive_whitespaces: int = _env_or_default_field(CONFIG_ENV_VAR_MAX_CONSECUTIVE_WHITESPACES, 
+                                                             DEFAULT_MAX_CONSECUTIVE_WHITESPACES)
+    """How many consective whitespaces the JsonSchemaParser will allow"""
+    force_json_field_order: bool = _env_or_default_field(CONFIG_ENV_VAR_STRICT_JSON_FIELD_ORDER, 
+                                                         DEFAULT_FORCE_JSON_FIELD_ORDER)
+    """Whether the JsonSchemaParser will force fields to appear in the 
+    order of the 'required' field in the schema"""
+    max_json_array_length: int = _env_or_default_field(CONFIG_ENV_VAR_MAX_JSON_ARRAY_LENGTH,
+                                                       DEFAULT_MAX_JSON_ARRAY_LENGTH)
+    """What is the maximum json array length if not specified by the schema. Helps the LLM
+    avoid infinite loops."""
+
+
+class CharacterLevelParser(abc.ABC):
+    """CharacterLevelParser is an interface for classes that can parse strings one character at a time, and determine which characters are allowed at any specific time"""
+
+    def __init__(self, config: Optional[CharacterLevelParserConfig] = None):
+        self._config = config or CharacterLevelParserConfig()
+    
+    @abc.abstractmethod
+    def add_character(self, new_character: str) -> 'CharacterLevelParser':
+        """Add a character to the parser, and return a new parser that represents the state of the parser after the character has been added. This has to be
+        an immutable operation - the original CharacterLevelParser (self) must not be modified."""
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def get_allowed_characters(self) -> str:
+        """Return a string containing all characters that are allowed at the current point in the parsing process."""
+        raise NotImplementedError()
+    
+    @abc.abstractmethod
+    def can_end(self) -> bool:
+        """Return True if the parser is in a state where it can end (potentially finished parsing the desired structure), and False otherwise."""
+        raise NotImplementedError()
+    
+    def shortcut_key(self) -> Optional[Hashable]:
+        """Optional. Return a key that denotes that this state is a repeating state, full tree traversal should be avoided."""
+        return None
+    
+    def cache_key(self) -> Optional[Hashable]:
+        """Optional. Return a key that denotes that this state is a repeating state, and if it is visited again, results can be cached."""
+        return None
+    
+    @property
+    def config(self) -> CharacterLevelParserConfig:
+        return self._config
+    
+    @config.setter
+    def config(self, new_config: CharacterLevelParserConfig):
+        self._config = new_config
+        return self
+
+
+class StringParser(CharacterLevelParser):
+    """RegexParser is an example CharacterLevelParser that only allows an exact string. It is a debugging / learning tool
+    to show how CharacterLevelParser works together with TokenizerPrefixTree to filter the allowed tokens (some of whom may contain multiple characters)"""
+    def __init__(self, string: str):
+        self.target_str = string
+
+    def add_character(self, new_character: str) -> CharacterLevelParser:
+        if self.target_str.startswith(new_character):
+            return StringParser(self.target_str[len(new_character):])
+        else:
+            raise ValueError(f"Expected '{self.target_str[0]}' but got '{new_character}'")
+
+    def get_allowed_characters(self) -> str:
+        return self.target_str[0] if self.target_str else ""
+
+    def can_end(self) -> bool:
+        return not self.target_str
+    
+
+class ForceStopParser(CharacterLevelParser):
+    """A simple parser that forbids any characters except the stop token. Used to force stop LM operation"""
+    def __init__(self, allow_whitespace: bool = False):
+        self.allow_whitespace = allow_whitespace
+    def add_character(self, new_character: str) -> CharacterLevelParser:
+        return self
+    def get_allowed_characters(self) -> str:
+        return WHITESPACE_CHARACTERS if self.allow_whitespace else ""
+    def can_end(self) -> bool:
+        return True
+    
+
+class UnionParser(CharacterLevelParser):
+    """A parser that allows a string that would be allowed by any of several different parsers"""
+    def __init__(self, parsers: List[CharacterLevelParser]):
+        self.parsers = parsers
+
+    def add_character(self, new_character: str) -> CharacterLevelParser:
+        # This is a bit of a performance hit, as it means get_allowed_characters() is called twice.
+        relevant_parsers = [parser for parser in self.parsers if new_character in parser.get_allowed_characters()]
+        next_parsers = [parser.add_character(new_character) for parser in relevant_parsers]
+        if len(next_parsers) == 1:
+            return next_parsers[0]
+        return UnionParser(next_parsers)
+    
+    def get_allowed_characters(self) -> str:
+        allowed = "".join([parser.get_allowed_characters() for parser in self.parsers])
+        return "".join(set(allowed))
+    
+    def can_end(self) -> bool:
+        return any([parser.can_end() for parser in self.parsers])
+    
+    def shortcut_key(self) -> Optional[Hashable]:
+        unique_shortcut_keys = set(parser.shortcut_key() for parser in self.parsers)
+        if len(unique_shortcut_keys) == 1:
+            return next(iter(unique_shortcut_keys))
+        return None
+    
+    def cache_key(self) -> Optional[Hashable]:
+        all_cache_keys = tuple(parser.cache_key() for parser in self.parsers)
+        if all(key is not None for key in all_cache_keys):
+            return ('union', all_cache_keys)
+        return None
+
+
+class SequenceParser(CharacterLevelParser):
+    """A parser that is a sequence of multiple parsers."""
+    def __init__(self, parsers: List[CharacterLevelParser]):
+        self.parsers = parsers
+
+    def add_character(self, new_character: str) -> CharacterLevelParser:
+        legal_parsers = []
+        # Tricky edge case: if the first parser can both end and accept the character,
+        # and the second parser can also accept, we don't know which scenario we are dealing
+        # with, so we need to return a UnionParser.
+        for idx, parser in enumerate(self.parsers):
+            if new_character in parser.get_allowed_characters():
+                updated_parser = parser.add_character(new_character)
+                next_parsers = [updated_parser] + self.parsers[idx+1:]
+                if len(next_parsers) == 1:
+                    legal_parsers.append(next_parsers[0])
+                else:
+                    legal_parsers.append(SequenceParser(next_parsers))
+            if not parser.can_end():
+                break
+        if len(legal_parsers) == 1:
+            return legal_parsers[0]
+        return UnionParser(legal_parsers)
+    
+    def get_allowed_characters(self) -> str:
+        allowed_characters = set()
+        for parser in self.parsers:
+            allowed_characters.update(parser.get_allowed_characters())
+            if not parser.can_end():
+                break
+        return "".join(allowed_characters)
+    
+    def can_end(self) -> bool:
+        return all([parser.can_end() for parser in self.parsers])
+    
+    def shortcut_key(self) -> Optional[str]:
+        return self.parsers[0].shortcut_key() if len(self.parsers) == 1 else None
+    
+    def cache_key(self) -> Optional[Hashable]:
+        all_cache_keys = tuple(parser.cache_key() for parser in self.parsers)
+        if all(key is not None for key in all_cache_keys):
+            return ('sequence', all_cache_keys)
+        return None
+
+

deepseek/lib/python3.10/site-packages/lmformatenforcer/external/jsonschemaobjectutil.py

@@ -0,0 +1,231 @@
+# https://github.com/koxudaxi/datamodel-code-generator/blob/master/datamodel_code_generator/util.py
+# MIT License
+
+# Copyright (c) 2019 Koudai Aono
+
+# 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.
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable, TypeVar
+from enum import Enum, auto
+
+import pydantic
+from packaging import version
+from pydantic import BaseModel as _BaseModel
+
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Iterator,
+    TypeVar,
+    Union,
+)
+
+PYDANTIC_VERSION = version.parse(
+    pydantic.VERSION if isinstance(pydantic.VERSION, str) else str(pydantic.VERSION)
+)
+
+PYDANTIC_V2: bool = PYDANTIC_VERSION >= version.parse('2.0b3')
+
+if PYDANTIC_V2:
+    from pydantic import GetCoreSchemaHandler
+    from pydantic_core import core_schema
+
+if TYPE_CHECKING:
+    cached_property = property
+    from yaml import SafeLoader
+
+    Protocol = object
+    runtime_checkable: Callable[..., Any]
+
+    from typing_extensions import Literal
+else:
+    try:
+        from typing import Protocol
+    except ImportError:
+        from typing_extensions import Protocol  # noqa
+    try:
+        from typing import runtime_checkable
+    except ImportError:
+        from typing_extensions import runtime_checkable  # noqa
+    try:
+        from yaml import CSafeLoader as SafeLoader
+    except ImportError:  # pragma: no cover
+        from yaml import SafeLoader
+
+    try:
+        from functools import cached_property
+    except ImportError:
+        _NOT_FOUND = object()
+
+        class cached_property:
+            def __init__(self, func: Callable) -> None:
+                self.func: Callable = func
+                self.__doc__: Any = func.__doc__
+
+            def __get__(self, instance: Any, owner: Any = None) -> Any:
+                value = instance.__dict__.get(self.func.__name__, _NOT_FOUND)
+                if value is _NOT_FOUND:  # pragma: no cover
+                    value = instance.__dict__[self.func.__name__] = self.func(instance)
+                return value
+
+
+SafeLoader.yaml_constructors[
+    'tag:yaml.org,2002:timestamp'
+] = SafeLoader.yaml_constructors['tag:yaml.org,2002:str']
+
+
+Model = TypeVar('Model', bound=_BaseModel)
+
+
+def model_validator(
+    mode: Literal['before', 'after'] = 'after',
+) -> Callable[[Callable[[Model, Any], Any]], Callable[[Model, Any], Any]]:
+    def inner(method: Callable[[Model, Any], Any]) -> Callable[[Model, Any], Any]:
+        if PYDANTIC_V2:
+            from pydantic import model_validator as model_validator_v2
+
+            return model_validator_v2(mode=mode)(method)  # type: ignore
+        else:
+            from pydantic import root_validator
+
+            return root_validator(method, pre=mode == 'before')  # type: ignore
+
+    return inner
+
+
+def field_validator(
+    field_name: str,
+    *fields: str,
+    mode: Literal['before', 'after'] = 'after',
+) -> Callable[[Any], Callable[[Model, Any], Any]]:
+    def inner(method: Callable[[Model, Any], Any]) -> Callable[[Model, Any], Any]:
+        if PYDANTIC_V2:
+            from pydantic import field_validator as field_validator_v2
+
+            return field_validator_v2(field_name, *fields, mode=mode)(method)  # type: ignore
+        else:
+            from pydantic import validator
+
+            return validator(field_name, *fields, pre=mode == 'before')(method)  # type: ignore
+
+    return inner
+
+
+if PYDANTIC_V2:
+    from pydantic import ConfigDict as ConfigDict
+else:
+    ConfigDict = dict  # type: ignore
+
+
+class BaseModel(_BaseModel):
+    if PYDANTIC_V2:
+        model_config = ConfigDict(strict=False)
+
+
+def is_url(ref: str) -> bool:
+    return ref.startswith(('https://', 'http://'))
+
+
+class Types(Enum):
+    integer = auto()
+    int32 = auto()
+    int64 = auto()
+    number = auto()
+    float = auto()
+    double = auto()
+    decimal = auto()
+    time = auto()
+    string = auto()
+    byte = auto()
+    binary = auto()
+    date = auto()
+    date_time = auto()
+    password = auto()
+    email = auto()
+    uuid = auto()
+    uuid1 = auto()
+    uuid2 = auto()
+    uuid3 = auto()
+    uuid4 = auto()
+    uuid5 = auto()
+    uri = auto()
+    hostname = auto()
+    ipv4 = auto()
+    ipv4_network = auto()
+    ipv6 = auto()
+    ipv6_network = auto()
+    boolean = auto()
+    object = auto()
+    null = auto()
+    array = auto()
+    any = auto()
+
+class UnionIntFloat:
+    def __init__(self, value: Union[int, float]) -> None:
+        self.value: Union[int, float] = value
+
+    def __int__(self) -> int:
+        return int(self.value)
+
+    def __float__(self) -> float:
+        return float(self.value)
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @classmethod
+    def __get_validators__(cls) -> Iterator[Callable[[Any], Any]]:
+        yield cls.validate
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, _source_type: Any, _handler: GetCoreSchemaHandler
+    ) -> core_schema.CoreSchema:
+        from_int_schema = core_schema.chain_schema(
+            [
+                core_schema.union_schema(
+                    [core_schema.int_schema(), core_schema.float_schema()]
+                ),
+                core_schema.no_info_plain_validator_function(cls.validate),
+            ]
+        )
+
+        return core_schema.json_or_python_schema(
+            json_schema=core_schema.no_info_plain_validator_function(cls.validate),
+            python_schema=core_schema.union_schema(
+                [
+                    # check if it's an instance first before doing any further work
+                    core_schema.is_instance_schema(UnionIntFloat),
+                    from_int_schema,
+                ]
+            ),
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                lambda instance: instance.value
+            ),
+        )
+
+    @classmethod
+    def validate(cls, v: Any) -> UnionIntFloat:
+        if isinstance(v, UnionIntFloat):
+            return v
+        elif not isinstance(v, (int, float)):  # pragma: no cover
+            raise TypeError(f'{v} is not int or float')
+        return cls(v)

deepseek/lib/python3.10/site-packages/lmformatenforcer/integrations/llamacpp.py

@@ -0,0 +1,74 @@
+try:
+    from llama_cpp import Llama, LogitsProcessor
+except ImportError:
+    raise ImportError('llama-cpp-python is not installed. Please install it with "pip install llama-cpp-python"')
+from lmformatenforcer import CharacterLevelParser, TokenEnforcer, FormatEnforcerAnalyzer, TokenEnforcerTokenizerData
+import numpy as np
+import numpy.typing as npt
+from typing import Tuple, List, Union
+
+def _build_regular_tokens_list(llm: Llama) -> List[Tuple[int, str, bool]]:
+    token_0 = llm.tokenize(b"0")[-1]
+    regular_tokens = []
+    special_tokens = [llm.token_bos(), llm.token_eos()]
+    for token_idx in range(llm.n_vocab()):
+        if token_idx in special_tokens:
+            continue
+        # We prepend token 0 and skip the first letter of the result to get a space if the token is a start word.
+        try:
+            decoded_after_0 = llm.detokenize([token_0, token_idx]).decode('utf-8')[1:]
+            decoded_regular = llm.detokenize([token_idx]).decode('utf-8')
+            is_word_start_token = len(decoded_after_0) > len(decoded_regular)
+            regular_tokens.append((token_idx, decoded_after_0, is_word_start_token))
+        except:
+            # This can happen for cases such as raw bytes outside of the ASCII range. We assign this a value of �,
+            # which is what huggingface does for tokens that are meaningless on their own. Allowing this in the
+            # json_freetext field will allow the language model to build unicode sequences from multiple tokens
+            # in JSON-freetext fields.
+            regular_tokens.append((token_idx, '�', False))
+    return regular_tokens
+
+
+def build_token_enforcer_tokenizer_data(llm: Llama) -> TokenEnforcerTokenizerData:
+    regular_tokens = _build_regular_tokens_list(llm)
+
+    def decoder_fn(sent: List[int]) -> str:
+        try:
+            return llm.detokenize(sent).decode('utf-8')
+        except:
+            return decoder_fn(sent[:-1])
+    
+    return TokenEnforcerTokenizerData(regular_tokens, decoder_fn, llm.token_eos())
+
+
+class LlamaCppLogitsProcessor:
+    def __init__(self, token_enforcer: TokenEnforcer, analyze):
+        self.token_enforcer = token_enforcer
+        self.analyzer = FormatEnforcerAnalyzer(token_enforcer) if analyze else None
+        self.mask = None
+
+    def __call__(self, input_ids: npt.NDArray[np.intc], scores: npt.NDArray[np.single]) -> npt.NDArray[np.single]:
+        token_sequence = input_ids.tolist()
+        if self.analyzer:
+            self.analyzer.report_raw_logits(token_sequence, scores.tolist())
+        allowed_tokens = self.token_enforcer.get_allowed_tokens(token_sequence)
+        if self.mask is None:
+            self.mask = np.ones(scores.shape, bool)
+        else:
+            self.mask.fill(True)
+        self.mask[allowed_tokens] = False
+        scores[self.mask] = float('-inf')
+        return scores
+
+    
+def build_llamacpp_logits_processor(llm: Union[Llama, TokenEnforcerTokenizerData], character_level_parser: CharacterLevelParser, analyze: bool=False) -> LlamaCppLogitsProcessor:
+    """Build the logits processor function that llama.cpp will use to filter the tokens generated by the model. The result
+    can be passed in the logits_processor list that is sent to the call or generate() method of llama.cpp models."""
+    if isinstance(llm, Llama):
+        llm = build_token_enforcer_tokenizer_data(llm)
+    
+    token_enforcer = TokenEnforcer(llm, character_level_parser)
+    return LlamaCppLogitsProcessor(token_enforcer, analyze)
+
+
+__all__ = ['build_llamacpp_logits_processor', 'build_token_enforcer_tokenizer_data']

deepseek/lib/python3.10/site-packages/lmformatenforcer/integrations/transformers.py

@@ -0,0 +1,146 @@
+import functools
+from typing import Any, Callable, List, Optional, Tuple, Union
+try:
+    from transformers import AutoModelForCausalLM
+    from transformers.generation.logits_process import LogitsWarper, PrefixConstrainedLogitsProcessor
+    from transformers.tokenization_utils import PreTrainedTokenizerBase
+except ImportError:
+    raise ImportError('transformers is not installed. Please install it with "pip install transformers[torch]"')
+
+try:
+    import torch
+except ImportError:
+    raise ImportError('pytorch is not installed. See https://pytorch.org/get-started/locally/ for installation instructions."')
+
+from ..characterlevelparser import CharacterLevelParser
+from ..tokenenforcer import TokenEnforcer, TokenEnforcerTokenizerData
+from ..analyzer import FormatEnforcerAnalyzer
+
+class LogitsSaverWarper(LogitsWarper):
+    def __init__(self, analyzer: FormatEnforcerAnalyzer) -> None:
+        self.analyzer = analyzer
+        
+    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor:
+        cpu_inputs = input_ids.tolist()
+        cpu_scores = scores.tolist()
+        for single_batch_inputs, single_batch_scores in zip(cpu_inputs, cpu_scores):
+            self.analyzer.report_raw_logits(single_batch_inputs, single_batch_scores)
+        return scores
+    
+class LogitsSaverManager:
+    warper: LogitsSaverWarper
+
+    def __init__(self, model: AutoModelForCausalLM, analyzer: FormatEnforcerAnalyzer):
+        self.model = model
+        self.warper = None
+        self.old_warper = None
+        self.analyzer = analyzer
+
+    def replace_logits_warper(self, filter_func = None):
+        self.old_warper = self.model._get_logits_warper
+
+        def new_logits_warper(generation_config):
+            warpers = self.old_warper(generation_config)
+            self.warper = LogitsSaverWarper(self.analyzer)
+            warpers.insert(0, self.warper)
+            if filter_func is not None:
+                processor = PrefixConstrainedLogitsProcessor(filter_func, 1)
+                warpers.insert(1, processor)
+            return warpers
+        self.model._get_logits_warper = new_logits_warper
+
+    def unreplace_logits_warper(self):
+        self.model._get_logits_warper = self.old_warper
+
+
+def _build_regular_tokens_list(tokenizer: PreTrainedTokenizerBase, vocab_size: int) -> List[Tuple[int, str, bool]]:
+    token_0 = tokenizer.encode("0")[-1]
+    regular_tokens = []
+    for token_idx in range(vocab_size):
+        if token_idx in tokenizer.all_special_ids:
+            continue
+        # We prepend token 0 and skip the first letter of the result to get a space if the token is a start word.
+        decoded_after_0 = tokenizer.decode([token_0, token_idx])[1:]
+        decoded_regular = tokenizer.decode([token_idx])
+        is_word_start_token = len(decoded_after_0) > len(decoded_regular)
+        regular_tokens.append((token_idx, decoded_after_0, is_word_start_token))
+    return regular_tokens
+
+
+def _decode_function(tokenizer: PreTrainedTokenizerBase, tokens: List[int]) -> str:
+    decoded = tokenizer.decode(tokens)
+    cleaned = decoded.rstrip('�')
+    return cleaned
+
+
+def build_token_enforcer_tokenizer_data(tokenizer: PreTrainedTokenizerBase, 
+                                        vocab_size: Optional[int] = None) -> TokenEnforcerTokenizerData:
+    vocab_size = vocab_size or len(tokenizer)
+    regular_tokens = _build_regular_tokens_list(tokenizer, vocab_size)
+    decode_fn = functools.partial(_decode_function, tokenizer)
+    return TokenEnforcerTokenizerData(regular_tokens, decode_fn, tokenizer.eos_token_id)
+
+
+class TransformersPrefixAllowedTokensFn:
+    def __init__(self, token_enforcer: TokenEnforcer):
+        self.token_enforcer = token_enforcer
+        
+    def __call__(self, batch_id: int, sent: torch.Tensor) -> List[int]:
+        token_sequence = sent.tolist()
+        return self.token_enforcer.get_allowed_tokens(token_sequence)
+
+
+def build_transformers_prefix_allowed_tokens_fn(tokenizer_data: Union[PreTrainedTokenizerBase, TokenEnforcerTokenizerData], 
+                                                character_level_parser: CharacterLevelParser) -> TransformersPrefixAllowedTokensFn:
+    """Build the prefix allowed tokens function that transformers will use to filter the tokens generated by the model. The result
+    can be passed to the prefix_allowed_tokens_fn parameter of the generate() method of transformers models or pipeline configurations."""
+    if isinstance(tokenizer_data, PreTrainedTokenizerBase):
+        tokenizer_data = build_token_enforcer_tokenizer_data(tokenizer_data)
+    token_enforcer = TokenEnforcer(tokenizer_data, character_level_parser)
+    return TransformersPrefixAllowedTokensFn(token_enforcer)
+
+
+def generate_enforced(model: AutoModelForCausalLM, 
+                      tokenizer: Union[PreTrainedTokenizerBase, TokenEnforcerTokenizerData], 
+                      character_level_parser: CharacterLevelParser, 
+                      **kwargs: dict) -> Union[str, dict]:
+    """Generate text from a model while enforcing a given format, generating enforcing diagnostic information. 
+    This can be used instead of calling model.generate().
+    If return_dict_in_generate and output_scores parameters are True, diagnostic information will be returned in the result.
+    If you don't need this, consider using prefix_allowed_tokens_fn + build_transformers_prefix_allowed_tokens_fn() instead"""
+    
+    transformers_filter_allowed_tokens = build_transformers_prefix_allowed_tokens_fn(tokenizer, character_level_parser)
+    
+    is_multi_inputs = kwargs['input_ids'].shape[0] > 1
+    is_multi_beams = kwargs.get('num_beams', 1) > 1
+    support_diagnostics = not (is_multi_inputs or is_multi_beams)  # TODO: Support diagnostics in these cases as well.
+    return_dict_in_generate = kwargs.get('return_dict_in_generate', False)
+    output_scores = kwargs.get('output_scores', None)
+
+    # We do some internals hacking in order to extract the data needed for diagnostics. If we weren't asked for them,
+    # we are better off simply using prefix_allowed_tokens_fn parameter.
+    should_run_in_advanced_mode = return_dict_in_generate and output_scores and support_diagnostics
+
+    if should_run_in_advanced_mode:
+        analyzer = FormatEnforcerAnalyzer(transformers_filter_allowed_tokens.token_enforcer)
+        logits_saver = LogitsSaverManager(model, analyzer)
+        logits_saver.replace_logits_warper(transformers_filter_allowed_tokens)
+        generate_kwargs = kwargs
+        
+        try:
+            output = model.generate(**generate_kwargs)
+        finally:
+            logits_saver.unreplace_logits_warper()
+
+        df_dict = analyzer.generate_report_dict(output['sequences'][0].tolist())
+        output.enforced_scores = df_dict
+    else:
+        output = model.generate(**kwargs, prefix_allowed_tokens_fn=transformers_filter_allowed_tokens)
+    
+    return output
+
+__all__ = [
+    'build_transformers_prefix_allowed_tokens_fn', 
+    'generate_enforced',
+    'build_token_enforcer_tokenizer_data'
+]

deepseek/lib/python3.10/site-packages/lmformatenforcer/regexparser.py

@@ -0,0 +1,85 @@
+from typing import Dict, Hashable, Optional, Union, List
+import interegular
+from interegular.fsm import anything_else
+
+from .characterlevelparser import CharacterLevelParser, CharacterLevelParserConfig
+
+class RegexParser(CharacterLevelParser):
+    """RegexParser is an example CharacterLevelParser that only allows strings that match a given regular expression."""
+
+    UNINITIALIZED_STATE = -1
+    INVALID_STATE = -2
+
+    class _Context:
+        pattern: interegular.FSM
+        anything_else_characters: str
+        state_character_cache: Dict[int, str]
+    
+    context: _Context
+    current_state: int
+
+    def __init__(self, pattern: Union[str, _Context], config: Optional[CharacterLevelParserConfig] = None, current_state: int = UNINITIALIZED_STATE):
+        super().__init__(config)
+        if isinstance(pattern, str):
+            self.context = RegexParser._Context()
+            self.context.pattern = interegular.parse_pattern(pattern).to_fsm()
+            self.context.state_character_cache = {}
+            self._update_alphabet(self.config.alphabet)
+        else:
+            self.context = pattern
+        self.current_state: int = self.context.pattern.initial if current_state == RegexParser.UNINITIALIZED_STATE else current_state
+
+    def add_character(self, new_character: str) -> 'RegexParser':
+        if self.current_state == RegexParser.INVALID_STATE:
+            return self
+        
+        state = self.current_state
+        fsm = self.context.pattern
+        # Mostly taken from FSM.accept()
+        symbol = new_character
+        if anything_else in fsm.alphabet and not symbol in fsm.alphabet:
+            symbol = anything_else
+        transition = fsm.alphabet[symbol]
+
+        try:
+            # Prefer try-catch to checking if transition exists to avoid double lookup perf hit in valid case
+            state = fsm.map[state][transition]  # type: ignore
+            return RegexParser(self.context, self.config, state)
+        except KeyError:
+            # Missing transition = transition to dead state
+            return RegexParser(self.context, self.config, RegexParser.INVALID_STATE)
+    
+    def can_end(self) -> bool:
+        return self.current_state in self.context.pattern.finals or self.current_state == RegexParser.INVALID_STATE
+    
+    def get_allowed_characters(self) -> str:
+        if self.current_state not in self.context.pattern.map:
+            return ''
+        if self.current_state not in self.context.state_character_cache:
+            allowed_characters = []
+            state_map = self.context.pattern.map[self.current_state]
+            for symbol_idx in state_map:
+                symbols: List[str] = self.context.pattern.alphabet.by_transition[symbol_idx]
+                for symbol in symbols:
+                    if symbol == anything_else:
+                        allowed_characters.append(self.context.anything_else_characters)
+                    else:
+                        allowed_characters.append(symbol)
+            self.context.state_character_cache[self.current_state] = "".join(allowed_characters)
+        return self.context.state_character_cache[self.current_state]
+    
+    def cache_key(self) -> Optional[Hashable]:
+        # If we are in the same regex fsm state, the allowed next tokens are the same ones
+        return self.current_state
+
+    def _update_alphabet(self, new_alphabet: str):
+        if self.context:
+            not_anything_else_characters = set([c for c in self.context.pattern.alphabet.keys() if c != anything_else])
+            self.context.anything_else_characters = "".join([c for c in new_alphabet if c not in not_anything_else_characters])    
+    
+    @CharacterLevelParser.config.setter
+    def config(self, new_config: CharacterLevelParserConfig):
+        CharacterLevelParser.config.fset(self, new_config)  # Original set
+        self._update_alphabet(new_config.alphabet)
+
+

deepseek/lib/python3.10/site-packages/packaging-24.2.dist-info/LICENSE.APACHE

@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

deepseek/lib/python3.10/site-packages/packaging-24.2.dist-info/METADATA

@@ -0,0 +1,102 @@
+Metadata-Version: 2.3
+Name: packaging
+Version: 24.2
+Summary: Core utilities for Python packages
+Author-email: Donald Stufft <donald@stufft.io>
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Typing :: Typed
+Project-URL: Documentation, https://packaging.pypa.io/
+Project-URL: Source, https://github.com/pypa/packaging
+
+packaging
+=========
+
+.. start-intro
+
+Reusable core utilities for various Python Packaging
+`interoperability specifications <https://packaging.python.org/specifications/>`_.
+
+This library provides utilities that implement the interoperability
+specifications which have clearly one correct behaviour (eg: :pep:`440`)
+or benefit greatly from having a single shared implementation (eg: :pep:`425`).
+
+.. end-intro
+
+The ``packaging`` project includes the following: version handling, specifiers,
+markers, requirements, tags, utilities.
+
+Documentation
+-------------
+
+The `documentation`_ provides information and the API for the following:
+
+- Version Handling
+- Specifiers
+- Markers
+- Requirements
+- Tags
+- Utilities
+
+Installation
+------------
+
+Use ``pip`` to install these utilities::
+
+    pip install packaging
+
+The ``packaging`` library uses calendar-based versioning (``YY.N``).
+
+Discussion
+----------
+
+If you run into bugs, you can file them in our `issue tracker`_.
+
+You can also join ``#pypa`` on Freenode to ask questions or get involved.
+
+
+.. _`documentation`: https://packaging.pypa.io/
+.. _`issue tracker`: https://github.com/pypa/packaging/issues
+
+
+Code of Conduct
+---------------
+
+Everyone interacting in the packaging project's codebases, issue trackers, chat
+rooms, and mailing lists is expected to follow the `PSF Code of Conduct`_.
+
+.. _PSF Code of Conduct: https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md
+
+Contributing
+------------
+
+The ``CONTRIBUTING.rst`` file outlines how to contribute to this project as
+well as how to report a potential security issue. The documentation for this
+project also covers information about `project development`_ and `security`_.
+
+.. _`project development`: https://packaging.pypa.io/en/latest/development/
+.. _`security`: https://packaging.pypa.io/en/latest/security/
+
+Project History
+---------------
+
+Please review the ``CHANGELOG.rst`` file or the `Changelog documentation`_ for
+recent changes and project history.
+
+.. _`Changelog documentation`: https://packaging.pypa.io/en/latest/changelog/
+

deepseek/lib/python3.10/site-packages/setuptools/_vendor/__pycache__/typing_extensions.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d74d07fb876852c3181c7a6b54401a804941c909e42efc31fff34dc31da6c5b
+size 100332

deepseekvl2/lib/python3.10/site-packages/sympy/parsing/latex/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright 2016, latex2sympy
+
+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.

deepseekvl2/lib/python3.10/site-packages/sympy/parsing/latex/LaTeX.g4

@@ -0,0 +1,312 @@
+/*
+ ANTLR4 LaTeX Math Grammar
+
+ Ported from latex2sympy by @augustt198 https://github.com/augustt198/latex2sympy See license in
+ LICENSE.txt
+ */
+
+/*
+ After changing this file, it is necessary to run `python setup.py antlr` in the root directory of
+ the repository. This will regenerate the code in `sympy/parsing/latex/_antlr/*.py`.
+ */
+
+grammar LaTeX;
+
+options {
+	language = Python3;
+}
+
+WS: [ \t\r\n]+ -> skip;
+THINSPACE: ('\\,' | '\\thinspace') -> skip;
+MEDSPACE: ('\\:' | '\\medspace') -> skip;
+THICKSPACE: ('\\;' | '\\thickspace') -> skip;
+QUAD: '\\quad' -> skip;
+QQUAD: '\\qquad' -> skip;
+NEGTHINSPACE: ('\\!' | '\\negthinspace') -> skip;
+NEGMEDSPACE: '\\negmedspace' -> skip;
+NEGTHICKSPACE: '\\negthickspace' -> skip;
+CMD_LEFT: '\\left' -> skip;
+CMD_RIGHT: '\\right' -> skip;
+
+IGNORE:
+	(
+		'\\vrule'
+		| '\\vcenter'
+		| '\\vbox'
+		| '\\vskip'
+		| '\\vspace'
+		| '\\hfil'
+		| '\\*'
+		| '\\-'
+		| '\\.'
+		| '\\/'
+		| '\\"'
+		| '\\('
+		| '\\='
+	) -> skip;
+
+ADD: '+';
+SUB: '-';
+MUL: '*';
+DIV: '/';
+
+L_PAREN: '(';
+R_PAREN: ')';
+L_BRACE: '{';
+R_BRACE: '}';
+L_BRACE_LITERAL: '\\{';
+R_BRACE_LITERAL: '\\}';
+L_BRACKET: '[';
+R_BRACKET: ']';
+
+BAR: '|';
+
+R_BAR: '\\right|';
+L_BAR: '\\left|';
+
+L_ANGLE: '\\langle';
+R_ANGLE: '\\rangle';
+FUNC_LIM: '\\lim';
+LIM_APPROACH_SYM:
+	'\\to'
+	| '\\rightarrow'
+	| '\\Rightarrow'
+	| '\\longrightarrow'
+	| '\\Longrightarrow';
+FUNC_INT:
+    '\\int'
+    | '\\int\\limits';
+FUNC_SUM: '\\sum';
+FUNC_PROD: '\\prod';
+
+FUNC_EXP: '\\exp';
+FUNC_LOG: '\\log';
+FUNC_LG: '\\lg';
+FUNC_LN: '\\ln';
+FUNC_SIN: '\\sin';
+FUNC_COS: '\\cos';
+FUNC_TAN: '\\tan';
+FUNC_CSC: '\\csc';
+FUNC_SEC: '\\sec';
+FUNC_COT: '\\cot';
+
+FUNC_ARCSIN: '\\arcsin';
+FUNC_ARCCOS: '\\arccos';
+FUNC_ARCTAN: '\\arctan';
+FUNC_ARCCSC: '\\arccsc';
+FUNC_ARCSEC: '\\arcsec';
+FUNC_ARCCOT: '\\arccot';
+
+FUNC_SINH: '\\sinh';
+FUNC_COSH: '\\cosh';
+FUNC_TANH: '\\tanh';
+FUNC_ARSINH: '\\arsinh';
+FUNC_ARCOSH: '\\arcosh';
+FUNC_ARTANH: '\\artanh';
+
+L_FLOOR: '\\lfloor';
+R_FLOOR: '\\rfloor';
+L_CEIL: '\\lceil';
+R_CEIL: '\\rceil';
+
+FUNC_SQRT: '\\sqrt';
+FUNC_OVERLINE: '\\overline';
+
+CMD_TIMES: '\\times';
+CMD_CDOT: '\\cdot';
+CMD_DIV: '\\div';
+CMD_FRAC:
+    '\\frac'
+    | '\\dfrac'
+    | '\\tfrac';
+CMD_BINOM: '\\binom';
+CMD_DBINOM: '\\dbinom';
+CMD_TBINOM: '\\tbinom';
+
+CMD_MATHIT: '\\mathit';
+
+UNDERSCORE: '_';
+CARET: '^';
+COLON: ':';
+
+fragment WS_CHAR: [ \t\r\n];
+DIFFERENTIAL: 'd' WS_CHAR*? ([a-zA-Z] | '\\' [a-zA-Z]+);
+
+LETTER: [a-zA-Z];
+DIGIT: [0-9];
+
+EQUAL: (('&' WS_CHAR*?)? '=') | ('=' (WS_CHAR*? '&')?);
+NEQ: '\\neq';
+
+LT: '<';
+LTE: ('\\leq' | '\\le' | LTE_Q | LTE_S);
+LTE_Q: '\\leqq';
+LTE_S: '\\leqslant';
+
+GT: '>';
+GTE: ('\\geq' | '\\ge' | GTE_Q | GTE_S);
+GTE_Q: '\\geqq';
+GTE_S: '\\geqslant';
+
+BANG: '!';
+
+SINGLE_QUOTES: '\''+;
+
+SYMBOL: '\\' [a-zA-Z]+;
+
+math: relation;
+
+relation:
+	relation (EQUAL | LT | LTE | GT | GTE | NEQ) relation
+	| expr;
+
+equality: expr EQUAL expr;
+
+expr: additive;
+
+additive: additive (ADD | SUB) additive | mp;
+
+// mult part
+mp:
+	mp (MUL | CMD_TIMES | CMD_CDOT | DIV | CMD_DIV | COLON) mp
+	| unary;
+
+mp_nofunc:
+	mp_nofunc (
+		MUL
+		| CMD_TIMES
+		| CMD_CDOT
+		| DIV
+		| CMD_DIV
+		| COLON
+	) mp_nofunc
+	| unary_nofunc;
+
+unary: (ADD | SUB) unary | postfix+;
+
+unary_nofunc:
+	(ADD | SUB) unary_nofunc
+	| postfix postfix_nofunc*;
+
+postfix: exp postfix_op*;
+postfix_nofunc: exp_nofunc postfix_op*;
+postfix_op: BANG | eval_at;
+
+eval_at:
+	BAR (eval_at_sup | eval_at_sub | eval_at_sup eval_at_sub);
+
+eval_at_sub: UNDERSCORE L_BRACE (expr | equality) R_BRACE;
+
+eval_at_sup: CARET L_BRACE (expr | equality) R_BRACE;
+
+exp: exp CARET (atom | L_BRACE expr R_BRACE) subexpr? | comp;
+
+exp_nofunc:
+	exp_nofunc CARET (atom | L_BRACE expr R_BRACE) subexpr?
+	| comp_nofunc;
+
+comp:
+	group
+	| abs_group
+	| func
+	| atom
+	| floor
+	| ceil;
+
+comp_nofunc:
+	group
+	| abs_group
+	| atom
+	| floor
+	| ceil;
+
+group:
+	L_PAREN expr R_PAREN
+	| L_BRACKET expr R_BRACKET
+	| L_BRACE expr R_BRACE
+	| L_BRACE_LITERAL expr R_BRACE_LITERAL;
+
+abs_group: BAR expr BAR;
+
+number: DIGIT+ (',' DIGIT DIGIT DIGIT)* ('.' DIGIT+)?;
+
+atom: (LETTER | SYMBOL) (subexpr? SINGLE_QUOTES? | SINGLE_QUOTES? subexpr?)
+	| number
+	| DIFFERENTIAL
+	| mathit
+	| frac
+	| binom
+	| bra
+	| ket;
+
+bra: L_ANGLE expr (R_BAR | BAR);
+ket: (L_BAR | BAR) expr R_ANGLE;
+
+mathit: CMD_MATHIT L_BRACE mathit_text R_BRACE;
+mathit_text: LETTER*;
+
+frac: CMD_FRAC (upperd = DIGIT | L_BRACE upper = expr R_BRACE)
+    (lowerd = DIGIT | L_BRACE lower = expr R_BRACE);
+
+binom:
+	(CMD_BINOM | CMD_DBINOM | CMD_TBINOM) L_BRACE n = expr R_BRACE L_BRACE k = expr R_BRACE;
+
+floor: L_FLOOR val = expr R_FLOOR;
+ceil: L_CEIL val = expr R_CEIL;
+
+func_normal:
+	FUNC_EXP
+	| FUNC_LOG
+	| FUNC_LG
+	| FUNC_LN
+	| FUNC_SIN
+	| FUNC_COS
+	| FUNC_TAN
+	| FUNC_CSC
+	| FUNC_SEC
+	| FUNC_COT
+	| FUNC_ARCSIN
+	| FUNC_ARCCOS
+	| FUNC_ARCTAN
+	| FUNC_ARCCSC
+	| FUNC_ARCSEC
+	| FUNC_ARCCOT
+	| FUNC_SINH
+	| FUNC_COSH
+	| FUNC_TANH
+	| FUNC_ARSINH
+	| FUNC_ARCOSH
+	| FUNC_ARTANH;
+
+func:
+	func_normal (subexpr? supexpr? | supexpr? subexpr?) (
+		L_PAREN func_arg R_PAREN
+		| func_arg_noparens
+	)
+	| (LETTER | SYMBOL) (subexpr? SINGLE_QUOTES? | SINGLE_QUOTES? subexpr?) // e.g. f(x), f_1'(x)
+	L_PAREN args R_PAREN
+	| FUNC_INT (subexpr supexpr | supexpr subexpr)? (
+		additive? DIFFERENTIAL
+		| frac
+		| additive
+	)
+	| FUNC_SQRT (L_BRACKET root = expr R_BRACKET)? L_BRACE base = expr R_BRACE
+	| FUNC_OVERLINE L_BRACE base = expr R_BRACE
+	| (FUNC_SUM | FUNC_PROD) (subeq supexpr | supexpr subeq) mp
+	| FUNC_LIM limit_sub mp;
+
+args: (expr ',' args) | expr;
+
+limit_sub:
+	UNDERSCORE L_BRACE (LETTER | SYMBOL) LIM_APPROACH_SYM expr (
+		CARET ((L_BRACE (ADD | SUB) R_BRACE) | ADD | SUB)
+	)? R_BRACE;
+
+func_arg: expr | (expr ',' func_arg);
+func_arg_noparens: mp_nofunc;
+
+subexpr: UNDERSCORE (atom | L_BRACE expr R_BRACE);
+supexpr: CARET (atom | L_BRACE expr R_BRACE);
+
+subeq: UNDERSCORE L_BRACE equality R_BRACE;
+supeq: UNDERSCORE L_BRACE equality R_BRACE;

deepseekvl2/lib/python3.10/site-packages/sympy/parsing/latex/__init__.py

@@ -0,0 +1,66 @@
+from sympy.external import import_module
+from sympy.utilities.decorator import doctest_depends_on
+
+from sympy.parsing.latex.lark import LarkLaTeXParser, TransformToSymPyExpr, parse_latex_lark # noqa
+
+from .errors import LaTeXParsingError  # noqa
+
+
+__doctest_requires__ = {('parse_latex',): ['antlr4', 'lark']}
+
+
+@doctest_depends_on(modules=('antlr4', 'lark'))
+def parse_latex(s, strict=False, backend="antlr"):
+    r"""Converts the input LaTeX string ``s`` to a SymPy ``Expr``.
+
+    Parameters
+    ==========
+
+    s : str
+        The LaTeX string to parse. In Python source containing LaTeX,
+        *raw strings* (denoted with ``r"``, like this one) are preferred,
+        as LaTeX makes liberal use of the ``\`` character, which would
+        trigger escaping in normal Python strings.
+    backend : str, optional
+        Currently, there are two backends supported: ANTLR, and Lark.
+        The default setting is to use the ANTLR backend, which can be
+        changed to Lark if preferred.
+
+        Use ``backend="antlr"`` for the ANTLR-based parser, and
+        ``backend="lark"`` for the Lark-based parser.
+
+        The ``backend`` option is case-sensitive, and must be in
+        all lowercase.
+    strict : bool, optional
+        This option is only available with the ANTLR backend.
+
+        If True, raise an exception if the string cannot be parsed as
+        valid LaTeX. If False, try to recover gracefully from common
+        mistakes.
+
+    Examples
+    ========
+
+    >>> from sympy.parsing.latex import parse_latex
+    >>> expr = parse_latex(r"\frac {1 + \sqrt {\a}} {\b}")
+    >>> expr
+    (sqrt(a) + 1)/b
+    >>> expr.evalf(4, subs=dict(a=5, b=2))
+    1.618
+    >>> func = parse_latex(r"\int_1^\alpha \dfrac{\mathrm{d}t}{t}", backend="lark")
+    >>> func.evalf(subs={"alpha": 2})
+    0.693147180559945
+    """
+
+    if backend == "antlr":
+        _latex = import_module(
+            'sympy.parsing.latex._parse_latex_antlr',
+            import_kwargs={'fromlist': ['X']})
+
+        if _latex is not None:
+            return _latex.parse_latex(s, strict)
+    elif backend == "lark":
+        return parse_latex_lark(s)
+    else:
+        raise NotImplementedError(f"Using the '{backend}' backend in the LaTeX" \
+                                   " parser is not supported.")