Add files using upload-large-folder tool

evalkit_cambrian/lib/python3.10/site-packages/exceptiongroup-1.2.2.dist-info/INSTALLER

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

evalkit_cambrian/lib/python3.10/site-packages/exceptiongroup-1.2.2.dist-info/RECORD

@@ -0,0 +1,19 @@
+exceptiongroup-1.2.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+exceptiongroup-1.2.2.dist-info/LICENSE,sha256=blBw12UDHgrUA6HL-Qrm0ZoCKPgC4yC3rP9GCqcu1Hw,3704
+exceptiongroup-1.2.2.dist-info/METADATA,sha256=Ga1aA-LKR7SBZ4YVngvE0hRhLf9jVig38rLOHNgsDls,6636
+exceptiongroup-1.2.2.dist-info/RECORD,,
+exceptiongroup-1.2.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+exceptiongroup-1.2.2.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+exceptiongroup/__init__.py,sha256=7DHS0hDk-RIs3IQc3SbZVB0-1MhiSCJ9XgvEyEloL7M,1049
+exceptiongroup/__pycache__/__init__.cpython-310.pyc,,
+exceptiongroup/__pycache__/_catch.cpython-310.pyc,,
+exceptiongroup/__pycache__/_exceptions.cpython-310.pyc,,
+exceptiongroup/__pycache__/_formatting.cpython-310.pyc,,
+exceptiongroup/__pycache__/_suppress.cpython-310.pyc,,
+exceptiongroup/__pycache__/_version.cpython-310.pyc,,
+exceptiongroup/_catch.py,sha256=CaJez3E-Jkr-7B7RT3fzusdLWnuyeekooSFn7KyWt9s,4680
+exceptiongroup/_exceptions.py,sha256=h9vJO-Z8ufTr2iAb0S5mrKvkNtWZlqsWYHbNQjzC23I,11144
+exceptiongroup/_formatting.py,sha256=eu1bsvfX6ejwPwhgH1u5hrTnb2NSDH3n0Vx1uiKOrn0,20938
+exceptiongroup/_suppress.py,sha256=LX11PRNpchwfNWwEMY92nYN1F_5qFenQcS8EjIONXKE,1772
+exceptiongroup/_version.py,sha256=XEVwqOPlIChKtEnSO5v_SvghWXnn9WeQSoJ436w3v9Y,411
+exceptiongroup/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

evalkit_cambrian/lib/python3.10/site-packages/jinja2-3.1.5.dist-info/INSTALLER

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

evalkit_cambrian/lib/python3.10/site-packages/jinja2-3.1.5.dist-info/LICENSE.txt

@@ -0,0 +1,28 @@
+Copyright 2007 Pallets
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1.  Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+3.  Neither the name of the copyright holder nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

evalkit_cambrian/lib/python3.10/site-packages/jinja2-3.1.5.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.3
+Name: Jinja2
+Version: 3.1.5
+Summary: A very fast and expressive template engine.
+Maintainer-email: Pallets <contact@palletsprojects.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Classifier: Typing :: Typed
+Requires-Dist: MarkupSafe>=2.0
+Requires-Dist: Babel>=2.7 ; extra == "i18n"
+Project-URL: Changes, https://jinja.palletsprojects.com/changes/
+Project-URL: Chat, https://discord.gg/pallets
+Project-URL: Documentation, https://jinja.palletsprojects.com/
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Source, https://github.com/pallets/jinja/
+Provides-Extra: i18n
+
+# Jinja
+
+Jinja is a fast, expressive, extensible templating engine. Special
+placeholders in the template allow writing code similar to Python
+syntax. Then the template is passed data to render the final document.
+
+It includes:
+
+-   Template inheritance and inclusion.
+-   Define and import macros within templates.
+-   HTML templates can use autoescaping to prevent XSS from untrusted
+    user input.
+-   A sandboxed environment can safely render untrusted templates.
+-   AsyncIO support for generating templates and calling async
+    functions.
+-   I18N support with Babel.
+-   Templates are compiled to optimized Python code just-in-time and
+    cached, or can be compiled ahead-of-time.
+-   Exceptions point to the correct line in templates to make debugging
+    easier.
+-   Extensible filters, tests, functions, and even syntax.
+
+Jinja's philosophy is that while application logic belongs in Python if
+possible, it shouldn't make the template designer's job difficult by
+restricting functionality too much.
+
+
+## In A Nutshell
+
+```jinja
+{% extends "base.html" %}
+{% block title %}Members{% endblock %}
+{% block content %}
+  <ul>
+  {% for user in users %}
+    <li><a href="{{ user.url }}">{{ user.username }}</a></li>
+  {% endfor %}
+  </ul>
+{% endblock %}
+```
+
+## Donate
+
+The Pallets organization develops and supports Jinja and other popular
+packages. In order to grow the community of contributors and users, and
+allow the maintainers to devote more time to the projects, [please
+donate today][].
+
+[please donate today]: https://palletsprojects.com/donate
+

evalkit_cambrian/lib/python3.10/site-packages/jinja2-3.1.5.dist-info/WHEEL

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

evalkit_cambrian/lib/python3.10/site-packages/jsonschema_specifications/__init__.py

@@ -0,0 +1,12 @@
+"""
+The JSON Schema meta-schemas and vocabularies, exposed as a Registry.
+"""
+
+from referencing.jsonschema import EMPTY_REGISTRY as _EMPTY_REGISTRY
+
+from jsonschema_specifications._core import _schemas
+
+#: A `referencing.jsonschema.SchemaRegistry` containing all of the official
+#: meta-schemas and vocabularies.
+REGISTRY = (_schemas() @ _EMPTY_REGISTRY).crawl()
+__all__ = ["REGISTRY"]

evalkit_cambrian/lib/python3.10/site-packages/jsonschema_specifications/_core.py

@@ -0,0 +1,38 @@
+"""
+Load all the JSON Schema specification's official schemas.
+"""
+
+import json
+
+try:
+    from importlib.resources import files
+except ImportError:
+    from importlib_resources import (  # type: ignore[import-not-found, no-redef]
+        files,
+    )
+
+from referencing import Resource
+
+
+def _schemas():
+    """
+    All schemas we ship.
+    """
+    # importlib.resources.abc.Traversal doesn't have nice ways to do this that
+    # I'm aware of...
+    #
+    # It can't recurse arbitrarily, e.g. no ``.glob()``.
+    #
+    # So this takes some liberties given the real layout of what we ship
+    # (only 2 levels of nesting, no directories within the second level).
+
+    for version in files(__package__).joinpath("schemas").iterdir():
+        if version.name.startswith("."):
+            continue
+        for child in version.iterdir():
+            children = [child] if child.is_file() else child.iterdir()
+            for path in children:
+                if path.name.startswith("."):
+                    continue
+                contents = json.loads(path.read_text(encoding="utf-8"))
+                yield Resource.from_contents(contents)

evalkit_cambrian/lib/python3.10/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/applicator

@@ -0,0 +1,56 @@
+{
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$id": "https://json-schema.org/draft/2019-09/meta/applicator",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2019-09/vocab/applicator": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Applicator vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "additionalItems": { "$recursiveRef": "#" },
+        "unevaluatedItems": { "$recursiveRef": "#" },
+        "items": {
+            "anyOf": [
+                { "$recursiveRef": "#" },
+                { "$ref": "#/$defs/schemaArray" }
+            ]
+        },
+        "contains": { "$recursiveRef": "#" },
+        "additionalProperties": { "$recursiveRef": "#" },
+        "unevaluatedProperties": { "$recursiveRef": "#" },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$recursiveRef": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$recursiveRef": "#" },
+            "propertyNames": { "format": "regex" },
+            "default": {}
+        },
+        "dependentSchemas": {
+            "type": "object",
+            "additionalProperties": {
+                "$recursiveRef": "#"
+            }
+        },
+        "propertyNames": { "$recursiveRef": "#" },
+        "if": { "$recursiveRef": "#" },
+        "then": { "$recursiveRef": "#" },
+        "else": { "$recursiveRef": "#" },
+        "allOf": { "$ref": "#/$defs/schemaArray" },
+        "anyOf": { "$ref": "#/$defs/schemaArray" },
+        "oneOf": { "$ref": "#/$defs/schemaArray" },
+        "not": { "$recursiveRef": "#" }
+    },
+    "$defs": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$recursiveRef": "#" }
+        }
+    }
+}

