Add files using upload-large-folder tool

.gitattributes

@@ -4059,24 +4059,6 @@ tool_server/.venv/lib/python3.12/site-packages/nvidia/cufile/lib/libcufile.so.0
 tool_server/.venv/lib/python3.12/site-packages/nvidia/cuda_runtime/lib/libcudart.so.12 filter=lfs diff=lfs merge=lfs -text
 tool_server/.venv/lib/python3.12/site-packages/nvidia/cuda_nvrtc/lib/libnvrtc-builtins.so.12.6 filter=lfs diff=lfs merge=lfs -text
 tool_server/.venv/lib/python3.12/site-packages/nvidia/cuda_nvrtc/lib/libnvrtc.so.12 filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cuda_cupti/lib/libcheckpoint.so filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cuda_cupti/lib/libcupti.so.12 filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cuda_cupti/lib/libnvperf_host.so filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cuda_cupti/lib/libnvperf_target.so filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cuda_cupti/lib/libpcsamplingutil.so filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cublas/lib/libcublas.so.12 filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cublas/lib/libcublasLt.so.12 filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cublas/lib/libnvblas.so.12 filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cusparse/lib/libcusparse.so.12 filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cufft/lib/libcufft.so.11 filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cufft/lib/libcufftw.so.11 filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cudnn/lib/libcudnn.so.9 filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cudnn/lib/libcudnn_adv.so.9 filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cudnn/lib/libcudnn_cnn.so.9 filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cudnn/lib/libcudnn_engines_precompiled.so.9 filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cudnn/lib/libcudnn_engines_runtime_compiled.so.9 filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cudnn/lib/libcudnn_graph.so.9 filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cudnn/lib/libcudnn_heuristic.so.9 filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cudnn/lib/libcudnn_ops.so.9 filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cusolver/lib/libcusolver.so.11 filter=lfs diff=lfs merge=lfs -text
-tool_server/.venv/lib/python3.12/site-packages/nvidia/cusolver/lib/libcusolverMg.so.11 filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/llvmlite/binding/libllvmlite.so filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/llvmlite/tests/__pycache__/test_binding.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/llvmlite/tests/__pycache__/test_ir.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text

tool_server/.venv/lib/python3.12/site-packages/interegular/utils/__init__.py

@@ -0,0 +1,15 @@
+import logging
+from typing import Iterable
+
+logger = logging.getLogger('interegular')
+logger.addHandler(logging.StreamHandler())
+logger.setLevel(logging.CRITICAL)
+
+
+def soft_repr(s: str):
+    """
+    joins together the repr of each char in the string, while throwing away the repr
+    This for example turns `"'\""` into `'"` instead of `\'"` like the normal repr
+    would do.
+    """
+    return ''.join(repr(c)[1:-1] for c in str(s))

tool_server/.venv/lib/python3.12/site-packages/interegular/utils/simple_parser.py

