Add files using upload-large-folder tool

.venv/lib/python3.11/site-packages/distro/__init__.py

@@ -0,0 +1,54 @@
+from .distro import (
+    NORMALIZED_DISTRO_ID,
+    NORMALIZED_LSB_ID,
+    NORMALIZED_OS_ID,
+    LinuxDistribution,
+    __version__,
+    build_number,
+    codename,
+    distro_release_attr,
+    distro_release_info,
+    id,
+    info,
+    like,
+    linux_distribution,
+    lsb_release_attr,
+    lsb_release_info,
+    major_version,
+    minor_version,
+    name,
+    os_release_attr,
+    os_release_info,
+    uname_attr,
+    uname_info,
+    version,
+    version_parts,
+)
+
+__all__ = [
+    "NORMALIZED_DISTRO_ID",
+    "NORMALIZED_LSB_ID",
+    "NORMALIZED_OS_ID",
+    "LinuxDistribution",
+    "build_number",
+    "codename",
+    "distro_release_attr",
+    "distro_release_info",
+    "id",
+    "info",
+    "like",
+    "linux_distribution",
+    "lsb_release_attr",
+    "lsb_release_info",
+    "major_version",
+    "minor_version",
+    "name",
+    "os_release_attr",
+    "os_release_info",
+    "uname_attr",
+    "uname_info",
+    "version",
+    "version_parts",
+]
+
+__version__ = __version__

.venv/lib/python3.11/site-packages/distro/__main__.py

@@ -0,0 +1,4 @@
+from .distro import main
+
+if __name__ == "__main__":
+    main()

.venv/lib/python3.11/site-packages/distro/distro.py