evalkit_cambrian/lib/python3.10/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/content

@@ -0,0 +1,17 @@
+{
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$id": "https://json-schema.org/draft/2019-09/meta/content",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2019-09/vocab/content": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Content vocabulary meta-schema",
+
+    "type": ["object", "boolean"],
+    "properties": {
+        "contentMediaType": { "type": "string" },
+        "contentEncoding": { "type": "string" },
+        "contentSchema": { "$recursiveRef": "#" }
+    }
+}

evalkit_cambrian/lib/python3.10/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/core

@@ -0,0 +1,57 @@
+{
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$id": "https://json-schema.org/draft/2019-09/meta/core",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2019-09/vocab/core": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Core vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "type": "string",
+            "format": "uri-reference",
+            "$comment": "Non-empty fragments not allowed.",
+            "pattern": "^[^#]*#?$"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$anchor": {
+            "type": "string",
+            "pattern": "^[A-Za-z][-A-Za-z0-9.:_]*$"
+        },
+        "$ref": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$recursiveRef": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$recursiveAnchor": {
+            "type": "boolean",
+            "default": false
+        },
+        "$vocabulary": {
+            "type": "object",
+            "propertyNames": {
+                "type": "string",
+                "format": "uri"
+            },
+            "additionalProperties": {
+                "type": "boolean"
+            }
+        },
+        "$comment": {
+            "type": "string"
+        },
+        "$defs": {
+            "type": "object",
+            "additionalProperties": { "$recursiveRef": "#" },
+            "default": {}
+        }
+    }
+}

evalkit_cambrian/lib/python3.10/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/validation

@@ -0,0 +1,98 @@
+{
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$id": "https://json-schema.org/draft/2019-09/meta/validation",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2019-09/vocab/validation": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Validation vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "multipleOf": {
+            "type": "number",
+            "exclusiveMinimum": 0
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "number"
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "number"
+        },
+        "maxLength": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minLength": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "maxItems": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minItems": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxContains": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minContains": {
+            "$ref": "#/$defs/nonNegativeInteger",
+            "default": 1
+        },
+        "maxProperties": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minProperties": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+        "required": { "$ref": "#/$defs/stringArray" },
+        "dependentRequired": {
+            "type": "object",
+            "additionalProperties": {
+                "$ref": "#/$defs/stringArray"
+            }
+        },
+        "const": true,
+        "enum": {
+            "type": "array",
+            "items": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/$defs/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/$defs/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        }
+    },
+    "$defs": {
+        "nonNegativeInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "nonNegativeIntegerDefault0": {
+            "$ref": "#/$defs/nonNegativeInteger",
+            "default": 0
+        },
+        "simpleTypes": {
+            "enum": [
+                "array",
+                "boolean",
+                "integer",
+                "null",
+                "number",
+                "object",
+                "string"
+            ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "uniqueItems": true,
+            "default": []
+        }
+    }
+}

evalkit_cambrian/lib/python3.10/site-packages/jsonschema_specifications/schemas/draft202012/metaschema.json

@@ -0,0 +1,58 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/schema",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/core": true,
+        "https://json-schema.org/draft/2020-12/vocab/applicator": true,
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+        "https://json-schema.org/draft/2020-12/vocab/validation": true,
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+        "https://json-schema.org/draft/2020-12/vocab/content": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Core and Validation specifications meta-schema",
+    "allOf": [
+        {"$ref": "meta/core"},
+        {"$ref": "meta/applicator"},
+        {"$ref": "meta/unevaluated"},
+        {"$ref": "meta/validation"},
+        {"$ref": "meta/meta-data"},
+        {"$ref": "meta/format-annotation"},
+        {"$ref": "meta/content"}
+    ],
+    "type": ["object", "boolean"],
+    "$comment": "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
+    "properties": {
+        "definitions": {
+            "$comment": "\"definitions\" has been replaced by \"$defs\".",
+            "type": "object",
+            "additionalProperties": { "$dynamicRef": "#meta" },
+            "deprecated": true,
+            "default": {}
+        },
+        "dependencies": {
+            "$comment": "\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.",
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$dynamicRef": "#meta" },
+                    { "$ref": "meta/validation#/$defs/stringArray" }
+                ]
+            },
+            "deprecated": true,
+            "default": {}
+        },
+        "$recursiveAnchor": {
+            "$comment": "\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".",
+            "$ref": "meta/core#/$defs/anchorString",
+            "deprecated": true
+        },
+        "$recursiveRef": {
+            "$comment": "\"$recursiveRef\" has been replaced by \"$dynamicRef\".",
+            "$ref": "meta/core#/$defs/uriReferenceString",
+            "deprecated": true
+        }
+    }
+}

evalkit_cambrian/lib/python3.10/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/format-annotation

@@ -0,0 +1,14 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/meta/format-annotation",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Format vocabulary meta-schema for annotation results",
+    "type": ["object", "boolean"],
+    "properties": {
+        "format": { "type": "string" }
+    }
+}

evalkit_cambrian/lib/python3.10/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/unevaluated

@@ -0,0 +1,15 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/meta/unevaluated",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Unevaluated applicator vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "unevaluatedItems": { "$dynamicRef": "#meta" },
+        "unevaluatedProperties": { "$dynamicRef": "#meta" }
+    }
+}

evalkit_cambrian/lib/python3.10/site-packages/jsonschema_specifications/schemas/draft4/metaschema.json

@@ -0,0 +1,149 @@
+{
+    "id": "http://json-schema.org/draft-04/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "positiveInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "positiveIntegerDefault0": {
+            "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
+        },
+        "simpleTypes": {
+            "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "minItems": 1,
+            "uniqueItems": true
+        }
+    },
+    "type": "object",
+    "properties": {
+        "id": {
+            "type": "string"
+        },
+        "$schema": {
+            "type": "string"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "multipleOf": {
+            "type": "number",
+            "minimum": 0,
+            "exclusiveMinimum": true
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "boolean",
+            "default": false
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxLength": { "$ref": "#/definitions/positiveInteger" },
+        "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/positiveInteger" },
+        "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxProperties": { "$ref": "#/definitions/positiveInteger" },
+        "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "dependencies": {
+        "exclusiveMaximum": [ "maximum" ],
+        "exclusiveMinimum": [ "minimum" ]
+    },
+    "default": {}
+}

evalkit_cambrian/lib/python3.10/site-packages/jsonschema_specifications/schemas/draft6/metaschema.json