@@ -0,0 +1,165 @@
+"""
+A small util to simplify the creation of Parsers for simple context-free-grammars.
+
+"""
+
+from abc import ABC, abstractmethod
+from collections import defaultdict
+from functools import wraps
+from types import FunctionType, MethodType
+from typing import Generic, TypeVar, Optional, List
+
+__all__ = ['nomatch', 'NoMatch', 'SimpleParser']
+
+
+class nomatch(BaseException):
+    def __init__(self):
+        pass
+
+
+class NoMatch(ValueError):
+    def __init__(self, data: str, index: int, expected: List[str]):
+        self.data = data
+        self.index = index
+        self.expected = expected
+        super(NoMatch, self).__init__(f"Can not match at index {index}. Got {data[index:index + 5]!r},"
+                                      f" expected any of {expected}.\n"
+                                      f"Context(data[-10:+10]): {data[index - 10: index + 10]!r}")
+
+
+T = TypeVar('T')
+
+
+def _wrap_reset(m):
+    @wraps(m)
+    def w(self, *args, **kwargs):
+        p = self.index
+        try:
+            return m(self, *args, **kwargs)
+        except nomatch:
+            self.index = p
+            raise
+
+    return w
+
+
+class SimpleParser(Generic[T], ABC):
+    def __init__(self, data: str):
+        self.data = data
+        self.index = 0
+        self._expected = defaultdict(list)
+
+    def __init_subclass__(cls, **kwargs):
+        for n, v in cls.__dict__.items():
+            if isinstance(v, FunctionType) and not n.startswith('_'):
+                setattr(cls, n, _wrap_reset(v))
+
+    def parse(self) -> T:
+        try:
+            result = self.start()
+        except nomatch:
+            raise NoMatch(self.data, max(self._expected), self._expected[max(self._expected)]) from None
+        if self.index < len(self.data):
+            raise NoMatch(self.data, max(self._expected), self._expected[max(self._expected)])
+        return result
+
+    @abstractmethod
+    def start(self) -> T:
+        raise NotImplementedError
+
+    def peek_static(self, expected: str) -> bool:
+        l = len(expected)
+        if self.data[self.index:self.index + l] == expected:
+            return True
+        else:
+            self._expected[self.index].append(expected)
+            return False
+
+    def static(self, expected: str):
+        length = len(expected)
+        if self.data[self.index:self.index + length] == expected:
+            self.index += length
+        else:
+            self._expected[self.index].append(expected)
+            raise nomatch
+
+    def static_b(self, expected: str) -> bool:
+        l = len(expected)
+        if self.data[self.index:self.index + l] == expected:
+            self.index += l
+            return True
+        else:
+            self._expected[self.index].append(expected)
+            return False
+
+    def anyof(self, *strings: str) -> str:
+        for s in strings:
+            if self.static_b(s):
+                return s
+        else:
+            raise nomatch
+
+    def anyof_b(self, *strings: str) -> bool:
+        for s in strings:
+            if self.static_b(s):
+                return True
+        else:
+            return False
+
+    def any(self, length: int = 1) -> str:
+        if self.index + length <= len(self.data):
+            res = self.data[self.index:self.index + length]
+            self.index += length
+            return res
+        else:
+            self._expected[self.index].append(f"<Any {length}>")
+            raise nomatch
+
+    def any_but(self, *strings, length: int = 1) -> str:
+        if self.index + length <= len(self.data):
+            res = self.data[self.index:self.index + length]
+            if res not in strings:
+                self.index += length
+                return res
+            else:
+                self._expected[self.index].append(f"<Any {length} except {strings}>")
+                raise nomatch
+        else:
+            self._expected[self.index].append(f"<Any {length} except {strings}>")
+            raise nomatch
+
+    def multiple(self, chars: str, mi: int, ma: Optional[int]) -> str:
+        result = []
+        try:
+            for off in range(mi):
+                if self.data[self.index + off] in chars:
+                    result.append(self.data[self.index + off])
+                else:
+                    self._expected[self.index + off].extend(chars)
+                    raise nomatch
+        except IndexError:
+            raise nomatch
+        self.index += mi
+        if ma is None:
+            try:
+                while True:
+                    if self.data[self.index] in chars:
+                        result.append(self.data[self.index])
+                        self.index += 1
+                    else:
+                        self._expected[self.index].extend(chars)
+                        break
+            except IndexError:
+                pass
+        else:
+            try:
+                for _ in range(ma - mi):
+                    if self.data[self.index] in chars:
+                        result.append(self.data[self.index])
+                        self.index += 1
+                    else:
+                        self._expected[self.index].extend(chars)
+                        break
+            except IndexError:
+                pass
+        return ''.join(result)

tool_server/.venv/lib/python3.12/site-packages/llguidance-0.7.30.dist-info/licenses/LICENSE

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

tool_server/.venv/lib/python3.12/site-packages/llvmlite/binding/__init__.py

@@ -0,0 +1,19 @@
+"""
+Things that rely on the LLVM library
+"""
+from .dylib import *
+from .executionengine import *
+from .initfini import *
+from .linker import *
+from .module import *
+from .options import *
+from .newpassmanagers import *
+from .passmanagers import *
+from .targets import *
+from .transforms import *
+from .value import *
+from .typeref import *
+from .analysis import *
+from .object_file import *
+from .context import *
+from .orcjit import *

tool_server/.venv/lib/python3.12/site-packages/llvmlite/binding/analysis.py

@@ -0,0 +1,69 @@
+"""
+A collection of analysis utilities
+"""
+
+from ctypes import POINTER, c_char_p, c_int
+
+from llvmlite.binding import ffi
+from llvmlite.binding.module import parse_assembly
+
+
+def get_function_cfg(func, show_inst=True):
+    """Return a string of the control-flow graph of the function in DOT
+    format. If the input `func` is not a materialized function, the module
+    containing the function is parsed to create an actual LLVM module.
+    The `show_inst` flag controls whether the instructions of each block
+    are printed.
+    """
+    assert func is not None
+    from llvmlite import ir
+    if isinstance(func, ir.Function):
+        mod = parse_assembly(str(func.module))
+        func = mod.get_function(func.name)
+
+    # Assume func is a materialized function
+    with ffi.OutputString() as dotstr:
+        ffi.lib.LLVMPY_WriteCFG(func, dotstr, show_inst)
+        return str(dotstr)
+
+
+def view_dot_graph(graph, filename=None, view=False):
+    """
+    View the given DOT source.  If view is True, the image is rendered
+    and viewed by the default application in the system.  The file path of
+    the output is returned.  If view is False, a graphviz.Source object is
+    returned.  If view is False and the environment is in a IPython session,
+    an IPython image object is returned and can be displayed inline in the
+    notebook.
+
+    This function requires the graphviz package.
+
+    Args
+    ----
+    - graph [str]: a DOT source code
+    - filename [str]: optional.  if given and view is True, this specifies
+                      the file path for the rendered output to write to.
+    - view [bool]: if True, opens the rendered output file.
+
+    """
+    # Optionally depends on graphviz package
+    import graphviz as gv
+
+    src = gv.Source(graph)
+    if view:
+        # Returns the output file path
+        return src.render(filename, view=view)
+    else:
+        # Attempts to show the graph in IPython notebook
+        try:
+            __IPYTHON__
+        except NameError:
+            return src
+        else:
+            import IPython.display as display
+            format = 'svg'
+            return display.SVG(data=src.pipe(format))
+
+
+# Ctypes binding
+ffi.lib.LLVMPY_WriteCFG.argtypes = [ffi.LLVMValueRef, POINTER(c_char_p), c_int]

