diff --git a/.gitattributes b/.gitattributes
index 44545769e68860d8b37f4fb86325e339a5717c43..2c533e5251da1a0f6f1ecc1387b342130a9d4c98 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -200,3 +200,5 @@ llmeval-env/lib/python3.10/site-packages/pandas/_libs/hashtable.cpython-310-x86_
 llmeval-env/lib/python3.10/site-packages/nvidia/cublas/lib/libcublasLt.so.12 filter=lfs diff=lfs merge=lfs -text
 llmeval-env/lib/python3.10/site-packages/safetensors/_safetensors_rust.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 llmeval-env/lib/python3.10/site-packages/nvidia/cudnn/lib/libcudnn_cnn_infer.so.8 filter=lfs diff=lfs merge=lfs -text
+env-llmeval/lib/python3.10/site-packages/torch/bin/protoc filter=lfs diff=lfs merge=lfs -text
+env-llmeval/lib/python3.10/site-packages/torch/bin/protoc-3.13.0.0 filter=lfs diff=lfs merge=lfs -text
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/bin/protoc b/env-llmeval/lib/python3.10/site-packages/torch/bin/protoc
new file mode 100644
index 0000000000000000000000000000000000000000..f23bc1bcd86573d07a8fbaa6de1c47d2aac93d83
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/bin/protoc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3390873b2da56c1397adec3728f1588c51e182f15b123d3b4d4f248d31c1f4da
+size 5330888
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/bin/protoc-3.13.0.0 b/env-llmeval/lib/python3.10/site-packages/torch/bin/protoc-3.13.0.0
new file mode 100644
index 0000000000000000000000000000000000000000..f23bc1bcd86573d07a8fbaa6de1c47d2aac93d83
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/bin/protoc-3.13.0.0
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3390873b2da56c1397adec3728f1588c51e182f15b123d3b4d4f248d31c1f4da
+size 5330888
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__init__.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6eb6bb444dff6399dee5a56e28070ad4428a0edc
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__init__.py
@@ -0,0 +1,33 @@
+from ._infra import (
+    DiagnosticOptions,
+    Graph,
+    Invocation,
+    Level,
+    levels,
+    Location,
+    Rule,
+    RuleCollection,
+    Stack,
+    StackFrame,
+    Tag,
+    ThreadFlowLocation,
+)
+from .context import Diagnostic, DiagnosticContext, RuntimeErrorWithDiagnostic
+
+__all__ = [
+    "Diagnostic",
+    "DiagnosticContext",
+    "DiagnosticOptions",
+    "Graph",
+    "Invocation",
+    "Level",
+    "levels",
+    "Location",
+    "Rule",
+    "RuleCollection",
+    "RuntimeErrorWithDiagnostic",
+    "Stack",
+    "StackFrame",
+    "Tag",
+    "ThreadFlowLocation",
+]
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__pycache__/__init__.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c512c03a5ef672dee4362192542dbdfef66ca310
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__pycache__/__init__.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__pycache__/_infra.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__pycache__/_infra.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c0a40ab2f4b1304d9e155bb52612b03886b91f20
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__pycache__/_infra.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__pycache__/context.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__pycache__/context.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3dda5d63e6d61817d965cc78d9fd5ed2143254a2
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__pycache__/context.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__pycache__/decorator.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__pycache__/decorator.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0b5a447b4ffdfef005ac7564e1ad4a0fe435323a
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__pycache__/decorator.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__pycache__/formatter.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__pycache__/formatter.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1dbae6797a337af97ac3a4870a61cbf16665dbad
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__pycache__/formatter.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__pycache__/utils.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__pycache__/utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7a106eebde2750e425768cc4e544d21fc4c0f096
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/__pycache__/utils.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/_infra.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/_infra.py
new file mode 100644
index 0000000000000000000000000000000000000000..325cdc44ac7257cb7915db084295ae645e6c1eec
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/_infra.py
@@ -0,0 +1,284 @@
+"""This file defines an additional layer of abstraction on top of the SARIF OM."""
+
+from __future__ import annotations
+
+import dataclasses
+import enum
+import logging
+from typing import FrozenSet, List, Mapping, Optional, Sequence, Tuple
+
+from torch.onnx._internal.diagnostics.infra import formatter, sarif
+
+
+class Level(enum.IntEnum):
+    """The level of a diagnostic.
+
+    This class is used to represent the level of a diagnostic. The levels are defined
+    by the SARIF specification, and are not modifiable. For alternative categories,
+    please use infra.Tag instead. When selecting a level, please consider the following
+    guidelines:
+
+    - NONE: Informational result that does not indicate the presence of a problem.
+    - NOTE: An opportunity for improvement was found.
+    - WARNING: A potential problem was found.
+    - ERROR: A serious problem was found.
+
+    This level is a subclass of enum.IntEnum, and can be used as an integer. Its integer
+    value maps to the logging levels in Python's logging module. The mapping is as
+    follows:
+
+        Level.NONE = logging.DEBUG = 10
+        Level.NOTE = logging.INFO = 20
+        Level.WARNING = logging.WARNING = 30
+        Level.ERROR = logging.ERROR = 40
+    """
+
+    NONE = 10
+    NOTE = 20
+    WARNING = 30
+    ERROR = 40
+
+
+levels = Level
+
+
+class Tag(enum.Enum):
+    """The tag of a diagnostic. This class can be inherited to define custom tags."""
+
+
+class PatchedPropertyBag(sarif.PropertyBag):
+    """Key/value pairs that provide additional information about the object.
+
+    The definition of PropertyBag via SARIF spec is "A property bag is an object (§3.6)
+    containing an unordered set of properties with arbitrary names." However it is not
+    reflected in the json file, and therefore not captured by the python representation.
+    This patch adds additional **kwargs to the `__init__` method to allow recording
+    arbitrary key/value pairs.
+    """
+
+    def __init__(self, tags: Optional[List[str]] = None, **kwargs):
+        super().__init__(tags=tags)
+        self.__dict__.update(kwargs)
+
+
+@dataclasses.dataclass(frozen=True)
+class Rule:
+    id: str
+    name: str
+    message_default_template: str
+    short_description: Optional[str] = None
+    full_description: Optional[str] = None
+    full_description_markdown: Optional[str] = None
+    help_uri: Optional[str] = None
+
+    @classmethod
+    def from_sarif(cls, **kwargs):
+        """Returns a rule from the SARIF reporting descriptor."""
+        short_description = kwargs.get("short_description", {}).get("text")
+        full_description = kwargs.get("full_description", {}).get("text")
+        full_description_markdown = kwargs.get("full_description", {}).get("markdown")
+        help_uri = kwargs.get("help_uri")
+
+        rule = cls(
+            id=kwargs["id"],
+            name=kwargs["name"],
+            message_default_template=kwargs["message_strings"]["default"]["text"],
+            short_description=short_description,
+            full_description=full_description,
+            full_description_markdown=full_description_markdown,
+            help_uri=help_uri,
+        )
+        return rule
+
+    def sarif(self) -> sarif.ReportingDescriptor:
+        """Returns a SARIF reporting descriptor of this Rule."""
+        short_description = (
+            sarif.MultiformatMessageString(text=self.short_description)
+            if self.short_description is not None
+            else None
+        )
+        full_description = (
+            sarif.MultiformatMessageString(
+                text=self.full_description, markdown=self.full_description_markdown
+            )
+            if self.full_description is not None
+            else None
+        )
+        return sarif.ReportingDescriptor(
+            id=self.id,
+            name=self.name,
+            short_description=short_description,
+            full_description=full_description,
+            help_uri=self.help_uri,
+        )
+
+    def format(self, level: Level, *args, **kwargs) -> Tuple[Rule, Level, str]:
+        """Returns a tuple of (rule, level, message) for a diagnostic.
+
+        This method is used to format the message of a diagnostic. The message is
+        formatted using the default template of this rule, and the arguments passed in
+        as `*args` and `**kwargs`. The level is used to override the default level of
+        this rule.
+        """
+        return (self, level, self.format_message(*args, **kwargs))
+
+    def format_message(self, *args, **kwargs) -> str:
+        """Returns the formatted default message of this Rule.
+
+        This method should be overridden (with code generation) by subclasses to reflect
+        the exact arguments needed by the message template. This is a helper method to
+        create the default message for a diagnostic.
+        """
+        return self.message_default_template.format(*args, **kwargs)
+
+
+@dataclasses.dataclass
+class Location:
+    uri: Optional[str] = None
+    line: Optional[int] = None
+    message: Optional[str] = None
+    start_column: Optional[int] = None
+    end_column: Optional[int] = None
+    snippet: Optional[str] = None
+    function: Optional[str] = None
+
+    def sarif(self) -> sarif.Location:
+        """Returns the SARIF representation of this location."""
+        return sarif.Location(
+            physical_location=sarif.PhysicalLocation(
+                artifact_location=sarif.ArtifactLocation(uri=self.uri),
+                region=sarif.Region(
+                    start_line=self.line,
+                    start_column=self.start_column,
+                    end_column=self.end_column,
+                    snippet=sarif.ArtifactContent(text=self.snippet),
+                ),
+            ),
+            message=sarif.Message(text=self.message)
+            if self.message is not None
+            else None,
+        )
+
+
+@dataclasses.dataclass
+class StackFrame:
+    location: Location
+
+    def sarif(self) -> sarif.StackFrame:
+        """Returns the SARIF representation of this stack frame."""
+        return sarif.StackFrame(location=self.location.sarif())
+
+
+@dataclasses.dataclass
+class Stack:
+    """Records a stack trace. The frames are in order from newest to oldest stack frame."""
+
+    frames: List[StackFrame] = dataclasses.field(default_factory=list)
+    message: Optional[str] = None
+
+    def sarif(self) -> sarif.Stack:
+        """Returns the SARIF representation of this stack."""
+        return sarif.Stack(
+            frames=[frame.sarif() for frame in self.frames],
+            message=sarif.Message(text=self.message)
+            if self.message is not None
+            else None,
+        )
+
+
+@dataclasses.dataclass
+class ThreadFlowLocation:
+    """Records code location and the initial state."""
+
+    location: Location
+    state: Mapping[str, str]
+    index: int
+    stack: Optional[Stack] = None
+
+    def sarif(self) -> sarif.ThreadFlowLocation:
+        """Returns the SARIF representation of this thread flow location."""
+        return sarif.ThreadFlowLocation(
+            location=self.location.sarif(),
+            state=self.state,
+            stack=self.stack.sarif() if self.stack is not None else None,
+        )
+
+
+@dataclasses.dataclass
+class Graph:
+    """A graph of diagnostics.
+
+    This class stores the string representation of a model graph.
+    The `nodes` and `edges` fields are unused in the current implementation.
+    """
+
+    graph: str
+    name: str
+    description: Optional[str] = None
+
+    def sarif(self) -> sarif.Graph:
+        """Returns the SARIF representation of this graph."""
+        return sarif.Graph(
+            description=sarif.Message(text=self.graph),
+            properties=PatchedPropertyBag(name=self.name, description=self.description),
+        )
+
+
+@dataclasses.dataclass
+class RuleCollection:
+    _rule_id_name_set: FrozenSet[Tuple[str, str]] = dataclasses.field(init=False)
+
+    def __post_init__(self) -> None:
+        self._rule_id_name_set = frozenset(
+            {
+                (field.default.id, field.default.name)
+                for field in dataclasses.fields(self)
+                if isinstance(field.default, Rule)
+            }
+        )
+
+    def __contains__(self, rule: Rule) -> bool:
+        """Checks if the rule is in the collection."""
+        return (rule.id, rule.name) in self._rule_id_name_set
+
+    @classmethod
+    def custom_collection_from_list(
+        cls, new_collection_class_name: str, rules: Sequence[Rule]
+    ) -> RuleCollection:
+        """Creates a custom class inherited from RuleCollection with the list of rules."""
+        return dataclasses.make_dataclass(
+            new_collection_class_name,
+            [
+                (
+                    formatter.kebab_case_to_snake_case(rule.name),
+                    type(rule),
+                    dataclasses.field(default=rule),
+                )
+                for rule in rules
+            ],
+            bases=(cls,),
+        )()
+
+
+class Invocation:
+    # TODO: Implement this.
+    # Tracks top level call arguments and diagnostic options.
+    def __init__(self) -> None:
+        raise NotImplementedError()
+
+
+@dataclasses.dataclass
+class DiagnosticOptions:
+    """Options for diagnostic context.
+
+    Attributes:
+        verbosity_level: Set the amount of information logged for each diagnostics,
+            equivalent to the 'level' in Python logging module.
+        warnings_as_errors: When True, warning diagnostics are treated as error diagnostics.
+    """
+
+    verbosity_level: int = dataclasses.field(default=logging.INFO)
+    """Set the amount of information logged for each diagnostics, equivalent to the 'level' in Python logging module."""
+
+    warnings_as_errors: bool = dataclasses.field(default=False)
+    """If True, warning diagnostics are treated as error diagnostics."""
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/context.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/context.py
new file mode 100644
index 0000000000000000000000000000000000000000..22370850df86a3a48e79915e199e9c008ceb5a93
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/context.py
@@ -0,0 +1,415 @@
+"""A diagnostic context based on SARIF."""
+
+from __future__ import annotations
+
+import contextlib
+
+import dataclasses
+import gzip
+
+import logging
+
+from typing import (
+    Callable,
+    Generator,
+    Generic,
+    List,
+    Literal,
+    Mapping,
+    Optional,
+    Type,
+    TypeVar,
+)
+
+from torch.onnx._internal.diagnostics import infra
+from torch.onnx._internal.diagnostics.infra import formatter, sarif, utils
+from torch.onnx._internal.diagnostics.infra.sarif import version as sarif_version
+
+
+# This is a workaround for mypy not supporting Self from typing_extensions.
+_Diagnostic = TypeVar("_Diagnostic", bound="Diagnostic")
+diagnostic_logger: logging.Logger = logging.getLogger(__name__)
+
+
+@dataclasses.dataclass
+class Diagnostic:
+    rule: infra.Rule
+    level: infra.Level
+    message: Optional[str] = None
+    locations: List[infra.Location] = dataclasses.field(default_factory=list)
+    stacks: List[infra.Stack] = dataclasses.field(default_factory=list)
+    graphs: List[infra.Graph] = dataclasses.field(default_factory=list)
+    thread_flow_locations: List[infra.ThreadFlowLocation] = dataclasses.field(
+        default_factory=list
+    )
+    additional_messages: List[str] = dataclasses.field(default_factory=list)
+    tags: List[infra.Tag] = dataclasses.field(default_factory=list)
+    source_exception: Optional[Exception] = None
+    """The exception that caused this diagnostic to be created."""
+    logger: logging.Logger = dataclasses.field(init=False, default=diagnostic_logger)
+    """The logger for this diagnostic. Defaults to 'diagnostic_logger' which has the same
+    log level setting with `DiagnosticOptions.verbosity_level`."""
+    _current_log_section_depth: int = 0
+
+    def __post_init__(self) -> None:
+        pass
+
+    def sarif(self) -> sarif.Result:
+        """Returns the SARIF Result representation of this diagnostic."""
+        message = self.message or self.rule.message_default_template
+        if self.additional_messages:
+            additional_message = "\n".join(self.additional_messages)
+            message_markdown = (
+                f"{message}\n\n## Additional Message:\n\n{additional_message}"
+            )
+        else:
+            message_markdown = message
+
+        kind: Literal["informational", "fail"] = (
+            "informational" if self.level == infra.Level.NONE else "fail"
+        )
+
+        sarif_result = sarif.Result(
+            message=sarif.Message(text=message, markdown=message_markdown),
+            level=self.level.name.lower(),  # type: ignore[arg-type]
+            rule_id=self.rule.id,
+            kind=kind,
+        )
+        sarif_result.locations = [location.sarif() for location in self.locations]
+        sarif_result.stacks = [stack.sarif() for stack in self.stacks]
+        sarif_result.graphs = [graph.sarif() for graph in self.graphs]
+        sarif_result.code_flows = [
+            sarif.CodeFlow(
+                thread_flows=[
+                    sarif.ThreadFlow(
+                        locations=[loc.sarif() for loc in self.thread_flow_locations]
+                    )
+                ]
+            )
+        ]
+        sarif_result.properties = sarif.PropertyBag(
+            tags=[tag.value for tag in self.tags]
+        )
+        return sarif_result
+
+    def with_location(self: _Diagnostic, location: infra.Location) -> _Diagnostic:
+        """Adds a location to the diagnostic."""
+        self.locations.append(location)
+        return self
+
+    def with_thread_flow_location(
+        self: _Diagnostic, location: infra.ThreadFlowLocation
+    ) -> _Diagnostic:
+        """Adds a thread flow location to the diagnostic."""
+        self.thread_flow_locations.append(location)
+        return self
+
+    def with_stack(self: _Diagnostic, stack: infra.Stack) -> _Diagnostic:
+        """Adds a stack to the diagnostic."""
+        self.stacks.append(stack)
+        return self
+
+    def with_graph(self: _Diagnostic, graph: infra.Graph) -> _Diagnostic:
+        """Adds a graph to the diagnostic."""
+        self.graphs.append(graph)
+        return self
+
+    @contextlib.contextmanager
+    def log_section(
+        self, level: int, message: str, *args, **kwargs
+    ) -> Generator[None, None, None]:
+        """
+        Context manager for a section of log messages, denoted by a title message and increased indentation.
+
+        Same api as `logging.Logger.log`.
+
+        This context manager logs the given title at the specified log level, increases the current
+        section depth for subsequent log messages, and ensures that the section depth is decreased
+        again when exiting the context.
+
+        Args:
+            level: The log level.
+            message: The title message to log.
+            *args: The arguments to the message. Use `LazyString` to defer the
+                expensive evaluation of the arguments until the message is actually logged.
+            **kwargs: The keyword arguments for `logging.Logger.log`.
+
+        Yields:
+            None: This context manager does not yield any value.
+
+        Example:
+            >>> with DiagnosticContext("DummyContext", "1.0"):
+            ...     rule = infra.Rule("RuleID", "DummyRule", "Rule message")
+            ...     diagnostic = Diagnostic(rule, infra.Level.WARNING)
+            ...     with diagnostic.log_section(logging.INFO, "My Section"):
+            ...         diagnostic.log(logging.INFO, "My Message")
+            ...         with diagnostic.log_section(logging.INFO, "My Subsection"):
+            ...             diagnostic.log(logging.INFO, "My Submessage")
+            ...     diagnostic.additional_messages
+            ['## My Section', 'My Message', '### My Subsection', 'My Submessage']
+        """
+        if self.logger.isEnabledFor(level):
+            indented_format_message = (
+                f"##{'#' * self._current_log_section_depth } {message}"
+            )
+            self.log(
+                level,
+                indented_format_message,
+                *args,
+                **kwargs,
+            )
+        self._current_log_section_depth += 1
+        try:
+            yield
+        finally:
+            self._current_log_section_depth -= 1
+
+    def log(self, level: int, message: str, *args, **kwargs) -> None:
+        """Logs a message within the diagnostic. Same api as `logging.Logger.log`.
+
+        If logger is not enabled for the given level, the message will not be logged.
+        Otherwise, the message will be logged and also added to the diagnostic's additional_messages.
+
+        The default setting for `DiagnosticOptions.verbosity_level` is `logging.INFO`. Based on this default,
+        the log level recommendations are as follows. If you've set a different default verbosity level in your
+        application, please adjust accordingly:
+
+        - logging.ERROR: Log any events leading to application failure.
+        - logging.WARNING: Log events that might result in application issues or failures, although not guaranteed.
+        - logging.INFO: Log general useful information, ensuring minimal performance overhead.
+        - logging.DEBUG: Log detailed debug information, which might affect performance when logged.
+
+        Args:
+            level: The log level.
+            message: The message to log.
+            *args: The arguments to the message. Use `LazyString` to defer the
+                expensive evaluation of the arguments until the message is actually logged.
+            **kwargs: The keyword arguments for `logging.Logger.log`.
+        """
+        if self.logger.isEnabledFor(level):
+            formatted_message = message % args
+            self.logger.log(level, formatted_message, **kwargs)
+            self.additional_messages.append(formatted_message)
+
+    def debug(self, message: str, *args, **kwargs) -> None:
+        """Logs a debug message within the diagnostic. Same api as logging.Logger.debug.
+
+        Checkout `log` for more details.
+        """
+        self.log(logging.DEBUG, message, *args, **kwargs)
+
+    def info(self, message: str, *args, **kwargs) -> None:
+        """Logs an info message within the diagnostic. Same api as logging.Logger.info.
+
+        Checkout `log` for more details.
+        """
+        self.log(logging.INFO, message, *args, **kwargs)
+
+    def warning(self, message: str, *args, **kwargs) -> None:
+        """Logs a warning message within the diagnostic. Same api as logging.Logger.warning.
+
+        Checkout `log` for more details.
+        """
+        self.log(logging.WARNING, message, *args, **kwargs)
+
+    def error(self, message: str, *args, **kwargs) -> None:
+        """Logs an error message within the diagnostic. Same api as logging.Logger.error.
+
+        Checkout `log` for more details.
+        """
+        self.log(logging.ERROR, message, *args, **kwargs)
+
+    def log_source_exception(self, level: int, exception: Exception) -> None:
+        """Logs a source exception within the diagnostic.
+
+        Invokes `log_section` and `log` to log the exception in markdown section format.
+        """
+        self.source_exception = exception
+        with self.log_section(level, "Exception log"):
+            self.log(level, "%s", formatter.lazy_format_exception(exception))
+
+    def record_python_call_stack(self, frames_to_skip: int) -> infra.Stack:
+        """Records the current Python call stack."""
+        frames_to_skip += 1  # Skip this function.
+        stack = utils.python_call_stack(frames_to_skip=frames_to_skip)
+        self.with_stack(stack)
+        if len(stack.frames) > 0:
+            self.with_location(stack.frames[0].location)
+        return stack
+
+    def record_python_call(
+        self,
+        fn: Callable,
+        state: Mapping[str, str],
+        message: Optional[str] = None,
+        frames_to_skip: int = 0,
+    ) -> infra.ThreadFlowLocation:
+        """Records a python call as one thread flow step."""
+        frames_to_skip += 1  # Skip this function.
+        stack = utils.python_call_stack(frames_to_skip=frames_to_skip, frames_to_log=5)
+        location = utils.function_location(fn)
+        location.message = message
+        # Add function location to the top of the stack.
+        stack.frames.insert(0, infra.StackFrame(location=location))
+        thread_flow_location = infra.ThreadFlowLocation(
+            location=location,
+            state=state,
+            index=len(self.thread_flow_locations),
+            stack=stack,
+        )
+        self.with_thread_flow_location(thread_flow_location)
+        return thread_flow_location
+
+
+class RuntimeErrorWithDiagnostic(RuntimeError):
+    """Runtime error with enclosed diagnostic information."""
+
+    def __init__(self, diagnostic: Diagnostic):
+        super().__init__(diagnostic.message)
+        self.diagnostic = diagnostic
+
+
+@dataclasses.dataclass
+class DiagnosticContext(Generic[_Diagnostic]):
+    name: str
+    version: str
+    options: infra.DiagnosticOptions = dataclasses.field(
+        default_factory=infra.DiagnosticOptions
+    )
+    diagnostics: List[_Diagnostic] = dataclasses.field(init=False, default_factory=list)
+    # TODO(bowbao): Implement this.
+    # _invocation: infra.Invocation = dataclasses.field(init=False)
+    _inflight_diagnostics: List[_Diagnostic] = dataclasses.field(
+        init=False, default_factory=list
+    )
+    _previous_log_level: int = dataclasses.field(init=False, default=logging.WARNING)
+    logger: logging.Logger = dataclasses.field(init=False, default=diagnostic_logger)
+    _bound_diagnostic_type: Type = dataclasses.field(init=False, default=Diagnostic)
+
+    def __enter__(self):
+        self._previous_log_level = self.logger.level
+        self.logger.setLevel(self.options.verbosity_level)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.logger.setLevel(self._previous_log_level)
+        return None
+
+    def sarif(self) -> sarif.Run:
+        """Returns the SARIF Run object."""
+        unique_rules = {diagnostic.rule for diagnostic in self.diagnostics}
+        return sarif.Run(
+            sarif.Tool(
+                driver=sarif.ToolComponent(
+                    name=self.name,
+                    version=self.version,
+                    rules=[rule.sarif() for rule in unique_rules],
+                )
+            ),
+            results=[diagnostic.sarif() for diagnostic in self.diagnostics],
+        )
+
+    def sarif_log(self) -> sarif.SarifLog:  # type: ignore[name-defined]
+        """Returns the SARIF Log object."""
+        return sarif.SarifLog(
+            version=sarif_version.SARIF_VERSION,
+            schema_uri=sarif_version.SARIF_SCHEMA_LINK,
+            runs=[self.sarif()],
+        )
+
+    def to_json(self) -> str:
+        return formatter.sarif_to_json(self.sarif_log())
+
+    def dump(self, file_path: str, compress: bool = False) -> None:
+        """Dumps the SARIF log to a file."""
+        if compress:
+            with gzip.open(file_path, "wt") as f:
+                f.write(self.to_json())
+        else:
+            with open(file_path, "w") as f:
+                f.write(self.to_json())
+
+    def log(self, diagnostic: _Diagnostic) -> None:
+        """Logs a diagnostic.
+
+        This method should be used only after all the necessary information for the diagnostic
+        has been collected.
+
+        Args:
+            diagnostic: The diagnostic to add.
+        """
+        if not isinstance(diagnostic, self._bound_diagnostic_type):
+            raise TypeError(
+                f"Expected diagnostic of type {self._bound_diagnostic_type}, got {type(diagnostic)}"
+            )
+        if self.options.warnings_as_errors and diagnostic.level == infra.Level.WARNING:
+            diagnostic.level = infra.Level.ERROR
+        self.diagnostics.append(diagnostic)
+
+    def log_and_raise_if_error(self, diagnostic: _Diagnostic) -> None:
+        """Logs a diagnostic and raises an exception if it is an error.
+
+        Use this method for logging non inflight diagnostics where diagnostic level is not known or
+        lower than ERROR. If it is always expected raise, use `log` and explicit
+        `raise` instead. Otherwise there is no way to convey the message that it always
+        raises to Python intellisense and type checking tools.
+
+        This method should be used only after all the necessary information for the diagnostic
+        has been collected.
+
+        Args:
+            diagnostic: The diagnostic to add.
+        """
+        self.log(diagnostic)
+        if diagnostic.level == infra.Level.ERROR:
+            if diagnostic.source_exception is not None:
+                raise diagnostic.source_exception
+            raise RuntimeErrorWithDiagnostic(diagnostic)
+
+    @contextlib.contextmanager
+    def add_inflight_diagnostic(
+        self, diagnostic: _Diagnostic
+    ) -> Generator[_Diagnostic, None, None]:
+        """Adds a diagnostic to the context.
+
+        Use this method to add diagnostics that are not created by the context.
+        Args:
+            diagnostic: The diagnostic to add.
+        """
+        self._inflight_diagnostics.append(diagnostic)
+        try:
+            yield diagnostic
+        finally:
+            self._inflight_diagnostics.pop()
+
+    def push_inflight_diagnostic(self, diagnostic: _Diagnostic) -> None:
+        """Pushes a diagnostic to the inflight diagnostics stack.
+
+        Args:
+            diagnostic: The diagnostic to push.
+
+        Raises:
+            ValueError: If the rule is not supported by the tool.
+        """
+        self._inflight_diagnostics.append(diagnostic)
+
+    def pop_inflight_diagnostic(self) -> _Diagnostic:
+        """Pops the last diagnostic from the inflight diagnostics stack.
+
+        Returns:
+            The popped diagnostic.
+        """
+        return self._inflight_diagnostics.pop()
+
+    def inflight_diagnostic(self, rule: Optional[infra.Rule] = None) -> _Diagnostic:
+        if rule is None:
+            # TODO(bowbao): Create builtin-rules and create diagnostic using that.
+            if len(self._inflight_diagnostics) <= 0:
+                raise AssertionError("No inflight diagnostics")
+
+            return self._inflight_diagnostics[-1]
+        else:
+            for diagnostic in reversed(self._inflight_diagnostics):
+                if diagnostic.rule == rule:
+                    return diagnostic
+            raise AssertionError(f"No inflight diagnostic for rule {rule.name}")
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/decorator.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/decorator.py
new file mode 100644
index 0000000000000000000000000000000000000000..0ac803815703e258201d78417e9faeb3a1efc02d
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/decorator.py
@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import functools
+import logging
+import traceback
+from typing import Any, Callable, Dict, Optional, Tuple, Type
+
+from torch.onnx._internal import _beartype
+from torch.onnx._internal.diagnostics import infra
+from torch.onnx._internal.diagnostics.infra import formatter, utils
+
+
+MessageFormatterType = Callable[..., str]
+
+
+@_beartype.beartype
+def format_message_in_text(fn: Callable, *args: Any, **kwargs: Any) -> str:
+    return f"{formatter.display_name(fn)}. "
+
+
+@_beartype.beartype
+def format_exception_in_markdown(exception: Exception) -> str:
+    msg_list = ["### Exception log", "```"]
+    msg_list.extend(
+        traceback.format_exception(type(exception), exception, exception.__traceback__)
+    )
+    msg_list.append("```")
+    return "\n".join(msg_list)
+
+
+@_beartype.beartype
+def format_function_signature_in_markdown(
+    fn: Callable,
+    args: Tuple[Any, ...],
+    kwargs: Dict[str, Any],
+    format_argument: Callable[[Any], str] = formatter.format_argument,
+) -> str:
+    msg_list = [f"### Function Signature {formatter.display_name(fn)}"]
+
+    state = utils.function_state(fn, args, kwargs)
+
+    for k, v in state.items():
+        msg_list.append(f"- {k}: {format_argument(v)}")
+
+    return "\n".join(msg_list)
+
+
+@_beartype.beartype
+def format_return_values_in_markdown(
+    return_values: Any,
+    format_argument: Callable[[Any], str] = formatter.format_argument,
+) -> str:
+    return f"{format_argument(return_values)}"
+
+
+ModifierCallableType = Callable[
+    [infra.Diagnostic, Callable, Tuple[Any, ...], Dict[str, Any], Any], None
+]
+
+
+@_beartype.beartype
+def diagnose_call(
+    rule: infra.Rule,
+    *,
+    level: infra.Level = infra.Level.NONE,
+    diagnostic_type: Type[infra.Diagnostic] = infra.Diagnostic,
+    format_argument: Callable[[Any], str] = formatter.format_argument,
+    diagnostic_message_formatter: MessageFormatterType = format_message_in_text,
+) -> Callable:
+    def decorator(fn):
+        @functools.wraps(fn)
+        def wrapper(*args, **kwargs):
+            common_error_message = "diagnose_call can only be applied to callables"
+            if not callable(fn):
+                raise AssertionError(
+                    f"{common_error_message}. Got {type(fn)} instead of callable."
+                )
+            arg0 = args[0] if len(args) > 0 else None
+            if isinstance(ctx := arg0, infra.DiagnosticContext):
+                pass
+            elif isinstance(
+                ctx := getattr(arg0, "diagnostic_context", None),
+                infra.DiagnosticContext,
+            ):
+                pass
+            else:
+                # NOTE: At decorate time, it can't tell if a callable is function or method.
+                # Technically both are regarded as function at that time.
+                raise AssertionError(
+                    f"{common_error_message}. For {fn}, "
+                    f"If it is a function, a DiagnosticContext instance must be present as "
+                    f"the first argument. "
+                    f"If it is a method, a DiagnosticContext instance must be present as "
+                    f"the attribute 'diagnostic_context' of the 'self' argument."
+                )
+
+            diag = diagnostic_type(
+                rule,
+                level,
+                diagnostic_message_formatter(fn, *args, **kwargs),
+            )
+
+            # pop the decorator frame
+            # TODO(bowbao): by default diagnostic doesn't have stack.
+            # So need to check before doing this. Make the code cleaner.
+            # Option: do not capture stack by default in diagnostic initialization.
+            stack: Optional[infra.Stack] = None
+            if len(diag.stacks) > 0:
+                stack = diag.stacks[0]
+                stack.frames.pop(0)
+
+            # set function location
+            fn_location = utils.function_location(fn)
+            diag.locations.insert(0, fn_location)
+            # Add function location to the top of the stack.
+            if stack is not None:
+                stack.frames.insert(0, infra.StackFrame(location=fn_location))
+
+            with diag.log_section(logging.INFO, "Function Signature"):
+                diag.log(
+                    logging.INFO,
+                    "%s",
+                    formatter.LazyString(
+                        format_function_signature_in_markdown,
+                        fn,
+                        args,
+                        kwargs,
+                        format_argument,
+                    ),
+                )
+
+            return_values: Any = None
+            with ctx.add_inflight_diagnostic(diag) as diag:
+                try:
+                    return_values = fn(*args, **kwargs)
+                    with diag.log_section(logging.INFO, "Return values"):
+                        diag.log(
+                            logging.INFO,
+                            "%s",
+                            formatter.LazyString(
+                                format_return_values_in_markdown,
+                                return_values,
+                                format_argument,
+                            ),
+                        )
+                    return return_values
+                except Exception as e:
+                    diag.log_source_exception(logging.ERROR, e)
+                    diag.level = infra.Level.ERROR
+                finally:
+                    ctx.log_and_raise_if_error(diag)
+
+        return wrapper
+
+    return decorator
+
+
+# TODO(bowbao): decorator to report only when failed.
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/formatter.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/formatter.py
new file mode 100644
index 0000000000000000000000000000000000000000..d5b69924f3bd3cf1862d010fa9dbc9257cf896f3
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/formatter.py
@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import dataclasses
+import json
+import re
+import traceback
+from typing import Any, Callable, Dict, List, Optional, Union
+
+from torch._logging import LazyString
+from torch.onnx._internal import _beartype
+from torch.onnx._internal.diagnostics.infra import sarif
+
+
+# A list of types in the SARIF module to support pretty printing.
+# This is solely for type annotation for the functions below.
+_SarifClass = Union[
+    sarif.SarifLog,
+    sarif.Run,
+    sarif.ReportingDescriptor,
+    sarif.Result,
+]
+
+
+def lazy_format_exception(exception: Exception) -> LazyString:
+    return LazyString(
+        lambda: "\n".join(
+            (
+                "```",
+                *traceback.format_exception(
+                    type(exception), exception, exception.__traceback__
+                ),
+                "```",
+            )
+        ),
+    )
+
+
+@_beartype.beartype
+def snake_case_to_camel_case(s: str) -> str:
+    splits = s.split("_")
+    if len(splits) <= 1:
+        return s
+    return "".join([splits[0], *map(str.capitalize, splits[1:])])
+
+
+@_beartype.beartype
+def camel_case_to_snake_case(s: str) -> str:
+    return re.sub(r"([A-Z])", r"_\1", s).lower()
+
+
+@_beartype.beartype
+def kebab_case_to_snake_case(s: str) -> str:
+    return s.replace("-", "_")
+
+
+@_beartype.beartype
+def _convert_key(
+    object: Union[Dict[str, Any], Any], convert: Callable[[str], str]
+) -> Union[Dict[str, Any], Any]:
+    """Convert and update keys in a dictionary with "convert".
+
+    Any value that is a dictionary will be recursively updated.
+    Any value that is a list will be recursively searched.
+
+    Args:
+        object: The object to update.
+        convert: The function to convert the keys, e.g. `kebab_case_to_snake_case`.
+
+    Returns:
+        The updated object.
+    """
+    if not isinstance(object, Dict):
+        return object
+    new_dict = {}
+    for k, v in object.items():
+        new_k = convert(k)
+        if isinstance(v, Dict):
+            new_v = _convert_key(v, convert)
+        elif isinstance(v, List):
+            new_v = [_convert_key(elem, convert) for elem in v]
+        else:
+            new_v = v
+        if new_v is None:
+            # Otherwise unnecessarily bloated sarif log with "null"s.
+            continue
+        if new_v == -1:
+            # WAR: -1 as default value shouldn't be logged into sarif.
+            continue
+
+        new_dict[new_k] = new_v
+
+    return new_dict
+
+
+@_beartype.beartype
+def sarif_to_json(attr_cls_obj: _SarifClass, indent: Optional[str] = " ") -> str:
+    dict = dataclasses.asdict(attr_cls_obj)
+    dict = _convert_key(dict, snake_case_to_camel_case)
+    return json.dumps(dict, indent=indent, separators=(",", ":"))
+
+
+@_beartype.beartype
+def format_argument(obj: Any) -> str:
+    return f"{type(obj)}"
+
+
+@_beartype.beartype
+def display_name(fn: Callable) -> str:
+    if hasattr(fn, "__qualname__"):
+        return fn.__qualname__
+    elif hasattr(fn, "__name__"):
+        return fn.__name__
+    else:
+        return str(fn)
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__init__.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..34fd40e5b93879223c6d3ba97a6065ac03042fbc
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__init__.py
@@ -0,0 +1,100 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from torch.onnx._internal.diagnostics.infra.sarif._address import Address
+from torch.onnx._internal.diagnostics.infra.sarif._artifact import Artifact
+from torch.onnx._internal.diagnostics.infra.sarif._artifact_change import ArtifactChange
+from torch.onnx._internal.diagnostics.infra.sarif._artifact_content import (
+    ArtifactContent,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._artifact_location import (
+    ArtifactLocation,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._attachment import Attachment
+from torch.onnx._internal.diagnostics.infra.sarif._code_flow import CodeFlow
+from torch.onnx._internal.diagnostics.infra.sarif._configuration_override import (
+    ConfigurationOverride,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._conversion import Conversion
+from torch.onnx._internal.diagnostics.infra.sarif._edge import Edge
+from torch.onnx._internal.diagnostics.infra.sarif._edge_traversal import EdgeTraversal
+from torch.onnx._internal.diagnostics.infra.sarif._exception import Exception
+from torch.onnx._internal.diagnostics.infra.sarif._external_properties import (
+    ExternalProperties,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._external_property_file_reference import (
+    ExternalPropertyFileReference,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._external_property_file_references import (
+    ExternalPropertyFileReferences,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._fix import Fix
+from torch.onnx._internal.diagnostics.infra.sarif._graph import Graph
+from torch.onnx._internal.diagnostics.infra.sarif._graph_traversal import GraphTraversal
+from torch.onnx._internal.diagnostics.infra.sarif._invocation import Invocation
+from torch.onnx._internal.diagnostics.infra.sarif._location import Location
+from torch.onnx._internal.diagnostics.infra.sarif._location_relationship import (
+    LocationRelationship,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._logical_location import (
+    LogicalLocation,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._message import Message
+from torch.onnx._internal.diagnostics.infra.sarif._multiformat_message_string import (
+    MultiformatMessageString,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._node import Node
+from torch.onnx._internal.diagnostics.infra.sarif._notification import Notification
+from torch.onnx._internal.diagnostics.infra.sarif._physical_location import (
+    PhysicalLocation,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._property_bag import PropertyBag
+from torch.onnx._internal.diagnostics.infra.sarif._rectangle import Rectangle
+from torch.onnx._internal.diagnostics.infra.sarif._region import Region
+from torch.onnx._internal.diagnostics.infra.sarif._replacement import Replacement
+from torch.onnx._internal.diagnostics.infra.sarif._reporting_configuration import (
+    ReportingConfiguration,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._reporting_descriptor import (
+    ReportingDescriptor,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._reporting_descriptor_reference import (
+    ReportingDescriptorReference,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._reporting_descriptor_relationship import (
+    ReportingDescriptorRelationship,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._result import Result
+from torch.onnx._internal.diagnostics.infra.sarif._result_provenance import (
+    ResultProvenance,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._run import Run
+from torch.onnx._internal.diagnostics.infra.sarif._run_automation_details import (
+    RunAutomationDetails,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._sarif_log import SarifLog
+from torch.onnx._internal.diagnostics.infra.sarif._special_locations import (
+    SpecialLocations,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._stack import Stack
+from torch.onnx._internal.diagnostics.infra.sarif._stack_frame import StackFrame
+from torch.onnx._internal.diagnostics.infra.sarif._suppression import Suppression
+from torch.onnx._internal.diagnostics.infra.sarif._thread_flow import ThreadFlow
+from torch.onnx._internal.diagnostics.infra.sarif._thread_flow_location import (
+    ThreadFlowLocation,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._tool import Tool
+from torch.onnx._internal.diagnostics.infra.sarif._tool_component import ToolComponent
+from torch.onnx._internal.diagnostics.infra.sarif._tool_component_reference import (
+    ToolComponentReference,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._translation_metadata import (
+    TranslationMetadata,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._version_control_details import (
+    VersionControlDetails,
+)
+from torch.onnx._internal.diagnostics.infra.sarif._web_request import WebRequest
+from torch.onnx._internal.diagnostics.infra.sarif._web_response import WebResponse
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/__init__.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..15f08a426120cae14157e153200820d669b1680e
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/__init__.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_code_flow.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_code_flow.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f087526efcc4dde86c357b2025c2d0ca0646ea0e
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_code_flow.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_conversion.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_conversion.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..67dd3bfb57bace49511ef4c1ee4aba3d13713f34
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_conversion.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_edge.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_edge.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..94786e98fd93f1577110d51e817716da87cd535a
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_edge.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_edge_traversal.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_edge_traversal.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ac1024699af6893a86254cde43f9d2996a2f83b0
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_edge_traversal.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_exception.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_exception.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f420485e921a5d7a7d0252a45da40a76815b1dbd
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_exception.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_external_property_file_reference.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_external_property_file_reference.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e2a0c20b1c319ddbc3866d5b9ce48934e75d8756
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_external_property_file_reference.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_graph_traversal.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_graph_traversal.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b54fc3977e5289a6ca89e830c58289f28af4cf2f
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_graph_traversal.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_invocation.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_invocation.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..81613caa122bd93e5fe121bbb240bd05cd0c6129
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_invocation.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_location_relationship.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_location_relationship.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d6bde5fc2e0e95c93cc67799331a93129a0ae508
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_location_relationship.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_message.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_message.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ca7281d372c5cfcf9b9d271e5fa0a441e3edbd5b
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_message.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_node.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_node.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..44d1353d6f84342c92bd7acae5716cec981fa5c4
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_node.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_property_bag.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_property_bag.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6977ca51a611522586dc07714e4869a31b5452e3
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_property_bag.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_region.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_region.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..76eea07b6eaa4e017db831dcae47c99cf66b909c
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_region.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_reporting_configuration.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_reporting_configuration.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..45ae70d56c1546c0d5ca3aef744905e9ec36d77b
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_reporting_configuration.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_reporting_descriptor.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_reporting_descriptor.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e038050057dbe37fedcb569ea7067202aaa50b5e
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_reporting_descriptor.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_reporting_descriptor_reference.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_reporting_descriptor_reference.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e1a157e76286316fe956f732bb9cb603c7c88e6b
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_reporting_descriptor_reference.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_result.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_result.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e40c2f55f2aae74f007cbd61b569b9c5b64d3e56
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_result.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_result_provenance.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_result_provenance.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e23d164a024d9adc2aeef8f41451c1c417a640b5
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_result_provenance.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_run.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_run.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f97425d527a5e4b98603cde232553f7ca0351695
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_run.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_sarif_log.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_sarif_log.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..71ea0a72c1d77d31f063f89728c17e43a04f27b4
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_sarif_log.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_stack_frame.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_stack_frame.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..98463d176de5b14ca7190a34ee485a8990d6cba4
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_stack_frame.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_thread_flow.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_thread_flow.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5373538a158d6b3750a9ea4eba1734b579dc3d5a
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_thread_flow.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_version_control_details.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_version_control_details.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0b57eafddb35faf5bee1b919328f644d1bb89256
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_version_control_details.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_web_request.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_web_request.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f11ea28c6569436573b0ef6b0a9acc0851009276
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_web_request.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_web_response.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_web_response.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c3c37308fa988cc4c44069065c69745925c5228c
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/_web_response.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/version.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/version.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..49971ded6d904d98b019d6d81d1c3ac7cb1fccd3
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__pycache__/version.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_address.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_address.py
new file mode 100644
index 0000000000000000000000000000000000000000..df68b103374ae9af848c44ea41030967951c9be8
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_address.py
@@ -0,0 +1,48 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import _property_bag
+
+
+@dataclasses.dataclass
+class Address(object):
+    """A physical or virtual address, or a range of addresses, in an 'addressable region' (memory or a binary file)."""
+
+    absolute_address: int = dataclasses.field(
+        default=-1, metadata={"schema_property_name": "absoluteAddress"}
+    )
+    fully_qualified_name: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "fullyQualifiedName"}
+    )
+    index: int = dataclasses.field(
+        default=-1, metadata={"schema_property_name": "index"}
+    )
+    kind: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "kind"}
+    )
+    length: Optional[int] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "length"}
+    )
+    name: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "name"}
+    )
+    offset_from_parent: Optional[int] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "offsetFromParent"}
+    )
+    parent_index: int = dataclasses.field(
+        default=-1, metadata={"schema_property_name": "parentIndex"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    relative_address: Optional[int] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "relativeAddress"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_artifact.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_artifact.py
new file mode 100644
index 0000000000000000000000000000000000000000..2f66167772488624c6fba14c0de36a0ffb846f0a
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_artifact.py
@@ -0,0 +1,88 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Any, List, Literal, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _artifact_content,
+    _artifact_location,
+    _message,
+    _property_bag,
+)
+
+
+@dataclasses.dataclass
+class Artifact(object):
+    """A single artifact. In some cases, this artifact might be nested within another artifact."""
+
+    contents: Optional[_artifact_content.ArtifactContent] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "contents"}
+    )
+    description: Optional[_message.Message] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "description"}
+    )
+    encoding: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "encoding"}
+    )
+    hashes: Any = dataclasses.field(
+        default=None, metadata={"schema_property_name": "hashes"}
+    )
+    last_modified_time_utc: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "lastModifiedTimeUtc"}
+    )
+    length: int = dataclasses.field(
+        default=-1, metadata={"schema_property_name": "length"}
+    )
+    location: Optional[_artifact_location.ArtifactLocation] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "location"}
+    )
+    mime_type: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "mimeType"}
+    )
+    offset: Optional[int] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "offset"}
+    )
+    parent_index: int = dataclasses.field(
+        default=-1, metadata={"schema_property_name": "parentIndex"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    roles: Optional[
+        List[
+            Literal[
+                "analysisTarget",
+                "attachment",
+                "responseFile",
+                "resultFile",
+                "standardStream",
+                "tracedFile",
+                "unmodified",
+                "modified",
+                "added",
+                "deleted",
+                "renamed",
+                "uncontrolled",
+                "driver",
+                "extension",
+                "translation",
+                "taxonomy",
+                "policy",
+                "referencedOnCommandLine",
+                "memoryContents",
+                "directory",
+                "userSpecifiedConfiguration",
+                "toolSpecifiedConfiguration",
+                "debugOutputFile",
+            ]
+        ]
+    ] = dataclasses.field(default=None, metadata={"schema_property_name": "roles"})
+    source_language: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "sourceLanguage"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_artifact_change.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_artifact_change.py
new file mode 100644
index 0000000000000000000000000000000000000000..f8cca329f25b13bceb6469e5a59321bcc29c643e
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_artifact_change.py
@@ -0,0 +1,31 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import List, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _artifact_location,
+    _property_bag,
+    _replacement,
+)
+
+
+@dataclasses.dataclass
+class ArtifactChange(object):
+    """A change to a single artifact."""
+
+    artifact_location: _artifact_location.ArtifactLocation = dataclasses.field(
+        metadata={"schema_property_name": "artifactLocation"}
+    )
+    replacements: List[_replacement.Replacement] = dataclasses.field(
+        metadata={"schema_property_name": "replacements"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_artifact_content.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_artifact_content.py
new file mode 100644
index 0000000000000000000000000000000000000000..134c89841bf2148930385cfa0ca8a521d500f06f
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_artifact_content.py
@@ -0,0 +1,33 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _multiformat_message_string,
+    _property_bag,
+)
+
+
+@dataclasses.dataclass
+class ArtifactContent(object):
+    """Represents the contents of an artifact."""
+
+    binary: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "binary"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    rendered: Optional[
+        _multiformat_message_string.MultiformatMessageString
+    ] = dataclasses.field(default=None, metadata={"schema_property_name": "rendered"})
+    text: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "text"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_code_flow.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_code_flow.py
new file mode 100644
index 0000000000000000000000000000000000000000..5515ef78bee12bc129aeb41da6d1a8db2c3e0810
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_code_flow.py
@@ -0,0 +1,31 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import List, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _message,
+    _property_bag,
+    _thread_flow,
+)
+
+
+@dataclasses.dataclass
+class CodeFlow(object):
+    """A set of threadFlows which together describe a pattern of code execution relevant to detecting a result."""
+
+    thread_flows: List[_thread_flow.ThreadFlow] = dataclasses.field(
+        metadata={"schema_property_name": "threadFlows"}
+    )
+    message: Optional[_message.Message] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "message"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_configuration_override.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_configuration_override.py
new file mode 100644
index 0000000000000000000000000000000000000000..be32e77ff4e18c10b9a8576c857594133c9d3613
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_configuration_override.py
@@ -0,0 +1,31 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _property_bag,
+    _reporting_configuration,
+    _reporting_descriptor_reference,
+)
+
+
+@dataclasses.dataclass
+class ConfigurationOverride(object):
+    """Information about how a specific rule or notification was reconfigured at runtime."""
+
+    configuration: _reporting_configuration.ReportingConfiguration = dataclasses.field(
+        metadata={"schema_property_name": "configuration"}
+    )
+    descriptor: _reporting_descriptor_reference.ReportingDescriptorReference = (
+        dataclasses.field(metadata={"schema_property_name": "descriptor"})
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_conversion.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_conversion.py
new file mode 100644
index 0000000000000000000000000000000000000000..522202bc78ddd27ec9dba72469b4fb4d4f251f86
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_conversion.py
@@ -0,0 +1,35 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import List, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _artifact_location,
+    _invocation,
+    _property_bag,
+    _tool,
+)
+
+
+@dataclasses.dataclass
+class Conversion(object):
+    """Describes how a converter transformed the output of a static analysis tool from the analysis tool's native output format into the SARIF format."""
+
+    tool: _tool.Tool = dataclasses.field(metadata={"schema_property_name": "tool"})
+    analysis_tool_log_files: Optional[
+        List[_artifact_location.ArtifactLocation]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "analysisToolLogFiles"}
+    )
+    invocation: Optional[_invocation.Invocation] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "invocation"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_edge_traversal.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_edge_traversal.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8f12d921704b55654991fb0ff7e3ca73aa63f4b
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_edge_traversal.py
@@ -0,0 +1,31 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Any, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import _message, _property_bag
+
+
+@dataclasses.dataclass
+class EdgeTraversal(object):
+    """Represents the traversal of a single edge during a graph traversal."""
+
+    edge_id: str = dataclasses.field(metadata={"schema_property_name": "edgeId"})
+    final_state: Any = dataclasses.field(
+        default=None, metadata={"schema_property_name": "finalState"}
+    )
+    message: Optional[_message.Message] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "message"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    step_over_edge_count: Optional[int] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "stepOverEdgeCount"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_exception.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_exception.py
new file mode 100644
index 0000000000000000000000000000000000000000..9afa806332413726547a5d71d86d45e5a20c18a9
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_exception.py
@@ -0,0 +1,37 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import List, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _exception,
+    _property_bag,
+    _stack,
+)
+
+
+@dataclasses.dataclass
+class Exception(object):
+    """Describes a runtime exception encountered during the execution of an analysis tool."""
+
+    inner_exceptions: Optional[List[_exception.Exception]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "innerExceptions"}
+    )
+    kind: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "kind"}
+    )
+    message: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "message"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    stack: Optional[_stack.Stack] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "stack"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_external_properties.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_external_properties.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae5a530a090f59870c2faf927f1863b344aeab2c
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_external_properties.py
@@ -0,0 +1,98 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import List, Literal, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _address,
+    _artifact,
+    _conversion,
+    _graph,
+    _invocation,
+    _logical_location,
+    _property_bag,
+    _result,
+    _thread_flow_location,
+    _tool_component,
+    _web_request,
+    _web_response,
+)
+
+
+@dataclasses.dataclass
+class ExternalProperties(object):
+    """The top-level element of an external property file."""
+
+    addresses: Optional[List[_address.Address]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "addresses"}
+    )
+    artifacts: Optional[List[_artifact.Artifact]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "artifacts"}
+    )
+    conversion: Optional[_conversion.Conversion] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "conversion"}
+    )
+    driver: Optional[_tool_component.ToolComponent] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "driver"}
+    )
+    extensions: Optional[List[_tool_component.ToolComponent]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "extensions"}
+    )
+    externalized_properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "externalizedProperties"}
+    )
+    graphs: Optional[List[_graph.Graph]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "graphs"}
+    )
+    guid: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "guid"}
+    )
+    invocations: Optional[List[_invocation.Invocation]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "invocations"}
+    )
+    logical_locations: Optional[
+        List[_logical_location.LogicalLocation]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "logicalLocations"}
+    )
+    policies: Optional[List[_tool_component.ToolComponent]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "policies"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    results: Optional[List[_result.Result]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "results"}
+    )
+    run_guid: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "runGuid"}
+    )
+    schema: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "schema"}
+    )
+    taxonomies: Optional[List[_tool_component.ToolComponent]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "taxonomies"}
+    )
+    thread_flow_locations: Optional[
+        List[_thread_flow_location.ThreadFlowLocation]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "threadFlowLocations"}
+    )
+    translations: Optional[List[_tool_component.ToolComponent]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "translations"}
+    )
+    version: Optional[Literal["2.1.0"]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "version"}
+    )
+    web_requests: Optional[List[_web_request.WebRequest]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "webRequests"}
+    )
+    web_responses: Optional[List[_web_response.WebResponse]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "webResponses"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_external_property_file_references.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_external_property_file_references.py
new file mode 100644
index 0000000000000000000000000000000000000000..78ae2db62708adb20fd8e9246854c56d7db8a3b7
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_external_property_file_references.py
@@ -0,0 +1,86 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import List, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _external_property_file_reference,
+    _property_bag,
+)
+
+
+@dataclasses.dataclass
+class ExternalPropertyFileReferences(object):
+    """References to external property files that should be inlined with the content of a root log file."""
+
+    addresses: Optional[
+        List[_external_property_file_reference.ExternalPropertyFileReference]
+    ] = dataclasses.field(default=None, metadata={"schema_property_name": "addresses"})
+    artifacts: Optional[
+        List[_external_property_file_reference.ExternalPropertyFileReference]
+    ] = dataclasses.field(default=None, metadata={"schema_property_name": "artifacts"})
+    conversion: Optional[
+        _external_property_file_reference.ExternalPropertyFileReference
+    ] = dataclasses.field(default=None, metadata={"schema_property_name": "conversion"})
+    driver: Optional[
+        _external_property_file_reference.ExternalPropertyFileReference
+    ] = dataclasses.field(default=None, metadata={"schema_property_name": "driver"})
+    extensions: Optional[
+        List[_external_property_file_reference.ExternalPropertyFileReference]
+    ] = dataclasses.field(default=None, metadata={"schema_property_name": "extensions"})
+    externalized_properties: Optional[
+        _external_property_file_reference.ExternalPropertyFileReference
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "externalizedProperties"}
+    )
+    graphs: Optional[
+        List[_external_property_file_reference.ExternalPropertyFileReference]
+    ] = dataclasses.field(default=None, metadata={"schema_property_name": "graphs"})
+    invocations: Optional[
+        List[_external_property_file_reference.ExternalPropertyFileReference]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "invocations"}
+    )
+    logical_locations: Optional[
+        List[_external_property_file_reference.ExternalPropertyFileReference]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "logicalLocations"}
+    )
+    policies: Optional[
+        List[_external_property_file_reference.ExternalPropertyFileReference]
+    ] = dataclasses.field(default=None, metadata={"schema_property_name": "policies"})
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    results: Optional[
+        List[_external_property_file_reference.ExternalPropertyFileReference]
+    ] = dataclasses.field(default=None, metadata={"schema_property_name": "results"})
+    taxonomies: Optional[
+        List[_external_property_file_reference.ExternalPropertyFileReference]
+    ] = dataclasses.field(default=None, metadata={"schema_property_name": "taxonomies"})
+    thread_flow_locations: Optional[
+        List[_external_property_file_reference.ExternalPropertyFileReference]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "threadFlowLocations"}
+    )
+    translations: Optional[
+        List[_external_property_file_reference.ExternalPropertyFileReference]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "translations"}
+    )
+    web_requests: Optional[
+        List[_external_property_file_reference.ExternalPropertyFileReference]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "webRequests"}
+    )
+    web_responses: Optional[
+        List[_external_property_file_reference.ExternalPropertyFileReference]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "webResponses"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_graph.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_graph.py
new file mode 100644
index 0000000000000000000000000000000000000000..306d6b305126a796e9f67c0b69d81ec0f22fad40
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_graph.py
@@ -0,0 +1,35 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import List, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _edge,
+    _message,
+    _node,
+    _property_bag,
+)
+
+
+@dataclasses.dataclass
+class Graph(object):
+    """A network of nodes and directed edges that describes some aspect of the structure of the code (for example, a call graph)."""
+
+    description: Optional[_message.Message] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "description"}
+    )
+    edges: Optional[List[_edge.Edge]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "edges"}
+    )
+    nodes: Optional[List[_node.Node]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "nodes"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_graph_traversal.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_graph_traversal.py
new file mode 100644
index 0000000000000000000000000000000000000000..bdc25c4591a2da71cdde040731ee1a472a4cca7a
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_graph_traversal.py
@@ -0,0 +1,43 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Any, List, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _edge_traversal,
+    _message,
+    _property_bag,
+)
+
+
+@dataclasses.dataclass
+class GraphTraversal(object):
+    """Represents a path through a graph."""
+
+    description: Optional[_message.Message] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "description"}
+    )
+    edge_traversals: Optional[List[_edge_traversal.EdgeTraversal]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "edgeTraversals"}
+    )
+    immutable_state: Any = dataclasses.field(
+        default=None, metadata={"schema_property_name": "immutableState"}
+    )
+    initial_state: Any = dataclasses.field(
+        default=None, metadata={"schema_property_name": "initialState"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    result_graph_index: int = dataclasses.field(
+        default=-1, metadata={"schema_property_name": "resultGraphIndex"}
+    )
+    run_graph_index: int = dataclasses.field(
+        default=-1, metadata={"schema_property_name": "runGraphIndex"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_invocation.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_invocation.py
new file mode 100644
index 0000000000000000000000000000000000000000..77fb36997507483f20fc89154f2b90532abbcc94
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_invocation.py
@@ -0,0 +1,117 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Any, List, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _artifact_location,
+    _configuration_override,
+    _notification,
+    _property_bag,
+)
+
+
+@dataclasses.dataclass
+class Invocation(object):
+    """The runtime environment of the analysis tool run."""
+
+    execution_successful: bool = dataclasses.field(
+        metadata={"schema_property_name": "executionSuccessful"}
+    )
+    account: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "account"}
+    )
+    arguments: Optional[List[str]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "arguments"}
+    )
+    command_line: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "commandLine"}
+    )
+    end_time_utc: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "endTimeUtc"}
+    )
+    environment_variables: Any = dataclasses.field(
+        default=None, metadata={"schema_property_name": "environmentVariables"}
+    )
+    executable_location: Optional[
+        _artifact_location.ArtifactLocation
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "executableLocation"}
+    )
+    exit_code: Optional[int] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "exitCode"}
+    )
+    exit_code_description: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "exitCodeDescription"}
+    )
+    exit_signal_name: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "exitSignalName"}
+    )
+    exit_signal_number: Optional[int] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "exitSignalNumber"}
+    )
+    machine: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "machine"}
+    )
+    notification_configuration_overrides: Optional[
+        List[_configuration_override.ConfigurationOverride]
+    ] = dataclasses.field(
+        default=None,
+        metadata={"schema_property_name": "notificationConfigurationOverrides"},
+    )
+    process_id: Optional[int] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "processId"}
+    )
+    process_start_failure_message: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "processStartFailureMessage"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    response_files: Optional[
+        List[_artifact_location.ArtifactLocation]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "responseFiles"}
+    )
+    rule_configuration_overrides: Optional[
+        List[_configuration_override.ConfigurationOverride]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "ruleConfigurationOverrides"}
+    )
+    start_time_utc: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "startTimeUtc"}
+    )
+    stderr: Optional[_artifact_location.ArtifactLocation] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "stderr"}
+    )
+    stdin: Optional[_artifact_location.ArtifactLocation] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "stdin"}
+    )
+    stdout: Optional[_artifact_location.ArtifactLocation] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "stdout"}
+    )
+    stdout_stderr: Optional[_artifact_location.ArtifactLocation] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "stdoutStderr"}
+    )
+    tool_configuration_notifications: Optional[
+        List[_notification.Notification]
+    ] = dataclasses.field(
+        default=None,
+        metadata={"schema_property_name": "toolConfigurationNotifications"},
+    )
+    tool_execution_notifications: Optional[
+        List[_notification.Notification]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "toolExecutionNotifications"}
+    )
+    working_directory: Optional[
+        _artifact_location.ArtifactLocation
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "workingDirectory"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_location.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_location.py
new file mode 100644
index 0000000000000000000000000000000000000000..06ce42546e125384f6191f378cc8925c99d7e8a3
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_location.py
@@ -0,0 +1,50 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import List, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _location_relationship,
+    _logical_location,
+    _message,
+    _physical_location,
+    _property_bag,
+    _region,
+)
+
+
+@dataclasses.dataclass
+class Location(object):
+    """A location within a programming artifact."""
+
+    annotations: Optional[List[_region.Region]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "annotations"}
+    )
+    id: int = dataclasses.field(default=-1, metadata={"schema_property_name": "id"})
+    logical_locations: Optional[
+        List[_logical_location.LogicalLocation]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "logicalLocations"}
+    )
+    message: Optional[_message.Message] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "message"}
+    )
+    physical_location: Optional[
+        _physical_location.PhysicalLocation
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "physicalLocation"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    relationships: Optional[
+        List[_location_relationship.LocationRelationship]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "relationships"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_location_relationship.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_location_relationship.py
new file mode 100644
index 0000000000000000000000000000000000000000..92f6c4128e04b8e51e832deaeb82debf48ee02f6
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_location_relationship.py
@@ -0,0 +1,28 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import List, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import _message, _property_bag
+
+
+@dataclasses.dataclass
+class LocationRelationship(object):
+    """Information about the relation of one location to another."""
+
+    target: int = dataclasses.field(metadata={"schema_property_name": "target"})
+    description: Optional[_message.Message] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "description"}
+    )
+    kinds: List[str] = dataclasses.field(
+        default_factory=lambda: ["relevant"], metadata={"schema_property_name": "kinds"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_logical_location.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_logical_location.py
new file mode 100644
index 0000000000000000000000000000000000000000..70e67528a95a811e0b2d1ce9a83171728c88d758
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_logical_location.py
@@ -0,0 +1,39 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import _property_bag
+
+
+@dataclasses.dataclass
+class LogicalLocation(object):
+    """A logical location of a construct that produced a result."""
+
+    decorated_name: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "decoratedName"}
+    )
+    fully_qualified_name: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "fullyQualifiedName"}
+    )
+    index: int = dataclasses.field(
+        default=-1, metadata={"schema_property_name": "index"}
+    )
+    kind: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "kind"}
+    )
+    name: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "name"}
+    )
+    parent_index: int = dataclasses.field(
+        default=-1, metadata={"schema_property_name": "parentIndex"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_message.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_message.py
new file mode 100644
index 0000000000000000000000000000000000000000..03528747fa5abbb2aa0a62cbefdd2af4158bc9b7
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_message.py
@@ -0,0 +1,33 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import List, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import _property_bag
+
+
+@dataclasses.dataclass
+class Message(object):
+    """Encapsulates a message intended to be read by the end user."""
+
+    arguments: Optional[List[str]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "arguments"}
+    )
+    id: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "id"}
+    )
+    markdown: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "markdown"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    text: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "text"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_node.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_node.py
new file mode 100644
index 0000000000000000000000000000000000000000..a4b3f74db3a2930a21db7da4c9e23469d63e4ca5
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_node.py
@@ -0,0 +1,36 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import List, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _location,
+    _message,
+    _node,
+    _property_bag,
+)
+
+
+@dataclasses.dataclass
+class Node(object):
+    """Represents a node in a graph."""
+
+    id: str = dataclasses.field(metadata={"schema_property_name": "id"})
+    children: Optional[List[_node.Node]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "children"}
+    )
+    label: Optional[_message.Message] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "label"}
+    )
+    location: Optional[_location.Location] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "location"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_notification.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_notification.py
new file mode 100644
index 0000000000000000000000000000000000000000..9ffb40b4d19bb1c2e1d4311dadee56573b471ac8
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_notification.py
@@ -0,0 +1,53 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import List, Literal, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _exception,
+    _location,
+    _message,
+    _property_bag,
+    _reporting_descriptor_reference,
+)
+
+
+@dataclasses.dataclass
+class Notification(object):
+    """Describes a condition relevant to the tool itself, as opposed to being relevant to a target being analyzed by the tool."""
+
+    message: _message.Message = dataclasses.field(
+        metadata={"schema_property_name": "message"}
+    )
+    associated_rule: Optional[
+        _reporting_descriptor_reference.ReportingDescriptorReference
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "associatedRule"}
+    )
+    descriptor: Optional[
+        _reporting_descriptor_reference.ReportingDescriptorReference
+    ] = dataclasses.field(default=None, metadata={"schema_property_name": "descriptor"})
+    exception: Optional[_exception.Exception] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "exception"}
+    )
+    level: Literal["none", "note", "warning", "error"] = dataclasses.field(
+        default="warning", metadata={"schema_property_name": "level"}
+    )
+    locations: Optional[List[_location.Location]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "locations"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    thread_id: Optional[int] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "threadId"}
+    )
+    time_utc: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "timeUtc"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_rectangle.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_rectangle.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf24d758252657d2e415cbe39dd2bc1a9aa51684
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_rectangle.py
@@ -0,0 +1,36 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import _message, _property_bag
+
+
+@dataclasses.dataclass
+class Rectangle(object):
+    """An area within an image."""
+
+    bottom: Optional[float] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "bottom"}
+    )
+    left: Optional[float] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "left"}
+    )
+    message: Optional[_message.Message] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "message"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    right: Optional[float] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "right"}
+    )
+    top: Optional[float] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "top"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_replacement.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_replacement.py
new file mode 100644
index 0000000000000000000000000000000000000000..9acbc9d8133a118c3aa215ee42f7767178f6d19b
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_replacement.py
@@ -0,0 +1,31 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _artifact_content,
+    _property_bag,
+    _region,
+)
+
+
+@dataclasses.dataclass
+class Replacement(object):
+    """The replacement of a single region of an artifact."""
+
+    deleted_region: _region.Region = dataclasses.field(
+        metadata={"schema_property_name": "deletedRegion"}
+    )
+    inserted_content: Optional[_artifact_content.ArtifactContent] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "insertedContent"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_reporting_configuration.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_reporting_configuration.py
new file mode 100644
index 0000000000000000000000000000000000000000..fbc74a9fb35b7c7ba80d7534f1dd0b9dfca765ca
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_reporting_configuration.py
@@ -0,0 +1,33 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Literal, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import _property_bag
+
+
+@dataclasses.dataclass
+class ReportingConfiguration(object):
+    """Information about a rule or notification that can be configured at runtime."""
+
+    enabled: bool = dataclasses.field(
+        default=True, metadata={"schema_property_name": "enabled"}
+    )
+    level: Literal["none", "note", "warning", "error"] = dataclasses.field(
+        default="warning", metadata={"schema_property_name": "level"}
+    )
+    parameters: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "parameters"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    rank: float = dataclasses.field(
+        default=-1.0, metadata={"schema_property_name": "rank"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_reporting_descriptor_reference.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_reporting_descriptor_reference.py
new file mode 100644
index 0000000000000000000000000000000000000000..4d057d508446ea24fff5320219b69e0cdef51743
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_reporting_descriptor_reference.py
@@ -0,0 +1,38 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _property_bag,
+    _tool_component_reference,
+)
+
+
+@dataclasses.dataclass
+class ReportingDescriptorReference(object):
+    """Information about how to locate a relevant reporting descriptor."""
+
+    guid: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "guid"}
+    )
+    id: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "id"}
+    )
+    index: int = dataclasses.field(
+        default=-1, metadata={"schema_property_name": "index"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    tool_component: Optional[
+        _tool_component_reference.ToolComponentReference
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "toolComponent"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_reporting_descriptor_relationship.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_reporting_descriptor_relationship.py
new file mode 100644
index 0000000000000000000000000000000000000000..b66bd1bb4c0f359c038df836c8f4f55516e64a9d
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_reporting_descriptor_relationship.py
@@ -0,0 +1,34 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import List, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _message,
+    _property_bag,
+    _reporting_descriptor_reference,
+)
+
+
+@dataclasses.dataclass
+class ReportingDescriptorRelationship(object):
+    """Information about the relation of one reporting descriptor to another."""
+
+    target: _reporting_descriptor_reference.ReportingDescriptorReference = (
+        dataclasses.field(metadata={"schema_property_name": "target"})
+    )
+    description: Optional[_message.Message] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "description"}
+    )
+    kinds: List[str] = dataclasses.field(
+        default_factory=lambda: ["relevant"], metadata={"schema_property_name": "kinds"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_result.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_result.py
new file mode 100644
index 0000000000000000000000000000000000000000..829cd3cdf5dc954c4b3180c0c39605d6f83f02ca
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_result.py
@@ -0,0 +1,128 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Any, List, Literal, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _artifact_location,
+    _attachment,
+    _code_flow,
+    _fix,
+    _graph,
+    _graph_traversal,
+    _location,
+    _message,
+    _property_bag,
+    _reporting_descriptor_reference,
+    _result_provenance,
+    _stack,
+    _suppression,
+    _web_request,
+    _web_response,
+)
+
+
+@dataclasses.dataclass
+class Result(object):
+    """A result produced by an analysis tool."""
+
+    message: _message.Message = dataclasses.field(
+        metadata={"schema_property_name": "message"}
+    )
+    analysis_target: Optional[_artifact_location.ArtifactLocation] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "analysisTarget"}
+    )
+    attachments: Optional[List[_attachment.Attachment]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "attachments"}
+    )
+    baseline_state: Optional[
+        Literal["new", "unchanged", "updated", "absent"]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "baselineState"}
+    )
+    code_flows: Optional[List[_code_flow.CodeFlow]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "codeFlows"}
+    )
+    correlation_guid: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "correlationGuid"}
+    )
+    fingerprints: Any = dataclasses.field(
+        default=None, metadata={"schema_property_name": "fingerprints"}
+    )
+    fixes: Optional[List[_fix.Fix]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "fixes"}
+    )
+    graph_traversals: Optional[
+        List[_graph_traversal.GraphTraversal]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "graphTraversals"}
+    )
+    graphs: Optional[List[_graph.Graph]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "graphs"}
+    )
+    guid: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "guid"}
+    )
+    hosted_viewer_uri: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "hostedViewerUri"}
+    )
+    kind: Literal[
+        "notApplicable", "pass", "fail", "review", "open", "informational"
+    ] = dataclasses.field(default="fail", metadata={"schema_property_name": "kind"})
+    level: Literal["none", "note", "warning", "error"] = dataclasses.field(
+        default="warning", metadata={"schema_property_name": "level"}
+    )
+    locations: Optional[List[_location.Location]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "locations"}
+    )
+    occurrence_count: Optional[int] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "occurrenceCount"}
+    )
+    partial_fingerprints: Any = dataclasses.field(
+        default=None, metadata={"schema_property_name": "partialFingerprints"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    provenance: Optional[_result_provenance.ResultProvenance] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "provenance"}
+    )
+    rank: float = dataclasses.field(
+        default=-1.0, metadata={"schema_property_name": "rank"}
+    )
+    related_locations: Optional[List[_location.Location]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "relatedLocations"}
+    )
+    rule: Optional[
+        _reporting_descriptor_reference.ReportingDescriptorReference
+    ] = dataclasses.field(default=None, metadata={"schema_property_name": "rule"})
+    rule_id: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "ruleId"}
+    )
+    rule_index: int = dataclasses.field(
+        default=-1, metadata={"schema_property_name": "ruleIndex"}
+    )
+    stacks: Optional[List[_stack.Stack]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "stacks"}
+    )
+    suppressions: Optional[List[_suppression.Suppression]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "suppressions"}
+    )
+    taxa: Optional[
+        List[_reporting_descriptor_reference.ReportingDescriptorReference]
+    ] = dataclasses.field(default=None, metadata={"schema_property_name": "taxa"})
+    web_request: Optional[_web_request.WebRequest] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "webRequest"}
+    )
+    web_response: Optional[_web_response.WebResponse] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "webResponse"}
+    )
+    work_item_uris: Optional[List[str]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "workItemUris"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_result_provenance.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_result_provenance.py
new file mode 100644
index 0000000000000000000000000000000000000000..e542414a8da533445256edf5e1887945439305b9
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_result_provenance.py
@@ -0,0 +1,44 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import List, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _physical_location,
+    _property_bag,
+)
+
+
+@dataclasses.dataclass
+class ResultProvenance(object):
+    """Contains information about how and when a result was detected."""
+
+    conversion_sources: Optional[
+        List[_physical_location.PhysicalLocation]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "conversionSources"}
+    )
+    first_detection_run_guid: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "firstDetectionRunGuid"}
+    )
+    first_detection_time_utc: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "firstDetectionTimeUtc"}
+    )
+    invocation_index: int = dataclasses.field(
+        default=-1, metadata={"schema_property_name": "invocationIndex"}
+    )
+    last_detection_run_guid: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "lastDetectionRunGuid"}
+    )
+    last_detection_time_utc: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "lastDetectionTimeUtc"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_run.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_run.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2aca9ba5e32e01e48ddcafefc4dd9a077b6bf94
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_run.py
@@ -0,0 +1,134 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Any, List, Literal, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _address,
+    _artifact,
+    _conversion,
+    _external_property_file_references,
+    _graph,
+    _invocation,
+    _logical_location,
+    _property_bag,
+    _result,
+    _run_automation_details,
+    _special_locations,
+    _thread_flow_location,
+    _tool,
+    _tool_component,
+    _version_control_details,
+    _web_request,
+    _web_response,
+)
+
+
+@dataclasses.dataclass
+class Run(object):
+    """Describes a single run of an analysis tool, and contains the reported output of that run."""
+
+    tool: _tool.Tool = dataclasses.field(metadata={"schema_property_name": "tool"})
+    addresses: Optional[List[_address.Address]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "addresses"}
+    )
+    artifacts: Optional[List[_artifact.Artifact]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "artifacts"}
+    )
+    automation_details: Optional[
+        _run_automation_details.RunAutomationDetails
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "automationDetails"}
+    )
+    baseline_guid: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "baselineGuid"}
+    )
+    column_kind: Optional[
+        Literal["utf16CodeUnits", "unicodeCodePoints"]
+    ] = dataclasses.field(default=None, metadata={"schema_property_name": "columnKind"})
+    conversion: Optional[_conversion.Conversion] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "conversion"}
+    )
+    default_encoding: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "defaultEncoding"}
+    )
+    default_source_language: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "defaultSourceLanguage"}
+    )
+    external_property_file_references: Optional[
+        _external_property_file_references.ExternalPropertyFileReferences
+    ] = dataclasses.field(
+        default=None,
+        metadata={"schema_property_name": "externalPropertyFileReferences"},
+    )
+    graphs: Optional[List[_graph.Graph]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "graphs"}
+    )
+    invocations: Optional[List[_invocation.Invocation]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "invocations"}
+    )
+    language: str = dataclasses.field(
+        default="en-US", metadata={"schema_property_name": "language"}
+    )
+    logical_locations: Optional[
+        List[_logical_location.LogicalLocation]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "logicalLocations"}
+    )
+    newline_sequences: List[str] = dataclasses.field(
+        default_factory=lambda: ["\r\n", "\n"],
+        metadata={"schema_property_name": "newlineSequences"},
+    )
+    original_uri_base_ids: Any = dataclasses.field(
+        default=None, metadata={"schema_property_name": "originalUriBaseIds"}
+    )
+    policies: Optional[List[_tool_component.ToolComponent]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "policies"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    redaction_tokens: Optional[List[str]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "redactionTokens"}
+    )
+    results: Optional[List[_result.Result]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "results"}
+    )
+    run_aggregates: Optional[
+        List[_run_automation_details.RunAutomationDetails]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "runAggregates"}
+    )
+    special_locations: Optional[
+        _special_locations.SpecialLocations
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "specialLocations"}
+    )
+    taxonomies: Optional[List[_tool_component.ToolComponent]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "taxonomies"}
+    )
+    thread_flow_locations: Optional[
+        List[_thread_flow_location.ThreadFlowLocation]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "threadFlowLocations"}
+    )
+    translations: Optional[List[_tool_component.ToolComponent]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "translations"}
+    )
+    version_control_provenance: Optional[
+        List[_version_control_details.VersionControlDetails]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "versionControlProvenance"}
+    )
+    web_requests: Optional[List[_web_request.WebRequest]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "webRequests"}
+    )
+    web_responses: Optional[List[_web_response.WebResponse]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "webResponses"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_run_automation_details.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_run_automation_details.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae63959240b34fd8d71d3eef87d40c240717431d
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_run_automation_details.py
@@ -0,0 +1,33 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import _message, _property_bag
+
+
+@dataclasses.dataclass
+class RunAutomationDetails(object):
+    """Information that describes a run's identity and role within an engineering system process."""
+
+    correlation_guid: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "correlationGuid"}
+    )
+    description: Optional[_message.Message] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "description"}
+    )
+    guid: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "guid"}
+    )
+    id: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "id"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_sarif_log.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_sarif_log.py
new file mode 100644
index 0000000000000000000000000000000000000000..c738222981e59eb4fc528d0b74088bd3134024dd
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_sarif_log.py
@@ -0,0 +1,37 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import List, Literal, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _external_properties,
+    _property_bag,
+    _run,
+)
+
+
+@dataclasses.dataclass
+class SarifLog(object):
+    """Static Analysis Results Format (SARIF) Version 2.1.0 JSON Schema: a standard format for the output of static analysis tools."""
+
+    runs: List[_run.Run] = dataclasses.field(metadata={"schema_property_name": "runs"})
+    version: Literal["2.1.0"] = dataclasses.field(
+        metadata={"schema_property_name": "version"}
+    )
+    schema_uri: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "$schema"}
+    )
+    inline_external_properties: Optional[
+        List[_external_properties.ExternalProperties]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "inlineExternalProperties"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_suppression.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_suppression.py
new file mode 100644
index 0000000000000000000000000000000000000000..c1dcb014809d994a4777917e5e1764388b48dff5
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_suppression.py
@@ -0,0 +1,36 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Literal, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import _location, _property_bag
+
+
+@dataclasses.dataclass
+class Suppression(object):
+    """A suppression that is relevant to a result."""
+
+    kind: Literal["inSource", "external"] = dataclasses.field(
+        metadata={"schema_property_name": "kind"}
+    )
+    guid: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "guid"}
+    )
+    justification: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "justification"}
+    )
+    location: Optional[_location.Location] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "location"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    state: Optional[Literal["accepted", "underReview", "rejected"]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "state"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_thread_flow_location.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_thread_flow_location.py
new file mode 100644
index 0000000000000000000000000000000000000000..43c67cf62ccf79a75d5227d0b2018bc29d416640
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_thread_flow_location.py
@@ -0,0 +1,67 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Any, List, Literal, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _location,
+    _property_bag,
+    _reporting_descriptor_reference,
+    _stack,
+    _web_request,
+    _web_response,
+)
+
+
+@dataclasses.dataclass
+class ThreadFlowLocation(object):
+    """A location visited by an analysis tool while simulating or monitoring the execution of a program."""
+
+    execution_order: int = dataclasses.field(
+        default=-1, metadata={"schema_property_name": "executionOrder"}
+    )
+    execution_time_utc: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "executionTimeUtc"}
+    )
+    importance: Literal["important", "essential", "unimportant"] = dataclasses.field(
+        default="important", metadata={"schema_property_name": "importance"}
+    )
+    index: int = dataclasses.field(
+        default=-1, metadata={"schema_property_name": "index"}
+    )
+    kinds: Optional[List[str]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "kinds"}
+    )
+    location: Optional[_location.Location] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "location"}
+    )
+    module: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "module"}
+    )
+    nesting_level: Optional[int] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "nestingLevel"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    stack: Optional[_stack.Stack] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "stack"}
+    )
+    state: Any = dataclasses.field(
+        default=None, metadata={"schema_property_name": "state"}
+    )
+    taxa: Optional[
+        List[_reporting_descriptor_reference.ReportingDescriptorReference]
+    ] = dataclasses.field(default=None, metadata={"schema_property_name": "taxa"})
+    web_request: Optional[_web_request.WebRequest] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "webRequest"}
+    )
+    web_response: Optional[_web_response.WebResponse] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "webResponse"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_tool.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_tool.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6cfa87b05d7599cdc4cefe203180b38dc39c1dc
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_tool.py
@@ -0,0 +1,27 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import List, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import _property_bag, _tool_component
+
+
+@dataclasses.dataclass
+class Tool(object):
+    """The analysis tool that was run."""
+
+    driver: _tool_component.ToolComponent = dataclasses.field(
+        metadata={"schema_property_name": "driver"}
+    )
+    extensions: Optional[List[_tool_component.ToolComponent]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "extensions"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_tool_component.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_tool_component.py
new file mode 100644
index 0000000000000000000000000000000000000000..2421393b8ac30097c1d1078d1456a54e5a1dcd76
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_tool_component.py
@@ -0,0 +1,123 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Any, List, Literal, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _artifact_location,
+    _multiformat_message_string,
+    _property_bag,
+    _reporting_descriptor,
+    _tool_component_reference,
+    _translation_metadata,
+)
+
+
+@dataclasses.dataclass
+class ToolComponent(object):
+    """A component, such as a plug-in or the driver, of the analysis tool that was run."""
+
+    name: str = dataclasses.field(metadata={"schema_property_name": "name"})
+    associated_component: Optional[
+        _tool_component_reference.ToolComponentReference
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "associatedComponent"}
+    )
+    contents: List[Literal["localizedData", "nonLocalizedData"]] = dataclasses.field(
+        default_factory=lambda: ["localizedData", "nonLocalizedData"],
+        metadata={"schema_property_name": "contents"},
+    )
+    dotted_quad_file_version: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "dottedQuadFileVersion"}
+    )
+    download_uri: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "downloadUri"}
+    )
+    full_description: Optional[
+        _multiformat_message_string.MultiformatMessageString
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "fullDescription"}
+    )
+    full_name: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "fullName"}
+    )
+    global_message_strings: Any = dataclasses.field(
+        default=None, metadata={"schema_property_name": "globalMessageStrings"}
+    )
+    guid: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "guid"}
+    )
+    information_uri: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "informationUri"}
+    )
+    is_comprehensive: Optional[bool] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "isComprehensive"}
+    )
+    language: str = dataclasses.field(
+        default="en-US", metadata={"schema_property_name": "language"}
+    )
+    localized_data_semantic_version: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "localizedDataSemanticVersion"}
+    )
+    locations: Optional[List[_artifact_location.ArtifactLocation]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "locations"}
+    )
+    minimum_required_localized_data_semantic_version: Optional[str] = dataclasses.field(
+        default=None,
+        metadata={
+            "schema_property_name": "minimumRequiredLocalizedDataSemanticVersion"
+        },
+    )
+    notifications: Optional[
+        List[_reporting_descriptor.ReportingDescriptor]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "notifications"}
+    )
+    organization: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "organization"}
+    )
+    product: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "product"}
+    )
+    product_suite: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "productSuite"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    release_date_utc: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "releaseDateUtc"}
+    )
+    rules: Optional[
+        List[_reporting_descriptor.ReportingDescriptor]
+    ] = dataclasses.field(default=None, metadata={"schema_property_name": "rules"})
+    semantic_version: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "semanticVersion"}
+    )
+    short_description: Optional[
+        _multiformat_message_string.MultiformatMessageString
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "shortDescription"}
+    )
+    supported_taxonomies: Optional[
+        List[_tool_component_reference.ToolComponentReference]
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "supportedTaxonomies"}
+    )
+    taxa: Optional[List[_reporting_descriptor.ReportingDescriptor]] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "taxa"}
+    )
+    translation_metadata: Optional[
+        _translation_metadata.TranslationMetadata
+    ] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "translationMetadata"}
+    )
+    version: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "version"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_web_response.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_web_response.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e86deedb3c6319448868a2a355d4f0721912635
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_web_response.py
@@ -0,0 +1,48 @@
+# DO NOT EDIT! This file was generated by jschema_to_python version 0.0.1.dev29,
+# with extension for dataclasses and type annotation.
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Any, Optional
+
+from torch.onnx._internal.diagnostics.infra.sarif import (
+    _artifact_content,
+    _property_bag,
+)
+
+
+@dataclasses.dataclass
+class WebResponse(object):
+    """Describes the response to an HTTP request."""
+
+    body: Optional[_artifact_content.ArtifactContent] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "body"}
+    )
+    headers: Any = dataclasses.field(
+        default=None, metadata={"schema_property_name": "headers"}
+    )
+    index: int = dataclasses.field(
+        default=-1, metadata={"schema_property_name": "index"}
+    )
+    no_response_received: Optional[bool] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "noResponseReceived"}
+    )
+    properties: Optional[_property_bag.PropertyBag] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "properties"}
+    )
+    protocol: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "protocol"}
+    )
+    reason_phrase: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "reasonPhrase"}
+    )
+    status_code: Optional[int] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "statusCode"}
+    )
+    version: Optional[str] = dataclasses.field(
+        default=None, metadata={"schema_property_name": "version"}
+    )
+
+
+# flake8: noqa
diff --git a/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/utils.py b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..4648b477515025d8fea7df71a7c732c2ed4fb764
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/torch/onnx/_internal/diagnostics/infra/utils.py
@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import functools
+
+import inspect
+import traceback
+from typing import Any, Callable, Dict, Mapping, Optional, Sequence, Tuple
+
+from torch.onnx._internal import _beartype
+from torch.onnx._internal.diagnostics.infra import _infra, formatter
+
+
+@_beartype.beartype
+def python_frame(frame: traceback.FrameSummary) -> _infra.StackFrame:
+    """Returns a StackFrame for the given traceback.FrameSummary."""
+    snippet = frame.line
+
+    return _infra.StackFrame(
+        location=_infra.Location(
+            uri=frame.filename,
+            line=frame.lineno,
+            snippet=snippet,
+            function=frame.name,
+            message=snippet,
+        )
+    )
+
+
+@_beartype.beartype
+def python_call_stack(frames_to_skip: int = 0, frames_to_log: int = 16) -> _infra.Stack:
+    """Returns the current Python call stack."""
+    if frames_to_skip < 0:
+        raise ValueError("frames_to_skip must be non-negative")
+    if frames_to_log < 0:
+        raise ValueError("frames_to_log must be non-negative")
+    frames_to_skip += 2  # Skip this function and beartype.
+    stack = _infra.Stack()
+    # Frames are returned in order of oldest to newest.
+    frames = traceback.extract_stack(limit=frames_to_skip + frames_to_log)
+    frames.reverse()
+    stack.frames = [python_frame(frame) for frame in frames[frames_to_skip:]]
+    stack.message = "Python call stack"
+    return stack
+
+
+@functools.lru_cache
+def _function_source_info(fn: Callable) -> Tuple[Sequence[str], int, Optional[str]]:
+    """Returns the source lines, line number, and source file path for the given function.
+
+    Essentially, inspect.getsourcelines() and inspect.getsourcefile() combined.
+    Caching is applied to reduce the performance impact of this function.
+    """
+    source_lines, lineno = inspect.getsourcelines(fn)
+    return source_lines, lineno, inspect.getsourcefile(fn)
+
+
+@_beartype.beartype
+def function_location(fn: Callable) -> _infra.Location:
+    """Returns a Location for the given function."""
+    source_lines, lineno, uri = _function_source_info(fn)
+    snippet = source_lines[0].strip() if len(source_lines) > 0 else "<unknown>"
+    return _infra.Location(
+        uri=uri,
+        line=lineno,
+        snippet=snippet,
+        message=formatter.display_name(fn),
+    )
+
+
+@_beartype.beartype
+def function_state(
+    fn: Callable, args: Tuple[Any, ...], kwargs: Dict[str, Any]
+) -> Mapping[str, Any]:
+    bind = inspect.signature(fn).bind(*args, **kwargs)
+    return bind.arguments