@@ -0,0 +1,153 @@
+{
+    "$schema": "http://json-schema.org/draft-06/schema#",
+    "$id": "http://json-schema.org/draft-06/schema#",
+    "title": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "nonNegativeInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "nonNegativeIntegerDefault0": {
+            "allOf": [
+                { "$ref": "#/definitions/nonNegativeInteger" },
+                { "default": 0 }
+            ]
+        },
+        "simpleTypes": {
+            "enum": [
+                "array",
+                "boolean",
+                "integer",
+                "null",
+                "number",
+                "object",
+                "string"
+            ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "uniqueItems": true,
+            "default": []
+        }
+    },
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$ref": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "examples": {
+            "type": "array",
+            "items": {}
+        },
+        "multipleOf": {
+            "type": "number",
+            "exclusiveMinimum": 0
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "number"
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "number"
+        },
+        "maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": { "$ref": "#" },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "contains": { "$ref": "#" },
+        "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": { "$ref": "#" },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "propertyNames": { "format": "regex" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "propertyNames": { "$ref": "#" },
+        "const": {},
+        "enum": {
+            "type": "array"
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "default": {}
+}

evalkit_cambrian/lib/python3.10/site-packages/jsonschema_specifications/schemas/draft7/metaschema.json

@@ -0,0 +1,166 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "$id": "http://json-schema.org/draft-07/schema#",
+    "title": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "nonNegativeInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "nonNegativeIntegerDefault0": {
+            "allOf": [
+                { "$ref": "#/definitions/nonNegativeInteger" },
+                { "default": 0 }
+            ]
+        },
+        "simpleTypes": {
+            "enum": [
+                "array",
+                "boolean",
+                "integer",
+                "null",
+                "number",
+                "object",
+                "string"
+            ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "uniqueItems": true,
+            "default": []
+        }
+    },
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$ref": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$comment": {
+            "type": "string"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": true,
+        "readOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "examples": {
+            "type": "array",
+            "items": true
+        },
+        "multipleOf": {
+            "type": "number",
+            "exclusiveMinimum": 0
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "number"
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "number"
+        },
+        "maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": { "$ref": "#" },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": true
+        },
+        "maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "contains": { "$ref": "#" },
+        "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": { "$ref": "#" },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "propertyNames": { "format": "regex" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "propertyNames": { "$ref": "#" },
+        "const": true,
+        "enum": {
+            "type": "array",
+            "items": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "contentMediaType": { "type": "string" },
+        "contentEncoding": { "type": "string" },
+        "if": {"$ref": "#"},
+        "then": {"$ref": "#"},
+        "else": {"$ref": "#"},
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "default": true
+}

evalkit_cambrian/lib/python3.10/site-packages/jsonschema_specifications/tests/test_jsonschema_specifications.py

@@ -0,0 +1,41 @@
+from collections.abc import Mapping
+from pathlib import Path
+
+import pytest
+
+from jsonschema_specifications import REGISTRY
+
+
+def test_it_contains_metaschemas():
+    schema = REGISTRY.contents("http://json-schema.org/draft-07/schema#")
+    assert isinstance(schema, Mapping)
+    assert schema["$id"] == "http://json-schema.org/draft-07/schema#"
+    assert schema["title"] == "Core schema meta-schema"
+
+
+def test_it_is_crawled():
+    assert REGISTRY.crawl() == REGISTRY
+
+
+@pytest.mark.parametrize(
+    "ignored_relative_path",
+    ["schemas/.DS_Store", "schemas/draft7/.DS_Store"],
+)
+def test_it_copes_with_dotfiles(ignored_relative_path):
+    """
+    Ignore files like .DS_Store if someone has actually caused one to exist.
+
+    We test here through the private interface as of course the global has
+    already loaded our schemas.
+    """
+
+    import jsonschema_specifications
+
+    package = Path(jsonschema_specifications.__file__).parent
+
+    ignored = package / ignored_relative_path
+    ignored.touch()
+    try:
+        list(jsonschema_specifications._schemas())
+    finally:
+        ignored.unlink()

evalkit_cambrian/lib/python3.10/site-packages/matplotlib_inline-0.1.7.dist-info/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2019-2022, IPython Development Team.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

evalkit_cambrian/lib/python3.10/site-packages/multidict/__init__.py

@@ -0,0 +1,48 @@
+"""Multidict implementation.
+
+HTTP Headers and URL query string require specific data structure:
+multidict. It behaves mostly like a dict but it can have
+several values for the same key.
+"""
+
+from ._abc import MultiMapping, MutableMultiMapping
+from ._compat import USE_EXTENSIONS
+
+__all__ = (
+    "MultiMapping",
+    "MutableMultiMapping",
+    "MultiDictProxy",
+    "CIMultiDictProxy",
+    "MultiDict",
+    "CIMultiDict",
+    "upstr",
+    "istr",
+    "getversion",
+)
+
+__version__ = "6.1.0"
+
+
+try:
+    if not USE_EXTENSIONS:
+        raise ImportError
+    from ._multidict import (
+        CIMultiDict,
+        CIMultiDictProxy,
+        MultiDict,
+        MultiDictProxy,
+        getversion,
+        istr,
+    )
+except ImportError:  # pragma: no cover
+    from ._multidict_py import (
+        CIMultiDict,
+        CIMultiDictProxy,
+        MultiDict,
+        MultiDictProxy,
+        getversion,
+        istr,
+    )
+
+
+upstr = istr

evalkit_cambrian/lib/python3.10/site-packages/multidict/__init__.pyi

@@ -0,0 +1,152 @@
+import abc
+from typing import (
+    Generic,
+    Iterable,
+    Iterator,
+    Mapping,
+    MutableMapping,
+    TypeVar,
+    overload,
+)
+
+class istr(str): ...
+
+upstr = istr
+
+_S = str | istr
+
+_T = TypeVar("_T")
+
+_T_co = TypeVar("_T_co", covariant=True)
+
+_D = TypeVar("_D")
+
+class MultiMapping(Mapping[_S, _T_co]):
+    @overload
+    @abc.abstractmethod
+    def getall(self, key: _S) -> list[_T_co]: ...
+    @overload
+    @abc.abstractmethod
+    def getall(self, key: _S, default: _D) -> list[_T_co] | _D: ...
+    @overload
+    @abc.abstractmethod
+    def getone(self, key: _S) -> _T_co: ...
+    @overload
+    @abc.abstractmethod
+    def getone(self, key: _S, default: _D) -> _T_co | _D: ...
+
+_Arg = (
+    Mapping[str, _T]
+    | Mapping[istr, _T]
+    | dict[str, _T]
+    | dict[istr, _T]
+    | MultiMapping[_T]
+    | Iterable[tuple[str, _T]]
+    | Iterable[tuple[istr, _T]]
+)
+
+class MutableMultiMapping(MultiMapping[_T], MutableMapping[_S, _T], Generic[_T]):
+    @abc.abstractmethod
+    def add(self, key: _S, value: _T) -> None: ...
+    @abc.abstractmethod
+    def extend(self, arg: _Arg[_T] = ..., **kwargs: _T) -> None: ...
+    @overload
+    @abc.abstractmethod
+    def popone(self, key: _S) -> _T: ...
+    @overload
+    @abc.abstractmethod
+    def popone(self, key: _S, default: _D) -> _T | _D: ...
+    @overload
+    @abc.abstractmethod
+    def popall(self, key: _S) -> list[_T]: ...
+    @overload
+    @abc.abstractmethod
+    def popall(self, key: _S, default: _D) -> list[_T] | _D: ...
+
+class MultiDict(MutableMultiMapping[_T], Generic[_T]):
+    def __init__(self, arg: _Arg[_T] = ..., **kwargs: _T) -> None: ...
+    def copy(self) -> MultiDict[_T]: ...
+    def __getitem__(self, k: _S) -> _T: ...
+    def __setitem__(self, k: _S, v: _T) -> None: ...
+    def __delitem__(self, v: _S) -> None: ...
+    def __iter__(self) -> Iterator[_S]: ...
+    def __len__(self) -> int: ...
+    @overload
+    def getall(self, key: _S) -> list[_T]: ...
+    @overload
+    def getall(self, key: _S, default: _D) -> list[_T] | _D: ...
+    @overload
+    def getone(self, key: _S) -> _T: ...
+    @overload
+    def getone(self, key: _S, default: _D) -> _T | _D: ...
+    def add(self, key: _S, value: _T) -> None: ...
+    def extend(self, arg: _Arg[_T] = ..., **kwargs: _T) -> None: ...
+    @overload
+    def popone(self, key: _S) -> _T: ...
+    @overload
+    def popone(self, key: _S, default: _D) -> _T | _D: ...
+    @overload
+    def popall(self, key: _S) -> list[_T]: ...
+    @overload
+    def popall(self, key: _S, default: _D) -> list[_T] | _D: ...
+
+class CIMultiDict(MutableMultiMapping[_T], Generic[_T]):
+    def __init__(self, arg: _Arg[_T] = ..., **kwargs: _T) -> None: ...
+    def copy(self) -> CIMultiDict[_T]: ...
+    def __getitem__(self, k: _S) -> _T: ...
+    def __setitem__(self, k: _S, v: _T) -> None: ...
+    def __delitem__(self, v: _S) -> None: ...
+    def __iter__(self) -> Iterator[_S]: ...
+    def __len__(self) -> int: ...
+    @overload
+    def getall(self, key: _S) -> list[_T]: ...
+    @overload
+    def getall(self, key: _S, default: _D) -> list[_T] | _D: ...
+    @overload
+    def getone(self, key: _S) -> _T: ...
+    @overload
+    def getone(self, key: _S, default: _D) -> _T | _D: ...
+    def add(self, key: _S, value: _T) -> None: ...
+    def extend(self, arg: _Arg[_T] = ..., **kwargs: _T) -> None: ...
+    @overload
+    def popone(self, key: _S) -> _T: ...
+    @overload
+    def popone(self, key: _S, default: _D) -> _T | _D: ...
+    @overload
+    def popall(self, key: _S) -> list[_T]: ...
+    @overload
+    def popall(self, key: _S, default: _D) -> list[_T] | _D: ...
+
+class MultiDictProxy(MultiMapping[_T], Generic[_T]):
+    def __init__(self, arg: MultiMapping[_T] | MutableMultiMapping[_T]) -> None: ...
+    def copy(self) -> MultiDict[_T]: ...
+    def __getitem__(self, k: _S) -> _T: ...
+    def __iter__(self) -> Iterator[_S]: ...
+    def __len__(self) -> int: ...
+    @overload
+    def getall(self, key: _S) -> list[_T]: ...
+    @overload
+    def getall(self, key: _S, default: _D) -> list[_T] | _D: ...
+    @overload
+    def getone(self, key: _S) -> _T: ...
+    @overload
+    def getone(self, key: _S, default: _D) -> _T | _D: ...
+
+class CIMultiDictProxy(MultiMapping[_T], Generic[_T]):
+    def __init__(self, arg: MultiMapping[_T] | MutableMultiMapping[_T]) -> None: ...
+    def __getitem__(self, k: _S) -> _T: ...
+    def __iter__(self) -> Iterator[_S]: ...
+    def __len__(self) -> int: ...
+    @overload
+    def getall(self, key: _S) -> list[_T]: ...
+    @overload
+    def getall(self, key: _S, default: _D) -> list[_T] | _D: ...
+    @overload
+    def getone(self, key: _S) -> _T: ...
+    @overload
+    def getone(self, key: _S, default: _D) -> _T | _D: ...
+    def copy(self) -> CIMultiDict[_T]: ...
+
+def getversion(
+    md: MultiDict[_T] | CIMultiDict[_T] | MultiDictProxy[_T] | CIMultiDictProxy[_T],
+) -> int: ...

evalkit_cambrian/lib/python3.10/site-packages/multidict/_abc.py

@@ -0,0 +1,48 @@
+import abc
+import sys
+import types
+from collections.abc import Mapping, MutableMapping
+
+
+class _TypingMeta(abc.ABCMeta):
+    # A fake metaclass to satisfy typing deps in runtime
+    # basically MultiMapping[str] and other generic-like type instantiations
+    # are emulated.
+    # Note: real type hints are provided by __init__.pyi stub file
+    if sys.version_info >= (3, 9):
+
+        def __getitem__(self, key):
+            return types.GenericAlias(self, key)
+
+    else:
+
+        def __getitem__(self, key):
+            return self
+
+
+class MultiMapping(Mapping, metaclass=_TypingMeta):
+    @abc.abstractmethod
+    def getall(self, key, default=None):
+        raise KeyError
+
+    @abc.abstractmethod
+    def getone(self, key, default=None):
+        raise KeyError
+
+
+class MutableMultiMapping(MultiMapping, MutableMapping):
+    @abc.abstractmethod
+    def add(self, key, value):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def extend(self, *args, **kwargs):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def popone(self, key, default=None):
+        raise KeyError
+
+    @abc.abstractmethod
+    def popall(self, key, default=None):
+        raise KeyError

evalkit_cambrian/lib/python3.10/site-packages/multidict/_compat.py

@@ -0,0 +1,14 @@
+import os
+import platform
+
+NO_EXTENSIONS = bool(os.environ.get("MULTIDICT_NO_EXTENSIONS"))
+
+PYPY = platform.python_implementation() == "PyPy"
+
+USE_EXTENSIONS = not NO_EXTENSIONS and not PYPY
+
+if USE_EXTENSIONS:
+    try:
+        from . import _multidict  # type: ignore[attr-defined]  # noqa: F401
+    except ImportError:
+        USE_EXTENSIONS = False

evalkit_cambrian/lib/python3.10/site-packages/multidict/_multidict_base.py

@@ -0,0 +1,152 @@
+import sys
+from collections.abc import ItemsView, Iterable, KeysView, Set, ValuesView
+
+if sys.version_info >= (3, 11):
+    from typing import assert_never
+else:
+    from typing_extensions import assert_never
+
+
+def _abc_itemsview_register(view_cls):
+    ItemsView.register(view_cls)
+
+
+def _abc_keysview_register(view_cls):
+    KeysView.register(view_cls)
+
+
+def _abc_valuesview_register(view_cls):
+    ValuesView.register(view_cls)
+
+
+def _viewbaseset_richcmp(view, other, op):
+    if op == 0:  # <
+        if not isinstance(other, Set):
+            return NotImplemented
+        return len(view) < len(other) and view <= other
+    elif op == 1:  # <=
+        if not isinstance(other, Set):
+            return NotImplemented
+        if len(view) > len(other):
+            return False
+        for elem in view:
+            if elem not in other:
+                return False
+        return True
+    elif op == 2:  # ==
+        if not isinstance(other, Set):
+            return NotImplemented
+        return len(view) == len(other) and view <= other
+    elif op == 3:  # !=
+        return not view == other
+    elif op == 4:  # >
+        if not isinstance(other, Set):
+            return NotImplemented
+        return len(view) > len(other) and view >= other
+    elif op == 5:  # >=
+        if not isinstance(other, Set):
+            return NotImplemented
+        if len(view) < len(other):
+            return False
+        for elem in other:
+            if elem not in view:
+                return False
+        return True
+    else:  # pragma: no cover
+        assert_never(op)
+
+
+def _viewbaseset_and(view, other):
+    if not isinstance(other, Iterable):
+        return NotImplemented
+    if isinstance(view, Set):
+        view = set(iter(view))
+    if isinstance(other, Set):
+        other = set(iter(other))
+    if not isinstance(other, Set):
+        other = set(iter(other))
+    return view & other
+
+
+def _viewbaseset_or(view, other):
+    if not isinstance(other, Iterable):
+        return NotImplemented
+    if isinstance(view, Set):
+        view = set(iter(view))
+    if isinstance(other, Set):
+        other = set(iter(other))
+    if not isinstance(other, Set):
+        other = set(iter(other))
+    return view | other
+
+
+def _viewbaseset_sub(view, other):
+    if not isinstance(other, Iterable):
+        return NotImplemented
+    if isinstance(view, Set):
+        view = set(iter(view))
+    if isinstance(other, Set):
+        other = set(iter(other))
+    if not isinstance(other, Set):
+        other = set(iter(other))
+    return view - other
+
+
+def _viewbaseset_xor(view, other):
+    if not isinstance(other, Iterable):
+        return NotImplemented
+    if isinstance(view, Set):
+        view = set(iter(view))
+    if isinstance(other, Set):
+        other = set(iter(other))
+    if not isinstance(other, Set):
+        other = set(iter(other))
+    return view ^ other
+
+
+def _itemsview_isdisjoint(view, other):
+    "Return True if two sets have a null intersection."
+    for v in other:
+        if v in view:
+            return False
+    return True
+
+
+def _itemsview_repr(view):
+    lst = []
+    for k, v in view:
+        lst.append("{!r}: {!r}".format(k, v))
+    body = ", ".join(lst)
+    return "{}({})".format(view.__class__.__name__, body)
+
+
+def _keysview_isdisjoint(view, other):
+    "Return True if two sets have a null intersection."
+    for k in other:
+        if k in view:
+            return False
+    return True
+
+
+def _keysview_repr(view):
+    lst = []
+    for k in view:
+        lst.append("{!r}".format(k))
+    body = ", ".join(lst)
+    return "{}({})".format(view.__class__.__name__, body)
+
+
+def _valuesview_repr(view):
+    lst = []
+    for v in view:
+        lst.append("{!r}".format(v))
+    body = ", ".join(lst)
+    return "{}({})".format(view.__class__.__name__, body)
+
+
+def _mdrepr(md):
+    lst = []
+    for k, v in md.items():
+        lst.append("'{}': {!r}".format(k, v))
+    body = ", ".join(lst)
+    return "<{}({})>".format(md.__class__.__name__, body)

evalkit_cambrian/lib/python3.10/site-packages/multidict/_multidict_py.py

@@ -0,0 +1,527 @@
+import sys
+import types
+from array import array
+from collections import abc
+
+from ._abc import MultiMapping, MutableMultiMapping
+
+_marker = object()
+
+if sys.version_info >= (3, 9):
+    GenericAlias = types.GenericAlias
+else:
+
+    def GenericAlias(cls):
+        return cls
+
+
+class istr(str):
+
+    """Case insensitive str."""
+
+    __is_istr__ = True
+
+
+upstr = istr  # for relaxing backward compatibility problems
+
+
+def getversion(md):
+    if not isinstance(md, _Base):
+        raise TypeError("Parameter should be multidict or proxy")
+    return md._impl._version
+
+
+_version = array("Q", [0])
+
+
+class _Impl:
+    __slots__ = ("_items", "_version")
+
+    def __init__(self):
+        self._items = []
+        self.incr_version()
+
+    def incr_version(self):
+        global _version
+        v = _version
+        v[0] += 1
+        self._version = v[0]
+
+    if sys.implementation.name != "pypy":
+
+        def __sizeof__(self):
+            return object.__sizeof__(self) + sys.getsizeof(self._items)
+
+
+class _Base:
+    def _title(self, key):
+        return key
+
+    def getall(self, key, default=_marker):
+        """Return a list of all values matching the key."""
+        identity = self._title(key)
+        res = [v for i, k, v in self._impl._items if i == identity]
+        if res:
+            return res
+        if not res and default is not _marker:
+            return default
+        raise KeyError("Key not found: %r" % key)
+
+    def getone(self, key, default=_marker):
+        """Get first value matching the key.
+
+        Raises KeyError if the key is not found and no default is provided.
+        """
+        identity = self._title(key)
+        for i, k, v in self._impl._items:
+            if i == identity:
+                return v
+        if default is not _marker:
+            return default
+        raise KeyError("Key not found: %r" % key)
+
+    # Mapping interface #
+
+    def __getitem__(self, key):
+        return self.getone(key)
+
+    def get(self, key, default=None):
+        """Get first value matching the key.
+
+        If the key is not found, returns the default (or None if no default is provided)
+        """
+        return self.getone(key, default)
+
+    def __iter__(self):
+        return iter(self.keys())
+
+    def __len__(self):
+        return len(self._impl._items)
+
+    def keys(self):
+        """Return a new view of the dictionary's keys."""
+        return _KeysView(self._impl)
+
+    def items(self):
+        """Return a new view of the dictionary's items *(key, value) pairs)."""
+        return _ItemsView(self._impl)
+
+    def values(self):
+        """Return a new view of the dictionary's values."""
+        return _ValuesView(self._impl)
+
+    def __eq__(self, other):
+        if not isinstance(other, abc.Mapping):
+            return NotImplemented
+        if isinstance(other, _Base):
+            lft = self._impl._items
+            rht = other._impl._items
+            if len(lft) != len(rht):
+                return False
+            for (i1, k2, v1), (i2, k2, v2) in zip(lft, rht):
+                if i1 != i2 or v1 != v2:
+                    return False
+            return True
+        if len(self._impl._items) != len(other):
+            return False
+        for k, v in self.items():
+            nv = other.get(k, _marker)
+            if v != nv:
+                return False
+        return True
+
+    def __contains__(self, key):
+        identity = self._title(key)
+        for i, k, v in self._impl._items:
+            if i == identity:
+                return True
+        return False
+
+    def __repr__(self):
+        body = ", ".join("'{}': {!r}".format(k, v) for k, v in self.items())
+        return "<{}({})>".format(self.__class__.__name__, body)
+
+    __class_getitem__ = classmethod(GenericAlias)
+
+
+class MultiDictProxy(_Base, MultiMapping):
+    """Read-only proxy for MultiDict instance."""
+
+    def __init__(self, arg):
+        if not isinstance(arg, (MultiDict, MultiDictProxy)):
+            raise TypeError(
+                "ctor requires MultiDict or MultiDictProxy instance"
+                ", not {}".format(type(arg))
+            )
+
+        self._impl = arg._impl
+
+    def __reduce__(self):
+        raise TypeError("can't pickle {} objects".format(self.__class__.__name__))
+
+    def copy(self):
+        """Return a copy of itself."""
+        return MultiDict(self.items())
+
+
+class CIMultiDictProxy(MultiDictProxy):
+    """Read-only proxy for CIMultiDict instance."""
+
+    def __init__(self, arg):
+        if not isinstance(arg, (CIMultiDict, CIMultiDictProxy)):
+            raise TypeError(
+                "ctor requires CIMultiDict or CIMultiDictProxy instance"
+                ", not {}".format(type(arg))
+            )
+
+        self._impl = arg._impl
+
+    def _title(self, key):
+        return key.title()
+
+    def copy(self):
+        """Return a copy of itself."""
+        return CIMultiDict(self.items())
+
+
+class MultiDict(_Base, MutableMultiMapping):
+    """Dictionary with the support for duplicate keys."""
+
+    def __init__(self, *args, **kwargs):
+        self._impl = _Impl()
+
+        self._extend(args, kwargs, self.__class__.__name__, self._extend_items)
+
+    if sys.implementation.name != "pypy":
+
+        def __sizeof__(self):
+            return object.__sizeof__(self) + sys.getsizeof(self._impl)
+
+    def __reduce__(self):
+        return (self.__class__, (list(self.items()),))
+
+    def _title(self, key):
+        return key
+
+    def _key(self, key):
+        if isinstance(key, str):
+            return key
+        else:
+            raise TypeError(
+                "MultiDict keys should be either str " "or subclasses of str"
+            )
+
+    def add(self, key, value):
+        identity = self._title(key)
+        self._impl._items.append((identity, self._key(key), value))
+        self._impl.incr_version()
+
+    def copy(self):
+        """Return a copy of itself."""
+        cls = self.__class__
+        return cls(self.items())
+
+    __copy__ = copy
+
+    def extend(self, *args, **kwargs):
+        """Extend current MultiDict with more values.
+
+        This method must be used instead of update.
+        """
+        self._extend(args, kwargs, "extend", self._extend_items)
+
+    def _extend(self, args, kwargs, name, method):
+        if len(args) > 1:
+            raise TypeError(
+                "{} takes at most 1 positional argument"
+                " ({} given)".format(name, len(args))
+            )
+        if args:
+            arg = args[0]
+            if isinstance(args[0], (MultiDict, MultiDictProxy)) and not kwargs:
+                items = arg._impl._items
+            else:
+                if hasattr(arg, "items"):
+                    arg = arg.items()
+                if kwargs:
+                    arg = list(arg)
+                    arg.extend(list(kwargs.items()))
+                items = []
+                for item in arg:
+                    if not len(item) == 2:
+                        raise TypeError(
+                            "{} takes either dict or list of (key, value) "
+                            "tuples".format(name)
+                        )
+                    items.append((self._title(item[0]), self._key(item[0]), item[1]))
+
+            method(items)
+        else:
+            method(
+                [
+                    (self._title(key), self._key(key), value)
+                    for key, value in kwargs.items()
+                ]
+            )
+
+    def _extend_items(self, items):
+        for identity, key, value in items:
+            self.add(key, value)
+
+    def clear(self):
+        """Remove all items from MultiDict."""
+        self._impl._items.clear()
+        self._impl.incr_version()
+
+    # Mapping interface #
+
+    def __setitem__(self, key, value):
+        self._replace(key, value)
+
+    def __delitem__(self, key):
+        identity = self._title(key)
+        items = self._impl._items
+        found = False
+        for i in range(len(items) - 1, -1, -1):
+            if items[i][0] == identity:
+                del items[i]
+                found = True
+        if not found:
+            raise KeyError(key)
+        else:
+            self._impl.incr_version()
+
+    def setdefault(self, key, default=None):
+        """Return value for key, set value to default if key is not present."""
+        identity = self._title(key)
+        for i, k, v in self._impl._items:
+            if i == identity:
+                return v
+        self.add(key, default)
+        return default
+
+    def popone(self, key, default=_marker):
+        """Remove specified key and return the corresponding value.
+
+        If key is not found, d is returned if given, otherwise
+        KeyError is raised.
+
+        """
+        identity = self._title(key)
+        for i in range(len(self._impl._items)):
+            if self._impl._items[i][0] == identity:
+                value = self._impl._items[i][2]
+                del self._impl._items[i]
+                self._impl.incr_version()
+                return value
+        if default is _marker:
+            raise KeyError(key)
+        else:
+            return default
+
+    pop = popone  # type: ignore
+
+    def popall(self, key, default=_marker):
+        """Remove all occurrences of key and return the list of corresponding
+        values.
+
+        If key is not found, default is returned if given, otherwise
+        KeyError is raised.
+
+        """
+        found = False
+        identity = self._title(key)
+        ret = []
+        for i in range(len(self._impl._items) - 1, -1, -1):
+            item = self._impl._items[i]
+            if item[0] == identity:
+                ret.append(item[2])
+                del self._impl._items[i]
+                self._impl.incr_version()
+                found = True
+        if not found:
+            if default is _marker:
+                raise KeyError(key)
+            else:
+                return default
+        else:
+            ret.reverse()
+            return ret
+
+    def popitem(self):
+        """Remove and return an arbitrary (key, value) pair."""
+        if self._impl._items:
+            i = self._impl._items.pop(0)
+            self._impl.incr_version()
+            return i[1], i[2]
+        else:
+            raise KeyError("empty multidict")
+
+    def update(self, *args, **kwargs):
+        """Update the dictionary from *other*, overwriting existing keys."""
+        self._extend(args, kwargs, "update", self._update_items)
+
+    def _update_items(self, items):
+        if not items:
+            return
+        used_keys = {}
+        for identity, key, value in items:
+            start = used_keys.get(identity, 0)
+            for i in range(start, len(self._impl._items)):
+                item = self._impl._items[i]
+                if item[0] == identity:
+                    used_keys[identity] = i + 1
+                    self._impl._items[i] = (identity, key, value)
+                    break
+            else:
+                self._impl._items.append((identity, key, value))
+                used_keys[identity] = len(self._impl._items)
+
+        # drop tails
+        i = 0
+        while i < len(self._impl._items):
+            item = self._impl._items[i]
+            identity = item[0]
+            pos = used_keys.get(identity)
+            if pos is None:
+                i += 1
+                continue
+            if i >= pos:
+                del self._impl._items[i]
+            else:
+                i += 1
+
+        self._impl.incr_version()
+
+    def _replace(self, key, value):
+        key = self._key(key)
+        identity = self._title(key)
+        items = self._impl._items
+
+        for i in range(len(items)):
+            item = items[i]
+            if item[0] == identity:
+                items[i] = (identity, key, value)
+                # i points to last found item
+                rgt = i
+                self._impl.incr_version()
+                break
+        else:
+            self._impl._items.append((identity, key, value))
+            self._impl.incr_version()
+            return
+
+        # remove all tail items
+        i = rgt + 1
+        while i < len(items):
+            item = items[i]
+            if item[0] == identity:
+                del items[i]
+            else:
+                i += 1
+
+
+class CIMultiDict(MultiDict):
+    """Dictionary with the support for duplicate case-insensitive keys."""
+
+    def _title(self, key):
+        return key.title()
+
+
+class _Iter:
+    __slots__ = ("_size", "_iter")
+
+    def __init__(self, size, iterator):
+        self._size = size
+        self._iter = iterator
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        return next(self._iter)
+
+    def __length_hint__(self):
+        return self._size
+
+
+class _ViewBase:
+    def __init__(self, impl):
+        self._impl = impl
+
+    def __len__(self):
+        return len(self._impl._items)
+
+
+class _ItemsView(_ViewBase, abc.ItemsView):
+    def __contains__(self, item):
+        assert isinstance(item, tuple) or isinstance(item, list)
+        assert len(item) == 2
+        for i, k, v in self._impl._items:
+            if item[0] == k and item[1] == v:
+                return True
+        return False
+
+    def __iter__(self):
+        return _Iter(len(self), self._iter(self._impl._version))
+
+    def _iter(self, version):
+        for i, k, v in self._impl._items:
+            if version != self._impl._version:
+                raise RuntimeError("Dictionary changed during iteration")
+            yield k, v
+
+    def __repr__(self):
+        lst = []
+        for item in self._impl._items:
+            lst.append("{!r}: {!r}".format(item[1], item[2]))
+        body = ", ".join(lst)
+        return "{}({})".format(self.__class__.__name__, body)
+
+
+class _ValuesView(_ViewBase, abc.ValuesView):
+    def __contains__(self, value):
+        for item in self._impl._items:
+            if item[2] == value:
+                return True
+        return False
+
+    def __iter__(self):
+        return _Iter(len(self), self._iter(self._impl._version))
+
+    def _iter(self, version):
+        for item in self._impl._items:
+            if version != self._impl._version:
+                raise RuntimeError("Dictionary changed during iteration")
+            yield item[2]
+
+    def __repr__(self):
+        lst = []
+        for item in self._impl._items:
+            lst.append("{!r}".format(item[2]))
+        body = ", ".join(lst)
+        return "{}({})".format(self.__class__.__name__, body)
+
+
+class _KeysView(_ViewBase, abc.KeysView):
+    def __contains__(self, key):
+        for item in self._impl._items:
+            if item[1] == key:
+                return True
+        return False
+
+    def __iter__(self):
+        return _Iter(len(self), self._iter(self._impl._version))
+
+    def _iter(self, version):
+        for item in self._impl._items:
+            if version != self._impl._version:
+                raise RuntimeError("Dictionary changed during iteration")
+            yield item[1]
+
+    def __repr__(self):
+        lst = []
+        for item in self._impl._items:
+            lst.append("{!r}".format(item[1]))
+        body = ", ".join(lst)
+        return "{}({})".format(self.__class__.__name__, body)

evalkit_cambrian/lib/python3.10/site-packages/multidict/py.typed

@@ -0,0 +1 @@
+PEP-561 marker.

evalkit_cambrian/lib/python3.10/site-packages/proto_plus-1.25.0.dist-info/INSTALLER

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

evalkit_cambrian/lib/python3.10/site-packages/proto_plus-1.25.0.dist-info/LICENSE

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

evalkit_cambrian/lib/python3.10/site-packages/proto_plus-1.25.0.dist-info/METADATA

@@ -0,0 +1,58 @@
+Metadata-Version: 2.1
+Name: proto-plus
+Version: 1.25.0
+Summary: Beautiful, Pythonic protocol buffers.
+Home-page: https://github.com/googleapis/proto-plus-python.git
+Author: Google LLC
+Author-email: googleapis-packages@google.com
+License: Apache 2.0
+Platform: Posix; MacOS X
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+License-File: LICENSE
+Requires-Dist: protobuf<6.0.0dev,>=3.19.0
+Provides-Extra: testing
+Requires-Dist: google-api-core>=1.31.5; extra == "testing"
+
+Proto Plus for Python
+=====================
+
+|pypi| |release level| |docs|
+
+    Beautiful, Pythonic protocol buffers.
+
+This is a wrapper around `protocol buffers`_. Protocol buffers is a
+specification format for APIs, such as those inside Google.
+This library provides protocol buffer message classes and objects that
+largely behave like native Python types.
+
+.. _protocol buffers: https://developers.google.com/protocol-buffers/
+
+
+Documentation
+-------------
+
+`Documentation`_ is available on Read the Docs.
+
+.. _documentation: https://proto-plus-python.readthedocs.io/en/latest/
+
+.. |pypi| image:: https://img.shields.io/pypi/v/proto-plus.svg
+   :target: https://pypi.org/project/proto-plus
+.. |release level| image:: https://img.shields.io/badge/release%20level-ga-gold.svg?style&#x3D;flat
+  :target: https://cloud.google.com/terms/launch-stages
+.. |docs| image:: https://readthedocs.org/projects/proto-plus-python/badge/?version=latest
+  :target: https://proto-plus-python.readthedocs.io/en/latest/

evalkit_cambrian/lib/python3.10/site-packages/proto_plus-1.25.0.dist-info/RECORD

@@ -0,0 +1,59 @@
+proto/__init__.py,sha256=UtrqR9GHCxPRf_W6wpLYuiMOy74XyYyF6LuafAOWe5A,1712
+proto/__pycache__/__init__.cpython-310.pyc,,
+proto/__pycache__/_file_info.cpython-310.pyc,,
+proto/__pycache__/_package_info.cpython-310.pyc,,
+proto/__pycache__/datetime_helpers.cpython-310.pyc,,
+proto/__pycache__/enums.cpython-310.pyc,,
+proto/__pycache__/fields.cpython-310.pyc,,
+proto/__pycache__/message.cpython-310.pyc,,
+proto/__pycache__/modules.cpython-310.pyc,,
+proto/__pycache__/primitives.cpython-310.pyc,,
+proto/__pycache__/utils.cpython-310.pyc,,
+proto/__pycache__/version.cpython-310.pyc,,
+proto/_file_info.py,sha256=4aR7FZynZ0oYUe586ta04M7_eQ8Xful--T-ACUtAF30,7914
+proto/_package_info.py,sha256=UdF-V5E193kvOt_IqUqeylJzdxY1B_RRYc7-aCMMl84,1906
+proto/datetime_helpers.py,sha256=foMj8XA_6a9ZghbwfTK4DplXmpcMmGHQU2fEmdg54x8,7371
+proto/enums.py,sha256=SSi8CFy3TcojPYmr8GKkWTyzcDOlxy8EJu6CQCvC63E,5842
+proto/fields.py,sha256=qBoQ_Tl7ZRheD17PzmZR6DXkbET_nZYEGRpQUtMfixE,5372
+proto/marshal/__init__.py,sha256=ughdxBgTpZ_GtOWnS2Waz1yVEbCno-61m5eRUmYxbSo,630
+proto/marshal/__pycache__/__init__.cpython-310.pyc,,
+proto/marshal/__pycache__/compat.cpython-310.pyc,,
+proto/marshal/__pycache__/marshal.cpython-310.pyc,,
+proto/marshal/collections/__init__.py,sha256=mX2bO-HTvp4vcWw1Due9WMf717-QP97ZhNeHvkXGJsw,755
+proto/marshal/collections/__pycache__/__init__.cpython-310.pyc,,
+proto/marshal/collections/__pycache__/maps.cpython-310.pyc,,
+proto/marshal/collections/__pycache__/repeated.cpython-310.pyc,,
+proto/marshal/collections/maps.py,sha256=PeBFLnGHyHdwRjuZWEyIvs2ZrWttYN_cNk8Z6HUguno,2921
+proto/marshal/collections/repeated.py,sha256=Yum54SAaqwUSCmtJ4-7SbAJjAKuwjTmHj4O7fV8I-QI,6934
+proto/marshal/compat.py,sha256=MLA_C3zXO8QUJA3VeMXBgySmaqroGqjN8Ta520SkZlw,2349
+proto/marshal/marshal.py,sha256=pH47NsNP-a1xnD-E4EumGLd18A3oK_CBmfGs-ZoeoGM,12030
+proto/marshal/rules/__init__.py,sha256=rdttj_i0e4IpRZYX9oZSTs5AnjAW4Zl__BoNHfUUHpU,575
+proto/marshal/rules/__pycache__/__init__.cpython-310.pyc,,
+proto/marshal/rules/__pycache__/bytes.cpython-310.pyc,,
+proto/marshal/rules/__pycache__/dates.cpython-310.pyc,,
+proto/marshal/rules/__pycache__/enums.cpython-310.pyc,,
+proto/marshal/rules/__pycache__/field_mask.cpython-310.pyc,,
+proto/marshal/rules/__pycache__/message.cpython-310.pyc,,
+proto/marshal/rules/__pycache__/stringy_numbers.cpython-310.pyc,,
+proto/marshal/rules/__pycache__/struct.cpython-310.pyc,,
+proto/marshal/rules/__pycache__/wrappers.cpython-310.pyc,,
+proto/marshal/rules/bytes.py,sha256=Af26mG5e1Hqn0ty5NxCxhq0m7CxaeYWTatOQ8hTN0jM,1593
+proto/marshal/rules/dates.py,sha256=XbVAF4OYifQAnVLrYiUWndMlMoaL-VYzav52Vtu143I,3135
+proto/marshal/rules/enums.py,sha256=9NZIQ214sgY3RcyR640TRWnKLH4rl36mRWGyU56EA-4,2213
+proto/marshal/rules/field_mask.py,sha256=_CG9kvla4-32pqHVYzoXJDPfC9yySJzEJCAKZQC-2Io,1182
+proto/marshal/rules/message.py,sha256=6jaliKljASRjEBeeI7Pw5i4-gMZz3Vzswvvlca6JuWE,2152
+proto/marshal/rules/stringy_numbers.py,sha256=sOsCol-dB7epbVCj_AZu1ZEYo5ualmg5zm4hk0X1klU,1787
+proto/marshal/rules/struct.py,sha256=kY2iGZO0c8IxojgF8OllfuDb63lmdpjH-5tBod5zLoQ,5226
+proto/marshal/rules/wrappers.py,sha256=FDVuwLxXCnhm77j0kZ-F1hVGY4PllmgQha_TH9vjE3c,2280
+proto/message.py,sha256=KMQpiKEc2_l_hXFb15nVwihYBS9FNoxDx7bckcUnBGg,38955
+proto/modules.py,sha256=1g3HAZW0JWBx7LCrlMPamUOMHxaaf-QFwbYa6zgiplg,1585
+proto/primitives.py,sha256=Fwu6KQdn1i6vVPPD3MxQXHKvbz7z5B42QlOwSTkcidI,1000
+proto/utils.py,sha256=5-Dqe2WOPJQ0gsT5MTiMiPTDa8q56VfD-EcqIJD4eD0,1651
+proto/version.py,sha256=NkVihyIrODY2gYLQ6-QMB5sbB83rI_ErSFGUguC75PE,599
+proto_plus-1.25.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+proto_plus-1.25.0.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+proto_plus-1.25.0.dist-info/METADATA,sha256=ceDO5rVjQoM60L8V6wYIVJM1qqt6xp7TgCWQr8cBZ0A,2220
+proto_plus-1.25.0.dist-info/RECORD,,
+proto_plus-1.25.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+proto_plus-1.25.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+proto_plus-1.25.0.dist-info/top_level.txt,sha256=BAFr-aEHEy59jLoOOoHvPC0u3dx4iDSw-MoNX6NljG0,19

evalkit_cambrian/lib/python3.10/site-packages/proto_plus-1.25.0.dist-info/WHEEL

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

evalkit_cambrian/lib/python3.10/site-packages/proto_plus-1.25.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+docs
+proto
+testing

evalkit_cambrian/lib/python3.10/site-packages/torchvision-0.17.0+cu118.dist-info/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) Soumith Chintala 2016, 
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