@@ -0,0 +1,1403 @@
+#!/usr/bin/env python
+# Copyright 2015-2021 Nir Cohen
+#
+# 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.
+
+"""
+The ``distro`` package (``distro`` stands for Linux Distribution) provides
+information about the Linux distribution it runs on, such as a reliable
+machine-readable distro ID, or version information.
+
+It is the recommended replacement for Python's original
+:py:func:`platform.linux_distribution` function, but it provides much more
+functionality. An alternative implementation became necessary because Python
+3.5 deprecated this function, and Python 3.8 removed it altogether. Its
+predecessor function :py:func:`platform.dist` was already deprecated since
+Python 2.6 and removed in Python 3.8. Still, there are many cases in which
+access to OS distribution information is needed. See `Python issue 1322
+<https://bugs.python.org/issue1322>`_ for more information.
+"""
+
+import argparse
+import json
+import logging
+import os
+import re
+import shlex
+import subprocess
+import sys
+import warnings
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    Optional,
+    Sequence,
+    TextIO,
+    Tuple,
+    Type,
+)
+
+try:
+    from typing import TypedDict
+except ImportError:
+    # Python 3.7
+    TypedDict = dict
+
+__version__ = "1.9.0"
+
+
+class VersionDict(TypedDict):
+    major: str
+    minor: str
+    build_number: str
+
+
+class InfoDict(TypedDict):
+    id: str
+    version: str
+    version_parts: VersionDict
+    like: str
+    codename: str
+
+
+_UNIXCONFDIR = os.environ.get("UNIXCONFDIR", "/etc")
+_UNIXUSRLIBDIR = os.environ.get("UNIXUSRLIBDIR", "/usr/lib")
+_OS_RELEASE_BASENAME = "os-release"
+
+#: Translation table for normalizing the "ID" attribute defined in os-release
+#: files, for use by the :func:`distro.id` method.
+#:
+#: * Key: Value as defined in the os-release file, translated to lower case,
+#:   with blanks translated to underscores.
+#:
+#: * Value: Normalized value.
+NORMALIZED_OS_ID = {
+    "ol": "oracle",  # Oracle Linux
+    "opensuse-leap": "opensuse",  # Newer versions of OpenSuSE report as opensuse-leap
+}
+
+#: Translation table for normalizing the "Distributor ID" attribute returned by
+#: the lsb_release command, for use by the :func:`distro.id` method.
+#:
+#: * Key: Value as returned by the lsb_release command, translated to lower
+#:   case, with blanks translated to underscores.
+#:
+#: * Value: Normalized value.
+NORMALIZED_LSB_ID = {
+    "enterpriseenterpriseas": "oracle",  # Oracle Enterprise Linux 4
+    "enterpriseenterpriseserver": "oracle",  # Oracle Linux 5
+    "redhatenterpriseworkstation": "rhel",  # RHEL 6, 7 Workstation
+    "redhatenterpriseserver": "rhel",  # RHEL 6, 7 Server
+    "redhatenterprisecomputenode": "rhel",  # RHEL 6 ComputeNode
+}
+
+#: Translation table for normalizing the distro ID derived from the file name
+#: of distro release files, for use by the :func:`distro.id` method.
+#:
+#: * Key: Value as derived from the file name of a distro release file,
+#:   translated to lower case, with blanks translated to underscores.
+#:
+#: * Value: Normalized value.
+NORMALIZED_DISTRO_ID = {
+    "redhat": "rhel",  # RHEL 6.x, 7.x
+}
+
+# Pattern for content of distro release file (reversed)
+_DISTRO_RELEASE_CONTENT_REVERSED_PATTERN = re.compile(
+    r"(?:[^)]*\)(.*)\()? *(?:STL )?([\d.+\-a-z]*\d) *(?:esaeler *)?(.+)"
+)
+
+# Pattern for base file name of distro release file
+_DISTRO_RELEASE_BASENAME_PATTERN = re.compile(r"(\w+)[-_](release|version)$")
+
+# Base file names to be looked up for if _UNIXCONFDIR is not readable.
+_DISTRO_RELEASE_BASENAMES = [
+    "SuSE-release",
+    "altlinux-release",
+    "arch-release",
+    "base-release",
+    "centos-release",
+    "fedora-release",
+    "gentoo-release",
+    "mageia-release",
+    "mandrake-release",
+    "mandriva-release",
+    "mandrivalinux-release",
+    "manjaro-release",
+    "oracle-release",
+    "redhat-release",
+    "rocky-release",
+    "sl-release",
+    "slackware-version",
+]
+
+# Base file names to be ignored when searching for distro release file
+_DISTRO_RELEASE_IGNORE_BASENAMES = (
+    "debian_version",
+    "lsb-release",
+    "oem-release",
+    _OS_RELEASE_BASENAME,
+    "system-release",
+    "plesk-release",
+    "iredmail-release",
+    "board-release",
+    "ec2_version",
+)
+
+
+def linux_distribution(full_distribution_name: bool = True) -> Tuple[str, str, str]:
+    """
+    .. deprecated:: 1.6.0
+
+        :func:`distro.linux_distribution()` is deprecated. It should only be
+        used as a compatibility shim with Python's
+        :py:func:`platform.linux_distribution()`. Please use :func:`distro.id`,
+        :func:`distro.version` and :func:`distro.name` instead.
+
+    Return information about the current OS distribution as a tuple
+    ``(id_name, version, codename)`` with items as follows:
+
+    * ``id_name``:  If *full_distribution_name* is false, the result of
+      :func:`distro.id`. Otherwise, the result of :func:`distro.name`.
+
+    * ``version``:  The result of :func:`distro.version`.
+
+    * ``codename``:  The extra item (usually in parentheses) after the
+      os-release version number, or the result of :func:`distro.codename`.
+
+    The interface of this function is compatible with the original
+    :py:func:`platform.linux_distribution` function, supporting a subset of
+    its parameters.
+
+    The data it returns may not exactly be the same, because it uses more data
+    sources than the original function, and that may lead to different data if
+    the OS distribution is not consistent across multiple data sources it
+    provides (there are indeed such distributions ...).
+
+    Another reason for differences is the fact that the :func:`distro.id`
+    method normalizes the distro ID string to a reliable machine-readable value
+    for a number of popular OS distributions.
+    """
+    warnings.warn(
+        "distro.linux_distribution() is deprecated. It should only be used as a "
+        "compatibility shim with Python's platform.linux_distribution(). Please use "
+        "distro.id(), distro.version() and distro.name() instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return _distro.linux_distribution(full_distribution_name)
+
+
+def id() -> str:
+    """
+    Return the distro ID of the current distribution, as a
+    machine-readable string.
+
+    For a number of OS distributions, the returned distro ID value is
+    *reliable*, in the sense that it is documented and that it does not change
+    across releases of the distribution.
+
+    This package maintains the following reliable distro ID values:
+
+    ==============  =========================================
+    Distro ID       Distribution
+    ==============  =========================================
+    "ubuntu"        Ubuntu
+    "debian"        Debian
+    "rhel"          RedHat Enterprise Linux
+    "centos"        CentOS
+    "fedora"        Fedora
+    "sles"          SUSE Linux Enterprise Server
+    "opensuse"      openSUSE
+    "amzn"          Amazon Linux
+    "arch"          Arch Linux
+    "buildroot"     Buildroot
+    "cloudlinux"    CloudLinux OS
+    "exherbo"       Exherbo Linux
+    "gentoo"        GenToo Linux
+    "ibm_powerkvm"  IBM PowerKVM
+    "kvmibm"        KVM for IBM z Systems
+    "linuxmint"     Linux Mint
+    "mageia"        Mageia
+    "mandriva"      Mandriva Linux
+    "parallels"     Parallels
+    "pidora"        Pidora
+    "raspbian"      Raspbian
+    "oracle"        Oracle Linux (and Oracle Enterprise Linux)
+    "scientific"    Scientific Linux
+    "slackware"     Slackware
+    "xenserver"     XenServer
+    "openbsd"       OpenBSD
+    "netbsd"        NetBSD
+    "freebsd"       FreeBSD
+    "midnightbsd"   MidnightBSD
+    "rocky"         Rocky Linux
+    "aix"           AIX
+    "guix"          Guix System
+    "altlinux"      ALT Linux
+    ==============  =========================================
+
+    If you have a need to get distros for reliable IDs added into this set,
+    or if you find that the :func:`distro.id` function returns a different
+    distro ID for one of the listed distros, please create an issue in the
+    `distro issue tracker`_.
+
+    **Lookup hierarchy and transformations:**
+
+    First, the ID is obtained from the following sources, in the specified
+    order. The first available and non-empty value is used:
+
+    * the value of the "ID" attribute of the os-release file,
+
+    * the value of the "Distributor ID" attribute returned by the lsb_release
+      command,
+
+    * the first part of the file name of the distro release file,
+
+    The so determined ID value then passes the following transformations,
+    before it is returned by this method:
+
+    * it is translated to lower case,
+
+    * blanks (which should not be there anyway) are translated to underscores,
+
+    * a normalization of the ID is performed, based upon
+      `normalization tables`_. The purpose of this normalization is to ensure
+      that the ID is as reliable as possible, even across incompatible changes
+      in the OS distributions. A common reason for an incompatible change is
+      the addition of an os-release file, or the addition of the lsb_release
+      command, with ID values that differ from what was previously determined
+      from the distro release file name.
+    """
+    return _distro.id()
+
+
+def name(pretty: bool = False) -> str:
+    """
+    Return the name of the current OS distribution, as a human-readable
+    string.
+
+    If *pretty* is false, the name is returned without version or codename.
+    (e.g. "CentOS Linux")
+
+    If *pretty* is true, the version and codename are appended.
+    (e.g. "CentOS Linux 7.1.1503 (Core)")
+
+    **Lookup hierarchy:**
+
+    The name is obtained from the following sources, in the specified order.
+    The first available and non-empty value is used:
+
+    * If *pretty* is false:
+
+      - the value of the "NAME" attribute of the os-release file,
+
+      - the value of the "Distributor ID" attribute returned by the lsb_release
+        command,
+
+      - the value of the "<name>" field of the distro release file.
+
+    * If *pretty* is true:
+
+      - the value of the "PRETTY_NAME" attribute of the os-release file,
+
+      - the value of the "Description" attribute returned by the lsb_release
+        command,
+
+      - the value of the "<name>" field of the distro release file, appended
+        with the value of the pretty version ("<version_id>" and "<codename>"
+        fields) of the distro release file, if available.
+    """
+    return _distro.name(pretty)
+
+
+def version(pretty: bool = False, best: bool = False) -> str:
+    """
+    Return the version of the current OS distribution, as a human-readable
+    string.
+
+    If *pretty* is false, the version is returned without codename (e.g.
+    "7.0").
+
+    If *pretty* is true, the codename in parenthesis is appended, if the
+    codename is non-empty (e.g. "7.0 (Maipo)").
+
+    Some distributions provide version numbers with different precisions in
+    the different sources of distribution information. Examining the different
+    sources in a fixed priority order does not always yield the most precise
+    version (e.g. for Debian 8.2, or CentOS 7.1).
+
+    Some other distributions may not provide this kind of information. In these
+    cases, an empty string would be returned. This behavior can be observed
+    with rolling releases distributions (e.g. Arch Linux).
+
+    The *best* parameter can be used to control the approach for the returned
+    version:
+
+    If *best* is false, the first non-empty version number in priority order of
+    the examined sources is returned.
+
+    If *best* is true, the most precise version number out of all examined
+    sources is returned.
+
+    **Lookup hierarchy:**
+
+    In all cases, the version number is obtained from the following sources.
+    If *best* is false, this order represents the priority order:
+
+    * the value of the "VERSION_ID" attribute of the os-release file,
+    * the value of the "Release" attribute returned by the lsb_release
+      command,
+    * the version number parsed from the "<version_id>" field of the first line
+      of the distro release file,
+    * the version number parsed from the "PRETTY_NAME" attribute of the
+      os-release file, if it follows the format of the distro release files.
+    * the version number parsed from the "Description" attribute returned by
+      the lsb_release command, if it follows the format of the distro release
+      files.
+    """
+    return _distro.version(pretty, best)
+
+
+def version_parts(best: bool = False) -> Tuple[str, str, str]:
+    """
+    Return the version of the current OS distribution as a tuple
+    ``(major, minor, build_number)`` with items as follows:
+
+    * ``major``:  The result of :func:`distro.major_version`.
+
+    * ``minor``:  The result of :func:`distro.minor_version`.
+
+    * ``build_number``:  The result of :func:`distro.build_number`.
+
+    For a description of the *best* parameter, see the :func:`distro.version`
+    method.
+    """
+    return _distro.version_parts(best)
+
+
+def major_version(best: bool = False) -> str:
+    """
+    Return the major version of the current OS distribution, as a string,
+    if provided.
+    Otherwise, the empty string is returned. The major version is the first
+    part of the dot-separated version string.
+
+    For a description of the *best* parameter, see the :func:`distro.version`
+    method.
+    """
+    return _distro.major_version(best)
+
+
+def minor_version(best: bool = False) -> str:
+    """
+    Return the minor version of the current OS distribution, as a string,
+    if provided.
+    Otherwise, the empty string is returned. The minor version is the second
+    part of the dot-separated version string.
+
+    For a description of the *best* parameter, see the :func:`distro.version`
+    method.
+    """
+    return _distro.minor_version(best)
+
+
+def build_number(best: bool = False) -> str:
+    """
+    Return the build number of the current OS distribution, as a string,
+    if provided.
+    Otherwise, the empty string is returned. The build number is the third part
+    of the dot-separated version string.
+
+    For a description of the *best* parameter, see the :func:`distro.version`
+    method.
+    """
+    return _distro.build_number(best)
+
+
+def like() -> str:
+    """
+    Return a space-separated list of distro IDs of distributions that are
+    closely related to the current OS distribution in regards to packaging
+    and programming interfaces, for example distributions the current
+    distribution is a derivative from.
+
+    **Lookup hierarchy:**
+
+    This information item is only provided by the os-release file.
+    For details, see the description of the "ID_LIKE" attribute in the
+    `os-release man page
+    <http://www.freedesktop.org/software/systemd/man/os-release.html>`_.
+    """
+    return _distro.like()
+
+
+def codename() -> str:
+    """
+    Return the codename for the release of the current OS distribution,
+    as a string.
+
+    If the distribution does not have a codename, an empty string is returned.
+
+    Note that the returned codename is not always really a codename. For
+    example, openSUSE returns "x86_64". This function does not handle such
+    cases in any special way and just returns the string it finds, if any.
+
+    **Lookup hierarchy:**
+
+    * the codename within the "VERSION" attribute of the os-release file, if
+      provided,
+
+    * the value of the "Codename" attribute returned by the lsb_release
+      command,
+
+    * the value of the "<codename>" field of the distro release file.
+    """
+    return _distro.codename()
+
+
+def info(pretty: bool = False, best: bool = False) -> InfoDict:
+    """
+    Return certain machine-readable information items about the current OS
+    distribution in a dictionary, as shown in the following example:
+
+    .. sourcecode:: python
+
+        {
+            'id': 'rhel',
+            'version': '7.0',
+            'version_parts': {
+                'major': '7',
+                'minor': '0',
+                'build_number': ''
+            },
+            'like': 'fedora',
+            'codename': 'Maipo'
+        }
+
+    The dictionary structure and keys are always the same, regardless of which
+    information items are available in the underlying data sources. The values
+    for the various keys are as follows:
+
+    * ``id``:  The result of :func:`distro.id`.
+
+    * ``version``:  The result of :func:`distro.version`.
+
+    * ``version_parts -> major``:  The result of :func:`distro.major_version`.
+
+    * ``version_parts -> minor``:  The result of :func:`distro.minor_version`.
+
+    * ``version_parts -> build_number``:  The result of
+      :func:`distro.build_number`.
+
+    * ``like``:  The result of :func:`distro.like`.
+
+    * ``codename``:  The result of :func:`distro.codename`.
+
+    For a description of the *pretty* and *best* parameters, see the
+    :func:`distro.version` method.
+    """
+    return _distro.info(pretty, best)
+
+
+def os_release_info() -> Dict[str, str]:
+    """
+    Return a dictionary containing key-value pairs for the information items
+    from the os-release file data source of the current OS distribution.
+
+    See `os-release file`_ for details about these information items.
+    """
+    return _distro.os_release_info()
+
+
+def lsb_release_info() -> Dict[str, str]:
+    """
+    Return a dictionary containing key-value pairs for the information items
+    from the lsb_release command data source of the current OS distribution.
+
+    See `lsb_release command output`_ for details about these information
+    items.
+    """
+    return _distro.lsb_release_info()
+
+
+def distro_release_info() -> Dict[str, str]:
+    """
+    Return a dictionary containing key-value pairs for the information items
+    from the distro release file data source of the current OS distribution.
+
+    See `distro release file`_ for details about these information items.
+    """
+    return _distro.distro_release_info()
+
+
+def uname_info() -> Dict[str, str]:
+    """
+    Return a dictionary containing key-value pairs for the information items
+    from the distro release file data source of the current OS distribution.
+    """
+    return _distro.uname_info()
+
+
+def os_release_attr(attribute: str) -> str:
+    """
+    Return a single named information item from the os-release file data source
+    of the current OS distribution.
+
+    Parameters:
+
+    * ``attribute`` (string): Key of the information item.
+
+    Returns:
+
+    * (string): Value of the information item, if the item exists.
+      The empty string, if the item does not exist.
+
+    See `os-release file`_ for details about these information items.
+    """
+    return _distro.os_release_attr(attribute)
+
+
+def lsb_release_attr(attribute: str) -> str:
+    """
+    Return a single named information item from the lsb_release command output
+    data source of the current OS distribution.
+
+    Parameters:
+
+    * ``attribute`` (string): Key of the information item.
+
+    Returns:
+
+    * (string): Value of the information item, if the item exists.
+      The empty string, if the item does not exist.
+
+    See `lsb_release command output`_ for details about these information
+    items.
+    """
+    return _distro.lsb_release_attr(attribute)
+
+
+def distro_release_attr(attribute: str) -> str:
+    """
+    Return a single named information item from the distro release file
+    data source of the current OS distribution.
+
+    Parameters:
+
+    * ``attribute`` (string): Key of the information item.
+
+    Returns:
+
+    * (string): Value of the information item, if the item exists.
+      The empty string, if the item does not exist.
+
+    See `distro release file`_ for details about these information items.
+    """
+    return _distro.distro_release_attr(attribute)
+
+
+def uname_attr(attribute: str) -> str:
+    """
+    Return a single named information item from the distro release file
+    data source of the current OS distribution.
+
+    Parameters:
+
+    * ``attribute`` (string): Key of the information item.
+
+    Returns:
+
+    * (string): Value of the information item, if the item exists.
+                The empty string, if the item does not exist.
+    """
+    return _distro.uname_attr(attribute)
+
+
+try:
+    from functools import cached_property
+except ImportError:
+    # Python < 3.8
+    class cached_property:  # type: ignore
+        """A version of @property which caches the value.  On access, it calls the
+        underlying function and sets the value in `__dict__` so future accesses
+        will not re-call the property.
+        """
+
+        def __init__(self, f: Callable[[Any], Any]) -> None:
+            self._fname = f.__name__
+            self._f = f
+
+        def __get__(self, obj: Any, owner: Type[Any]) -> Any:
+            assert obj is not None, f"call {self._fname} on an instance"
+            ret = obj.__dict__[self._fname] = self._f(obj)
+            return ret
+
+
+class LinuxDistribution:
+    """
+    Provides information about a OS distribution.
+
+    This package creates a private module-global instance of this class with
+    default initialization arguments, that is used by the
+    `consolidated accessor functions`_ and `single source accessor functions`_.
+    By using default initialization arguments, that module-global instance
+    returns data about the current OS distribution (i.e. the distro this
+    package runs on).
+
+    Normally, it is not necessary to create additional instances of this class.
+    However, in situations where control is needed over the exact data sources
+    that are used, instances of this class can be created with a specific
+    distro release file, or a specific os-release file, or without invoking the
+    lsb_release command.
+    """
+
+    def __init__(
+        self,
+        include_lsb: Optional[bool] = None,
+        os_release_file: str = "",
+        distro_release_file: str = "",
+        include_uname: Optional[bool] = None,
+        root_dir: Optional[str] = None,
+        include_oslevel: Optional[bool] = None,
+    ) -> None:
+        """
+        The initialization method of this class gathers information from the
+        available data sources, and stores that in private instance attributes.
+        Subsequent access to the information items uses these private instance
+        attributes, so that the data sources are read only once.
+
+        Parameters:
+
+        * ``include_lsb`` (bool): Controls whether the
+          `lsb_release command output`_ is included as a data source.
+
+          If the lsb_release command is not available in the program execution
+          path, the data source for the lsb_release command will be empty.
+
+        * ``os_release_file`` (string): The path name of the
+          `os-release file`_ that is to be used as a data source.
+
+          An empty string (the default) will cause the default path name to
+          be used (see `os-release file`_ for details).
+
+          If the specified or defaulted os-release file does not exist, the
+          data source for the os-release file will be empty.
+
+        * ``distro_release_file`` (string): The path name of the
+          `distro release file`_ that is to be used as a data source.
+
+          An empty string (the default) will cause a default search algorithm
+          to be used (see `distro release file`_ for details).
+
+          If the specified distro release file does not exist, or if no default
+          distro release file can be found, the data source for the distro
+          release file will be empty.
+
+        * ``include_uname`` (bool): Controls whether uname command output is
+          included as a data source. If the uname command is not available in
+          the program execution path the data source for the uname command will
+          be empty.
+
+        * ``root_dir`` (string): The absolute path to the root directory to use
+          to find distro-related information files. Note that ``include_*``
+          parameters must not be enabled in combination with ``root_dir``.
+
+        * ``include_oslevel`` (bool): Controls whether (AIX) oslevel command
+          output is included as a data source. If the oslevel command is not
+          available in the program execution path the data source will be
+          empty.
+
+        Public instance attributes:
+
+        * ``os_release_file`` (string): The path name of the
+          `os-release file`_ that is actually used as a data source. The
+          empty string if no distro release file is used as a data source.
+
+        * ``distro_release_file`` (string): The path name of the
+          `distro release file`_ that is actually used as a data source. The
+          empty string if no distro release file is used as a data source.
+
+        * ``include_lsb`` (bool): The result of the ``include_lsb`` parameter.
+          This controls whether the lsb information will be loaded.
+
+        * ``include_uname`` (bool): The result of the ``include_uname``
+          parameter. This controls whether the uname information will
+          be loaded.
+
+        * ``include_oslevel`` (bool): The result of the ``include_oslevel``
+          parameter. This controls whether (AIX) oslevel information will be
+          loaded.
+
+        * ``root_dir`` (string): The result of the ``root_dir`` parameter.
+          The absolute path to the root directory to use to find distro-related
+          information files.
+
+        Raises:
+
+        * :py:exc:`ValueError`: Initialization parameters combination is not
+           supported.
+
+        * :py:exc:`OSError`: Some I/O issue with an os-release file or distro
+          release file.
+
+        * :py:exc:`UnicodeError`: A data source has unexpected characters or
+          uses an unexpected encoding.
+        """
+        self.root_dir = root_dir
+        self.etc_dir = os.path.join(root_dir, "etc") if root_dir else _UNIXCONFDIR
+        self.usr_lib_dir = (
+            os.path.join(root_dir, "usr/lib") if root_dir else _UNIXUSRLIBDIR
+        )
+
+        if os_release_file:
+            self.os_release_file = os_release_file
+        else:
+            etc_dir_os_release_file = os.path.join(self.etc_dir, _OS_RELEASE_BASENAME)
+            usr_lib_os_release_file = os.path.join(
+                self.usr_lib_dir, _OS_RELEASE_BASENAME
+            )
+
+            # NOTE: The idea is to respect order **and** have it set
+            #       at all times for API backwards compatibility.
+            if os.path.isfile(etc_dir_os_release_file) or not os.path.isfile(
+                usr_lib_os_release_file
+            ):
+                self.os_release_file = etc_dir_os_release_file
+            else:
+                self.os_release_file = usr_lib_os_release_file
+
+        self.distro_release_file = distro_release_file or ""  # updated later
+
+        is_root_dir_defined = root_dir is not None
+        if is_root_dir_defined and (include_lsb or include_uname or include_oslevel):
+            raise ValueError(
+                "Including subprocess data sources from specific root_dir is disallowed"
+                " to prevent false information"
+            )
+        self.include_lsb = (
+            include_lsb if include_lsb is not None else not is_root_dir_defined
+        )
+        self.include_uname = (
+            include_uname if include_uname is not None else not is_root_dir_defined
+        )
+        self.include_oslevel = (
+            include_oslevel if include_oslevel is not None else not is_root_dir_defined
+        )
+
+    def __repr__(self) -> str:
+        """Return repr of all info"""
+        return (
+            "LinuxDistribution("
+            "os_release_file={self.os_release_file!r}, "
+            "distro_release_file={self.distro_release_file!r}, "
+            "include_lsb={self.include_lsb!r}, "
+            "include_uname={self.include_uname!r}, "
+            "include_oslevel={self.include_oslevel!r}, "
+            "root_dir={self.root_dir!r}, "
+            "_os_release_info={self._os_release_info!r}, "
+            "_lsb_release_info={self._lsb_release_info!r}, "
+            "_distro_release_info={self._distro_release_info!r}, "
+            "_uname_info={self._uname_info!r}, "
+            "_oslevel_info={self._oslevel_info!r})".format(self=self)
+        )
+
+    def linux_distribution(
+        self, full_distribution_name: bool = True
+    ) -> Tuple[str, str, str]:
+        """
+        Return information about the OS distribution that is compatible
+        with Python's :func:`platform.linux_distribution`, supporting a subset
+        of its parameters.
+
+        For details, see :func:`distro.linux_distribution`.
+        """
+        return (
+            self.name() if full_distribution_name else self.id(),
+            self.version(),
+            self._os_release_info.get("release_codename") or self.codename(),
+        )
+
+    def id(self) -> str:
+        """Return the distro ID of the OS distribution, as a string.
+
+        For details, see :func:`distro.id`.
+        """
+
+        def normalize(distro_id: str, table: Dict[str, str]) -> str:
+            distro_id = distro_id.lower().replace(" ", "_")
+            return table.get(distro_id, distro_id)
+
+        distro_id = self.os_release_attr("id")
+        if distro_id:
+            return normalize(distro_id, NORMALIZED_OS_ID)
+
+        distro_id = self.lsb_release_attr("distributor_id")
+        if distro_id:
+            return normalize(distro_id, NORMALIZED_LSB_ID)
+
+        distro_id = self.distro_release_attr("id")
+        if distro_id:
+            return normalize(distro_id, NORMALIZED_DISTRO_ID)
+
+        distro_id = self.uname_attr("id")
+        if distro_id:
+            return normalize(distro_id, NORMALIZED_DISTRO_ID)
+
+        return ""
+
+    def name(self, pretty: bool = False) -> str:
+        """
+        Return the name of the OS distribution, as a string.
+
+        For details, see :func:`distro.name`.
+        """
+        name = (
+            self.os_release_attr("name")
+            or self.lsb_release_attr("distributor_id")
+            or self.distro_release_attr("name")
+            or self.uname_attr("name")
+        )
+        if pretty:
+            name = self.os_release_attr("pretty_name") or self.lsb_release_attr(
+                "description"
+            )
+            if not name:
+                name = self.distro_release_attr("name") or self.uname_attr("name")
+                version = self.version(pretty=True)
+                if version:
+                    name = f"{name} {version}"
+        return name or ""
+
+    def version(self, pretty: bool = False, best: bool = False) -> str:
+        """
+        Return the version of the OS distribution, as a string.
+
+        For details, see :func:`distro.version`.
+        """
+        versions = [
+            self.os_release_attr("version_id"),
+            self.lsb_release_attr("release"),
+            self.distro_release_attr("version_id"),
+            self._parse_distro_release_content(self.os_release_attr("pretty_name")).get(
+                "version_id", ""
+            ),
+            self._parse_distro_release_content(
+                self.lsb_release_attr("description")
+            ).get("version_id", ""),
+            self.uname_attr("release"),
+        ]
+        if self.uname_attr("id").startswith("aix"):
+            # On AIX platforms, prefer oslevel command output.
+            versions.insert(0, self.oslevel_info())
+        elif self.id() == "debian" or "debian" in self.like().split():
+            # On Debian-like, add debian_version file content to candidates list.
+            versions.append(self._debian_version)
+        version = ""
+        if best:
+            # This algorithm uses the last version in priority order that has
+            # the best precision. If the versions are not in conflict, that
+            # does not matter; otherwise, using the last one instead of the
+            # first one might be considered a surprise.
+            for v in versions:
+                if v.count(".") > version.count(".") or version == "":
+                    version = v
+        else:
+            for v in versions:
+                if v != "":
+                    version = v
+                    break
+        if pretty and version and self.codename():
+            version = f"{version} ({self.codename()})"
+        return version
+
+    def version_parts(self, best: bool = False) -> Tuple[str, str, str]:
+        """
+        Return the version of the OS distribution, as a tuple of version
+        numbers.
+
+        For details, see :func:`distro.version_parts`.
+        """
+        version_str = self.version(best=best)
+        if version_str:
+            version_regex = re.compile(r"(\d+)\.?(\d+)?\.?(\d+)?")
+            matches = version_regex.match(version_str)
+            if matches:
+                major, minor, build_number = matches.groups()
+                return major, minor or "", build_number or ""
+        return "", "", ""
+
+    def major_version(self, best: bool = False) -> str:
+        """
+        Return the major version number of the current distribution.
+
+        For details, see :func:`distro.major_version`.
+        """
+        return self.version_parts(best)[0]
+
+    def minor_version(self, best: bool = False) -> str:
+        """
+        Return the minor version number of the current distribution.
+
+        For details, see :func:`distro.minor_version`.
+        """
+        return self.version_parts(best)[1]
+
+    def build_number(self, best: bool = False) -> str:
+        """
+        Return the build number of the current distribution.
+
+        For details, see :func:`distro.build_number`.
+        """
+        return self.version_parts(best)[2]
+
+    def like(self) -> str:
+        """
+        Return the IDs of distributions that are like the OS distribution.
+
+        For details, see :func:`distro.like`.
+        """
+        return self.os_release_attr("id_like") or ""
+
+    def codename(self) -> str:
+        """
+        Return the codename of the OS distribution.
+
+        For details, see :func:`distro.codename`.
+        """
+        try:
+            # Handle os_release specially since distros might purposefully set
+            # this to empty string to have no codename
+            return self._os_release_info["codename"]
+        except KeyError:
+            return (
+                self.lsb_release_attr("codename")
+                or self.distro_release_attr("codename")
+                or ""
+            )
+
+    def info(self, pretty: bool = False, best: bool = False) -> InfoDict:
+        """
+        Return certain machine-readable information about the OS
+        distribution.
+
+        For details, see :func:`distro.info`.
+        """
+        return InfoDict(
+            id=self.id(),
+            version=self.version(pretty, best),
+            version_parts=VersionDict(
+                major=self.major_version(best),
+                minor=self.minor_version(best),
+                build_number=self.build_number(best),
+            ),
+            like=self.like(),
+            codename=self.codename(),
+        )
+
+    def os_release_info(self) -> Dict[str, str]:
+        """
+        Return a dictionary containing key-value pairs for the information
+        items from the os-release file data source of the OS distribution.
+
+        For details, see :func:`distro.os_release_info`.
+        """
+        return self._os_release_info
+
+    def lsb_release_info(self) -> Dict[str, str]:
+        """
+        Return a dictionary containing key-value pairs for the information
+        items from the lsb_release command data source of the OS
+        distribution.
+
+        For details, see :func:`distro.lsb_release_info`.
+        """
+        return self._lsb_release_info
+
+    def distro_release_info(self) -> Dict[str, str]:
+        """
+        Return a dictionary containing key-value pairs for the information
+        items from the distro release file data source of the OS
+        distribution.
+
+        For details, see :func:`distro.distro_release_info`.
+        """
+        return self._distro_release_info
+
+    def uname_info(self) -> Dict[str, str]:
+        """
+        Return a dictionary containing key-value pairs for the information
+        items from the uname command data source of the OS distribution.
+
+        For details, see :func:`distro.uname_info`.
+        """
+        return self._uname_info
+
+    def oslevel_info(self) -> str:
+        """
+        Return AIX' oslevel command output.
+        """
+        return self._oslevel_info
+
+    def os_release_attr(self, attribute: str) -> str:
+        """
+        Return a single named information item from the os-release file data
+        source of the OS distribution.
+
+        For details, see :func:`distro.os_release_attr`.
+        """
+        return self._os_release_info.get(attribute, "")
+
+    def lsb_release_attr(self, attribute: str) -> str:
+        """
+        Return a single named information item from the lsb_release command
+        output data source of the OS distribution.
+
+        For details, see :func:`distro.lsb_release_attr`.
+        """
+        return self._lsb_release_info.get(attribute, "")
+
+    def distro_release_attr(self, attribute: str) -> str:
+        """
+        Return a single named information item from the distro release file
+        data source of the OS distribution.
+
+        For details, see :func:`distro.distro_release_attr`.
+        """
+        return self._distro_release_info.get(attribute, "")
+
+    def uname_attr(self, attribute: str) -> str:
+        """
+        Return a single named information item from the uname command
+        output data source of the OS distribution.
+
+        For details, see :func:`distro.uname_attr`.
+        """
+        return self._uname_info.get(attribute, "")
+
+    @cached_property
+    def _os_release_info(self) -> Dict[str, str]:
+        """
+        Get the information items from the specified os-release file.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        if os.path.isfile(self.os_release_file):
+            with open(self.os_release_file, encoding="utf-8") as release_file:
+                return self._parse_os_release_content(release_file)
+        return {}
+
+    @staticmethod
+    def _parse_os_release_content(lines: TextIO) -> Dict[str, str]:
+        """
+        Parse the lines of an os-release file.
+
+        Parameters:
+
+        * lines: Iterable through the lines in the os-release file.
+                 Each line must be a unicode string or a UTF-8 encoded byte
+                 string.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        props = {}
+        lexer = shlex.shlex(lines, posix=True)
+        lexer.whitespace_split = True
+
+        tokens = list(lexer)
+        for token in tokens:
+            # At this point, all shell-like parsing has been done (i.e.
+            # comments processed, quotes and backslash escape sequences
+            # processed, multi-line values assembled, trailing newlines
+            # stripped, etc.), so the tokens are now either:
+            # * variable assignments: var=value
+            # * commands or their arguments (not allowed in os-release)
+            # Ignore any tokens that are not variable assignments
+            if "=" in token:
+                k, v = token.split("=", 1)
+                props[k.lower()] = v
+
+        if "version" in props:
+            # extract release codename (if any) from version attribute
+            match = re.search(r"\((\D+)\)|,\s*(\D+)", props["version"])
+            if match:
+                release_codename = match.group(1) or match.group(2)
+                props["codename"] = props["release_codename"] = release_codename
+
+        if "version_codename" in props:
+            # os-release added a version_codename field.  Use that in
+            # preference to anything else Note that some distros purposefully
+            # do not have code names.  They should be setting
+            # version_codename=""
+            props["codename"] = props["version_codename"]
+        elif "ubuntu_codename" in props:
+            # Same as above but a non-standard field name used on older Ubuntus
+            props["codename"] = props["ubuntu_codename"]
+
+        return props
+
+    @cached_property
+    def _lsb_release_info(self) -> Dict[str, str]:
+        """
+        Get the information items from the lsb_release command output.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        if not self.include_lsb:
+            return {}
+        try:
+            cmd = ("lsb_release", "-a")
+            stdout = subprocess.check_output(cmd, stderr=subprocess.DEVNULL)
+        # Command not found or lsb_release returned error
+        except (OSError, subprocess.CalledProcessError):
+            return {}
+        content = self._to_str(stdout).splitlines()
+        return self._parse_lsb_release_content(content)
+
+    @staticmethod
+    def _parse_lsb_release_content(lines: Iterable[str]) -> Dict[str, str]:
+        """
+        Parse the output of the lsb_release command.
+
+        Parameters:
+
+        * lines: Iterable through the lines of the lsb_release output.
+                 Each line must be a unicode string or a UTF-8 encoded byte
+                 string.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        props = {}
+        for line in lines:
+            kv = line.strip("\n").split(":", 1)
+            if len(kv) != 2:
+                # Ignore lines without colon.
+                continue
+            k, v = kv
+            props.update({k.replace(" ", "_").lower(): v.strip()})
+        return props
+
+    @cached_property
+    def _uname_info(self) -> Dict[str, str]:
+        if not self.include_uname:
+            return {}
+        try:
+            cmd = ("uname", "-rs")
+            stdout = subprocess.check_output(cmd, stderr=subprocess.DEVNULL)
+        except OSError:
+            return {}
+        content = self._to_str(stdout).splitlines()
+        return self._parse_uname_content(content)
+
+    @cached_property
+    def _oslevel_info(self) -> str:
+        if not self.include_oslevel:
+            return ""
+        try:
+            stdout = subprocess.check_output("oslevel", stderr=subprocess.DEVNULL)
+        except (OSError, subprocess.CalledProcessError):
+            return ""
+        return self._to_str(stdout).strip()
+
+    @cached_property
+    def _debian_version(self) -> str:
+        try:
+            with open(
+                os.path.join(self.etc_dir, "debian_version"), encoding="ascii"
+            ) as fp:
+                return fp.readline().rstrip()
+        except FileNotFoundError:
+            return ""
+
+    @staticmethod
+    def _parse_uname_content(lines: Sequence[str]) -> Dict[str, str]:
+        if not lines:
+            return {}
+        props = {}
+        match = re.search(r"^([^\s]+)\s+([\d\.]+)", lines[0].strip())
+        if match:
+            name, version = match.groups()
+
+            # This is to prevent the Linux kernel version from
+            # appearing as the 'best' version on otherwise
+            # identifiable distributions.
+            if name == "Linux":
+                return {}
+            props["id"] = name.lower()
+            props["name"] = name
+            props["release"] = version
+        return props
+
+    @staticmethod
+    def _to_str(bytestring: bytes) -> str:
+        encoding = sys.getfilesystemencoding()
+        return bytestring.decode(encoding)
+
+    @cached_property
+    def _distro_release_info(self) -> Dict[str, str]:
+        """
+        Get the information items from the specified distro release file.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        if self.distro_release_file:
+            # If it was specified, we use it and parse what we can, even if
+            # its file name or content does not match the expected pattern.
+            distro_info = self._parse_distro_release_file(self.distro_release_file)
+            basename = os.path.basename(self.distro_release_file)
+            # The file name pattern for user-specified distro release files
+            # is somewhat more tolerant (compared to when searching for the
+            # file), because we want to use what was specified as best as
+            # possible.
+            match = _DISTRO_RELEASE_BASENAME_PATTERN.match(basename)
+        else:
+            try:
+                basenames = [
+                    basename
+                    for basename in os.listdir(self.etc_dir)
+                    if basename not in _DISTRO_RELEASE_IGNORE_BASENAMES
+                    and os.path.isfile(os.path.join(self.etc_dir, basename))
+                ]
+                # We sort for repeatability in cases where there are multiple
+                # distro specific files; e.g. CentOS, Oracle, Enterprise all
+                # containing `redhat-release` on top of their own.
+                basenames.sort()
+            except OSError:
+                # This may occur when /etc is not readable but we can't be
+                # sure about the *-release files. Check common entries of
+                # /etc for information. If they turn out to not be there the
+                # error is handled in `_parse_distro_release_file()`.
+                basenames = _DISTRO_RELEASE_BASENAMES
+            for basename in basenames:
+                match = _DISTRO_RELEASE_BASENAME_PATTERN.match(basename)
+                if match is None:
+                    continue
+                filepath = os.path.join(self.etc_dir, basename)
+                distro_info = self._parse_distro_release_file(filepath)
+                # The name is always present if the pattern matches.
+                if "name" not in distro_info:
+                    continue
+                self.distro_release_file = filepath
+                break
+            else:  # the loop didn't "break": no candidate.
+                return {}
+
+        if match is not None:
+            distro_info["id"] = match.group(1)
+
+        # CloudLinux < 7: manually enrich info with proper id.
+        if "cloudlinux" in distro_info.get("name", "").lower():
+            distro_info["id"] = "cloudlinux"
+
+        return distro_info
+
+    def _parse_distro_release_file(self, filepath: str) -> Dict[str, str]:
+        """
+        Parse a distro release file.
+
+        Parameters:
+
+        * filepath: Path name of the distro release file.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        try:
+            with open(filepath, encoding="utf-8") as fp:
+                # Only parse the first line. For instance, on SLES there
+                # are multiple lines. We don't want them...
+                return self._parse_distro_release_content(fp.readline())
+        except OSError:
+            # Ignore not being able to read a specific, seemingly version
+            # related file.
+            # See https://github.com/python-distro/distro/issues/162
+            return {}
+
+    @staticmethod
+    def _parse_distro_release_content(line: str) -> Dict[str, str]:
+        """
+        Parse a line from a distro release file.
+
+        Parameters:
+        * line: Line from the distro release file. Must be a unicode string
+                or a UTF-8 encoded byte string.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        matches = _DISTRO_RELEASE_CONTENT_REVERSED_PATTERN.match(line.strip()[::-1])
+        distro_info = {}
+        if matches:
+            # regexp ensures non-None
+            distro_info["name"] = matches.group(3)[::-1]
+            if matches.group(2):
+                distro_info["version_id"] = matches.group(2)[::-1]
+            if matches.group(1):
+                distro_info["codename"] = matches.group(1)[::-1]
+        elif line:
+            distro_info["name"] = line.strip()
+        return distro_info
+
+
+_distro = LinuxDistribution()
+
+
+def main() -> None:
+    logger = logging.getLogger(__name__)
+    logger.setLevel(logging.DEBUG)
+    logger.addHandler(logging.StreamHandler(sys.stdout))
+
+    parser = argparse.ArgumentParser(description="OS distro info tool")
+    parser.add_argument(
+        "--json", "-j", help="Output in machine readable format", action="store_true"
+    )
+
+    parser.add_argument(
+        "--root-dir",
+        "-r",
+        type=str,
+        dest="root_dir",
+        help="Path to the root filesystem directory (defaults to /)",
+    )
+
+    args = parser.parse_args()
+
+    if args.root_dir:
+        dist = LinuxDistribution(
+            include_lsb=False,
+            include_uname=False,
+            include_oslevel=False,
+            root_dir=args.root_dir,
+        )
+    else:
+        dist = _distro
+
+    if args.json:
+        logger.info(json.dumps(dist.info(), indent=4, sort_keys=True))
+    else:
+        logger.info("Name: %s", dist.name(pretty=True))
+        distribution_version = dist.version(pretty=True)
+        logger.info("Version: %s", distribution_version)
+        distribution_codename = dist.codename()
+        logger.info("Codename: %s", distribution_codename)
+
+
+if __name__ == "__main__":
+    main()

.venv/lib/python3.11/site-packages/gguf-0.10.0.dist-info/INSTALLER

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

.venv/lib/python3.11/site-packages/gguf-0.10.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Georgi Gerganov
+
+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.

.venv/lib/python3.11/site-packages/gguf-0.10.0.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.1
+Name: gguf
+Version: 0.10.0
+Summary: Read and write ML models in GGUF for GGML
+Home-page: https://ggml.ai
+Keywords: ggml,gguf,llama.cpp
+Author: GGML
+Author-email: [email protected]
+Requires-Python: >=3.8
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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
+Requires-Dist: numpy (>=1.17)
+Requires-Dist: pyyaml (>=5.1)
+Requires-Dist: tqdm (>=4.27)
+Project-URL: Repository, https://github.com/ggerganov/llama.cpp
+Description-Content-Type: text/markdown
+
+## gguf
+
+This is a Python package for writing binary files in the [GGUF](https://github.com/ggerganov/ggml/pull/302)
+(GGML Universal File) format.
+
+See [convert_hf_to_gguf.py](https://github.com/ggerganov/llama.cpp/blob/master/convert_hf_to_gguf.py)
+as an example for its usage.
+
+## Installation
+```sh
+pip install gguf
+```
+
+## API Examples/Simple Tools
+
+[examples/writer.py](https://github.com/ggerganov/llama.cpp/blob/master/gguf-py/examples/writer.py) — Generates `example.gguf` in the current directory to demonstrate generating a GGUF file. Note that this file cannot be used as a model.
+
+[scripts/gguf_dump.py](https://github.com/ggerganov/llama.cpp/blob/master/gguf-py/scripts/gguf_dump.py) — Dumps a GGUF file's metadata to the console.
+
+[scripts/gguf_set_metadata.py](https://github.com/ggerganov/llama.cpp/blob/master/gguf-py/scripts/gguf_set_metadata.py) — Allows changing simple metadata values in a GGUF file by key.
+
+[scripts/gguf_convert_endian.py](https://github.com/ggerganov/llama.cpp/blob/master/gguf-py/scripts/gguf_convert_endian.py) — Allows converting the endianness of GGUF files.
+
+[scripts/gguf_new_metadata.py](https://github.com/ggerganov/llama.cpp/blob/master/gguf-py/scripts/gguf_new_metadata.py) — Copies a GGUF file with added/modified/removed metadata values.
+
+## Development
+Maintainers who participate in development of this package are advised to install it in editable mode:
+
+```sh
+cd /path/to/llama.cpp/gguf-py
+
+pip install --editable .
+```
+
+**Note**: This may require to upgrade your Pip installation, with a message saying that editable installation currently requires `setup.py`.
+In this case, upgrade Pip to the latest:
+
+```sh
+pip install --upgrade pip
+```
+
+## Automatic publishing with CI
+
+There's a GitHub workflow to make a release automatically upon creation of tags in a specified format.
+
+1. Bump the version in `pyproject.toml`.
+2. Create a tag named `gguf-vx.x.x` where `x.x.x` is the semantic version number.
+
+```sh
+git tag -a gguf-v1.0.0 -m "Version 1.0 release"
+```
+
+3. Push the tags.
+
+```sh
+git push origin --tags
+```
+
+## Manual publishing
+If you want to publish the package manually for any reason, you need to have `twine` and `build` installed:
+
+```sh
+pip install build twine
+```
+
+Then, follow these steps to release a new version:
+
+1. Bump the version in `pyproject.toml`.
+2. Build the package:
+
+```sh
+python -m build
+```
+
+3. Upload the generated distribution archives:
+
+```sh
+python -m twine upload dist/*
+```
+
+## Run Unit Tests
+
+From root of this repository you can run this command to run all the unit tests
+
+```bash
+python -m unittest discover ./gguf-py -v
+```
+
+## TODO
+- [ ] Include conversion scripts as command line entry points in this package.
+

.venv/lib/python3.11/site-packages/gguf-0.10.0.dist-info/RECORD

@@ -0,0 +1,45 @@
+../../../bin/gguf-convert-endian,sha256=W53Q9wLM4ktx91uKrLfyuFNGS7UCbZr-mA2U66A_W0E,276
+../../../bin/gguf-dump,sha256=v29_dyj4DF8zullVHEvLoQotNn0dgtrt8f-NjwDigFw,256
+../../../bin/gguf-new-metadata,sha256=UwjDwictRuL-TFKI2mlnkzB8YzGJSNWJ69870J9w64Y,272
+../../../bin/gguf-set-metadata,sha256=iqt1mYpW1z41SzKpVu0r6NLBVYPDc-k06JH7cmo-e9s,272
+gguf-0.10.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+gguf-0.10.0.dist-info/LICENSE,sha256=73jH5mWeNMeYGU8NNE6AfHIt5wy8oTWe9UdyZh4Ryjg,1072
+gguf-0.10.0.dist-info/METADATA,sha256=0jck7V9EOoT24ugiLaorfqFzhmN3eJM7lj-fyq8tvy8,3533
+gguf-0.10.0.dist-info/RECORD,,
+gguf-0.10.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+gguf-0.10.0.dist-info/entry_points.txt,sha256=6SBOHW2PZstAG6hvoQ63pyxPF8CIGjGLXZyG-NFFnAc,227
+gguf/__init__.py,sha256=PM_AEEzX6ojGAodDt78_LIm19HRCXeA6IXpgcjINfC8,219
+gguf/__pycache__/__init__.cpython-311.pyc,,
+gguf/__pycache__/constants.cpython-311.pyc,,
+gguf/__pycache__/gguf.cpython-311.pyc,,
+gguf/__pycache__/gguf_reader.cpython-311.pyc,,
+gguf/__pycache__/gguf_writer.cpython-311.pyc,,
+gguf/__pycache__/lazy.cpython-311.pyc,,
+gguf/__pycache__/metadata.cpython-311.pyc,,
+gguf/__pycache__/quants.cpython-311.pyc,,
+gguf/__pycache__/tensor_mapping.cpython-311.pyc,,
+gguf/__pycache__/utility.cpython-311.pyc,,
+gguf/__pycache__/vocab.cpython-311.pyc,,
+gguf/constants.py,sha256=00pCXTqoWP36ZR9OcuxJfhezZfxqjUTKGCNvGMrkLGU,49158
+gguf/gguf.py,sha256=8MDu7a0JEXhLUv_tjhYqDrWubVNc41cFvBYZbkZZenI,478
+gguf/gguf_reader.py,sha256=0Y86qmxYfPNq3u_AiAwSnhU_G-V2SjXK2b7CM3MoPP4,12365
+gguf/gguf_writer.py,sha256=ZWW_XwN6tyDIzBCwl6ARDwwRZ9TewNMV32IQaVYRNP8,35090
+gguf/lazy.py,sha256=QwxFAtj-5nIm_a3mvLBezpShFuo-pjJhoAiXreK9ITQ,8601
+gguf/metadata.py,sha256=nFEqgODwH6jYF3_jcycZkN4FjLnfXOQ7A73cLKZJb0Y,25722
+gguf/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gguf/quants.py,sha256=_6kmSprMfawH3gcPz9WbxnlXCeZQIYivf_HjfUvUkM0,57336
+gguf/tensor_mapping.py,sha256=8CpqXKwKYFz6v11Fpzhe85hPcH18gnieh_FQsISpcVc,30893
+gguf/utility.py,sha256=jbd1bduLFjjNAQhjghSyrRQfJ_kjiTFhRAZxm0oabZw,2934
+gguf/vocab.py,sha256=N4PNulV8x_m7cdbmbUBF3nqQ0UXGTDi31oEIh3h8hAs,19046
+scripts/__init__.py,sha256=-Az7fR5lhVb9GPB5U_BaDb8Xp706km53vSY7aXQYw9I,297
+scripts/__pycache__/__init__.cpython-311.pyc,,
+scripts/__pycache__/gguf_convert_endian.cpython-311.pyc,,
+scripts/__pycache__/gguf_dump.cpython-311.pyc,,
+scripts/__pycache__/gguf_hash.cpython-311.pyc,,
+scripts/__pycache__/gguf_new_metadata.cpython-311.pyc,,
+scripts/__pycache__/gguf_set_metadata.cpython-311.pyc,,
+scripts/gguf_convert_endian.py,sha256=tcpe1O6xLTSetYD5T8dYcDN7cwiTWS-5sH7iFCP7ga8,5279
+scripts/gguf_dump.py,sha256=Ej3XWrYupFOg-Bz-ff9EAN5hdmp2OCdEkd46D4PtZ58,21934
+scripts/gguf_hash.py,sha256=DtzQ3xSdS8bHxdsp8ELQaBlaZiqqDBXzqtRSEzYTkhM,3711
+scripts/gguf_new_metadata.py,sha256=bGuF8iXkElxIsr4mR952DHEBTosA9ob-UkF-zEqlPqo,10713
+scripts/gguf_set_metadata.py,sha256=9jISgnh2atbwKh-68oN5b0wLxs0mYpXOWILjuqLTt-Q,4131

.venv/lib/python3.11/site-packages/gguf-0.10.0.dist-info/WHEEL

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

.venv/lib/python3.11/site-packages/gguf-0.10.0.dist-info/entry_points.txt

@@ -0,0 +1,6 @@
+[console_scripts]
+gguf-convert-endian=scripts:gguf_convert_endian_entrypoint
+gguf-dump=scripts:gguf_dump_entrypoint
+gguf-new-metadata=scripts:gguf_new_metadata_entrypoint
+gguf-set-metadata=scripts:gguf_set_metadata_entrypoint
+

.venv/lib/python3.11/site-packages/mistral_common/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.5.2"

.venv/lib/python3.11/site-packages/mistral_common/base.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel, ConfigDict
+
+
+class MistralBase(BaseModel):
+    """
+    Base class for all Mistral Pydantic models.
+    """
+
+    model_config = ConfigDict(extra="forbid", validate_default=True, use_enum_values=True)

.venv/lib/python3.11/site-packages/mistral_common/exceptions.py

@@ -0,0 +1,67 @@
+from typing import Optional
+
+
+class MistralCommonException(Exception):
+    message: str = "Internal server error"
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+    ) -> None:
+        if message:
+            self.message = message
+
+
+class TokenizerException(MistralCommonException):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class UnsupportedTokenizerFeatureException(MistralCommonException):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class InvalidRequestException(MistralCommonException):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class InvalidSystemPromptException(MistralCommonException):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class InvalidMessageStructureException(MistralCommonException):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class InvalidAssistantMessageException(MistralCommonException):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class InvalidToolMessageException(MistralCommonException):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class InvalidToolSchemaException(MistralCommonException):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class InvalidUserMessageException(MistralCommonException):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class InvalidFunctionCallException(MistralCommonException):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class InvalidToolException(MistralCommonException):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)

.venv/lib/python3.11/site-packages/mistral_common/multimodal.py

@@ -0,0 +1,70 @@
+import base64
+import io
+from typing import Union
+
+import requests
+from PIL import Image
+from pydantic import BeforeValidator, PlainSerializer, SerializationInfo
+from typing_extensions import Annotated
+
+from mistral_common import __version__
+
+
+def download_image(url: str) -> Image.Image:
+    headers = {"User-Agent": f"mistral-common/{__version__}"}
+    try:
+        # Make a request to download the image
+        response = requests.get(url, headers=headers)
+        response.raise_for_status()  # Raise an error for bad responses (4xx, 5xx)
+
+        # Convert the image content to a PIL Image
+        img = Image.open(io.BytesIO(response.content))
+        return img
+
+    except requests.exceptions.RequestException as e:
+        raise RuntimeError(f"Error downloading the image from {url}: {e}.")
+    except Exception as e:
+        raise RuntimeError(f"Error converting to PIL image: {e}")
+
+
+def maybe_load_image_from_str_or_bytes(x: Union[Image.Image, str, bytes]) -> Image.Image:
+    if isinstance(x, Image.Image):
+        return x
+    if isinstance(x, bytes):
+        try:
+            return Image.open(io.BytesIO(x))
+        except Exception:
+            raise RuntimeError("Encountered an error when loading image from bytes.")
+
+    try:
+        image = Image.open(io.BytesIO(base64.b64decode(x.encode("ascii"))))
+        return image
+    except Exception as e:
+        raise RuntimeError(
+            f"Encountered an error when loading image from bytes starting "
+            f"with '{x[:20]}'. Expected either a PIL.Image.Image or a base64 "
+            f"encoded string of bytes."
+        ) from e
+
+
+def serialize_image_to_byte_str(im: Image.Image, info: SerializationInfo) -> str:
+    if hasattr(info, "context"):
+        context = info.context or {}
+    else:
+        context = {}
+
+    stream = io.BytesIO()
+    im_format = im.format or "PNG"
+    im.save(stream, format=im_format)
+    im_b64 = base64.b64encode(stream.getvalue()).decode("ascii")
+    if context and (max_image_b64_len := context.get("max_image_b64_len")):
+        return im_b64[:max_image_b64_len] + "..."
+    return im_b64
+
+
+# A normal PIL image that supports serialization to b64 bytes string
+SerializableImage = Annotated[
+    Image.Image,
+    BeforeValidator(maybe_load_image_from_str_or_bytes),
+    PlainSerializer(serialize_image_to_byte_str),
+]

.venv/lib/python3.11/site-packages/mistral_common/protocol/base.py

@@ -0,0 +1,18 @@
+from typing import Optional
+
+from pydantic import Field
+
+from mistral_common.base import MistralBase
+
+
+class UsageInfo(MistralBase):
+    prompt_tokens: int = 0
+    total_tokens: int = 0
+    completion_tokens: Optional[int] = 0
+
+
+class BaseCompletionRequest(MistralBase):
+    temperature: float = Field(default=0.7, ge=0.0, le=1.0)
+    top_p: float = Field(default=1.0, ge=0.0, le=1.0)
+    max_tokens: Optional[int] = Field(default=None, ge=0)
+    random_seed: Optional[int] = Field(default=None, ge=0)

.venv/lib/python3.11/site-packages/mistral_common/protocol/instruct/messages.py

@@ -0,0 +1,113 @@
+from enum import Enum
+from typing import List, Literal, Optional, TypeVar, Union
+
+from pydantic import ConfigDict, Field
+from typing_extensions import Annotated, TypeAlias
+
+from mistral_common.base import MistralBase
+from mistral_common.multimodal import SerializableImage
+from mistral_common.protocol.instruct.tool_calls import ToolCall
+
+
+class ChunkTypes(str, Enum):
+    text = "text"
+    image = "image"
+    image_url = "image_url"
+
+
+class BaseContentChunk(MistralBase):
+    type: Literal[ChunkTypes.text, ChunkTypes.image, ChunkTypes.image_url]
+
+
+class ImageChunk(BaseContentChunk):
+    type: Literal[ChunkTypes.image] = ChunkTypes.image
+    image: SerializableImage
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class ImageURL(MistralBase):
+    url: str
+    detail: Optional[str] = None
+
+
+class ImageURLChunk(BaseContentChunk):
+    """
+    {"type":"image_url","image_url":{"url":"data:image/png;base64,iVBORw0
+    """
+
+    type: Literal[ChunkTypes.image_url] = ChunkTypes.image_url
+    image_url: Union[ImageURL, str]
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def get_url(self) -> str:
+        if isinstance(self.image_url, ImageURL):
+            return self.image_url.url
+        return self.image_url
+
+
+class TextChunk(BaseContentChunk):
+    type: Literal[ChunkTypes.text] = ChunkTypes.text
+    text: str
+
+
+ContentChunk = Annotated[Union[TextChunk, ImageChunk, ImageURLChunk], Field(discriminator="type")]
+
+
+class Roles(str, Enum):
+    system = "system"
+    user = "user"
+    assistant = "assistant"
+    tool = "tool"
+
+
+class BaseMessage(MistralBase):
+    role: Literal[Roles.system, Roles.user, Roles.assistant, Roles.tool]
+
+
+class UserMessage(BaseMessage):
+    role: Literal[Roles.user] = Roles.user
+    content: Union[str, List[ContentChunk]]
+
+
+class SystemMessage(BaseMessage):
+    role: Literal[Roles.system] = Roles.system
+    content: Union[str, List[ContentChunk]]
+
+
+class AssistantMessage(BaseMessage):
+    role: Literal[Roles.assistant] = Roles.assistant
+    content: Optional[str] = None
+    tool_calls: Optional[List[ToolCall]] = None
+    prefix: bool = False
+
+
+class FinetuningAssistantMessage(AssistantMessage):
+    weight: Optional[float] = None
+
+
+class ToolMessage(BaseMessage):
+    content: str
+    role: Literal[Roles.tool] = Roles.tool
+    tool_call_id: Optional[str] = None
+
+    # Deprecated in V3 tokenization
+    name: Optional[str] = None
+
+
+ChatMessage = Annotated[Union[SystemMessage, UserMessage, AssistantMessage, ToolMessage], Field(discriminator="role")]
+
+FinetuningMessage = Annotated[
+    Union[SystemMessage, UserMessage, FinetuningAssistantMessage, ToolMessage],
+    Field(discriminator="role"),
+]
+
+ChatMessageType = TypeVar("ChatMessageType", bound=ChatMessage)
+
+# Used for type hinting in generic classes where we might override the message types
+UserMessageType = TypeVar("UserMessageType", bound=UserMessage)
+AssistantMessageType = TypeVar("AssistantMessageType", bound=AssistantMessage)
+ToolMessageType = TypeVar("ToolMessageType", bound=ToolMessage)
+SystemMessageType = TypeVar("SystemMessageType", bound=SystemMessage)
+
+UATS: TypeAlias = Union[UserMessageType, AssistantMessageType, ToolMessageType, SystemMessageType]

.venv/lib/python3.11/site-packages/mistral_common/protocol/instruct/normalize.py

@@ -0,0 +1,265 @@
+import json
+from typing import Generic, List, Optional, Sequence, Type, Union
+
+from mistral_common.protocol.instruct.messages import (
+    UATS,
+    AssistantMessage,
+    AssistantMessageType,
+    ContentChunk,
+    FinetuningAssistantMessage,
+    Roles,
+    SystemMessage,
+    SystemMessageType,
+    TextChunk,
+    ToolMessage,
+    ToolMessageType,
+    UserMessage,
+    UserMessageType,
+)
+from mistral_common.protocol.instruct.request import ChatCompletionRequest
+from mistral_common.protocol.instruct.tool_calls import FunctionCall, Tool, ToolCall
+from mistral_common.tokens.instruct.request import InstructRequest
+from mistral_common.tokens.tokenizers.base import InstructRequestType, TokenizerVersion
+
+
+class InstructRequestNormalizer(
+    Generic[UserMessageType, AssistantMessageType, ToolMessageType, SystemMessageType, InstructRequestType]
+):
+    """
+    Takes a ChatCompletionRequest and normalizes it into an InstructRequest.
+
+    The normalization process does several things such as:
+    - Aggregate consecutive messages of the same role
+    - Aggregate system prompts
+    - Normalize json content
+    - Normalize tool calls
+    """
+
+    system_prompt_in_begin: bool = False
+
+    def __init__(
+        self,
+        user_message_class: Type[UserMessageType],
+        assistant_message_class: Type[AssistantMessageType],
+        tool_message_class: Type[ToolMessageType],
+        system_message_class: Type[SystemMessageType],
+        instruct_request_class: Type[InstructRequestType],
+    ):
+        self._user_message_class = user_message_class
+        self._assistant_message_class = assistant_message_class
+        self._tool_message_class = tool_message_class
+        self._instruct_request_class = instruct_request_class
+        # this is unused but makes creation nicer
+        self._system_message_class = system_message_class
+
+    @staticmethod
+    def normalizer() -> "InstructRequestNormalizer":
+        return InstructRequestNormalizer(
+            UserMessage,
+            AssistantMessage,
+            ToolMessage,
+            SystemMessage,
+            InstructRequest[UATS, Tool],
+        )
+
+    def _normalize_json_content(self, content: Optional[str]) -> str:
+        if content is None or len(content) == 0:
+            return "{}"
+
+        try:
+            parsed_json = json.loads(content)
+            normalized_content = json.dumps(parsed_json, ensure_ascii=False)
+        except json.JSONDecodeError:
+            normalized_content = content
+        return normalized_content
+
+    def _aggregate_content_chunks(self, content: Union[str, List[TextChunk]], chunk_join_str: str = "\n\n") -> str:
+        if isinstance(content, list):
+            return chunk_join_str.join([chunk.text for chunk in content])
+        else:
+            return content
+
+    def _aggregate_system_prompts(self, request: ChatCompletionRequest[UATS]) -> Optional[str]:
+        system_prompt: List[str] = []
+
+        for message in request.messages:
+            if message.role == Roles.system and message.content:
+                system_prompt.append(self._aggregate_content_chunks(message.content))
+
+        return "\n\n".join(system_prompt) if len(system_prompt) else None
+
+    def _aggregate_tool_messages(self, messages: List[UATS]) -> List[ToolMessageType]:
+        """
+        We currently do not do any aggregation for tool messages, but we normalize the json content
+        """
+        tool_messages: List[ToolMessageType] = []
+        for message in messages:
+            assert isinstance(message, self._tool_message_class), "Expected tool message"
+            content = self._aggregate_content_chunks(message.content)
+            normalized_content = self._normalize_json_content(content)
+            tool_messages.append(
+                self._tool_message_class(
+                    content=normalized_content, tool_call_id=message.tool_call_id, name=message.name
+                )
+            )
+
+        return tool_messages
+
+    def _normalize_tool_call(self, tool_call: ToolCall) -> ToolCall:
+        normalized_function_aruments = self._normalize_json_content(tool_call.function.arguments)
+        return ToolCall(
+            function=FunctionCall(name=tool_call.function.name, arguments=normalized_function_aruments),
+            id=tool_call.id,
+        )
+
+    def _aggregate_assistant_messages(self, messages: List[UATS]) -> AssistantMessageType:
+        aggregated_content: List[str] = []
+        tool_calls: List[ToolCall] = []
+        prefix: bool = False
+        weight: Optional[float] = None
+        for message in messages:
+            assert isinstance(message, self._assistant_message_class), "Expected assistant message"
+            if message.tool_calls is not None and len(message.tool_calls) > 0:
+                for tool_call in message.tool_calls:
+                    normalized_tool_call = self._normalize_tool_call(tool_call)
+                    tool_calls.append(normalized_tool_call)
+            elif message.content:
+                aggregated_content.append(self._aggregate_content_chunks(message.content))
+            prefix |= message.prefix
+            if isinstance(message, FinetuningAssistantMessage):
+                # Only FinetuningAssistantMessage can be weighted
+                if weight is not None:
+                    assert (
+                        weight == message.weight
+                    ), "Expected weights of aggregated FinetuningAssistantMessage to be equal"
+                weight = message.weight
+
+        aggregated_message = self._assistant_message_class(
+            content="\n\n".join(aggregated_content) if len(aggregated_content) else None,
+            tool_calls=tool_calls or None,
+            prefix=prefix,
+        )
+
+        if weight is not None and hasattr(aggregated_message, "weight"):
+            aggregated_message.weight = weight
+        return aggregated_message
+
+    def _aggregate_user_messages(self, messages: List[UATS]) -> UserMessageType:
+        """
+        Just coalesce neighboring blocks of text
+        """
+        all_content: List[ContentChunk] = []
+        text_chunks: List[str] = []
+        for message in messages:
+            assert isinstance(message, self._user_message_class), f"Expected user message got {type(message)}"
+            if isinstance(message.content, str):
+                text_chunks.append(message.content)
+            else:  # it's a List[ContentChunk]
+                for chunk in message.content:
+                    if isinstance(chunk, TextChunk):
+                        text_chunks.append(chunk.text)
+                    else:
+                        if text_chunks:
+                            all_content.append(TextChunk(text="\n\n".join(text_chunks)))
+                            text_chunks = []
+                        all_content.append(chunk)
+
+        text_content = "\n\n".join(text_chunks) if text_chunks else ""
+
+        if not all_content:
+            # if no ContentChunk was passed, we return content as a str
+            return self._user_message_class(content=text_content)
+
+        if text_content:
+            # else we return a List of content chunks
+            all_content.append(TextChunk(text=text_content))
+
+        return self._user_message_class(content=all_content)
+
+    def _aggregate_role(self, messages: List[UATS], role: Optional[Roles]) -> Sequence[UATS]:
+        if role == Roles.tool:
+            return self._aggregate_tool_messages(messages)
+        elif role == Roles.assistant:
+            return [self._aggregate_assistant_messages(messages)]
+        elif role == Roles.user:
+            return [self._aggregate_user_messages(messages)]
+        else:  # System messages are ignored
+            return []
+
+    def _aggregate_messages(self, request: ChatCompletionRequest[UATS]) -> List[UATS]:
+        aggregated_messages: List[UATS] = []
+        messages_to_aggregate: List[UATS] = []
+        current_role: Optional[Roles] = None
+        current_weight: Optional[float] = None
+
+        # Collect consecutive lists of messages with the same role and weight
+        for message in request.messages:
+            new_weight = getattr(message, "weight", None)
+            if current_role != message.role or (new_weight != current_weight):
+                aggregated_messages.extend(self._aggregate_role(messages_to_aggregate, current_role))
+                messages_to_aggregate.clear()
+            current_weight = new_weight
+            current_role = message.role
+            messages_to_aggregate.append(message)
+
+        # Add the last set of messages
+        aggregated_messages.extend(self._aggregate_role(messages_to_aggregate, current_role))
+
+        # If the first message is not a user message, or we didnt aggregate
+        # anything (all system messages) for example, add an empty user message
+        if len(aggregated_messages) == 0 or (
+            not self.system_prompt_in_begin and aggregated_messages[0].role != Roles.user
+        ):
+            aggregated_messages.insert(0, self._user_message_class(content=""))
+
+        return aggregated_messages
+
+    def from_chat_completion_request(self, request: ChatCompletionRequest[UATS]) -> InstructRequestType:
+        system_prompt = self._aggregate_system_prompts(request)
+        messages = self._aggregate_messages(request)
+
+        return self._instruct_request_class(
+            messages=messages, system_prompt=system_prompt, available_tools=request.tools
+        )
+
+
+class InstructRequestNormalizerV7(InstructRequestNormalizer):
+    system_prompt_in_begin: bool = True
+
+    @staticmethod
+    def normalizer() -> "InstructRequestNormalizerV7":
+        return InstructRequestNormalizerV7(
+            UserMessage,
+            AssistantMessage,
+            ToolMessage,
+            SystemMessage,
+            InstructRequest[UATS, Tool],
+        )
+
+    def _aggregate_role(self, messages: List[UATS], role: Optional[Roles]) -> Sequence[UATS]:
+        if role == Roles.tool:
+            return self._aggregate_tool_messages(messages)
+        elif role == Roles.assistant:
+            return [self._aggregate_assistant_messages(messages)]
+        elif role == Roles.user:
+            return [self._aggregate_user_messages(messages)]
+        elif role == Roles.system:
+            return messages
+        else:
+            assert role is None and len(messages) == 0
+            return []
+
+    def _aggregate_system_prompts(self, request: ChatCompletionRequest[UATS]) -> Optional[str]:
+        raise NotImplementedError("We should not aggregate system prompts")
+
+    def from_chat_completion_request(self, request: ChatCompletionRequest[UATS]) -> InstructRequestType:  # type: ignore[type-var]
+        messages = self._aggregate_messages(request)
+        return self._instruct_request_class(messages=messages, system_prompt=None, available_tools=request.tools)  # type: ignore[no-any-return]
+
+
+def normalizer_for_tokenizer_version(version: TokenizerVersion) -> InstructRequestNormalizer:
+    if version in {TokenizerVersion.v1, TokenizerVersion.v2, TokenizerVersion.v3}:
+        return InstructRequestNormalizer.normalizer()
+    elif version == TokenizerVersion.v7:
+        return InstructRequestNormalizerV7.normalizer()
+    raise ValueError(f"Unknown tokenizer version {version}")

.venv/lib/python3.11/site-packages/mistral_common/protocol/instruct/request.py

@@ -0,0 +1,27 @@
+from enum import Enum
+from typing import Generic, List, Optional
+
+from pydantic import Field
+
+from mistral_common.base import MistralBase
+from mistral_common.protocol.base import BaseCompletionRequest
+from mistral_common.protocol.instruct.messages import ChatMessageType
+from mistral_common.protocol.instruct.tool_calls import Tool, ToolChoice
+
+
+class ResponseFormats(str, Enum):
+    text: str = "text"
+    json: str = "json_object"
+
+
+class ResponseFormat(MistralBase):
+    type: ResponseFormats = ResponseFormats.text
+
+
+class ChatCompletionRequest(BaseCompletionRequest, Generic[ChatMessageType]):
+    model: Optional[str] = None
+    messages: List[ChatMessageType]
+    response_format: ResponseFormat = Field(default_factory=ResponseFormat)
+    tools: Optional[List[Tool]] = None
+    tool_choice: ToolChoice = ToolChoice.auto
+    truncate_for_context_length: bool = False

.venv/lib/python3.11/site-packages/mistral_common/protocol/instruct/response.py

@@ -0,0 +1,66 @@
+import time
+from enum import Enum
+from typing import List, Optional
+
+from pydantic import Field
+
+from mistral_common.base import MistralBase
+from mistral_common.protocol.base import UsageInfo
+from mistral_common.protocol.instruct.tool_calls import ToolCall
+from mistral_common.protocol.utils import random_uuid
+
+
+class FinishReason(str, Enum):
+    stop: str = "stop"
+    length: str = "length"
+    model_length: str = "model_length"
+    error: str = "error"
+    tool_call: str = "tool_calls"
+
+
+class ChatCompletionTokenLogprobs(MistralBase):
+    token: str
+    logprob: float
+    bytes: List[int]
+
+
+class ChatCompletionResponseChoiceLogprobs(MistralBase):
+    content: List[ChatCompletionTokenLogprobs]
+
+
+class DeltaMessage(MistralBase):
+    role: Optional[str] = None
+    content: Optional[str] = None
+    tool_calls: Optional[List[ToolCall]] = None
+
+
+class ChatCompletionResponseChoice(MistralBase):
+    index: int
+    message: DeltaMessage
+    finish_reason: Optional[FinishReason] = None
+    logprobs: Optional[ChatCompletionResponseChoiceLogprobs] = None
+
+
+class ChatCompletionResponse(MistralBase):
+    id: str = Field(default_factory=lambda: f"chatcmpl-{random_uuid()}")
+    object: str = "chat.completion"
+    created: int = Field(default_factory=lambda: int(time.time()))
+    model: str
+    choices: List[ChatCompletionResponseChoice]
+    usage: UsageInfo
+
+
+class ChatCompletionResponseStreamChoice(MistralBase):
+    index: int
+    delta: DeltaMessage
+    finish_reason: Optional[FinishReason] = None
+    logprobs: Optional[ChatCompletionResponseChoiceLogprobs] = None
+
+
+class ChatCompletionStreamResponse(MistralBase):
+    id: str = Field(default_factory=lambda: f"chatcmpl-{random_uuid()}")
+    object: str = "chat.completion.chunk"
+    created: int = Field(default_factory=lambda: int(time.time()))
+    model: str
+    choices: List[ChatCompletionResponseStreamChoice]
+    usage: Optional[UsageInfo] = None

.venv/lib/python3.11/site-packages/mistral_common/protocol/instruct/tool_calls.py

@@ -0,0 +1,51 @@
+import json
+from enum import Enum
+from typing import Any, Dict, TypeVar, Union
+
+from pydantic import field_validator
+
+from mistral_common.base import MistralBase
+
+
+class Function(MistralBase):
+    name: str
+    description: str = ""
+    parameters: Dict[str, Any]
+
+
+class ToolTypes(str, Enum):
+    function = "function"
+
+
+class ToolChoice(str, Enum):
+    auto: str = "auto"
+    none: str = "none"
+    any: str = "any"
+
+
+class Tool(MistralBase):
+    type: ToolTypes = ToolTypes.function
+    function: Function
+
+
+class FunctionCall(MistralBase):
+    name: str
+    arguments: str
+
+    @field_validator("arguments", mode="before")
+    def validate_arguments(cls, v: Union[str, Dict[str, Any]]) -> str:
+        """
+        This is for backward compatibility
+        """
+        if isinstance(v, dict):
+            return json.dumps(v)
+        return v
+
+
+class ToolCall(MistralBase):
+    id: str = "null"  # required for V3 tokenization
+    type: ToolTypes = ToolTypes.function
+    function: FunctionCall
+
+
+ToolType = TypeVar("ToolType", bound=Tool)

.venv/lib/python3.11/site-packages/mistral_common/protocol/instruct/validator.py

@@ -0,0 +1,328 @@
+import re
+from enum import Enum
+from typing import Generic, List
+
+from jsonschema import Draft7Validator, SchemaError
+
+from mistral_common.exceptions import (
+    InvalidAssistantMessageException,
+    InvalidFunctionCallException,
+    InvalidMessageStructureException,
+    InvalidRequestException,
+    InvalidSystemPromptException,
+    InvalidToolException,
+    InvalidToolMessageException,
+    InvalidToolSchemaException,
+)
+from mistral_common.protocol.instruct.messages import (
+    UATS,
+    AssistantMessage,
+    AssistantMessageType,
+    FinetuningAssistantMessage,
+    Roles,
+    SystemMessageType,
+    ToolMessageType,
+    UserMessageType,
+)
+from mistral_common.protocol.instruct.request import ChatCompletionRequest
+from mistral_common.protocol.instruct.tool_calls import (
+    Function,
+    FunctionCall,
+    Tool,
+    ToolCall,
+)
+
+
+class ValidationMode(Enum):
+    serving = "serving"
+    finetuning = "finetuning"
+    test = "test"
+
+
+class MistralRequestValidator(Generic[UserMessageType, AssistantMessageType, ToolMessageType, SystemMessageType]):
+    def __init__(self, mode: ValidationMode = ValidationMode.test):
+        self._mode = mode
+
+    def validate_messages(self, messages: List[UATS]) -> None:
+        """
+        Validates the list of messages
+        """
+        self._validate_message_list_structure(messages)
+        self._validate_message_list_content(messages)
+
+    def validate_request(self, request: ChatCompletionRequest) -> ChatCompletionRequest[UATS]:
+        """
+        Validates the request
+        """
+
+        if self._mode == ValidationMode.serving:
+            if request.model is None:
+                raise InvalidRequestException("Model name parameter is required for serving mode")
+
+        # Validate the messages
+        self.validate_messages(request.messages)
+
+        # Validate the tools
+        self._validate_tools(request.tools or [])
+
+        return request
+
+    def _validate_function(self, function: Function) -> None:
+        """
+        Checks:
+        - That the function schema is valid
+        """
+        try:
+            Draft7Validator.check_schema(function.parameters)
+        except SchemaError as e:
+            raise InvalidToolSchemaException(f"Invalid tool schema: {e.message}")
+
+        if not re.match(r"^[a-zA-Z0-9_-]{1,64}$", function.name):
+            raise InvalidToolException(
+                f"Function name was {function.name} but must be a-z, A-Z, 0-9, "
+                "or contain underscores and dashes, with a maximum length of 64."
+            )
+
+    def _validate_tools(self, tools: List[Tool]) -> None:
+        """
+        Checks:
+        - That the tool schemas are valid
+        """
+
+        for tool in tools:
+            self._validate_function(tool.function)
+
+    def _validate_user_message(self, message: UserMessageType) -> None:
+        pass
+
+    def _validate_tool_message(self, message: ToolMessageType) -> None:
+        """
+        Checks:
+        - The tool name is valid
+        """
+        if message.name is not None:
+            if not re.match(r"^[a-zA-Z0-9_-]{1,64}$", message.name):
+                raise InvalidToolMessageException(
+                    f"Function name was {message.name} but must be a-z, A-Z, 0-9, "
+                    "or contain underscores and dashes, with a maximum length of 64."
+                )
+
+    def _validate_system_message(self, message: SystemMessageType) -> None:
+        """
+        Checks:
+        - That the system prompt has content
+        """
+        if message.content is None:
+            raise InvalidSystemPromptException("System prompt must have content")
+
+    def _validate_function_call(self, function_call: FunctionCall) -> None:
+        """
+        Checks:
+        - That the function call has a valid name
+        """
+        if not re.match(r"^[a-zA-Z0-9_-]{1,64}$", function_call.name):
+            raise InvalidFunctionCallException(
+                f"Function name was {function_call.name} but must be a-z, A-Z, 0-9, "
+                "or contain underscores and dashes, with a maximum length of 64."
+            )
+
+    def _validate_tool_call(self, tool_call: ToolCall, is_last_message: bool) -> None:
+        """
+        Checks:
+        - That the tool call has a valid function
+        """
+
+        self._validate_function_call(tool_call.function)
+
+    def _validate_assistant_message(self, message: AssistantMessageType, is_last_message: bool = False) -> None:
+        """
+        Checks:
+        - That the assistant message has either text or tool_calls, but not both
+        - That the tool calls are valid
+        """
+
+        # Validate that the message has either text or tool_calls
+        # but not both and not neither.
+        if bool(message.content) == bool(message.tool_calls):
+            raise InvalidAssistantMessageException(
+                "Assistant message must have either content or tool_calls, but not both."
+            )
+
+        # If we have tool calls, validate them
+        if message.tool_calls is not None:
+            # Validate that the tool calls are valid
+            for tool_call in message.tool_calls:
+                self._validate_tool_call(tool_call, is_last_message=is_last_message)
+
+        if self._mode == ValidationMode.finetuning and isinstance(message, FinetuningAssistantMessage):
+            if message.weight is not None and message.weight not in [0, 1]:
+                raise InvalidAssistantMessageException("Assistant message weight must be either 0 or 1")
+
+        if message.prefix:
+            if not is_last_message:
+                raise InvalidAssistantMessageException("Assistant message with prefix True must be last message")
+            # note : we already validate that assistant messsage has content 3 lines up.
+
+    def _validate_tool_calls_followed_by_tool_messages(self, messages: List[UATS]) -> None:
+        """
+        Checks:
+        - That the number of tool calls and tool messages are the same
+        - That the tool calls are followed by tool messages
+        """
+        prev_role = None
+        expected_tool_messages = 0
+        for message in messages:
+            if prev_role is None:
+                prev_role = message.role
+                continue
+
+            if message.role == Roles.tool:
+                expected_tool_messages -= 1
+            elif message.role == Roles.assistant:
+                # if we have an assistant message and we have not received all the function calls
+                # we need to raise an exception
+                if expected_tool_messages != 0:
+                    raise InvalidMessageStructureException("Not the same number of function calls and responses")
+
+                if message.tool_calls is not None:
+                    # Validate that the number of function calls and responses are the same
+                    expected_tool_messages = len(message.tool_calls)
+
+            prev_role = message.role
+
+        if expected_tool_messages != 0 and self._mode == ValidationMode.serving:
+            raise InvalidMessageStructureException("Not the same number of function calls and responses")
+        elif expected_tool_messages < 0 and self._mode == ValidationMode.finetuning:
+            raise InvalidMessageStructureException("More tool responses than tool calls")
+
+    def _validate_message_order(self, messages: List[UATS]) -> None:
+        """
+        Validates the order of the messages, for example user -> assistant -> user -> assistant -> ...
+        """
+        previous_role = None
+        for message in messages:
+            current_role = message.role
+
+            if previous_role is not None:
+                if previous_role == Roles.system:
+                    expected_roles = {Roles.user, Roles.assistant, Roles.system}
+                elif previous_role == Roles.user:
+                    expected_roles = {Roles.assistant, Roles.system, Roles.user}
+                elif previous_role == Roles.assistant:
+                    expected_roles = {Roles.assistant, Roles.user, Roles.tool}
+                elif previous_role == Roles.tool:
+                    expected_roles = {Roles.assistant, Roles.tool}
+
+                if current_role not in expected_roles:
+                    raise InvalidMessageStructureException(
+                        f"Unexpected role '{current_role}' after role '{previous_role}'"
+                    )
+
+            previous_role = current_role
+
+    def _validate_last_message(self, message: UATS) -> None:
+        # The last message must be a user or tool message in serving mode or an assistant message in finetuning mode
+        last_message_role = message.role
+        if self._mode == ValidationMode.finetuning:
+            if last_message_role != Roles.assistant:
+                raise InvalidMessageStructureException(
+                    f"Expected last role Assistant for finetuning but got {last_message_role}"
+                )
+        else:
+            bad_assistant = isinstance(message, AssistantMessage) and not message.prefix
+            bad_role = message.role not in {Roles.user, Roles.tool}
+            if bad_assistant and bad_role:
+                raise InvalidMessageStructureException(
+                    f"Expected last role User or Tool (or Assistant with prefix True) for serving"
+                    f" but got {last_message_role}"
+                )
+
+    def _validate_message_list_structure(self, messages: List[UATS]) -> None:
+        """
+        Validates the structure of the list of messages
+
+        For example the messages must be in the correct order of user/assistant/tool
+        """
+
+        if len(messages) == 0:
+            raise InvalidMessageStructureException("Conversation must have at least one message")
+
+        # If we have one message it must be a user or a system message
+        if len(messages) == 1:
+            if messages[0].role not in {Roles.user, Roles.system}:
+                raise InvalidMessageStructureException("Conversation must start with a user message or system message")
+
+        # Always check the last message if in fine-tuning mode
+        if self._mode == ValidationMode.finetuning or len(messages) > 1:
+            self._validate_last_message(messages[-1])
+
+        self._validate_message_order(messages)
+        self._validate_tool_calls_followed_by_tool_messages(messages)
+
+    def _validate_message_list_content(self, messages: List[UATS]) -> None:
+        """
+        Validates the content of the messages
+        """
+
+        for idx, message in enumerate(messages):
+            if message.role == Roles.user:
+                self._validate_user_message(message)
+            elif message.role == Roles.assistant:
+                self._validate_assistant_message(message, is_last_message=idx == len(messages) - 1)
+            elif message.role == Roles.tool:
+                self._validate_tool_message(message)
+            elif message.role == Roles.system:
+                self._validate_system_message(message)
+            else:
+                raise InvalidRequestException(f"Unsupported message type {type(message)}")
+
+
+class MistralRequestValidatorV3(MistralRequestValidator):
+    def _validate_tool_message(self, message: ToolMessageType) -> None:
+        """
+        Checks:
+        - The tool name is valid
+        - Tool call id is valid
+        """
+        if message.name is not None:
+            if not re.match(r"^[a-zA-Z0-9_-]{1,64}$", message.name):
+                raise InvalidToolMessageException(
+                    f"Function name was {message.name} but must be a-z, A-Z, 0-9, "
+                    "or contain underscores and dashes, with a maximum length of 64."
+                )
+
+        if message.tool_call_id is None:
+            raise InvalidRequestException("Tool call id has to be defined.")
+
+        if not re.match(r"^[a-zA-Z0-9]{9}$", message.tool_call_id):
+            raise InvalidToolMessageException(
+                f"Tool call id was {message.tool_call_id} but must be a-z, A-Z, 0-9, with a length of 9."
+            )
+
+    def _validate_tool_call(self, tool_call: ToolCall, is_last_message: bool) -> None:
+        """
+        Validate that the tool call has a valid ID
+        """
+        if tool_call.id != "null":
+            if not re.match(r"^[a-zA-Z0-9]{9}$", tool_call.id):
+                raise InvalidFunctionCallException(
+                    f"Tool call id was {tool_call.id} but must be a-z, A-Z, 0-9, with a length of 9."
+                )
+        if self._mode == ValidationMode.finetuning and not is_last_message and tool_call.id == "null":
+            err_message = "Tool call id of assistant message that is not last has to be defined in finetuning mode."
+            raise InvalidFunctionCallException(err_message)
+
+        if self._mode == ValidationMode.serving and tool_call.id == "null":
+            raise InvalidFunctionCallException("Tool call id has to be defined in serving mode.")
+
+        self._validate_function_call(tool_call.function)
+
+    def _validate_last_message(self, message: UATS) -> None:
+        super()._validate_last_message(message)
+
+        if self._mode == ValidationMode.finetuning:
+            # in finetuning mode it has to be an assistant message
+            # as checked by parent `_validate_last_message`
+            if message.tool_calls is not None:
+                for tool_call in message.tool_calls:
+                    self._validate_tool_call(tool_call, is_last_message=True)

.venv/lib/python3.11/site-packages/mistral_common/protocol/utils.py

@@ -0,0 +1,5 @@
+import uuid
+
+
+def random_uuid() -> str:
+    return str(uuid.uuid4().hex)

.venv/lib/python3.11/site-packages/vllm-0.7.2.dist-info/INSTALLER

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

.venv/lib/python3.11/site-packages/vllm-0.7.2.dist-info/LICENSE

@@ -0,0 +1,201 @@
+                                 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.

.venv/lib/python3.11/site-packages/vllm-0.7.2.dist-info/METADATA

@@ -0,0 +1,238 @@
+Metadata-Version: 2.2
+Name: vllm
+Version: 0.7.2
+Summary: A high-throughput and memory-efficient inference and serving engine for LLMs
+Home-page: https://github.com/vllm-project/vllm
+Author: vLLM Team
+License: Apache 2.0
+Project-URL: Homepage, https://github.com/vllm-project/vllm
+Project-URL: Documentation, https://vllm.readthedocs.io/en/latest/
+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: License :: OSI Approved :: Apache Software License
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psutil
+Requires-Dist: sentencepiece
+Requires-Dist: numpy<2.0.0
+Requires-Dist: requests>=2.26.0
+Requires-Dist: tqdm
+Requires-Dist: blake3
+Requires-Dist: py-cpuinfo
+Requires-Dist: transformers>=4.48.2
+Requires-Dist: tokenizers>=0.19.1
+Requires-Dist: protobuf
+Requires-Dist: fastapi<0.113.0,>=0.107.0; python_version < "3.9"
+Requires-Dist: fastapi!=0.113.*,!=0.114.0,>=0.107.0; python_version >= "3.9"
+Requires-Dist: aiohttp
+Requires-Dist: openai>=1.52.0
+Requires-Dist: uvicorn[standard]
+Requires-Dist: pydantic>=2.9
+Requires-Dist: prometheus_client>=0.18.0
+Requires-Dist: pillow
+Requires-Dist: prometheus-fastapi-instrumentator>=7.0.0
+Requires-Dist: tiktoken>=0.6.0
+Requires-Dist: lm-format-enforcer<0.11,>=0.10.9
+Requires-Dist: outlines==0.1.11
+Requires-Dist: lark==1.2.2
+Requires-Dist: xgrammar>=0.1.6; platform_machine == "x86_64"
+Requires-Dist: typing_extensions>=4.10
+Requires-Dist: filelock>=3.16.1
+Requires-Dist: partial-json-parser
+Requires-Dist: pyzmq
+Requires-Dist: msgspec
+Requires-Dist: gguf==0.10.0
+Requires-Dist: importlib_metadata
+Requires-Dist: mistral_common[opencv]>=1.5.0
+Requires-Dist: pyyaml
+Requires-Dist: six>=1.16.0; python_version > "3.11"
+Requires-Dist: setuptools>=74.1.1; python_version > "3.11"
+Requires-Dist: einops
+Requires-Dist: compressed-tensors==0.9.1
+Requires-Dist: depyf==0.18.0
+Requires-Dist: cloudpickle
+Requires-Dist: ray[default]>=2.9
+Requires-Dist: nvidia-ml-py>=12.560.30
+Requires-Dist: torch==2.5.1
+Requires-Dist: torchaudio==2.5.1
+Requires-Dist: torchvision==0.20.1
+Requires-Dist: xformers==0.0.28.post3; platform_system == "Linux" and platform_machine == "x86_64"
+Provides-Extra: tensorizer
+Requires-Dist: tensorizer>=2.9.0; extra == "tensorizer"
+Provides-Extra: runai
+Requires-Dist: runai-model-streamer; extra == "runai"
+Requires-Dist: runai-model-streamer-s3; extra == "runai"
+Requires-Dist: boto3; extra == "runai"
+Provides-Extra: audio
+Requires-Dist: librosa; extra == "audio"
+Requires-Dist: soundfile; extra == "audio"
+Provides-Extra: video
+Requires-Dist: decord; extra == "video"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/vllm-project/vllm/main/docs/source/assets/logos/vllm-logo-text-dark.png">
+    <img alt="vLLM" src="https://raw.githubusercontent.com/vllm-project/vllm/main/docs/source/assets/logos/vllm-logo-text-light.png" width=55%>
+  </picture>
+</p>
+
+<h3 align="center">
+Easy, fast, and cheap LLM serving for everyone
+</h3>
+
+<p align="center">
+| <a href="https://docs.vllm.ai"><b>Documentation</b></a> | <a href="https://vllm.ai"><b>Blog</b></a> | <a href="https://arxiv.org/abs/2309.06180"><b>Paper</b></a> | <a href="https://x.com/vllm_project"><b>Twitter/X</b></a> | <a href="https://slack.vllm.ai"><b>Developer Slack</b></a> |
+</p>
+
+---
+
+*Latest News* 🔥
+- [2025/01] We are excited to announce the alpha release of vLLM V1: A major architectural upgrade with 1.7x speedup! Clean code, optimized execution loop, zero-overhead prefix caching, enhanced multimodal support, and more. Please check out our blog post [here](https://blog.vllm.ai/2025/01/27/v1-alpha-release.html).
+- [2025/01] We hosted [the eighth vLLM meetup](https://lu.ma/zep56hui) with Google Cloud! Please find the meetup slides from vLLM team [here](https://docs.google.com/presentation/d/1epVkt4Zu8Jz_S5OhEHPc798emsYh2BwYfRuDDVEF7u4/edit?usp=sharing).
+- [2024/12] vLLM joins [pytorch ecosystem](https://pytorch.org/blog/vllm-joins-pytorch)! Easy, Fast, and Cheap LLM Serving for Everyone!
+- [2024/11] We hosted [the seventh vLLM meetup](https://lu.ma/h0qvrajz) with Snowflake! Please find the meetup slides from vLLM team [here](https://docs.google.com/presentation/d/1e3CxQBV3JsfGp30SwyvS3eM_tW-ghOhJ9PAJGK6KR54/edit?usp=sharing), and Snowflake team [here](https://docs.google.com/presentation/d/1qF3RkDAbOULwz9WK5TOltt2fE9t6uIc_hVNLFAaQX6A/edit?usp=sharing).
+- [2024/10] We have just created a developer slack ([slack.vllm.ai](https://slack.vllm.ai)) focusing on coordinating contributions and discussing features. Please feel free to join us there!
+- [2024/10] Ray Summit 2024 held a special track for vLLM! Please find the opening talk slides from the vLLM team [here](https://docs.google.com/presentation/d/1B_KQxpHBTRa_mDF-tR6i8rWdOU5QoTZNcEg2MKZxEHM/edit?usp=sharing). Learn more from the [talks](https://www.youtube.com/playlist?list=PLzTswPQNepXl6AQwifuwUImLPFRVpksjR) from other vLLM contributors and users!
+- [2024/09] We hosted [the sixth vLLM meetup](https://lu.ma/87q3nvnh) with NVIDIA! Please find the meetup slides [here](https://docs.google.com/presentation/d/1wrLGwytQfaOTd5wCGSPNhoaW3nq0E-9wqyP7ny93xRs/edit?usp=sharing).
+- [2024/07] We hosted [the fifth vLLM meetup](https://lu.ma/lp0gyjqr) with AWS! Please find the meetup slides [here](https://docs.google.com/presentation/d/1RgUD8aCfcHocghoP3zmXzck9vX3RCI9yfUAB2Bbcl4Y/edit?usp=sharing).
+- [2024/07] In partnership with Meta, vLLM officially supports Llama 3.1 with FP8 quantization and pipeline parallelism! Please check out our blog post [here](https://blog.vllm.ai/2024/07/23/llama31.html).
+- [2024/06] We hosted [the fourth vLLM meetup](https://lu.ma/agivllm) with Cloudflare and BentoML! Please find the meetup slides [here](https://docs.google.com/presentation/d/1iJ8o7V2bQEi0BFEljLTwc5G1S10_Rhv3beed5oB0NJ4/edit?usp=sharing).
+- [2024/04] We hosted [the third vLLM meetup](https://robloxandvllmmeetup2024.splashthat.com/) with Roblox! Please find the meetup slides [here](https://docs.google.com/presentation/d/1A--47JAK4BJ39t954HyTkvtfwn0fkqtsL8NGFuslReM/edit?usp=sharing).
+- [2024/01] We hosted [the second vLLM meetup](https://lu.ma/ygxbpzhl) with IBM! Please find the meetup slides [here](https://docs.google.com/presentation/d/12mI2sKABnUw5RBWXDYY-HtHth4iMSNcEoQ10jDQbxgA/edit?usp=sharing).
+- [2023/10] We hosted [the first vLLM meetup](https://lu.ma/first-vllm-meetup) with a16z! Please find the meetup slides [here](https://docs.google.com/presentation/d/1QL-XPFXiFpDBh86DbEegFXBXFXjix4v032GhShbKf3s/edit?usp=sharing).
+- [2023/08] We would like to express our sincere gratitude to [Andreessen Horowitz](https://a16z.com/2023/08/30/supporting-the-open-source-ai-community/) (a16z) for providing a generous grant to support the open-source development and research of vLLM.
+- [2023/06] We officially released vLLM! FastChat-vLLM integration has powered [LMSYS Vicuna and Chatbot Arena](https://chat.lmsys.org) since mid-April. Check out our [blog post](https://vllm.ai).
+
+---
+## About
+vLLM is a fast and easy-to-use library for LLM inference and serving.
+
+Originally developed in the [Sky Computing Lab](https://sky.cs.berkeley.edu) at UC Berkeley, vLLM has evolved into a community-driven project with contributions from both academia and industry.
+
+vLLM is fast with:
+
+- State-of-the-art serving throughput
+- Efficient management of attention key and value memory with [**PagedAttention**](https://blog.vllm.ai/2023/06/20/vllm.html)
+- Continuous batching of incoming requests
+- Fast model execution with CUDA/HIP graph
+- Quantizations: [GPTQ](https://arxiv.org/abs/2210.17323), [AWQ](https://arxiv.org/abs/2306.00978), INT4, INT8, and FP8.
+- Optimized CUDA kernels, including integration with FlashAttention and FlashInfer.
+- Speculative decoding
+- Chunked prefill
+
+**Performance benchmark**: We include a performance benchmark at the end of [our blog post](https://blog.vllm.ai/2024/09/05/perf-update.html). It compares the performance of vLLM against other LLM serving engines ([TensorRT-LLM](https://github.com/NVIDIA/TensorRT-LLM), [SGLang](https://github.com/sgl-project/sglang) and [LMDeploy](https://github.com/InternLM/lmdeploy)). The implementation is under [nightly-benchmarks folder](.buildkite/nightly-benchmarks/) and you can [reproduce](https://github.com/vllm-project/vllm/issues/8176) this benchmark using our one-click runnable script.
+
+vLLM is flexible and easy to use with:
+
+- Seamless integration with popular Hugging Face models
+- High-throughput serving with various decoding algorithms, including *parallel sampling*, *beam search*, and more
+- Tensor parallelism and pipeline parallelism support for distributed inference
+- Streaming outputs
+- OpenAI-compatible API server
+- Support NVIDIA GPUs, AMD CPUs and GPUs, Intel CPUs and GPUs, PowerPC CPUs, TPU, and AWS Neuron.
+- Prefix caching support
+- Multi-lora support
+
+vLLM seamlessly supports most popular open-source models on HuggingFace, including:
+- Transformer-like LLMs (e.g., Llama)
+- Mixture-of-Expert LLMs (e.g., Mixtral, Deepseek-V2 and V3)
+- Embedding Models (e.g. E5-Mistral)
+- Multi-modal LLMs (e.g., LLaVA)
+
+Find the full list of supported models [here](https://docs.vllm.ai/en/latest/models/supported_models.html).
+
+## Getting Started
+
+Install vLLM with `pip` or [from source](https://docs.vllm.ai/en/latest/getting_started/installation/gpu/index.html#build-wheel-from-source):
+
+```bash
+pip install vllm
+```
+
+Visit our [documentation](https://docs.vllm.ai/en/latest/) to learn more.
+- [Installation](https://docs.vllm.ai/en/latest/getting_started/installation/index.html)
+- [Quickstart](https://docs.vllm.ai/en/latest/getting_started/quickstart.html)
+- [List of Supported Models](https://docs.vllm.ai/en/latest/models/supported_models.html)
+
+## Contributing
+
+We welcome and value any contributions and collaborations.
+Please check out [CONTRIBUTING.md](./CONTRIBUTING.md) for how to get involved.
+
+## Sponsors
+
+vLLM is a community project. Our compute resources for development and testing are supported by the following organizations. Thank you for your support!
+
+<!-- Note: Please sort them in alphabetical order. -->
+<!-- Note: Please keep these consistent with docs/source/community/sponsors.md -->
+Cash Donations:
+- a16z
+- Dropbox
+- Sequoia Capital
+- Skywork AI
+- ZhenFund
+
+Compute Resources:
+- AMD
+- Anyscale
+- AWS
+- Crusoe Cloud
+- Databricks
+- DeepInfra
+- Google Cloud
+- Lambda Lab
+- Nebius
+- Novita AI
+- NVIDIA
+- Replicate
+- Roblox
+- RunPod
+- Trainy
+- UC Berkeley
+- UC San Diego
+
+Slack Sponsor: Anyscale
+
+We also have an official fundraising venue through [OpenCollective](https://opencollective.com/vllm). We plan to use the fund to support the development, maintenance, and adoption of vLLM.
+
+## Citation
+
+If you use vLLM for your research, please cite our [paper](https://arxiv.org/abs/2309.06180):
+```bibtex
+@inproceedings{kwon2023efficient,
+  title={Efficient Memory Management for Large Language Model Serving with PagedAttention},
+  author={Woosuk Kwon and Zhuohan Li and Siyuan Zhuang and Ying Sheng and Lianmin Zheng and Cody Hao Yu and Joseph E. Gonzalez and Hao Zhang and Ion Stoica},
+  booktitle={Proceedings of the ACM SIGOPS 29th Symposium on Operating Systems Principles},
+  year={2023}
+}
+```
+
+## Contact Us
+
+* For technical questions and feature requests, please use Github issues or discussions.
+* For discussing with fellow users and coordinating contributions and development, please use Slack.
+* For security disclosures, please use Github's security advisory feature.
+* For collaborations and partnerships, please contact us at vllm-questions AT lists.berkeley.edu.
+
+## Media Kit
+
+* If you wish to use vLLM's logo, please refer to [our media kit repo](https://github.com/vllm-project/media-kit).

.venv/lib/python3.11/site-packages/vllm-0.7.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: false
+Tag: cp38-abi3-linux_x86_64
+

.venv/lib/python3.11/site-packages/vllm-0.7.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+vllm = vllm.scripts:main

.venv/lib/python3.11/site-packages/vllm-0.7.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+vllm

.venv/lib/python3.11/site-packages/xgrammar/__init__.py

@@ -0,0 +1,13 @@
+from . import testing
+from .compiler import CompiledGrammar, GrammarCompiler
+from .contrib import hf
+from .grammar import Grammar, StructuralTagItem
+from .matcher import (
+    GrammarMatcher,
+    allocate_token_bitmask,
+    apply_token_bitmask_inplace,
+    bitmask_dtype,
+    get_bitmask_shape,
+    reset_token_bitmask,
+)
+from .tokenizer_info import TokenizerInfo, VocabType