tool_server/.venv/lib/python3.12/site-packages/llvmlite/binding/common.py

@@ -0,0 +1,34 @@
+import atexit
+
+
+def _encode_string(s):
+    encoded = s.encode('utf-8')
+    return encoded
+
+
+def _decode_string(b):
+    return b.decode('utf-8')
+
+
+_encode_string.__doc__ = """Encode a string for use by LLVM."""
+_decode_string.__doc__ = """Decode a LLVM character (byte)string."""
+
+
+_shutting_down = [False]
+
+
+def _at_shutdown():
+    _shutting_down[0] = True
+
+
+atexit.register(_at_shutdown)
+
+
+def _is_shutting_down(_shutting_down=_shutting_down):
+    """
+    Whether the interpreter is currently shutting down.
+    For use in finalizers, __del__ methods, and similar; it is advised
+    to early bind this function rather than look it up when calling it,
+    since at shutdown module globals may be cleared.
+    """
+    return _shutting_down[0]

tool_server/.venv/lib/python3.12/site-packages/llvmlite/binding/context.py

@@ -0,0 +1,39 @@
+from llvmlite.binding import ffi
+
+# FIXME: Remove me once typed pointers are no longer supported.
+from llvmlite import opaque_pointers_enabled
+from ctypes import c_bool
+
+
+def create_context():
+    return ContextRef(
+        ffi.lib.LLVMPY_ContextCreate(opaque_pointers_enabled))
+
+
+def get_global_context():
+    return GlobalContextRef(
+        ffi.lib.LLVMPY_GetGlobalContext(opaque_pointers_enabled))
+
+
+class ContextRef(ffi.ObjectRef):
+    def __init__(self, context_ptr):
+        super(ContextRef, self).__init__(context_ptr)
+
+    def _dispose(self):
+        ffi.lib.LLVMPY_ContextDispose(self)
+
+
+class GlobalContextRef(ContextRef):
+    def _dispose(self):
+        pass
+
+
+# FIXME: Remove argtypes once typed pointers are no longer supported.
+ffi.lib.LLVMPY_GetGlobalContext.argtypes = [c_bool]
+ffi.lib.LLVMPY_GetGlobalContext.restype = ffi.LLVMContextRef
+
+# FIXME: Remove argtypes once typed pointers are no longer supported.
+ffi.lib.LLVMPY_ContextCreate.argtypes = [c_bool]
+ffi.lib.LLVMPY_ContextCreate.restype = ffi.LLVMContextRef
+
+ffi.lib.LLVMPY_ContextDispose.argtypes = [ffi.LLVMContextRef]

tool_server/.venv/lib/python3.12/site-packages/llvmlite/binding/dylib.py

@@ -0,0 +1,45 @@
+from ctypes import c_void_p, c_char_p, c_bool, POINTER
+
+from llvmlite.binding import ffi
+from llvmlite.binding.common import _encode_string
+
+
+def address_of_symbol(name):
+    """
+    Get the in-process address of symbol named *name*.
+    An integer is returned, or None if the symbol isn't found.
+    """
+    return ffi.lib.LLVMPY_SearchAddressOfSymbol(_encode_string(name))
+
+
+def add_symbol(name, address):
+    """
+    Register the *address* of global symbol *name*.  This will make
+    it usable (e.g. callable) from LLVM-compiled functions.
+    """
+    ffi.lib.LLVMPY_AddSymbol(_encode_string(name), c_void_p(address))
+
+
+def load_library_permanently(filename):
+    """
+    Load an external library
+    """
+    with ffi.OutputString() as outerr:
+        if ffi.lib.LLVMPY_LoadLibraryPermanently(
+                _encode_string(filename), outerr):
+            raise RuntimeError(str(outerr))
+
+# ============================================================================
+# FFI
+
+
+ffi.lib.LLVMPY_AddSymbol.argtypes = [
+    c_char_p,
+    c_void_p,
+]
+
+ffi.lib.LLVMPY_SearchAddressOfSymbol.argtypes = [c_char_p]
+ffi.lib.LLVMPY_SearchAddressOfSymbol.restype = c_void_p
+
+ffi.lib.LLVMPY_LoadLibraryPermanently.argtypes = [c_char_p, POINTER(c_char_p)]
+ffi.lib.LLVMPY_LoadLibraryPermanently.restype = c_bool