infer_4_47_1/lib/python3.10/site-packages/torch/include/ATen/ops/_cast_Byte_compositeimplicitautograd_dispatch.h

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeimplicitautograd {
+
+TORCH_API at::Tensor _cast_Byte(const at::Tensor & self, bool non_blocking=false);
+
+} // namespace compositeimplicitautograd
+} // namespace at

infer_4_47_1/lib/python3.10/site-packages/torch/include/ATen/ops/_ctc_loss_backward_ops.h

@@ -0,0 +1,50 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API _ctc_loss_backward {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, const at::Tensor &, const at::Tensor &, int64_t, bool);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_ctc_loss_backward")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_ctc_loss_backward(Tensor grad, Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, Tensor neg_log_likelihood, Tensor log_alpha, int blank, bool zero_infinity=False) -> Tensor")
+  static at::Tensor call(const at::Tensor & grad, const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, const at::Tensor & neg_log_likelihood, const at::Tensor & log_alpha, int64_t blank, bool zero_infinity);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad, const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, const at::Tensor & neg_log_likelihood, const at::Tensor & log_alpha, int64_t blank, bool zero_infinity);
+};
+
+struct TORCH_API _ctc_loss_backward_Tensor {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, bool);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_ctc_loss_backward")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_ctc_loss_backward.Tensor(Tensor grad, Tensor log_probs, Tensor targets, Tensor input_lengths, Tensor target_lengths, Tensor neg_log_likelihood, Tensor log_alpha, int blank, bool zero_infinity=False) -> Tensor")
+  static at::Tensor call(const at::Tensor & grad, const at::Tensor & log_probs, const at::Tensor & targets, const at::Tensor & input_lengths, const at::Tensor & target_lengths, const at::Tensor & neg_log_likelihood, const at::Tensor & log_alpha, int64_t blank, bool zero_infinity);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad, const at::Tensor & log_probs, const at::Tensor & targets, const at::Tensor & input_lengths, const at::Tensor & target_lengths, const at::Tensor & neg_log_likelihood, const at::Tensor & log_alpha, int64_t blank, bool zero_infinity);
+};
+
+struct TORCH_API _ctc_loss_backward_out {
+  using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, const at::Tensor &, const at::Tensor &, int64_t, bool, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_ctc_loss_backward")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_ctc_loss_backward.out(Tensor grad, Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, Tensor neg_log_likelihood, Tensor log_alpha, int blank, bool zero_infinity=False, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & grad, const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, const at::Tensor & neg_log_likelihood, const at::Tensor & log_alpha, int64_t blank, bool zero_infinity, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad, const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, const at::Tensor & neg_log_likelihood, const at::Tensor & log_alpha, int64_t blank, bool zero_infinity, at::Tensor & out);
+};
+
+}} // namespace at::_ops

infer_4_47_1/lib/python3.10/site-packages/torch/include/ATen/ops/_ctc_loss_compositeexplicitautograd_dispatch.h

@@ -0,0 +1,26 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautograd {
+
+TORCH_API ::std::tuple<at::Tensor &,at::Tensor &> _ctc_loss_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, int64_t blank=0, bool zero_infinity=false);
+TORCH_API ::std::tuple<at::Tensor &,at::Tensor &> _ctc_loss_outf(const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, int64_t blank, bool zero_infinity, at::Tensor & out0, at::Tensor & out1);
+TORCH_API ::std::tuple<at::Tensor &,at::Tensor &> _ctc_loss_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & log_probs, const at::Tensor & targets, const at::Tensor & input_lengths, const at::Tensor & target_lengths, int64_t blank=0, bool zero_infinity=false);
+TORCH_API ::std::tuple<at::Tensor &,at::Tensor &> _ctc_loss_outf(const at::Tensor & log_probs, const at::Tensor & targets, const at::Tensor & input_lengths, const at::Tensor & target_lengths, int64_t blank, bool zero_infinity, at::Tensor & out0, at::Tensor & out1);
+
+} // namespace compositeexplicitautograd
+} // namespace at

infer_4_47_1/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_norm_cuda_dispatch.h

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cuda {
+
+TORCH_API ::std::vector<at::Tensor> _foreach_norm(at::TensorList self, const at::Scalar & ord=2, ::std::optional<at::ScalarType> dtype=::std::nullopt);
+
+} // namespace cuda
+} // namespace at

infer_4_47_1/lib/python3.10/site-packages/torch/include/ATen/ops/_scaled_mm.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <optional>
+
+
+
+#include <ATen/ops/_scaled_mm_ops.h>
+
+namespace at {
+
+
+// aten::_scaled_mm(Tensor self, Tensor mat2, Tensor scale_a, Tensor scale_b, Tensor? bias=None, Tensor? scale_result=None, ScalarType? out_dtype=None, bool use_fast_accum=False) -> Tensor
+inline at::Tensor _scaled_mm(const at::Tensor & self, const at::Tensor & mat2, const at::Tensor & scale_a, const at::Tensor & scale_b, const ::std::optional<at::Tensor> & bias={}, const ::std::optional<at::Tensor> & scale_result={}, ::std::optional<at::ScalarType> out_dtype=::std::nullopt, bool use_fast_accum=false) {
+    return at::_ops::_scaled_mm::call(self, mat2, scale_a, scale_b, bias, scale_result, out_dtype, use_fast_accum);
+}
+
+// aten::_scaled_mm.out(Tensor self, Tensor mat2, Tensor scale_a, Tensor scale_b, Tensor? bias=None, Tensor? scale_result=None, ScalarType? out_dtype=None, bool use_fast_accum=False, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & _scaled_mm_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mat2, const at::Tensor & scale_a, const at::Tensor & scale_b, const ::std::optional<at::Tensor> & bias={}, const ::std::optional<at::Tensor> & scale_result={}, ::std::optional<at::ScalarType> out_dtype=::std::nullopt, bool use_fast_accum=false) {
+    return at::_ops::_scaled_mm_out::call(self, mat2, scale_a, scale_b, bias, scale_result, out_dtype, use_fast_accum, out);
+}
+// aten::_scaled_mm.out(Tensor self, Tensor mat2, Tensor scale_a, Tensor scale_b, Tensor? bias=None, Tensor? scale_result=None, ScalarType? out_dtype=None, bool use_fast_accum=False, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & _scaled_mm_outf(const at::Tensor & self, const at::Tensor & mat2, const at::Tensor & scale_a, const at::Tensor & scale_b, const ::std::optional<at::Tensor> & bias, const ::std::optional<at::Tensor> & scale_result, ::std::optional<at::ScalarType> out_dtype, bool use_fast_accum, at::Tensor & out) {
+    return at::_ops::_scaled_mm_out::call(self, mat2, scale_a, scale_b, bias, scale_result, out_dtype, use_fast_accum, out);
+}
+
+}