[0-9]+(?:\.[0-9]+)*) # release segment
+ (?P # pre-release
+ [-_\.]?
+ (?Palpha|a|beta|b|preview|pre|c|rc)
+ [-_\.]?
+ (?P[0-9]+)?
+ )?
+ (?P # post release
+ (?:-(?P[0-9]+))
+ |
+ (?:
+ [-_\.]?
+ (?Ppost|rev|r)
+ [-_\.]?
+ (?P[0-9]+)?
+ )
+ )?
+ (?P # dev release
+ [-_\.]?
+ (?Pdev)
+ [-_\.]?
+ (?P[0-9]+)?
+ )?
+ )
+ (?:\+(?P[a-z0-9]+(?:[-_\.][a-z0-9]+)*))? # local version
+"""
+
+VERSION_PATTERN = _VERSION_PATTERN
+"""
+A string containing the regular expression used to match a valid version.
+
+The pattern is not anchored at either end, and is intended for embedding in larger
+expressions (for example, matching a version number as part of a file name). The
+regular expression should be compiled with the ``re.VERBOSE`` and ``re.IGNORECASE``
+flags set.
+
+:meta hide-value:
+"""
+
+
+class Version(_BaseVersion):
+ """This class abstracts handling of a project's versions.
+
+ A :class:`Version` instance is comparison aware and can be compared and
+ sorted using the standard Python interfaces.
+
+ >>> v1 = Version("1.0a5")
+ >>> v2 = Version("1.0")
+ >>> v1
+
+ >>> v2
+
+ >>> v1 < v2
+ True
+ >>> v1 == v2
+ False
+ >>> v1 > v2
+ False
+ >>> v1 >= v2
+ False
+ >>> v1 <= v2
+ True
+ """
+
+ _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)
+ _key: CmpKey
+
+ def __init__(self, version: str) -> None:
+ """Initialize a Version object.
+
+ :param version:
+ The string representation of a version which will be parsed and normalized
+ before use.
+ :raises InvalidVersion:
+ If the ``version`` does not conform to PEP 440 in any way then this
+ exception will be raised.
+ """
+
+ # Validate the version and parse it into pieces
+ match = self._regex.search(version)
+ if not match:
+ raise InvalidVersion(f"Invalid version: {version!r}")
+
+ # Store the parsed out pieces of the version
+ self._version = _Version(
+ epoch=int(match.group("epoch")) if match.group("epoch") else 0,
+ release=tuple(int(i) for i in match.group("release").split(".")),
+ pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")),
+ post=_parse_letter_version(
+ match.group("post_l"), match.group("post_n1") or match.group("post_n2")
+ ),
+ dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")),
+ local=_parse_local_version(match.group("local")),
+ )
+
+ # Generate a key which will be used for sorting
+ self._key = _cmpkey(
+ self._version.epoch,
+ self._version.release,
+ self._version.pre,
+ self._version.post,
+ self._version.dev,
+ self._version.local,
+ )
+
+ def __repr__(self) -> str:
+ """A representation of the Version that shows all internal state.
+
+ >>> Version('1.0.0')
+
+ """
+ return f""
+
+ def __str__(self) -> str:
+ """A string representation of the version that can be round-tripped.
+
+ >>> str(Version("1.0a5"))
+ '1.0a5'
+ """
+ parts = []
+
+ # Epoch
+ if self.epoch != 0:
+ parts.append(f"{self.epoch}!")
+
+ # Release segment
+ parts.append(".".join(str(x) for x in self.release))
+
+ # Pre-release
+ if self.pre is not None:
+ parts.append("".join(str(x) for x in self.pre))
+
+ # Post-release
+ if self.post is not None:
+ parts.append(f".post{self.post}")
+
+ # Development release
+ if self.dev is not None:
+ parts.append(f".dev{self.dev}")
+
+ # Local version segment
+ if self.local is not None:
+ parts.append(f"+{self.local}")
+
+ return "".join(parts)
+
+ @property
+ def epoch(self) -> int:
+ """The epoch of the version.
+
+ >>> Version("2.0.0").epoch
+ 0
+ >>> Version("1!2.0.0").epoch
+ 1
+ """
+ return self._version.epoch
+
+ @property
+ def release(self) -> tuple[int, ...]:
+ """The components of the "release" segment of the version.
+
+ >>> Version("1.2.3").release
+ (1, 2, 3)
+ >>> Version("2.0.0").release
+ (2, 0, 0)
+ >>> Version("1!2.0.0.post0").release
+ (2, 0, 0)
+
+ Includes trailing zeroes but not the epoch or any pre-release / development /
+ post-release suffixes.
+ """
+ return self._version.release
+
+ @property
+ def pre(self) -> tuple[str, int] | None:
+ """The pre-release segment of the version.
+
+ >>> print(Version("1.2.3").pre)
+ None
+ >>> Version("1.2.3a1").pre
+ ('a', 1)
+ >>> Version("1.2.3b1").pre
+ ('b', 1)
+ >>> Version("1.2.3rc1").pre
+ ('rc', 1)
+ """
+ return self._version.pre
+
+ @property
+ def post(self) -> int | None:
+ """The post-release number of the version.
+
+ >>> print(Version("1.2.3").post)
+ None
+ >>> Version("1.2.3.post1").post
+ 1
+ """
+ return self._version.post[1] if self._version.post else None
+
+ @property
+ def dev(self) -> int | None:
+ """The development number of the version.
+
+ >>> print(Version("1.2.3").dev)
+ None
+ >>> Version("1.2.3.dev1").dev
+ 1
+ """
+ return self._version.dev[1] if self._version.dev else None
+
+ @property
+ def local(self) -> str | None:
+ """The local version segment of the version.
+
+ >>> print(Version("1.2.3").local)
+ None
+ >>> Version("1.2.3+abc").local
+ 'abc'
+ """
+ if self._version.local:
+ return ".".join(str(x) for x in self._version.local)
+ else:
+ return None
+
+ @property
+ def public(self) -> str:
+ """The public portion of the version.
+
+ >>> Version("1.2.3").public
+ '1.2.3'
+ >>> Version("1.2.3+abc").public
+ '1.2.3'
+ >>> Version("1!1.2.3dev1+abc").public
+ '1!1.2.3.dev1'
+ """
+ return str(self).split("+", 1)[0]
+
+ @property
+ def base_version(self) -> str:
+ """The "base version" of the version.
+
+ >>> Version("1.2.3").base_version
+ '1.2.3'
+ >>> Version("1.2.3+abc").base_version
+ '1.2.3'
+ >>> Version("1!1.2.3dev1+abc").base_version
+ '1!1.2.3'
+
+ The "base version" is the public version of the project without any pre or post
+ release markers.
+ """
+ parts = []
+
+ # Epoch
+ if self.epoch != 0:
+ parts.append(f"{self.epoch}!")
+
+ # Release segment
+ parts.append(".".join(str(x) for x in self.release))
+
+ return "".join(parts)
+
+ @property
+ def is_prerelease(self) -> bool:
+ """Whether this version is a pre-release.
+
+ >>> Version("1.2.3").is_prerelease
+ False
+ >>> Version("1.2.3a1").is_prerelease
+ True
+ >>> Version("1.2.3b1").is_prerelease
+ True
+ >>> Version("1.2.3rc1").is_prerelease
+ True
+ >>> Version("1.2.3dev1").is_prerelease
+ True
+ """
+ return self.dev is not None or self.pre is not None
+
+ @property
+ def is_postrelease(self) -> bool:
+ """Whether this version is a post-release.
+
+ >>> Version("1.2.3").is_postrelease
+ False
+ >>> Version("1.2.3.post1").is_postrelease
+ True
+ """
+ return self.post is not None
+
+ @property
+ def is_devrelease(self) -> bool:
+ """Whether this version is a development release.
+
+ >>> Version("1.2.3").is_devrelease
+ False
+ >>> Version("1.2.3.dev1").is_devrelease
+ True
+ """
+ return self.dev is not None
+
+ @property
+ def major(self) -> int:
+ """The first item of :attr:`release` or ``0`` if unavailable.
+
+ >>> Version("1.2.3").major
+ 1
+ """
+ return self.release[0] if len(self.release) >= 1 else 0
+
+ @property
+ def minor(self) -> int:
+ """The second item of :attr:`release` or ``0`` if unavailable.
+
+ >>> Version("1.2.3").minor
+ 2
+ >>> Version("1").minor
+ 0
+ """
+ return self.release[1] if len(self.release) >= 2 else 0
+
+ @property
+ def micro(self) -> int:
+ """The third item of :attr:`release` or ``0`` if unavailable.
+
+ >>> Version("1.2.3").micro
+ 3
+ >>> Version("1").micro
+ 0
+ """
+ return self.release[2] if len(self.release) >= 3 else 0
+
+
+class _TrimmedRelease(Version):
+ @property
+ def release(self) -> tuple[int, ...]:
+ """
+ Release segment without any trailing zeros.
+
+ >>> _TrimmedRelease('1.0.0').release
+ (1,)
+ >>> _TrimmedRelease('0.0').release
+ (0,)
+ """
+ rel = super().release
+ nonzeros = (index for index, val in enumerate(rel) if val)
+ last_nonzero = max(nonzeros, default=0)
+ return rel[: last_nonzero + 1]
+
+
+def _parse_letter_version(
+ letter: str | None, number: str | bytes | SupportsInt | None
+) -> tuple[str, int] | None:
+ if letter:
+ # We consider there to be an implicit 0 in a pre-release if there is
+ # not a numeral associated with it.
+ if number is None:
+ number = 0
+
+ # We normalize any letters to their lower case form
+ letter = letter.lower()
+
+ # We consider some words to be alternate spellings of other words and
+ # in those cases we want to normalize the spellings to our preferred
+ # spelling.
+ if letter == "alpha":
+ letter = "a"
+ elif letter == "beta":
+ letter = "b"
+ elif letter in ["c", "pre", "preview"]:
+ letter = "rc"
+ elif letter in ["rev", "r"]:
+ letter = "post"
+
+ return letter, int(number)
+
+ assert not letter
+ if number:
+ # We assume if we are given a number, but we are not given a letter
+ # then this is using the implicit post release syntax (e.g. 1.0-1)
+ letter = "post"
+
+ return letter, int(number)
+
+ return None
+
+
+_local_version_separators = re.compile(r"[\._-]")
+
+
+def _parse_local_version(local: str | None) -> LocalType | None:
+ """
+ Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
+ """
+ if local is not None:
+ return tuple(
+ part.lower() if not part.isdigit() else int(part)
+ for part in _local_version_separators.split(local)
+ )
+ return None
+
+
+def _cmpkey(
+ epoch: int,
+ release: tuple[int, ...],
+ pre: tuple[str, int] | None,
+ post: tuple[str, int] | None,
+ dev: tuple[str, int] | None,
+ local: LocalType | None,
+) -> CmpKey:
+ # When we compare a release version, we want to compare it with all of the
+ # trailing zeros removed. So we'll use a reverse the list, drop all the now
+ # leading zeros until we come to something non zero, then take the rest
+ # re-reverse it back into the correct order and make it a tuple and use
+ # that for our sorting key.
+ _release = tuple(
+ reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release))))
+ )
+
+ # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
+ # We'll do this by abusing the pre segment, but we _only_ want to do this
+ # if there is not a pre or a post segment. If we have one of those then
+ # the normal sorting rules will handle this case correctly.
+ if pre is None and post is None and dev is not None:
+ _pre: CmpPrePostDevType = NegativeInfinity
+ # Versions without a pre-release (except as noted above) should sort after
+ # those with one.
+ elif pre is None:
+ _pre = Infinity
+ else:
+ _pre = pre
+
+ # Versions without a post segment should sort before those with one.
+ if post is None:
+ _post: CmpPrePostDevType = NegativeInfinity
+
+ else:
+ _post = post
+
+ # Versions without a development segment should sort after those with one.
+ if dev is None:
+ _dev: CmpPrePostDevType = Infinity
+
+ else:
+ _dev = dev
+
+ if local is None:
+ # Versions without a local segment should sort before those with one.
+ _local: CmpLocalType = NegativeInfinity
+ else:
+ # Versions with a local segment need that segment parsed to implement
+ # the sorting rules in PEP440.
+ # - Alpha numeric segments sort before numeric segments
+ # - Alpha numeric segments sort lexicographically
+ # - Numeric segments sort numerically
+ # - Shorter versions sort before longer versions when the prefixes
+ # match exactly
+ _local = tuple(
+ (i, "") if isinstance(i, int) else (NegativeInfinity, i) for i in local
+ )
+
+ return epoch, _release, _pre, _post, _dev, _local
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__init__.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b34b0fcbd409601aab6b579189824a230dabf25c
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__init__.py
@@ -0,0 +1,28 @@
+# SPDX-FileCopyrightText: 2015 Eric Larson
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""CacheControl import Interface.
+
+Make it easy to import from cachecontrol without long namespaces.
+"""
+__author__ = "Eric Larson"
+__email__ = "eric@ionrock.org"
+__version__ = "0.14.0"
+
+from pip._vendor.cachecontrol.adapter import CacheControlAdapter
+from pip._vendor.cachecontrol.controller import CacheController
+from pip._vendor.cachecontrol.wrapper import CacheControl
+
+__all__ = [
+ "__author__",
+ "__email__",
+ "__version__",
+ "CacheControlAdapter",
+ "CacheController",
+ "CacheControl",
+]
+
+import logging
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__pycache__/__init__.cpython-311.pyc b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1e682aec58bd50f95bec399fa8485bba460be45e
Binary files /dev/null and b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__pycache__/__init__.cpython-311.pyc differ
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__pycache__/_cmd.cpython-311.pyc b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__pycache__/_cmd.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..96fb8f4ddb22cd34ea48c2139b54fe0e5f2e5d65
Binary files /dev/null and b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__pycache__/_cmd.cpython-311.pyc differ
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__pycache__/adapter.cpython-311.pyc b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__pycache__/adapter.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..32767184aa03a9fe6c49d453230e6905edb4b5a4
Binary files /dev/null and b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__pycache__/adapter.cpython-311.pyc differ
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__pycache__/controller.cpython-311.pyc b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__pycache__/controller.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b5c5192ee4ee7d4b6d871f48b958a625a06b4270
Binary files /dev/null and b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__pycache__/controller.cpython-311.pyc differ
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__pycache__/heuristics.cpython-311.pyc b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__pycache__/heuristics.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..05a187db3536803ea8dd6edbdf7e97925b8cce20
Binary files /dev/null and b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__pycache__/heuristics.cpython-311.pyc differ
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__pycache__/wrapper.cpython-311.pyc b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__pycache__/wrapper.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7eff36a9ed3f700f34844bd6bb0b139c98c5cc43
Binary files /dev/null and b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__pycache__/wrapper.cpython-311.pyc differ
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/heuristics.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/heuristics.py
new file mode 100644
index 0000000000000000000000000000000000000000..f6e5634e38559efcb0c61e266f73ff7e8d0b1ad9
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/heuristics.py
@@ -0,0 +1,154 @@
+# SPDX-FileCopyrightText: 2015 Eric Larson
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import calendar
+import time
+from datetime import datetime, timedelta, timezone
+from email.utils import formatdate, parsedate, parsedate_tz
+from typing import TYPE_CHECKING, Any, Mapping
+
+if TYPE_CHECKING:
+ from pip._vendor.urllib3 import HTTPResponse
+
+TIME_FMT = "%a, %d %b %Y %H:%M:%S GMT"
+
+
+def expire_after(delta: timedelta, date: datetime | None = None) -> datetime:
+ date = date or datetime.now(timezone.utc)
+ return date + delta
+
+
+def datetime_to_header(dt: datetime) -> str:
+ return formatdate(calendar.timegm(dt.timetuple()))
+
+
+class BaseHeuristic:
+ def warning(self, response: HTTPResponse) -> str | None:
+ """
+ Return a valid 1xx warning header value describing the cache
+ adjustments.
+
+ The response is provided too allow warnings like 113
+ http://tools.ietf.org/html/rfc7234#section-5.5.4 where we need
+ to explicitly say response is over 24 hours old.
+ """
+ return '110 - "Response is Stale"'
+
+ def update_headers(self, response: HTTPResponse) -> dict[str, str]:
+ """Update the response headers with any new headers.
+
+ NOTE: This SHOULD always include some Warning header to
+ signify that the response was cached by the client, not
+ by way of the provided headers.
+ """
+ return {}
+
+ def apply(self, response: HTTPResponse) -> HTTPResponse:
+ updated_headers = self.update_headers(response)
+
+ if updated_headers:
+ response.headers.update(updated_headers)
+ warning_header_value = self.warning(response)
+ if warning_header_value is not None:
+ response.headers.update({"Warning": warning_header_value})
+
+ return response
+
+
+class OneDayCache(BaseHeuristic):
+ """
+ Cache the response by providing an expires 1 day in the
+ future.
+ """
+
+ def update_headers(self, response: HTTPResponse) -> dict[str, str]:
+ headers = {}
+
+ if "expires" not in response.headers:
+ date = parsedate(response.headers["date"])
+ expires = expire_after(timedelta(days=1), date=datetime(*date[:6], tzinfo=timezone.utc)) # type: ignore[index,misc]
+ headers["expires"] = datetime_to_header(expires)
+ headers["cache-control"] = "public"
+ return headers
+
+
+class ExpiresAfter(BaseHeuristic):
+ """
+ Cache **all** requests for a defined time period.
+ """
+
+ def __init__(self, **kw: Any) -> None:
+ self.delta = timedelta(**kw)
+
+ def update_headers(self, response: HTTPResponse) -> dict[str, str]:
+ expires = expire_after(self.delta)
+ return {"expires": datetime_to_header(expires), "cache-control": "public"}
+
+ def warning(self, response: HTTPResponse) -> str | None:
+ tmpl = "110 - Automatically cached for %s. Response might be stale"
+ return tmpl % self.delta
+
+
+class LastModified(BaseHeuristic):
+ """
+ If there is no Expires header already, fall back on Last-Modified
+ using the heuristic from
+ http://tools.ietf.org/html/rfc7234#section-4.2.2
+ to calculate a reasonable value.
+
+ Firefox also does something like this per
+ https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching_FAQ
+ http://lxr.mozilla.org/mozilla-release/source/netwerk/protocol/http/nsHttpResponseHead.cpp#397
+ Unlike mozilla we limit this to 24-hr.
+ """
+
+ cacheable_by_default_statuses = {
+ 200,
+ 203,
+ 204,
+ 206,
+ 300,
+ 301,
+ 404,
+ 405,
+ 410,
+ 414,
+ 501,
+ }
+
+ def update_headers(self, resp: HTTPResponse) -> dict[str, str]:
+ headers: Mapping[str, str] = resp.headers
+
+ if "expires" in headers:
+ return {}
+
+ if "cache-control" in headers and headers["cache-control"] != "public":
+ return {}
+
+ if resp.status not in self.cacheable_by_default_statuses:
+ return {}
+
+ if "date" not in headers or "last-modified" not in headers:
+ return {}
+
+ time_tuple = parsedate_tz(headers["date"])
+ assert time_tuple is not None
+ date = calendar.timegm(time_tuple[:6])
+ last_modified = parsedate(headers["last-modified"])
+ if last_modified is None:
+ return {}
+
+ now = time.time()
+ current_age = max(0, now - date)
+ delta = date - calendar.timegm(last_modified)
+ freshness_lifetime = max(0, min(delta / 10, 24 * 3600))
+ if freshness_lifetime <= current_age:
+ return {}
+
+ expires = date + freshness_lifetime
+ return {"expires": time.strftime(TIME_FMT, time.gmtime(expires))}
+
+ def warning(self, resp: HTTPResponse) -> str | None:
+ return None
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/_inspect.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/_inspect.py
new file mode 100644
index 0000000000000000000000000000000000000000..30446ceb3f0235721e435f5fbd53f2e306f078cd
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/_inspect.py
@@ -0,0 +1,270 @@
+from __future__ import absolute_import
+
+import inspect
+from inspect import cleandoc, getdoc, getfile, isclass, ismodule, signature
+from typing import Any, Collection, Iterable, Optional, Tuple, Type, Union
+
+from .console import Group, RenderableType
+from .control import escape_control_codes
+from .highlighter import ReprHighlighter
+from .jupyter import JupyterMixin
+from .panel import Panel
+from .pretty import Pretty
+from .table import Table
+from .text import Text, TextType
+
+
+def _first_paragraph(doc: str) -> str:
+ """Get the first paragraph from a docstring."""
+ paragraph, _, _ = doc.partition("\n\n")
+ return paragraph
+
+
+class Inspect(JupyterMixin):
+ """A renderable to inspect any Python Object.
+
+ Args:
+ obj (Any): An object to inspect.
+ title (str, optional): Title to display over inspect result, or None use type. Defaults to None.
+ help (bool, optional): Show full help text rather than just first paragraph. Defaults to False.
+ methods (bool, optional): Enable inspection of callables. Defaults to False.
+ docs (bool, optional): Also render doc strings. Defaults to True.
+ private (bool, optional): Show private attributes (beginning with underscore). Defaults to False.
+ dunder (bool, optional): Show attributes starting with double underscore. Defaults to False.
+ sort (bool, optional): Sort attributes alphabetically. Defaults to True.
+ all (bool, optional): Show all attributes. Defaults to False.
+ value (bool, optional): Pretty print value of object. Defaults to True.
+ """
+
+ def __init__(
+ self,
+ obj: Any,
+ *,
+ title: Optional[TextType] = None,
+ help: bool = False,
+ methods: bool = False,
+ docs: bool = True,
+ private: bool = False,
+ dunder: bool = False,
+ sort: bool = True,
+ all: bool = True,
+ value: bool = True,
+ ) -> None:
+ self.highlighter = ReprHighlighter()
+ self.obj = obj
+ self.title = title or self._make_title(obj)
+ if all:
+ methods = private = dunder = True
+ self.help = help
+ self.methods = methods
+ self.docs = docs or help
+ self.private = private or dunder
+ self.dunder = dunder
+ self.sort = sort
+ self.value = value
+
+ def _make_title(self, obj: Any) -> Text:
+ """Make a default title."""
+ title_str = (
+ str(obj)
+ if (isclass(obj) or callable(obj) or ismodule(obj))
+ else str(type(obj))
+ )
+ title_text = self.highlighter(title_str)
+ return title_text
+
+ def __rich__(self) -> Panel:
+ return Panel.fit(
+ Group(*self._render()),
+ title=self.title,
+ border_style="scope.border",
+ padding=(0, 1),
+ )
+
+ def _get_signature(self, name: str, obj: Any) -> Optional[Text]:
+ """Get a signature for a callable."""
+ try:
+ _signature = str(signature(obj)) + ":"
+ except ValueError:
+ _signature = "(...)"
+ except TypeError:
+ return None
+
+ source_filename: Optional[str] = None
+ try:
+ source_filename = getfile(obj)
+ except (OSError, TypeError):
+ # OSError is raised if obj has no source file, e.g. when defined in REPL.
+ pass
+
+ callable_name = Text(name, style="inspect.callable")
+ if source_filename:
+ callable_name.stylize(f"link file://{source_filename}")
+ signature_text = self.highlighter(_signature)
+
+ qualname = name or getattr(obj, "__qualname__", name)
+
+ # If obj is a module, there may be classes (which are callable) to display
+ if inspect.isclass(obj):
+ prefix = "class"
+ elif inspect.iscoroutinefunction(obj):
+ prefix = "async def"
+ else:
+ prefix = "def"
+
+ qual_signature = Text.assemble(
+ (f"{prefix} ", f"inspect.{prefix.replace(' ', '_')}"),
+ (qualname, "inspect.callable"),
+ signature_text,
+ )
+
+ return qual_signature
+
+ def _render(self) -> Iterable[RenderableType]:
+ """Render object."""
+
+ def sort_items(item: Tuple[str, Any]) -> Tuple[bool, str]:
+ key, (_error, value) = item
+ return (callable(value), key.strip("_").lower())
+
+ def safe_getattr(attr_name: str) -> Tuple[Any, Any]:
+ """Get attribute or any exception."""
+ try:
+ return (None, getattr(obj, attr_name))
+ except Exception as error:
+ return (error, None)
+
+ obj = self.obj
+ keys = dir(obj)
+ total_items = len(keys)
+ if not self.dunder:
+ keys = [key for key in keys if not key.startswith("__")]
+ if not self.private:
+ keys = [key for key in keys if not key.startswith("_")]
+ not_shown_count = total_items - len(keys)
+ items = [(key, safe_getattr(key)) for key in keys]
+ if self.sort:
+ items.sort(key=sort_items)
+
+ items_table = Table.grid(padding=(0, 1), expand=False)
+ items_table.add_column(justify="right")
+ add_row = items_table.add_row
+ highlighter = self.highlighter
+
+ if callable(obj):
+ signature = self._get_signature("", obj)
+ if signature is not None:
+ yield signature
+ yield ""
+
+ if self.docs:
+ _doc = self._get_formatted_doc(obj)
+ if _doc is not None:
+ doc_text = Text(_doc, style="inspect.help")
+ doc_text = highlighter(doc_text)
+ yield doc_text
+ yield ""
+
+ if self.value and not (isclass(obj) or callable(obj) or ismodule(obj)):
+ yield Panel(
+ Pretty(obj, indent_guides=True, max_length=10, max_string=60),
+ border_style="inspect.value.border",
+ )
+ yield ""
+
+ for key, (error, value) in items:
+ key_text = Text.assemble(
+ (
+ key,
+ "inspect.attr.dunder" if key.startswith("__") else "inspect.attr",
+ ),
+ (" =", "inspect.equals"),
+ )
+ if error is not None:
+ warning = key_text.copy()
+ warning.stylize("inspect.error")
+ add_row(warning, highlighter(repr(error)))
+ continue
+
+ if callable(value):
+ if not self.methods:
+ continue
+
+ _signature_text = self._get_signature(key, value)
+ if _signature_text is None:
+ add_row(key_text, Pretty(value, highlighter=highlighter))
+ else:
+ if self.docs:
+ docs = self._get_formatted_doc(value)
+ if docs is not None:
+ _signature_text.append("\n" if "\n" in docs else " ")
+ doc = highlighter(docs)
+ doc.stylize("inspect.doc")
+ _signature_text.append(doc)
+
+ add_row(key_text, _signature_text)
+ else:
+ add_row(key_text, Pretty(value, highlighter=highlighter))
+ if items_table.row_count:
+ yield items_table
+ elif not_shown_count:
+ yield Text.from_markup(
+ f"[b cyan]{not_shown_count}[/][i] attribute(s) not shown.[/i] "
+ f"Run [b][magenta]inspect[/]([not b]inspect[/])[/b] for options."
+ )
+
+ def _get_formatted_doc(self, object_: Any) -> Optional[str]:
+ """
+ Extract the docstring of an object, process it and returns it.
+ The processing consists in cleaning up the doctring's indentation,
+ taking only its 1st paragraph if `self.help` is not True,
+ and escape its control codes.
+
+ Args:
+ object_ (Any): the object to get the docstring from.
+
+ Returns:
+ Optional[str]: the processed docstring, or None if no docstring was found.
+ """
+ docs = getdoc(object_)
+ if docs is None:
+ return None
+ docs = cleandoc(docs).strip()
+ if not self.help:
+ docs = _first_paragraph(docs)
+ return escape_control_codes(docs)
+
+
+def get_object_types_mro(obj: Union[object, Type[Any]]) -> Tuple[type, ...]:
+ """Returns the MRO of an object's class, or of the object itself if it's a class."""
+ if not hasattr(obj, "__mro__"):
+ # N.B. we cannot use `if type(obj) is type` here because it doesn't work with
+ # some types of classes, such as the ones that use abc.ABCMeta.
+ obj = type(obj)
+ return getattr(obj, "__mro__", ())
+
+
+def get_object_types_mro_as_strings(obj: object) -> Collection[str]:
+ """
+ Returns the MRO of an object's class as full qualified names, or of the object itself if it's a class.
+
+ Examples:
+ `object_types_mro_as_strings(JSONDecoder)` will return `['json.decoder.JSONDecoder', 'builtins.object']`
+ """
+ return [
+ f'{getattr(type_, "__module__", "")}.{getattr(type_, "__qualname__", "")}'
+ for type_ in get_object_types_mro(obj)
+ ]
+
+
+def is_object_one_of_types(
+ obj: object, fully_qualified_types_names: Collection[str]
+) -> bool:
+ """
+ Returns `True` if the given object's class (or the object itself, if it's a class) has one of the
+ fully qualified names in its MRO.
+ """
+ for type_name in get_object_types_mro_as_strings(obj):
+ if type_name in fully_qualified_types_names:
+ return True
+ return False
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/_log_render.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/_log_render.py
new file mode 100644
index 0000000000000000000000000000000000000000..fc16c84437a8a34231c44d3f0a331459ddcb0f34
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/_log_render.py
@@ -0,0 +1,94 @@
+from datetime import datetime
+from typing import Iterable, List, Optional, TYPE_CHECKING, Union, Callable
+
+
+from .text import Text, TextType
+
+if TYPE_CHECKING:
+ from .console import Console, ConsoleRenderable, RenderableType
+ from .table import Table
+
+FormatTimeCallable = Callable[[datetime], Text]
+
+
+class LogRender:
+ def __init__(
+ self,
+ show_time: bool = True,
+ show_level: bool = False,
+ show_path: bool = True,
+ time_format: Union[str, FormatTimeCallable] = "[%x %X]",
+ omit_repeated_times: bool = True,
+ level_width: Optional[int] = 8,
+ ) -> None:
+ self.show_time = show_time
+ self.show_level = show_level
+ self.show_path = show_path
+ self.time_format = time_format
+ self.omit_repeated_times = omit_repeated_times
+ self.level_width = level_width
+ self._last_time: Optional[Text] = None
+
+ def __call__(
+ self,
+ console: "Console",
+ renderables: Iterable["ConsoleRenderable"],
+ log_time: Optional[datetime] = None,
+ time_format: Optional[Union[str, FormatTimeCallable]] = None,
+ level: TextType = "",
+ path: Optional[str] = None,
+ line_no: Optional[int] = None,
+ link_path: Optional[str] = None,
+ ) -> "Table":
+ from .containers import Renderables
+ from .table import Table
+
+ output = Table.grid(padding=(0, 1))
+ output.expand = True
+ if self.show_time:
+ output.add_column(style="log.time")
+ if self.show_level:
+ output.add_column(style="log.level", width=self.level_width)
+ output.add_column(ratio=1, style="log.message", overflow="fold")
+ if self.show_path and path:
+ output.add_column(style="log.path")
+ row: List["RenderableType"] = []
+ if self.show_time:
+ log_time = log_time or console.get_datetime()
+ time_format = time_format or self.time_format
+ if callable(time_format):
+ log_time_display = time_format(log_time)
+ else:
+ log_time_display = Text(log_time.strftime(time_format))
+ if log_time_display == self._last_time and self.omit_repeated_times:
+ row.append(Text(" " * len(log_time_display)))
+ else:
+ row.append(log_time_display)
+ self._last_time = log_time_display
+ if self.show_level:
+ row.append(level)
+
+ row.append(Renderables(renderables))
+ if self.show_path and path:
+ path_text = Text()
+ path_text.append(
+ path, style=f"link file://{link_path}" if link_path else ""
+ )
+ if line_no:
+ path_text.append(":")
+ path_text.append(
+ f"{line_no}",
+ style=f"link file://{link_path}#{line_no}" if link_path else "",
+ )
+ row.append(path_text)
+
+ output.add_row(*row)
+ return output
+
+
+if __name__ == "__main__": # pragma: no cover
+ from pip._vendor.rich.console import Console
+
+ c = Console()
+ c.print("[on blue]Hello", justify="right")
+ c.log("[on blue]hello", justify="right")
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/_win32_console.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/_win32_console.py
new file mode 100644
index 0000000000000000000000000000000000000000..81b1082905338a74b72b9de432ece50a456687bc
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/_win32_console.py
@@ -0,0 +1,662 @@
+"""Light wrapper around the Win32 Console API - this module should only be imported on Windows
+
+The API that this module wraps is documented at https://docs.microsoft.com/en-us/windows/console/console-functions
+"""
+import ctypes
+import sys
+from typing import Any
+
+windll: Any = None
+if sys.platform == "win32":
+ windll = ctypes.LibraryLoader(ctypes.WinDLL)
+else:
+ raise ImportError(f"{__name__} can only be imported on Windows")
+
+import time
+from ctypes import Structure, byref, wintypes
+from typing import IO, NamedTuple, Type, cast
+
+from pip._vendor.rich.color import ColorSystem
+from pip._vendor.rich.style import Style
+
+STDOUT = -11
+ENABLE_VIRTUAL_TERMINAL_PROCESSING = 4
+
+COORD = wintypes._COORD
+
+
+class LegacyWindowsError(Exception):
+ pass
+
+
+class WindowsCoordinates(NamedTuple):
+ """Coordinates in the Windows Console API are (y, x), not (x, y).
+ This class is intended to prevent that confusion.
+ Rows and columns are indexed from 0.
+ This class can be used in place of wintypes._COORD in arguments and argtypes.
+ """
+
+ row: int
+ col: int
+
+ @classmethod
+ def from_param(cls, value: "WindowsCoordinates") -> COORD:
+ """Converts a WindowsCoordinates into a wintypes _COORD structure.
+ This classmethod is internally called by ctypes to perform the conversion.
+
+ Args:
+ value (WindowsCoordinates): The input coordinates to convert.
+
+ Returns:
+ wintypes._COORD: The converted coordinates struct.
+ """
+ return COORD(value.col, value.row)
+
+
+class CONSOLE_SCREEN_BUFFER_INFO(Structure):
+ _fields_ = [
+ ("dwSize", COORD),
+ ("dwCursorPosition", COORD),
+ ("wAttributes", wintypes.WORD),
+ ("srWindow", wintypes.SMALL_RECT),
+ ("dwMaximumWindowSize", COORD),
+ ]
+
+
+class CONSOLE_CURSOR_INFO(ctypes.Structure):
+ _fields_ = [("dwSize", wintypes.DWORD), ("bVisible", wintypes.BOOL)]
+
+
+_GetStdHandle = windll.kernel32.GetStdHandle
+_GetStdHandle.argtypes = [
+ wintypes.DWORD,
+]
+_GetStdHandle.restype = wintypes.HANDLE
+
+
+def GetStdHandle(handle: int = STDOUT) -> wintypes.HANDLE:
+ """Retrieves a handle to the specified standard device (standard input, standard output, or standard error).
+
+ Args:
+ handle (int): Integer identifier for the handle. Defaults to -11 (stdout).
+
+ Returns:
+ wintypes.HANDLE: The handle
+ """
+ return cast(wintypes.HANDLE, _GetStdHandle(handle))
+
+
+_GetConsoleMode = windll.kernel32.GetConsoleMode
+_GetConsoleMode.argtypes = [wintypes.HANDLE, wintypes.LPDWORD]
+_GetConsoleMode.restype = wintypes.BOOL
+
+
+def GetConsoleMode(std_handle: wintypes.HANDLE) -> int:
+ """Retrieves the current input mode of a console's input buffer
+ or the current output mode of a console screen buffer.
+
+ Args:
+ std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
+
+ Raises:
+ LegacyWindowsError: If any error occurs while calling the Windows console API.
+
+ Returns:
+ int: Value representing the current console mode as documented at
+ https://docs.microsoft.com/en-us/windows/console/getconsolemode#parameters
+ """
+
+ console_mode = wintypes.DWORD()
+ success = bool(_GetConsoleMode(std_handle, console_mode))
+ if not success:
+ raise LegacyWindowsError("Unable to get legacy Windows Console Mode")
+ return console_mode.value
+
+
+_FillConsoleOutputCharacterW = windll.kernel32.FillConsoleOutputCharacterW
+_FillConsoleOutputCharacterW.argtypes = [
+ wintypes.HANDLE,
+ ctypes.c_char,
+ wintypes.DWORD,
+ cast(Type[COORD], WindowsCoordinates),
+ ctypes.POINTER(wintypes.DWORD),
+]
+_FillConsoleOutputCharacterW.restype = wintypes.BOOL
+
+
+def FillConsoleOutputCharacter(
+ std_handle: wintypes.HANDLE,
+ char: str,
+ length: int,
+ start: WindowsCoordinates,
+) -> int:
+ """Writes a character to the console screen buffer a specified number of times, beginning at the specified coordinates.
+
+ Args:
+ std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
+ char (str): The character to write. Must be a string of length 1.
+ length (int): The number of times to write the character.
+ start (WindowsCoordinates): The coordinates to start writing at.
+
+ Returns:
+ int: The number of characters written.
+ """
+ character = ctypes.c_char(char.encode())
+ num_characters = wintypes.DWORD(length)
+ num_written = wintypes.DWORD(0)
+ _FillConsoleOutputCharacterW(
+ std_handle,
+ character,
+ num_characters,
+ start,
+ byref(num_written),
+ )
+ return num_written.value
+
+
+_FillConsoleOutputAttribute = windll.kernel32.FillConsoleOutputAttribute
+_FillConsoleOutputAttribute.argtypes = [
+ wintypes.HANDLE,
+ wintypes.WORD,
+ wintypes.DWORD,
+ cast(Type[COORD], WindowsCoordinates),
+ ctypes.POINTER(wintypes.DWORD),
+]
+_FillConsoleOutputAttribute.restype = wintypes.BOOL
+
+
+def FillConsoleOutputAttribute(
+ std_handle: wintypes.HANDLE,
+ attributes: int,
+ length: int,
+ start: WindowsCoordinates,
+) -> int:
+ """Sets the character attributes for a specified number of character cells,
+ beginning at the specified coordinates in a screen buffer.
+
+ Args:
+ std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
+ attributes (int): Integer value representing the foreground and background colours of the cells.
+ length (int): The number of cells to set the output attribute of.
+ start (WindowsCoordinates): The coordinates of the first cell whose attributes are to be set.
+
+ Returns:
+ int: The number of cells whose attributes were actually set.
+ """
+ num_cells = wintypes.DWORD(length)
+ style_attrs = wintypes.WORD(attributes)
+ num_written = wintypes.DWORD(0)
+ _FillConsoleOutputAttribute(
+ std_handle, style_attrs, num_cells, start, byref(num_written)
+ )
+ return num_written.value
+
+
+_SetConsoleTextAttribute = windll.kernel32.SetConsoleTextAttribute
+_SetConsoleTextAttribute.argtypes = [
+ wintypes.HANDLE,
+ wintypes.WORD,
+]
+_SetConsoleTextAttribute.restype = wintypes.BOOL
+
+
+def SetConsoleTextAttribute(
+ std_handle: wintypes.HANDLE, attributes: wintypes.WORD
+) -> bool:
+ """Set the colour attributes for all text written after this function is called.
+
+ Args:
+ std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
+ attributes (int): Integer value representing the foreground and background colours.
+
+
+ Returns:
+ bool: True if the attribute was set successfully, otherwise False.
+ """
+ return bool(_SetConsoleTextAttribute(std_handle, attributes))
+
+
+_GetConsoleScreenBufferInfo = windll.kernel32.GetConsoleScreenBufferInfo
+_GetConsoleScreenBufferInfo.argtypes = [
+ wintypes.HANDLE,
+ ctypes.POINTER(CONSOLE_SCREEN_BUFFER_INFO),
+]
+_GetConsoleScreenBufferInfo.restype = wintypes.BOOL
+
+
+def GetConsoleScreenBufferInfo(
+ std_handle: wintypes.HANDLE,
+) -> CONSOLE_SCREEN_BUFFER_INFO:
+ """Retrieves information about the specified console screen buffer.
+
+ Args:
+ std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
+
+ Returns:
+ CONSOLE_SCREEN_BUFFER_INFO: A CONSOLE_SCREEN_BUFFER_INFO ctype struct contain information about
+ screen size, cursor position, colour attributes, and more."""
+ console_screen_buffer_info = CONSOLE_SCREEN_BUFFER_INFO()
+ _GetConsoleScreenBufferInfo(std_handle, byref(console_screen_buffer_info))
+ return console_screen_buffer_info
+
+
+_SetConsoleCursorPosition = windll.kernel32.SetConsoleCursorPosition
+_SetConsoleCursorPosition.argtypes = [
+ wintypes.HANDLE,
+ cast(Type[COORD], WindowsCoordinates),
+]
+_SetConsoleCursorPosition.restype = wintypes.BOOL
+
+
+def SetConsoleCursorPosition(
+ std_handle: wintypes.HANDLE, coords: WindowsCoordinates
+) -> bool:
+ """Set the position of the cursor in the console screen
+
+ Args:
+ std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
+ coords (WindowsCoordinates): The coordinates to move the cursor to.
+
+ Returns:
+ bool: True if the function succeeds, otherwise False.
+ """
+ return bool(_SetConsoleCursorPosition(std_handle, coords))
+
+
+_GetConsoleCursorInfo = windll.kernel32.GetConsoleCursorInfo
+_GetConsoleCursorInfo.argtypes = [
+ wintypes.HANDLE,
+ ctypes.POINTER(CONSOLE_CURSOR_INFO),
+]
+_GetConsoleCursorInfo.restype = wintypes.BOOL
+
+
+def GetConsoleCursorInfo(
+ std_handle: wintypes.HANDLE, cursor_info: CONSOLE_CURSOR_INFO
+) -> bool:
+ """Get the cursor info - used to get cursor visibility and width
+
+ Args:
+ std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
+ cursor_info (CONSOLE_CURSOR_INFO): CONSOLE_CURSOR_INFO ctype struct that receives information
+ about the console's cursor.
+
+ Returns:
+ bool: True if the function succeeds, otherwise False.
+ """
+ return bool(_GetConsoleCursorInfo(std_handle, byref(cursor_info)))
+
+
+_SetConsoleCursorInfo = windll.kernel32.SetConsoleCursorInfo
+_SetConsoleCursorInfo.argtypes = [
+ wintypes.HANDLE,
+ ctypes.POINTER(CONSOLE_CURSOR_INFO),
+]
+_SetConsoleCursorInfo.restype = wintypes.BOOL
+
+
+def SetConsoleCursorInfo(
+ std_handle: wintypes.HANDLE, cursor_info: CONSOLE_CURSOR_INFO
+) -> bool:
+ """Set the cursor info - used for adjusting cursor visibility and width
+
+ Args:
+ std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
+ cursor_info (CONSOLE_CURSOR_INFO): CONSOLE_CURSOR_INFO ctype struct containing the new cursor info.
+
+ Returns:
+ bool: True if the function succeeds, otherwise False.
+ """
+ return bool(_SetConsoleCursorInfo(std_handle, byref(cursor_info)))
+
+
+_SetConsoleTitle = windll.kernel32.SetConsoleTitleW
+_SetConsoleTitle.argtypes = [wintypes.LPCWSTR]
+_SetConsoleTitle.restype = wintypes.BOOL
+
+
+def SetConsoleTitle(title: str) -> bool:
+ """Sets the title of the current console window
+
+ Args:
+ title (str): The new title of the console window.
+
+ Returns:
+ bool: True if the function succeeds, otherwise False.
+ """
+ return bool(_SetConsoleTitle(title))
+
+
+class LegacyWindowsTerm:
+ """This class allows interaction with the legacy Windows Console API. It should only be used in the context
+ of environments where virtual terminal processing is not available. However, if it is used in a Windows environment,
+ the entire API should work.
+
+ Args:
+ file (IO[str]): The file which the Windows Console API HANDLE is retrieved from, defaults to sys.stdout.
+ """
+
+ BRIGHT_BIT = 8
+
+ # Indices are ANSI color numbers, values are the corresponding Windows Console API color numbers
+ ANSI_TO_WINDOWS = [
+ 0, # black The Windows colours are defined in wincon.h as follows:
+ 4, # red define FOREGROUND_BLUE 0x0001 -- 0000 0001
+ 2, # green define FOREGROUND_GREEN 0x0002 -- 0000 0010
+ 6, # yellow define FOREGROUND_RED 0x0004 -- 0000 0100
+ 1, # blue define FOREGROUND_INTENSITY 0x0008 -- 0000 1000
+ 5, # magenta define BACKGROUND_BLUE 0x0010 -- 0001 0000
+ 3, # cyan define BACKGROUND_GREEN 0x0020 -- 0010 0000
+ 7, # white define BACKGROUND_RED 0x0040 -- 0100 0000
+ 8, # bright black (grey) define BACKGROUND_INTENSITY 0x0080 -- 1000 0000
+ 12, # bright red
+ 10, # bright green
+ 14, # bright yellow
+ 9, # bright blue
+ 13, # bright magenta
+ 11, # bright cyan
+ 15, # bright white
+ ]
+
+ def __init__(self, file: "IO[str]") -> None:
+ handle = GetStdHandle(STDOUT)
+ self._handle = handle
+ default_text = GetConsoleScreenBufferInfo(handle).wAttributes
+ self._default_text = default_text
+
+ self._default_fore = default_text & 7
+ self._default_back = (default_text >> 4) & 7
+ self._default_attrs = self._default_fore | (self._default_back << 4)
+
+ self._file = file
+ self.write = file.write
+ self.flush = file.flush
+
+ @property
+ def cursor_position(self) -> WindowsCoordinates:
+ """Returns the current position of the cursor (0-based)
+
+ Returns:
+ WindowsCoordinates: The current cursor position.
+ """
+ coord: COORD = GetConsoleScreenBufferInfo(self._handle).dwCursorPosition
+ return WindowsCoordinates(row=cast(int, coord.Y), col=cast(int, coord.X))
+
+ @property
+ def screen_size(self) -> WindowsCoordinates:
+ """Returns the current size of the console screen buffer, in character columns and rows
+
+ Returns:
+ WindowsCoordinates: The width and height of the screen as WindowsCoordinates.
+ """
+ screen_size: COORD = GetConsoleScreenBufferInfo(self._handle).dwSize
+ return WindowsCoordinates(
+ row=cast(int, screen_size.Y), col=cast(int, screen_size.X)
+ )
+
+ def write_text(self, text: str) -> None:
+ """Write text directly to the terminal without any modification of styles
+
+ Args:
+ text (str): The text to write to the console
+ """
+ self.write(text)
+ self.flush()
+
+ def write_styled(self, text: str, style: Style) -> None:
+ """Write styled text to the terminal.
+
+ Args:
+ text (str): The text to write
+ style (Style): The style of the text
+ """
+ color = style.color
+ bgcolor = style.bgcolor
+ if style.reverse:
+ color, bgcolor = bgcolor, color
+
+ if color:
+ fore = color.downgrade(ColorSystem.WINDOWS).number
+ fore = fore if fore is not None else 7 # Default to ANSI 7: White
+ if style.bold:
+ fore = fore | self.BRIGHT_BIT
+ if style.dim:
+ fore = fore & ~self.BRIGHT_BIT
+ fore = self.ANSI_TO_WINDOWS[fore]
+ else:
+ fore = self._default_fore
+
+ if bgcolor:
+ back = bgcolor.downgrade(ColorSystem.WINDOWS).number
+ back = back if back is not None else 0 # Default to ANSI 0: Black
+ back = self.ANSI_TO_WINDOWS[back]
+ else:
+ back = self._default_back
+
+ assert fore is not None
+ assert back is not None
+
+ SetConsoleTextAttribute(
+ self._handle, attributes=ctypes.c_ushort(fore | (back << 4))
+ )
+ self.write_text(text)
+ SetConsoleTextAttribute(self._handle, attributes=self._default_text)
+
+ def move_cursor_to(self, new_position: WindowsCoordinates) -> None:
+ """Set the position of the cursor
+
+ Args:
+ new_position (WindowsCoordinates): The WindowsCoordinates representing the new position of the cursor.
+ """
+ if new_position.col < 0 or new_position.row < 0:
+ return
+ SetConsoleCursorPosition(self._handle, coords=new_position)
+
+ def erase_line(self) -> None:
+ """Erase all content on the line the cursor is currently located at"""
+ screen_size = self.screen_size
+ cursor_position = self.cursor_position
+ cells_to_erase = screen_size.col
+ start_coordinates = WindowsCoordinates(row=cursor_position.row, col=0)
+ FillConsoleOutputCharacter(
+ self._handle, " ", length=cells_to_erase, start=start_coordinates
+ )
+ FillConsoleOutputAttribute(
+ self._handle,
+ self._default_attrs,
+ length=cells_to_erase,
+ start=start_coordinates,
+ )
+
+ def erase_end_of_line(self) -> None:
+ """Erase all content from the cursor position to the end of that line"""
+ cursor_position = self.cursor_position
+ cells_to_erase = self.screen_size.col - cursor_position.col
+ FillConsoleOutputCharacter(
+ self._handle, " ", length=cells_to_erase, start=cursor_position
+ )
+ FillConsoleOutputAttribute(
+ self._handle,
+ self._default_attrs,
+ length=cells_to_erase,
+ start=cursor_position,
+ )
+
+ def erase_start_of_line(self) -> None:
+ """Erase all content from the cursor position to the start of that line"""
+ row, col = self.cursor_position
+ start = WindowsCoordinates(row, 0)
+ FillConsoleOutputCharacter(self._handle, " ", length=col, start=start)
+ FillConsoleOutputAttribute(
+ self._handle, self._default_attrs, length=col, start=start
+ )
+
+ def move_cursor_up(self) -> None:
+ """Move the cursor up a single cell"""
+ cursor_position = self.cursor_position
+ SetConsoleCursorPosition(
+ self._handle,
+ coords=WindowsCoordinates(
+ row=cursor_position.row - 1, col=cursor_position.col
+ ),
+ )
+
+ def move_cursor_down(self) -> None:
+ """Move the cursor down a single cell"""
+ cursor_position = self.cursor_position
+ SetConsoleCursorPosition(
+ self._handle,
+ coords=WindowsCoordinates(
+ row=cursor_position.row + 1,
+ col=cursor_position.col,
+ ),
+ )
+
+ def move_cursor_forward(self) -> None:
+ """Move the cursor forward a single cell. Wrap to the next line if required."""
+ row, col = self.cursor_position
+ if col == self.screen_size.col - 1:
+ row += 1
+ col = 0
+ else:
+ col += 1
+ SetConsoleCursorPosition(
+ self._handle, coords=WindowsCoordinates(row=row, col=col)
+ )
+
+ def move_cursor_to_column(self, column: int) -> None:
+ """Move cursor to the column specified by the zero-based column index, staying on the same row
+
+ Args:
+ column (int): The zero-based column index to move the cursor to.
+ """
+ row, _ = self.cursor_position
+ SetConsoleCursorPosition(self._handle, coords=WindowsCoordinates(row, column))
+
+ def move_cursor_backward(self) -> None:
+ """Move the cursor backward a single cell. Wrap to the previous line if required."""
+ row, col = self.cursor_position
+ if col == 0:
+ row -= 1
+ col = self.screen_size.col - 1
+ else:
+ col -= 1
+ SetConsoleCursorPosition(
+ self._handle, coords=WindowsCoordinates(row=row, col=col)
+ )
+
+ def hide_cursor(self) -> None:
+ """Hide the cursor"""
+ current_cursor_size = self._get_cursor_size()
+ invisible_cursor = CONSOLE_CURSOR_INFO(dwSize=current_cursor_size, bVisible=0)
+ SetConsoleCursorInfo(self._handle, cursor_info=invisible_cursor)
+
+ def show_cursor(self) -> None:
+ """Show the cursor"""
+ current_cursor_size = self._get_cursor_size()
+ visible_cursor = CONSOLE_CURSOR_INFO(dwSize=current_cursor_size, bVisible=1)
+ SetConsoleCursorInfo(self._handle, cursor_info=visible_cursor)
+
+ def set_title(self, title: str) -> None:
+ """Set the title of the terminal window
+
+ Args:
+ title (str): The new title of the console window
+ """
+ assert len(title) < 255, "Console title must be less than 255 characters"
+ SetConsoleTitle(title)
+
+ def _get_cursor_size(self) -> int:
+ """Get the percentage of the character cell that is filled by the cursor"""
+ cursor_info = CONSOLE_CURSOR_INFO()
+ GetConsoleCursorInfo(self._handle, cursor_info=cursor_info)
+ return int(cursor_info.dwSize)
+
+
+if __name__ == "__main__":
+ handle = GetStdHandle()
+
+ from pip._vendor.rich.console import Console
+
+ console = Console()
+
+ term = LegacyWindowsTerm(sys.stdout)
+ term.set_title("Win32 Console Examples")
+
+ style = Style(color="black", bgcolor="red")
+
+ heading = Style.parse("black on green")
+
+ # Check colour output
+ console.rule("Checking colour output")
+ console.print("[on red]on red!")
+ console.print("[blue]blue!")
+ console.print("[yellow]yellow!")
+ console.print("[bold yellow]bold yellow!")
+ console.print("[bright_yellow]bright_yellow!")
+ console.print("[dim bright_yellow]dim bright_yellow!")
+ console.print("[italic cyan]italic cyan!")
+ console.print("[bold white on blue]bold white on blue!")
+ console.print("[reverse bold white on blue]reverse bold white on blue!")
+ console.print("[bold black on cyan]bold black on cyan!")
+ console.print("[black on green]black on green!")
+ console.print("[blue on green]blue on green!")
+ console.print("[white on black]white on black!")
+ console.print("[black on white]black on white!")
+ console.print("[#1BB152 on #DA812D]#1BB152 on #DA812D!")
+
+ # Check cursor movement
+ console.rule("Checking cursor movement")
+ console.print()
+ term.move_cursor_backward()
+ term.move_cursor_backward()
+ term.write_text("went back and wrapped to prev line")
+ time.sleep(1)
+ term.move_cursor_up()
+ term.write_text("we go up")
+ time.sleep(1)
+ term.move_cursor_down()
+ term.write_text("and down")
+ time.sleep(1)
+ term.move_cursor_up()
+ term.move_cursor_backward()
+ term.move_cursor_backward()
+ term.write_text("we went up and back 2")
+ time.sleep(1)
+ term.move_cursor_down()
+ term.move_cursor_backward()
+ term.move_cursor_backward()
+ term.write_text("we went down and back 2")
+ time.sleep(1)
+
+ # Check erasing of lines
+ term.hide_cursor()
+ console.print()
+ console.rule("Checking line erasing")
+ console.print("\n...Deleting to the start of the line...")
+ term.write_text("The red arrow shows the cursor location, and direction of erase")
+ time.sleep(1)
+ term.move_cursor_to_column(16)
+ term.write_styled("<", Style.parse("black on red"))
+ term.move_cursor_backward()
+ time.sleep(1)
+ term.erase_start_of_line()
+ time.sleep(1)
+
+ console.print("\n\n...And to the end of the line...")
+ term.write_text("The red arrow shows the cursor location, and direction of erase")
+ time.sleep(1)
+
+ term.move_cursor_to_column(16)
+ term.write_styled(">", Style.parse("black on red"))
+ time.sleep(1)
+ term.erase_end_of_line()
+ time.sleep(1)
+
+ console.print("\n\n...Now the whole line will be erased...")
+ term.write_styled("I'm going to disappear!", style=Style.parse("black on cyan"))
+ time.sleep(1)
+ term.erase_line()
+
+ term.show_cursor()
+ print("\n")
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/abc.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/abc.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6e498efabfab0dcf31cd7731f8f821cc423bc4f
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/abc.py
@@ -0,0 +1,33 @@
+from abc import ABC
+
+
+class RichRenderable(ABC):
+ """An abstract base class for Rich renderables.
+
+ Note that there is no need to extend this class, the intended use is to check if an
+ object supports the Rich renderable protocol. For example::
+
+ if isinstance(my_object, RichRenderable):
+ console.print(my_object)
+
+ """
+
+ @classmethod
+ def __subclasshook__(cls, other: type) -> bool:
+ """Check if this class supports the rich render protocol."""
+ return hasattr(other, "__rich_console__") or hasattr(other, "__rich__")
+
+
+if __name__ == "__main__": # pragma: no cover
+ from pip._vendor.rich.text import Text
+
+ t = Text()
+ print(isinstance(Text, RichRenderable))
+ print(isinstance(t, RichRenderable))
+
+ class Foo:
+ pass
+
+ f = Foo()
+ print(isinstance(f, RichRenderable))
+ print(isinstance("", RichRenderable))
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/bar.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/bar.py
new file mode 100644
index 0000000000000000000000000000000000000000..022284b57881d8b133aced5b5a843e6447bb4e0b
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/bar.py
@@ -0,0 +1,93 @@
+from typing import Optional, Union
+
+from .color import Color
+from .console import Console, ConsoleOptions, RenderResult
+from .jupyter import JupyterMixin
+from .measure import Measurement
+from .segment import Segment
+from .style import Style
+
+# There are left-aligned characters for 1/8 to 7/8, but
+# the right-aligned characters exist only for 1/8 and 4/8.
+BEGIN_BLOCK_ELEMENTS = ["█", "█", "█", "▐", "▐", "▐", "▕", "▕"]
+END_BLOCK_ELEMENTS = [" ", "▏", "▎", "▍", "▌", "▋", "▊", "▉"]
+FULL_BLOCK = "█"
+
+
+class Bar(JupyterMixin):
+ """Renders a solid block bar.
+
+ Args:
+ size (float): Value for the end of the bar.
+ begin (float): Begin point (between 0 and size, inclusive).
+ end (float): End point (between 0 and size, inclusive).
+ width (int, optional): Width of the bar, or ``None`` for maximum width. Defaults to None.
+ color (Union[Color, str], optional): Color of the bar. Defaults to "default".
+ bgcolor (Union[Color, str], optional): Color of bar background. Defaults to "default".
+ """
+
+ def __init__(
+ self,
+ size: float,
+ begin: float,
+ end: float,
+ *,
+ width: Optional[int] = None,
+ color: Union[Color, str] = "default",
+ bgcolor: Union[Color, str] = "default",
+ ):
+ self.size = size
+ self.begin = max(begin, 0)
+ self.end = min(end, size)
+ self.width = width
+ self.style = Style(color=color, bgcolor=bgcolor)
+
+ def __repr__(self) -> str:
+ return f"Bar({self.size}, {self.begin}, {self.end})"
+
+ def __rich_console__(
+ self, console: Console, options: ConsoleOptions
+ ) -> RenderResult:
+ width = min(
+ self.width if self.width is not None else options.max_width,
+ options.max_width,
+ )
+
+ if self.begin >= self.end:
+ yield Segment(" " * width, self.style)
+ yield Segment.line()
+ return
+
+ prefix_complete_eights = int(width * 8 * self.begin / self.size)
+ prefix_bar_count = prefix_complete_eights // 8
+ prefix_eights_count = prefix_complete_eights % 8
+
+ body_complete_eights = int(width * 8 * self.end / self.size)
+ body_bar_count = body_complete_eights // 8
+ body_eights_count = body_complete_eights % 8
+
+ # When start and end fall into the same cell, we ideally should render
+ # a symbol that's "center-aligned", but there is no good symbol in Unicode.
+ # In this case, we fall back to right-aligned block symbol for simplicity.
+
+ prefix = " " * prefix_bar_count
+ if prefix_eights_count:
+ prefix += BEGIN_BLOCK_ELEMENTS[prefix_eights_count]
+
+ body = FULL_BLOCK * body_bar_count
+ if body_eights_count:
+ body += END_BLOCK_ELEMENTS[body_eights_count]
+
+ suffix = " " * (width - len(body))
+
+ yield Segment(prefix + body[len(prefix) :] + suffix, self.style)
+ yield Segment.line()
+
+ def __rich_measure__(
+ self, console: Console, options: ConsoleOptions
+ ) -> Measurement:
+ return (
+ Measurement(self.width, self.width)
+ if self.width is not None
+ else Measurement(4, options.max_width)
+ )
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/errors.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/errors.py
new file mode 100644
index 0000000000000000000000000000000000000000..0bcbe53ef59373c608e62ea285536f8b22b47ecb
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/errors.py
@@ -0,0 +1,34 @@
+class ConsoleError(Exception):
+ """An error in console operation."""
+
+
+class StyleError(Exception):
+ """An error in styles."""
+
+
+class StyleSyntaxError(ConsoleError):
+ """Style was badly formatted."""
+
+
+class MissingStyle(StyleError):
+ """No such style."""
+
+
+class StyleStackError(ConsoleError):
+ """Style stack is invalid."""
+
+
+class NotRenderableError(ConsoleError):
+ """Object is not renderable."""
+
+
+class MarkupError(ConsoleError):
+ """Markup was badly formatted."""
+
+
+class LiveError(ConsoleError):
+ """Error related to Live display."""
+
+
+class NoAltScreen(ConsoleError):
+ """Alt screen mode was required."""
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/filesize.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/filesize.py
new file mode 100644
index 0000000000000000000000000000000000000000..99f118e20103174993b865cfb43ac6b6e00296a4
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/filesize.py
@@ -0,0 +1,89 @@
+# coding: utf-8
+"""Functions for reporting filesizes. Borrowed from https://github.com/PyFilesystem/pyfilesystem2
+
+The functions declared in this module should cover the different
+use cases needed to generate a string representation of a file size
+using several different units. Since there are many standards regarding
+file size units, three different functions have been implemented.
+
+See Also:
+ * `Wikipedia: Binary prefix `_
+
+"""
+
+__all__ = ["decimal"]
+
+from typing import Iterable, List, Optional, Tuple
+
+
+def _to_str(
+ size: int,
+ suffixes: Iterable[str],
+ base: int,
+ *,
+ precision: Optional[int] = 1,
+ separator: Optional[str] = " ",
+) -> str:
+ if size == 1:
+ return "1 byte"
+ elif size < base:
+ return "{:,} bytes".format(size)
+
+ for i, suffix in enumerate(suffixes, 2): # noqa: B007
+ unit = base**i
+ if size < unit:
+ break
+ return "{:,.{precision}f}{separator}{}".format(
+ (base * size / unit),
+ suffix,
+ precision=precision,
+ separator=separator,
+ )
+
+
+def pick_unit_and_suffix(size: int, suffixes: List[str], base: int) -> Tuple[int, str]:
+ """Pick a suffix and base for the given size."""
+ for i, suffix in enumerate(suffixes):
+ unit = base**i
+ if size < unit * base:
+ break
+ return unit, suffix
+
+
+def decimal(
+ size: int,
+ *,
+ precision: Optional[int] = 1,
+ separator: Optional[str] = " ",
+) -> str:
+ """Convert a filesize in to a string (powers of 1000, SI prefixes).
+
+ In this convention, ``1000 B = 1 kB``.
+
+ This is typically the format used to advertise the storage
+ capacity of USB flash drives and the like (*256 MB* meaning
+ actually a storage capacity of more than *256 000 000 B*),
+ or used by **Mac OS X** since v10.6 to report file sizes.
+
+ Arguments:
+ int (size): A file size.
+ int (precision): The number of decimal places to include (default = 1).
+ str (separator): The string to separate the value from the units (default = " ").
+
+ Returns:
+ `str`: A string containing a abbreviated file size and units.
+
+ Example:
+ >>> filesize.decimal(30000)
+ '30.0 kB'
+ >>> filesize.decimal(30000, precision=2, separator="")
+ '30.00kB'
+
+ """
+ return _to_str(
+ size,
+ ("kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"),
+ 1000,
+ precision=precision,
+ separator=separator,
+ )
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/markup.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/markup.py
new file mode 100644
index 0000000000000000000000000000000000000000..f6171878f823183ee8f77195b3e944be222006dc
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/markup.py
@@ -0,0 +1,251 @@
+import re
+from ast import literal_eval
+from operator import attrgetter
+from typing import Callable, Iterable, List, Match, NamedTuple, Optional, Tuple, Union
+
+from ._emoji_replace import _emoji_replace
+from .emoji import EmojiVariant
+from .errors import MarkupError
+from .style import Style
+from .text import Span, Text
+
+RE_TAGS = re.compile(
+ r"""((\\*)\[([a-z#/@][^[]*?)])""",
+ re.VERBOSE,
+)
+
+RE_HANDLER = re.compile(r"^([\w.]*?)(\(.*?\))?$")
+
+
+class Tag(NamedTuple):
+ """A tag in console markup."""
+
+ name: str
+ """The tag name. e.g. 'bold'."""
+ parameters: Optional[str]
+ """Any additional parameters after the name."""
+
+ def __str__(self) -> str:
+ return (
+ self.name if self.parameters is None else f"{self.name} {self.parameters}"
+ )
+
+ @property
+ def markup(self) -> str:
+ """Get the string representation of this tag."""
+ return (
+ f"[{self.name}]"
+ if self.parameters is None
+ else f"[{self.name}={self.parameters}]"
+ )
+
+
+_ReStringMatch = Match[str] # regex match object
+_ReSubCallable = Callable[[_ReStringMatch], str] # Callable invoked by re.sub
+_EscapeSubMethod = Callable[[_ReSubCallable, str], str] # Sub method of a compiled re
+
+
+def escape(
+ markup: str,
+ _escape: _EscapeSubMethod = re.compile(r"(\\*)(\[[a-z#/@][^[]*?])").sub,
+) -> str:
+ """Escapes text so that it won't be interpreted as markup.
+
+ Args:
+ markup (str): Content to be inserted in to markup.
+
+ Returns:
+ str: Markup with square brackets escaped.
+ """
+
+ def escape_backslashes(match: Match[str]) -> str:
+ """Called by re.sub replace matches."""
+ backslashes, text = match.groups()
+ return f"{backslashes}{backslashes}\\{text}"
+
+ markup = _escape(escape_backslashes, markup)
+ if markup.endswith("\\") and not markup.endswith("\\\\"):
+ return markup + "\\"
+
+ return markup
+
+
+def _parse(markup: str) -> Iterable[Tuple[int, Optional[str], Optional[Tag]]]:
+ """Parse markup in to an iterable of tuples of (position, text, tag).
+
+ Args:
+ markup (str): A string containing console markup
+
+ """
+ position = 0
+ _divmod = divmod
+ _Tag = Tag
+ for match in RE_TAGS.finditer(markup):
+ full_text, escapes, tag_text = match.groups()
+ start, end = match.span()
+ if start > position:
+ yield start, markup[position:start], None
+ if escapes:
+ backslashes, escaped = _divmod(len(escapes), 2)
+ if backslashes:
+ # Literal backslashes
+ yield start, "\\" * backslashes, None
+ start += backslashes * 2
+ if escaped:
+ # Escape of tag
+ yield start, full_text[len(escapes) :], None
+ position = end
+ continue
+ text, equals, parameters = tag_text.partition("=")
+ yield start, None, _Tag(text, parameters if equals else None)
+ position = end
+ if position < len(markup):
+ yield position, markup[position:], None
+
+
+def render(
+ markup: str,
+ style: Union[str, Style] = "",
+ emoji: bool = True,
+ emoji_variant: Optional[EmojiVariant] = None,
+) -> Text:
+ """Render console markup in to a Text instance.
+
+ Args:
+ markup (str): A string containing console markup.
+ style: (Union[str, Style]): The style to use.
+ emoji (bool, optional): Also render emoji code. Defaults to True.
+ emoji_variant (str, optional): Optional emoji variant, either "text" or "emoji". Defaults to None.
+
+
+ Raises:
+ MarkupError: If there is a syntax error in the markup.
+
+ Returns:
+ Text: A test instance.
+ """
+ emoji_replace = _emoji_replace
+ if "[" not in markup:
+ return Text(
+ emoji_replace(markup, default_variant=emoji_variant) if emoji else markup,
+ style=style,
+ )
+ text = Text(style=style)
+ append = text.append
+ normalize = Style.normalize
+
+ style_stack: List[Tuple[int, Tag]] = []
+ pop = style_stack.pop
+
+ spans: List[Span] = []
+ append_span = spans.append
+
+ _Span = Span
+ _Tag = Tag
+
+ def pop_style(style_name: str) -> Tuple[int, Tag]:
+ """Pop tag matching given style name."""
+ for index, (_, tag) in enumerate(reversed(style_stack), 1):
+ if tag.name == style_name:
+ return pop(-index)
+ raise KeyError(style_name)
+
+ for position, plain_text, tag in _parse(markup):
+ if plain_text is not None:
+ # Handle open brace escapes, where the brace is not part of a tag.
+ plain_text = plain_text.replace("\\[", "[")
+ append(emoji_replace(plain_text) if emoji else plain_text)
+ elif tag is not None:
+ if tag.name.startswith("/"): # Closing tag
+ style_name = tag.name[1:].strip()
+
+ if style_name: # explicit close
+ style_name = normalize(style_name)
+ try:
+ start, open_tag = pop_style(style_name)
+ except KeyError:
+ raise MarkupError(
+ f"closing tag '{tag.markup}' at position {position} doesn't match any open tag"
+ ) from None
+ else: # implicit close
+ try:
+ start, open_tag = pop()
+ except IndexError:
+ raise MarkupError(
+ f"closing tag '[/]' at position {position} has nothing to close"
+ ) from None
+
+ if open_tag.name.startswith("@"):
+ if open_tag.parameters:
+ handler_name = ""
+ parameters = open_tag.parameters.strip()
+ handler_match = RE_HANDLER.match(parameters)
+ if handler_match is not None:
+ handler_name, match_parameters = handler_match.groups()
+ parameters = (
+ "()" if match_parameters is None else match_parameters
+ )
+
+ try:
+ meta_params = literal_eval(parameters)
+ except SyntaxError as error:
+ raise MarkupError(
+ f"error parsing {parameters!r} in {open_tag.parameters!r}; {error.msg}"
+ )
+ except Exception as error:
+ raise MarkupError(
+ f"error parsing {open_tag.parameters!r}; {error}"
+ ) from None
+
+ if handler_name:
+ meta_params = (
+ handler_name,
+ meta_params
+ if isinstance(meta_params, tuple)
+ else (meta_params,),
+ )
+
+ else:
+ meta_params = ()
+
+ append_span(
+ _Span(
+ start, len(text), Style(meta={open_tag.name: meta_params})
+ )
+ )
+ else:
+ append_span(_Span(start, len(text), str(open_tag)))
+
+ else: # Opening tag
+ normalized_tag = _Tag(normalize(tag.name), tag.parameters)
+ style_stack.append((len(text), normalized_tag))
+
+ text_length = len(text)
+ while style_stack:
+ start, tag = style_stack.pop()
+ style = str(tag)
+ if style:
+ append_span(_Span(start, text_length, style))
+
+ text.spans = sorted(spans[::-1], key=attrgetter("start"))
+ return text
+
+
+if __name__ == "__main__": # pragma: no cover
+ MARKUP = [
+ "[red]Hello World[/red]",
+ "[magenta]Hello [b]World[/b]",
+ "[bold]Bold[italic] bold and italic [/bold]italic[/italic]",
+ "Click [link=https://www.willmcgugan.com]here[/link] to visit my Blog",
+ ":warning-emoji: [bold red blink] DANGER![/]",
+ ]
+
+ from pip._vendor.rich import print
+ from pip._vendor.rich.table import Table
+
+ grid = Table("Markup", "Result", padding=(0, 1))
+
+ for markup in MARKUP:
+ grid.add_row(Text(markup), markup)
+
+ print(grid)
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/panel.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/panel.py
new file mode 100644
index 0000000000000000000000000000000000000000..95f4c84cf0b21d1bb518a40b22f39716a189f2fa
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/panel.py
@@ -0,0 +1,312 @@
+from typing import TYPE_CHECKING, Optional
+
+from .align import AlignMethod
+from .box import ROUNDED, Box
+from .cells import cell_len
+from .jupyter import JupyterMixin
+from .measure import Measurement, measure_renderables
+from .padding import Padding, PaddingDimensions
+from .segment import Segment
+from .style import Style, StyleType
+from .text import Text, TextType
+
+if TYPE_CHECKING:
+ from .console import Console, ConsoleOptions, RenderableType, RenderResult
+
+
+class Panel(JupyterMixin):
+ """A console renderable that draws a border around its contents.
+
+ Example:
+ >>> console.print(Panel("Hello, World!"))
+
+ Args:
+ renderable (RenderableType): A console renderable object.
+ box (Box, optional): A Box instance that defines the look of the border (see :ref:`appendix_box`.
+ Defaults to box.ROUNDED.
+ safe_box (bool, optional): Disable box characters that don't display on windows legacy terminal with *raster* fonts. Defaults to True.
+ expand (bool, optional): If True the panel will stretch to fill the console
+ width, otherwise it will be sized to fit the contents. Defaults to True.
+ style (str, optional): The style of the panel (border and contents). Defaults to "none".
+ border_style (str, optional): The style of the border. Defaults to "none".
+ width (Optional[int], optional): Optional width of panel. Defaults to None to auto-detect.
+ height (Optional[int], optional): Optional height of panel. Defaults to None to auto-detect.
+ padding (Optional[PaddingDimensions]): Optional padding around renderable. Defaults to 0.
+ highlight (bool, optional): Enable automatic highlighting of panel title (if str). Defaults to False.
+ """
+
+ def __init__(
+ self,
+ renderable: "RenderableType",
+ box: Box = ROUNDED,
+ *,
+ title: Optional[TextType] = None,
+ title_align: AlignMethod = "center",
+ subtitle: Optional[TextType] = None,
+ subtitle_align: AlignMethod = "center",
+ safe_box: Optional[bool] = None,
+ expand: bool = True,
+ style: StyleType = "none",
+ border_style: StyleType = "none",
+ width: Optional[int] = None,
+ height: Optional[int] = None,
+ padding: PaddingDimensions = (0, 1),
+ highlight: bool = False,
+ ) -> None:
+ self.renderable = renderable
+ self.box = box
+ self.title = title
+ self.title_align: AlignMethod = title_align
+ self.subtitle = subtitle
+ self.subtitle_align = subtitle_align
+ self.safe_box = safe_box
+ self.expand = expand
+ self.style = style
+ self.border_style = border_style
+ self.width = width
+ self.height = height
+ self.padding = padding
+ self.highlight = highlight
+
+ @classmethod
+ def fit(
+ cls,
+ renderable: "RenderableType",
+ box: Box = ROUNDED,
+ *,
+ title: Optional[TextType] = None,
+ title_align: AlignMethod = "center",
+ subtitle: Optional[TextType] = None,
+ subtitle_align: AlignMethod = "center",
+ safe_box: Optional[bool] = None,
+ style: StyleType = "none",
+ border_style: StyleType = "none",
+ width: Optional[int] = None,
+ height: Optional[int] = None,
+ padding: PaddingDimensions = (0, 1),
+ highlight: bool = False,
+ ) -> "Panel":
+ """An alternative constructor that sets expand=False."""
+ return cls(
+ renderable,
+ box,
+ title=title,
+ title_align=title_align,
+ subtitle=subtitle,
+ subtitle_align=subtitle_align,
+ safe_box=safe_box,
+ style=style,
+ border_style=border_style,
+ width=width,
+ height=height,
+ padding=padding,
+ highlight=highlight,
+ expand=False,
+ )
+
+ @property
+ def _title(self) -> Optional[Text]:
+ if self.title:
+ title_text = (
+ Text.from_markup(self.title)
+ if isinstance(self.title, str)
+ else self.title.copy()
+ )
+ title_text.end = ""
+ title_text.plain = title_text.plain.replace("\n", " ")
+ title_text.no_wrap = True
+ title_text.expand_tabs()
+ title_text.pad(1)
+ return title_text
+ return None
+
+ @property
+ def _subtitle(self) -> Optional[Text]:
+ if self.subtitle:
+ subtitle_text = (
+ Text.from_markup(self.subtitle)
+ if isinstance(self.subtitle, str)
+ else self.subtitle.copy()
+ )
+ subtitle_text.end = ""
+ subtitle_text.plain = subtitle_text.plain.replace("\n", " ")
+ subtitle_text.no_wrap = True
+ subtitle_text.expand_tabs()
+ subtitle_text.pad(1)
+ return subtitle_text
+ return None
+
+ def __rich_console__(
+ self, console: "Console", options: "ConsoleOptions"
+ ) -> "RenderResult":
+ _padding = Padding.unpack(self.padding)
+ renderable = (
+ Padding(self.renderable, _padding) if any(_padding) else self.renderable
+ )
+ style = console.get_style(self.style)
+ border_style = style + console.get_style(self.border_style)
+ width = (
+ options.max_width
+ if self.width is None
+ else min(options.max_width, self.width)
+ )
+
+ safe_box: bool = console.safe_box if self.safe_box is None else self.safe_box
+ box = self.box.substitute(options, safe=safe_box)
+
+ def align_text(
+ text: Text, width: int, align: str, character: str, style: Style
+ ) -> Text:
+ """Gets new aligned text.
+
+ Args:
+ text (Text): Title or subtitle text.
+ width (int): Desired width.
+ align (str): Alignment.
+ character (str): Character for alignment.
+ style (Style): Border style
+
+ Returns:
+ Text: New text instance
+ """
+ text = text.copy()
+ text.truncate(width)
+ excess_space = width - cell_len(text.plain)
+ if excess_space:
+ if align == "left":
+ return Text.assemble(
+ text,
+ (character * excess_space, style),
+ no_wrap=True,
+ end="",
+ )
+ elif align == "center":
+ left = excess_space // 2
+ return Text.assemble(
+ (character * left, style),
+ text,
+ (character * (excess_space - left), style),
+ no_wrap=True,
+ end="",
+ )
+ else:
+ return Text.assemble(
+ (character * excess_space, style),
+ text,
+ no_wrap=True,
+ end="",
+ )
+ return text
+
+ title_text = self._title
+ if title_text is not None:
+ title_text.stylize_before(border_style)
+
+ child_width = (
+ width - 2
+ if self.expand
+ else console.measure(
+ renderable, options=options.update_width(width - 2)
+ ).maximum
+ )
+ child_height = self.height or options.height or None
+ if child_height:
+ child_height -= 2
+ if title_text is not None:
+ child_width = min(
+ options.max_width - 2, max(child_width, title_text.cell_len + 2)
+ )
+
+ width = child_width + 2
+ child_options = options.update(
+ width=child_width, height=child_height, highlight=self.highlight
+ )
+ lines = console.render_lines(renderable, child_options, style=style)
+
+ line_start = Segment(box.mid_left, border_style)
+ line_end = Segment(f"{box.mid_right}", border_style)
+ new_line = Segment.line()
+ if title_text is None or width <= 4:
+ yield Segment(box.get_top([width - 2]), border_style)
+ else:
+ title_text = align_text(
+ title_text,
+ width - 4,
+ self.title_align,
+ box.top,
+ border_style,
+ )
+ yield Segment(box.top_left + box.top, border_style)
+ yield from console.render(title_text, child_options.update_width(width - 4))
+ yield Segment(box.top + box.top_right, border_style)
+
+ yield new_line
+ for line in lines:
+ yield line_start
+ yield from line
+ yield line_end
+ yield new_line
+
+ subtitle_text = self._subtitle
+ if subtitle_text is not None:
+ subtitle_text.stylize_before(border_style)
+
+ if subtitle_text is None or width <= 4:
+ yield Segment(box.get_bottom([width - 2]), border_style)
+ else:
+ subtitle_text = align_text(
+ subtitle_text,
+ width - 4,
+ self.subtitle_align,
+ box.bottom,
+ border_style,
+ )
+ yield Segment(box.bottom_left + box.bottom, border_style)
+ yield from console.render(
+ subtitle_text, child_options.update_width(width - 4)
+ )
+ yield Segment(box.bottom + box.bottom_right, border_style)
+
+ yield new_line
+
+ def __rich_measure__(
+ self, console: "Console", options: "ConsoleOptions"
+ ) -> "Measurement":
+ _title = self._title
+ _, right, _, left = Padding.unpack(self.padding)
+ padding = left + right
+ renderables = [self.renderable, _title] if _title else [self.renderable]
+
+ if self.width is None:
+ width = (
+ measure_renderables(
+ console,
+ options.update_width(options.max_width - padding - 2),
+ renderables,
+ ).maximum
+ + padding
+ + 2
+ )
+ else:
+ width = self.width
+ return Measurement(width, width)
+
+
+if __name__ == "__main__": # pragma: no cover
+ from .console import Console
+
+ c = Console()
+
+ from .box import DOUBLE, ROUNDED
+ from .padding import Padding
+
+ p = Panel(
+ "Hello, World!",
+ title="rich.Panel",
+ style="white on blue",
+ box=DOUBLE,
+ padding=1,
+ )
+
+ c.print()
+ c.print(p)
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/table.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/table.py
new file mode 100644
index 0000000000000000000000000000000000000000..43c718ebf5906c7aaca9fb14ac34dd80ae8bc01e
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/table.py
@@ -0,0 +1,1000 @@
+from dataclasses import dataclass, field, replace
+from typing import (
+ TYPE_CHECKING,
+ Dict,
+ Iterable,
+ List,
+ NamedTuple,
+ Optional,
+ Sequence,
+ Tuple,
+ Union,
+)
+
+from . import box, errors
+from ._loop import loop_first_last, loop_last
+from ._pick import pick_bool
+from ._ratio import ratio_distribute, ratio_reduce
+from .align import VerticalAlignMethod
+from .jupyter import JupyterMixin
+from .measure import Measurement
+from .padding import Padding, PaddingDimensions
+from .protocol import is_renderable
+from .segment import Segment
+from .style import Style, StyleType
+from .text import Text, TextType
+
+if TYPE_CHECKING:
+ from .console import (
+ Console,
+ ConsoleOptions,
+ JustifyMethod,
+ OverflowMethod,
+ RenderableType,
+ RenderResult,
+ )
+
+
+@dataclass
+class Column:
+ """Defines a column within a ~Table.
+
+ Args:
+ title (Union[str, Text], optional): The title of the table rendered at the top. Defaults to None.
+ caption (Union[str, Text], optional): The table caption rendered below. Defaults to None.
+ width (int, optional): The width in characters of the table, or ``None`` to automatically fit. Defaults to None.
+ min_width (Optional[int], optional): The minimum width of the table, or ``None`` for no minimum. Defaults to None.
+ box (box.Box, optional): One of the constants in box.py used to draw the edges (see :ref:`appendix_box`), or ``None`` for no box lines. Defaults to box.HEAVY_HEAD.
+ safe_box (Optional[bool], optional): Disable box characters that don't display on windows legacy terminal with *raster* fonts. Defaults to True.
+ padding (PaddingDimensions, optional): Padding for cells (top, right, bottom, left). Defaults to (0, 1).
+ collapse_padding (bool, optional): Enable collapsing of padding around cells. Defaults to False.
+ pad_edge (bool, optional): Enable padding of edge cells. Defaults to True.
+ expand (bool, optional): Expand the table to fit the available space if ``True``, otherwise the table width will be auto-calculated. Defaults to False.
+ show_header (bool, optional): Show a header row. Defaults to True.
+ show_footer (bool, optional): Show a footer row. Defaults to False.
+ show_edge (bool, optional): Draw a box around the outside of the table. Defaults to True.
+ show_lines (bool, optional): Draw lines between every row. Defaults to False.
+ leading (bool, optional): Number of blank lines between rows (precludes ``show_lines``). Defaults to 0.
+ style (Union[str, Style], optional): Default style for the table. Defaults to "none".
+ row_styles (List[Union, str], optional): Optional list of row styles, if more than one style is given then the styles will alternate. Defaults to None.
+ header_style (Union[str, Style], optional): Style of the header. Defaults to "table.header".
+ footer_style (Union[str, Style], optional): Style of the footer. Defaults to "table.footer".
+ border_style (Union[str, Style], optional): Style of the border. Defaults to None.
+ title_style (Union[str, Style], optional): Style of the title. Defaults to None.
+ caption_style (Union[str, Style], optional): Style of the caption. Defaults to None.
+ title_justify (str, optional): Justify method for title. Defaults to "center".
+ caption_justify (str, optional): Justify method for caption. Defaults to "center".
+ highlight (bool, optional): Highlight cell contents (if str). Defaults to False.
+ """
+
+ header: "RenderableType" = ""
+ """RenderableType: Renderable for the header (typically a string)"""
+
+ footer: "RenderableType" = ""
+ """RenderableType: Renderable for the footer (typically a string)"""
+
+ header_style: StyleType = ""
+ """StyleType: The style of the header."""
+
+ footer_style: StyleType = ""
+ """StyleType: The style of the footer."""
+
+ style: StyleType = ""
+ """StyleType: The style of the column."""
+
+ justify: "JustifyMethod" = "left"
+ """str: How to justify text within the column ("left", "center", "right", or "full")"""
+
+ vertical: "VerticalAlignMethod" = "top"
+ """str: How to vertically align content ("top", "middle", or "bottom")"""
+
+ overflow: "OverflowMethod" = "ellipsis"
+ """str: Overflow method."""
+
+ width: Optional[int] = None
+ """Optional[int]: Width of the column, or ``None`` (default) to auto calculate width."""
+
+ min_width: Optional[int] = None
+ """Optional[int]: Minimum width of column, or ``None`` for no minimum. Defaults to None."""
+
+ max_width: Optional[int] = None
+ """Optional[int]: Maximum width of column, or ``None`` for no maximum. Defaults to None."""
+
+ ratio: Optional[int] = None
+ """Optional[int]: Ratio to use when calculating column width, or ``None`` (default) to adapt to column contents."""
+
+ no_wrap: bool = False
+ """bool: Prevent wrapping of text within the column. Defaults to ``False``."""
+
+ _index: int = 0
+ """Index of column."""
+
+ _cells: List["RenderableType"] = field(default_factory=list)
+
+ def copy(self) -> "Column":
+ """Return a copy of this Column."""
+ return replace(self, _cells=[])
+
+ @property
+ def cells(self) -> Iterable["RenderableType"]:
+ """Get all cells in the column, not including header."""
+ yield from self._cells
+
+ @property
+ def flexible(self) -> bool:
+ """Check if this column is flexible."""
+ return self.ratio is not None
+
+
+@dataclass
+class Row:
+ """Information regarding a row."""
+
+ style: Optional[StyleType] = None
+ """Style to apply to row."""
+
+ end_section: bool = False
+ """Indicated end of section, which will force a line beneath the row."""
+
+
+class _Cell(NamedTuple):
+ """A single cell in a table."""
+
+ style: StyleType
+ """Style to apply to cell."""
+ renderable: "RenderableType"
+ """Cell renderable."""
+ vertical: VerticalAlignMethod
+ """Cell vertical alignment."""
+
+
+class Table(JupyterMixin):
+ """A console renderable to draw a table.
+
+ Args:
+ *headers (Union[Column, str]): Column headers, either as a string, or :class:`~rich.table.Column` instance.
+ title (Union[str, Text], optional): The title of the table rendered at the top. Defaults to None.
+ caption (Union[str, Text], optional): The table caption rendered below. Defaults to None.
+ width (int, optional): The width in characters of the table, or ``None`` to automatically fit. Defaults to None.
+ min_width (Optional[int], optional): The minimum width of the table, or ``None`` for no minimum. Defaults to None.
+ box (box.Box, optional): One of the constants in box.py used to draw the edges (see :ref:`appendix_box`), or ``None`` for no box lines. Defaults to box.HEAVY_HEAD.
+ safe_box (Optional[bool], optional): Disable box characters that don't display on windows legacy terminal with *raster* fonts. Defaults to True.
+ padding (PaddingDimensions, optional): Padding for cells (top, right, bottom, left). Defaults to (0, 1).
+ collapse_padding (bool, optional): Enable collapsing of padding around cells. Defaults to False.
+ pad_edge (bool, optional): Enable padding of edge cells. Defaults to True.
+ expand (bool, optional): Expand the table to fit the available space if ``True``, otherwise the table width will be auto-calculated. Defaults to False.
+ show_header (bool, optional): Show a header row. Defaults to True.
+ show_footer (bool, optional): Show a footer row. Defaults to False.
+ show_edge (bool, optional): Draw a box around the outside of the table. Defaults to True.
+ show_lines (bool, optional): Draw lines between every row. Defaults to False.
+ leading (bool, optional): Number of blank lines between rows (precludes ``show_lines``). Defaults to 0.
+ style (Union[str, Style], optional): Default style for the table. Defaults to "none".
+ row_styles (List[Union, str], optional): Optional list of row styles, if more than one style is given then the styles will alternate. Defaults to None.
+ header_style (Union[str, Style], optional): Style of the header. Defaults to "table.header".
+ footer_style (Union[str, Style], optional): Style of the footer. Defaults to "table.footer".
+ border_style (Union[str, Style], optional): Style of the border. Defaults to None.
+ title_style (Union[str, Style], optional): Style of the title. Defaults to None.
+ caption_style (Union[str, Style], optional): Style of the caption. Defaults to None.
+ title_justify (str, optional): Justify method for title. Defaults to "center".
+ caption_justify (str, optional): Justify method for caption. Defaults to "center".
+ highlight (bool, optional): Highlight cell contents (if str). Defaults to False.
+ """
+
+ columns: List[Column]
+ rows: List[Row]
+
+ def __init__(
+ self,
+ *headers: Union[Column, str],
+ title: Optional[TextType] = None,
+ caption: Optional[TextType] = None,
+ width: Optional[int] = None,
+ min_width: Optional[int] = None,
+ box: Optional[box.Box] = box.HEAVY_HEAD,
+ safe_box: Optional[bool] = None,
+ padding: PaddingDimensions = (0, 1),
+ collapse_padding: bool = False,
+ pad_edge: bool = True,
+ expand: bool = False,
+ show_header: bool = True,
+ show_footer: bool = False,
+ show_edge: bool = True,
+ show_lines: bool = False,
+ leading: int = 0,
+ style: StyleType = "none",
+ row_styles: Optional[Iterable[StyleType]] = None,
+ header_style: Optional[StyleType] = "table.header",
+ footer_style: Optional[StyleType] = "table.footer",
+ border_style: Optional[StyleType] = None,
+ title_style: Optional[StyleType] = None,
+ caption_style: Optional[StyleType] = None,
+ title_justify: "JustifyMethod" = "center",
+ caption_justify: "JustifyMethod" = "center",
+ highlight: bool = False,
+ ) -> None:
+ self.columns: List[Column] = []
+ self.rows: List[Row] = []
+ self.title = title
+ self.caption = caption
+ self.width = width
+ self.min_width = min_width
+ self.box = box
+ self.safe_box = safe_box
+ self._padding = Padding.unpack(padding)
+ self.pad_edge = pad_edge
+ self._expand = expand
+ self.show_header = show_header
+ self.show_footer = show_footer
+ self.show_edge = show_edge
+ self.show_lines = show_lines
+ self.leading = leading
+ self.collapse_padding = collapse_padding
+ self.style = style
+ self.header_style = header_style or ""
+ self.footer_style = footer_style or ""
+ self.border_style = border_style
+ self.title_style = title_style
+ self.caption_style = caption_style
+ self.title_justify: "JustifyMethod" = title_justify
+ self.caption_justify: "JustifyMethod" = caption_justify
+ self.highlight = highlight
+ self.row_styles: Sequence[StyleType] = list(row_styles or [])
+ append_column = self.columns.append
+ for header in headers:
+ if isinstance(header, str):
+ self.add_column(header=header)
+ else:
+ header._index = len(self.columns)
+ append_column(header)
+
+ @classmethod
+ def grid(
+ cls,
+ *headers: Union[Column, str],
+ padding: PaddingDimensions = 0,
+ collapse_padding: bool = True,
+ pad_edge: bool = False,
+ expand: bool = False,
+ ) -> "Table":
+ """Get a table with no lines, headers, or footer.
+
+ Args:
+ *headers (Union[Column, str]): Column headers, either as a string, or :class:`~rich.table.Column` instance.
+ padding (PaddingDimensions, optional): Get padding around cells. Defaults to 0.
+ collapse_padding (bool, optional): Enable collapsing of padding around cells. Defaults to True.
+ pad_edge (bool, optional): Enable padding around edges of table. Defaults to False.
+ expand (bool, optional): Expand the table to fit the available space if ``True``, otherwise the table width will be auto-calculated. Defaults to False.
+
+ Returns:
+ Table: A table instance.
+ """
+ return cls(
+ *headers,
+ box=None,
+ padding=padding,
+ collapse_padding=collapse_padding,
+ show_header=False,
+ show_footer=False,
+ show_edge=False,
+ pad_edge=pad_edge,
+ expand=expand,
+ )
+
+ @property
+ def expand(self) -> bool:
+ """Setting a non-None self.width implies expand."""
+ return self._expand or self.width is not None
+
+ @expand.setter
+ def expand(self, expand: bool) -> None:
+ """Set expand."""
+ self._expand = expand
+
+ @property
+ def _extra_width(self) -> int:
+ """Get extra width to add to cell content."""
+ width = 0
+ if self.box and self.show_edge:
+ width += 2
+ if self.box:
+ width += len(self.columns) - 1
+ return width
+
+ @property
+ def row_count(self) -> int:
+ """Get the current number of rows."""
+ return len(self.rows)
+
+ def get_row_style(self, console: "Console", index: int) -> StyleType:
+ """Get the current row style."""
+ style = Style.null()
+ if self.row_styles:
+ style += console.get_style(self.row_styles[index % len(self.row_styles)])
+ row_style = self.rows[index].style
+ if row_style is not None:
+ style += console.get_style(row_style)
+ return style
+
+ def __rich_measure__(
+ self, console: "Console", options: "ConsoleOptions"
+ ) -> Measurement:
+ max_width = options.max_width
+ if self.width is not None:
+ max_width = self.width
+ if max_width < 0:
+ return Measurement(0, 0)
+
+ extra_width = self._extra_width
+ max_width = sum(
+ self._calculate_column_widths(
+ console, options.update_width(max_width - extra_width)
+ )
+ )
+ _measure_column = self._measure_column
+
+ measurements = [
+ _measure_column(console, options.update_width(max_width), column)
+ for column in self.columns
+ ]
+ minimum_width = (
+ sum(measurement.minimum for measurement in measurements) + extra_width
+ )
+ maximum_width = (
+ sum(measurement.maximum for measurement in measurements) + extra_width
+ if (self.width is None)
+ else self.width
+ )
+ measurement = Measurement(minimum_width, maximum_width)
+ measurement = measurement.clamp(self.min_width)
+ return measurement
+
+ @property
+ def padding(self) -> Tuple[int, int, int, int]:
+ """Get cell padding."""
+ return self._padding
+
+ @padding.setter
+ def padding(self, padding: PaddingDimensions) -> "Table":
+ """Set cell padding."""
+ self._padding = Padding.unpack(padding)
+ return self
+
+ def add_column(
+ self,
+ header: "RenderableType" = "",
+ footer: "RenderableType" = "",
+ *,
+ header_style: Optional[StyleType] = None,
+ footer_style: Optional[StyleType] = None,
+ style: Optional[StyleType] = None,
+ justify: "JustifyMethod" = "left",
+ vertical: "VerticalAlignMethod" = "top",
+ overflow: "OverflowMethod" = "ellipsis",
+ width: Optional[int] = None,
+ min_width: Optional[int] = None,
+ max_width: Optional[int] = None,
+ ratio: Optional[int] = None,
+ no_wrap: bool = False,
+ ) -> None:
+ """Add a column to the table.
+
+ Args:
+ header (RenderableType, optional): Text or renderable for the header.
+ Defaults to "".
+ footer (RenderableType, optional): Text or renderable for the footer.
+ Defaults to "".
+ header_style (Union[str, Style], optional): Style for the header, or None for default. Defaults to None.
+ footer_style (Union[str, Style], optional): Style for the footer, or None for default. Defaults to None.
+ style (Union[str, Style], optional): Style for the column cells, or None for default. Defaults to None.
+ justify (JustifyMethod, optional): Alignment for cells. Defaults to "left".
+ vertical (VerticalAlignMethod, optional): Vertical alignment, one of "top", "middle", or "bottom". Defaults to "top".
+ overflow (OverflowMethod): Overflow method: "crop", "fold", "ellipsis". Defaults to "ellipsis".
+ width (int, optional): Desired width of column in characters, or None to fit to contents. Defaults to None.
+ min_width (Optional[int], optional): Minimum width of column, or ``None`` for no minimum. Defaults to None.
+ max_width (Optional[int], optional): Maximum width of column, or ``None`` for no maximum. Defaults to None.
+ ratio (int, optional): Flexible ratio for the column (requires ``Table.expand`` or ``Table.width``). Defaults to None.
+ no_wrap (bool, optional): Set to ``True`` to disable wrapping of this column.
+ """
+
+ column = Column(
+ _index=len(self.columns),
+ header=header,
+ footer=footer,
+ header_style=header_style or "",
+ footer_style=footer_style or "",
+ style=style or "",
+ justify=justify,
+ vertical=vertical,
+ overflow=overflow,
+ width=width,
+ min_width=min_width,
+ max_width=max_width,
+ ratio=ratio,
+ no_wrap=no_wrap,
+ )
+ self.columns.append(column)
+
+ def add_row(
+ self,
+ *renderables: Optional["RenderableType"],
+ style: Optional[StyleType] = None,
+ end_section: bool = False,
+ ) -> None:
+ """Add a row of renderables.
+
+ Args:
+ *renderables (None or renderable): Each cell in a row must be a renderable object (including str),
+ or ``None`` for a blank cell.
+ style (StyleType, optional): An optional style to apply to the entire row. Defaults to None.
+ end_section (bool, optional): End a section and draw a line. Defaults to False.
+
+ Raises:
+ errors.NotRenderableError: If you add something that can't be rendered.
+ """
+
+ def add_cell(column: Column, renderable: "RenderableType") -> None:
+ column._cells.append(renderable)
+
+ cell_renderables: List[Optional["RenderableType"]] = list(renderables)
+
+ columns = self.columns
+ if len(cell_renderables) < len(columns):
+ cell_renderables = [
+ *cell_renderables,
+ *[None] * (len(columns) - len(cell_renderables)),
+ ]
+ for index, renderable in enumerate(cell_renderables):
+ if index == len(columns):
+ column = Column(_index=index)
+ for _ in self.rows:
+ add_cell(column, Text(""))
+ self.columns.append(column)
+ else:
+ column = columns[index]
+ if renderable is None:
+ add_cell(column, "")
+ elif is_renderable(renderable):
+ add_cell(column, renderable)
+ else:
+ raise errors.NotRenderableError(
+ f"unable to render {type(renderable).__name__}; a string or other renderable object is required"
+ )
+ self.rows.append(Row(style=style, end_section=end_section))
+
+ def add_section(self) -> None:
+ """Add a new section (draw a line after current row)."""
+
+ if self.rows:
+ self.rows[-1].end_section = True
+
+ def __rich_console__(
+ self, console: "Console", options: "ConsoleOptions"
+ ) -> "RenderResult":
+ if not self.columns:
+ yield Segment("\n")
+ return
+
+ max_width = options.max_width
+ if self.width is not None:
+ max_width = self.width
+
+ extra_width = self._extra_width
+ widths = self._calculate_column_widths(
+ console, options.update_width(max_width - extra_width)
+ )
+ table_width = sum(widths) + extra_width
+
+ render_options = options.update(
+ width=table_width, highlight=self.highlight, height=None
+ )
+
+ def render_annotation(
+ text: TextType, style: StyleType, justify: "JustifyMethod" = "center"
+ ) -> "RenderResult":
+ render_text = (
+ console.render_str(text, style=style, highlight=False)
+ if isinstance(text, str)
+ else text
+ )
+ return console.render(
+ render_text, options=render_options.update(justify=justify)
+ )
+
+ if self.title:
+ yield from render_annotation(
+ self.title,
+ style=Style.pick_first(self.title_style, "table.title"),
+ justify=self.title_justify,
+ )
+ yield from self._render(console, render_options, widths)
+ if self.caption:
+ yield from render_annotation(
+ self.caption,
+ style=Style.pick_first(self.caption_style, "table.caption"),
+ justify=self.caption_justify,
+ )
+
+ def _calculate_column_widths(
+ self, console: "Console", options: "ConsoleOptions"
+ ) -> List[int]:
+ """Calculate the widths of each column, including padding, not including borders."""
+ max_width = options.max_width
+ columns = self.columns
+ width_ranges = [
+ self._measure_column(console, options, column) for column in columns
+ ]
+ widths = [_range.maximum or 1 for _range in width_ranges]
+ get_padding_width = self._get_padding_width
+ extra_width = self._extra_width
+ if self.expand:
+ ratios = [col.ratio or 0 for col in columns if col.flexible]
+ if any(ratios):
+ fixed_widths = [
+ 0 if column.flexible else _range.maximum
+ for _range, column in zip(width_ranges, columns)
+ ]
+ flex_minimum = [
+ (column.width or 1) + get_padding_width(column._index)
+ for column in columns
+ if column.flexible
+ ]
+ flexible_width = max_width - sum(fixed_widths)
+ flex_widths = ratio_distribute(flexible_width, ratios, flex_minimum)
+ iter_flex_widths = iter(flex_widths)
+ for index, column in enumerate(columns):
+ if column.flexible:
+ widths[index] = fixed_widths[index] + next(iter_flex_widths)
+ table_width = sum(widths)
+
+ if table_width > max_width:
+ widths = self._collapse_widths(
+ widths,
+ [(column.width is None and not column.no_wrap) for column in columns],
+ max_width,
+ )
+ table_width = sum(widths)
+ # last resort, reduce columns evenly
+ if table_width > max_width:
+ excess_width = table_width - max_width
+ widths = ratio_reduce(excess_width, [1] * len(widths), widths, widths)
+ table_width = sum(widths)
+
+ width_ranges = [
+ self._measure_column(console, options.update_width(width), column)
+ for width, column in zip(widths, columns)
+ ]
+ widths = [_range.maximum or 0 for _range in width_ranges]
+
+ if (table_width < max_width and self.expand) or (
+ self.min_width is not None and table_width < (self.min_width - extra_width)
+ ):
+ _max_width = (
+ max_width
+ if self.min_width is None
+ else min(self.min_width - extra_width, max_width)
+ )
+ pad_widths = ratio_distribute(_max_width - table_width, widths)
+ widths = [_width + pad for _width, pad in zip(widths, pad_widths)]
+
+ return widths
+
+ @classmethod
+ def _collapse_widths(
+ cls, widths: List[int], wrapable: List[bool], max_width: int
+ ) -> List[int]:
+ """Reduce widths so that the total is under max_width.
+
+ Args:
+ widths (List[int]): List of widths.
+ wrapable (List[bool]): List of booleans that indicate if a column may shrink.
+ max_width (int): Maximum width to reduce to.
+
+ Returns:
+ List[int]: A new list of widths.
+ """
+ total_width = sum(widths)
+ excess_width = total_width - max_width
+ if any(wrapable):
+ while total_width and excess_width > 0:
+ max_column = max(
+ width for width, allow_wrap in zip(widths, wrapable) if allow_wrap
+ )
+ second_max_column = max(
+ width if allow_wrap and width != max_column else 0
+ for width, allow_wrap in zip(widths, wrapable)
+ )
+ column_difference = max_column - second_max_column
+ ratios = [
+ (1 if (width == max_column and allow_wrap) else 0)
+ for width, allow_wrap in zip(widths, wrapable)
+ ]
+ if not any(ratios) or not column_difference:
+ break
+ max_reduce = [min(excess_width, column_difference)] * len(widths)
+ widths = ratio_reduce(excess_width, ratios, max_reduce, widths)
+
+ total_width = sum(widths)
+ excess_width = total_width - max_width
+ return widths
+
+ def _get_cells(
+ self, console: "Console", column_index: int, column: Column
+ ) -> Iterable[_Cell]:
+ """Get all the cells with padding and optional header."""
+
+ collapse_padding = self.collapse_padding
+ pad_edge = self.pad_edge
+ padding = self.padding
+ any_padding = any(padding)
+
+ first_column = column_index == 0
+ last_column = column_index == len(self.columns) - 1
+
+ _padding_cache: Dict[Tuple[bool, bool], Tuple[int, int, int, int]] = {}
+
+ def get_padding(first_row: bool, last_row: bool) -> Tuple[int, int, int, int]:
+ cached = _padding_cache.get((first_row, last_row))
+ if cached:
+ return cached
+ top, right, bottom, left = padding
+
+ if collapse_padding:
+ if not first_column:
+ left = max(0, left - right)
+ if not last_row:
+ bottom = max(0, top - bottom)
+
+ if not pad_edge:
+ if first_column:
+ left = 0
+ if last_column:
+ right = 0
+ if first_row:
+ top = 0
+ if last_row:
+ bottom = 0
+ _padding = (top, right, bottom, left)
+ _padding_cache[(first_row, last_row)] = _padding
+ return _padding
+
+ raw_cells: List[Tuple[StyleType, "RenderableType"]] = []
+ _append = raw_cells.append
+ get_style = console.get_style
+ if self.show_header:
+ header_style = get_style(self.header_style or "") + get_style(
+ column.header_style
+ )
+ _append((header_style, column.header))
+ cell_style = get_style(column.style or "")
+ for cell in column.cells:
+ _append((cell_style, cell))
+ if self.show_footer:
+ footer_style = get_style(self.footer_style or "") + get_style(
+ column.footer_style
+ )
+ _append((footer_style, column.footer))
+
+ if any_padding:
+ _Padding = Padding
+ for first, last, (style, renderable) in loop_first_last(raw_cells):
+ yield _Cell(
+ style,
+ _Padding(renderable, get_padding(first, last)),
+ getattr(renderable, "vertical", None) or column.vertical,
+ )
+ else:
+ for style, renderable in raw_cells:
+ yield _Cell(
+ style,
+ renderable,
+ getattr(renderable, "vertical", None) or column.vertical,
+ )
+
+ def _get_padding_width(self, column_index: int) -> int:
+ """Get extra width from padding."""
+ _, pad_right, _, pad_left = self.padding
+ if self.collapse_padding:
+ if column_index > 0:
+ pad_left = max(0, pad_left - pad_right)
+ return pad_left + pad_right
+
+ def _measure_column(
+ self,
+ console: "Console",
+ options: "ConsoleOptions",
+ column: Column,
+ ) -> Measurement:
+ """Get the minimum and maximum width of the column."""
+
+ max_width = options.max_width
+ if max_width < 1:
+ return Measurement(0, 0)
+
+ padding_width = self._get_padding_width(column._index)
+
+ if column.width is not None:
+ # Fixed width column
+ return Measurement(
+ column.width + padding_width, column.width + padding_width
+ ).with_maximum(max_width)
+ # Flexible column, we need to measure contents
+ min_widths: List[int] = []
+ max_widths: List[int] = []
+ append_min = min_widths.append
+ append_max = max_widths.append
+ get_render_width = Measurement.get
+ for cell in self._get_cells(console, column._index, column):
+ _min, _max = get_render_width(console, options, cell.renderable)
+ append_min(_min)
+ append_max(_max)
+
+ measurement = Measurement(
+ max(min_widths) if min_widths else 1,
+ max(max_widths) if max_widths else max_width,
+ ).with_maximum(max_width)
+ measurement = measurement.clamp(
+ None if column.min_width is None else column.min_width + padding_width,
+ None if column.max_width is None else column.max_width + padding_width,
+ )
+ return measurement
+
+ def _render(
+ self, console: "Console", options: "ConsoleOptions", widths: List[int]
+ ) -> "RenderResult":
+ table_style = console.get_style(self.style or "")
+
+ border_style = table_style + console.get_style(self.border_style or "")
+ _column_cells = (
+ self._get_cells(console, column_index, column)
+ for column_index, column in enumerate(self.columns)
+ )
+ row_cells: List[Tuple[_Cell, ...]] = list(zip(*_column_cells))
+ _box = (
+ self.box.substitute(
+ options, safe=pick_bool(self.safe_box, console.safe_box)
+ )
+ if self.box
+ else None
+ )
+ _box = _box.get_plain_headed_box() if _box and not self.show_header else _box
+
+ new_line = Segment.line()
+
+ columns = self.columns
+ show_header = self.show_header
+ show_footer = self.show_footer
+ show_edge = self.show_edge
+ show_lines = self.show_lines
+ leading = self.leading
+
+ _Segment = Segment
+ if _box:
+ box_segments = [
+ (
+ _Segment(_box.head_left, border_style),
+ _Segment(_box.head_right, border_style),
+ _Segment(_box.head_vertical, border_style),
+ ),
+ (
+ _Segment(_box.foot_left, border_style),
+ _Segment(_box.foot_right, border_style),
+ _Segment(_box.foot_vertical, border_style),
+ ),
+ (
+ _Segment(_box.mid_left, border_style),
+ _Segment(_box.mid_right, border_style),
+ _Segment(_box.mid_vertical, border_style),
+ ),
+ ]
+ if show_edge:
+ yield _Segment(_box.get_top(widths), border_style)
+ yield new_line
+ else:
+ box_segments = []
+
+ get_row_style = self.get_row_style
+ get_style = console.get_style
+
+ for index, (first, last, row_cell) in enumerate(loop_first_last(row_cells)):
+ header_row = first and show_header
+ footer_row = last and show_footer
+ row = (
+ self.rows[index - show_header]
+ if (not header_row and not footer_row)
+ else None
+ )
+ max_height = 1
+ cells: List[List[List[Segment]]] = []
+ if header_row or footer_row:
+ row_style = Style.null()
+ else:
+ row_style = get_style(
+ get_row_style(console, index - 1 if show_header else index)
+ )
+ for width, cell, column in zip(widths, row_cell, columns):
+ render_options = options.update(
+ width=width,
+ justify=column.justify,
+ no_wrap=column.no_wrap,
+ overflow=column.overflow,
+ height=None,
+ )
+ lines = console.render_lines(
+ cell.renderable,
+ render_options,
+ style=get_style(cell.style) + row_style,
+ )
+ max_height = max(max_height, len(lines))
+ cells.append(lines)
+
+ row_height = max(len(cell) for cell in cells)
+
+ def align_cell(
+ cell: List[List[Segment]],
+ vertical: "VerticalAlignMethod",
+ width: int,
+ style: Style,
+ ) -> List[List[Segment]]:
+ if header_row:
+ vertical = "bottom"
+ elif footer_row:
+ vertical = "top"
+
+ if vertical == "top":
+ return _Segment.align_top(cell, width, row_height, style)
+ elif vertical == "middle":
+ return _Segment.align_middle(cell, width, row_height, style)
+ return _Segment.align_bottom(cell, width, row_height, style)
+
+ cells[:] = [
+ _Segment.set_shape(
+ align_cell(
+ cell,
+ _cell.vertical,
+ width,
+ get_style(_cell.style) + row_style,
+ ),
+ width,
+ max_height,
+ )
+ for width, _cell, cell, column in zip(widths, row_cell, cells, columns)
+ ]
+
+ if _box:
+ if last and show_footer:
+ yield _Segment(
+ _box.get_row(widths, "foot", edge=show_edge), border_style
+ )
+ yield new_line
+ left, right, _divider = box_segments[0 if first else (2 if last else 1)]
+
+ # If the column divider is whitespace also style it with the row background
+ divider = (
+ _divider
+ if _divider.text.strip()
+ else _Segment(
+ _divider.text, row_style.background_style + _divider.style
+ )
+ )
+ for line_no in range(max_height):
+ if show_edge:
+ yield left
+ for last_cell, rendered_cell in loop_last(cells):
+ yield from rendered_cell[line_no]
+ if not last_cell:
+ yield divider
+ if show_edge:
+ yield right
+ yield new_line
+ else:
+ for line_no in range(max_height):
+ for rendered_cell in cells:
+ yield from rendered_cell[line_no]
+ yield new_line
+ if _box and first and show_header:
+ yield _Segment(
+ _box.get_row(widths, "head", edge=show_edge), border_style
+ )
+ yield new_line
+ end_section = row and row.end_section
+ if _box and (show_lines or leading or end_section):
+ if (
+ not last
+ and not (show_footer and index >= len(row_cells) - 2)
+ and not (show_header and header_row)
+ ):
+ if leading:
+ yield _Segment(
+ _box.get_row(widths, "mid", edge=show_edge) * leading,
+ border_style,
+ )
+ else:
+ yield _Segment(
+ _box.get_row(widths, "row", edge=show_edge), border_style
+ )
+ yield new_line
+
+ if _box and show_edge:
+ yield _Segment(_box.get_bottom(widths), border_style)
+ yield new_line
+
+
+if __name__ == "__main__": # pragma: no cover
+ from pip._vendor.rich.console import Console
+ from pip._vendor.rich.highlighter import ReprHighlighter
+ from pip._vendor.rich.table import Table as Table
+
+ from ._timer import timer
+
+ with timer("Table render"):
+ table = Table(
+ title="Star Wars Movies",
+ caption="Rich example table",
+ caption_justify="right",
+ )
+
+ table.add_column(
+ "Released", header_style="bright_cyan", style="cyan", no_wrap=True
+ )
+ table.add_column("Title", style="magenta")
+ table.add_column("Box Office", justify="right", style="green")
+
+ table.add_row(
+ "Dec 20, 2019",
+ "Star Wars: The Rise of Skywalker",
+ "$952,110,690",
+ )
+ table.add_row("May 25, 2018", "Solo: A Star Wars Story", "$393,151,347")
+ table.add_row(
+ "Dec 15, 2017",
+ "Star Wars Ep. V111: The Last Jedi",
+ "$1,332,539,889",
+ style="on black",
+ end_section=True,
+ )
+ table.add_row(
+ "Dec 16, 2016",
+ "Rogue One: A Star Wars Story",
+ "$1,332,439,889",
+ )
+
+ def header(text: str) -> None:
+ console.print()
+ console.rule(highlight(text))
+ console.print()
+
+ console = Console()
+ highlight = ReprHighlighter()
+ header("Example Table")
+ console.print(table, justify="center")
+
+ table.expand = True
+ header("expand=True")
+ console.print(table)
+
+ table.width = 50
+ header("width=50")
+
+ console.print(table, justify="center")
+
+ table.width = None
+ table.expand = False
+ table.row_styles = ["dim", "none"]
+ header("row_styles=['dim', 'none']")
+
+ console.print(table, justify="center")
+
+ table.width = None
+ table.expand = False
+ table.row_styles = ["dim", "none"]
+ table.leading = 1
+ header("leading=1, row_styles=['dim', 'none']")
+ console.print(table, justify="center")
+
+ table.width = None
+ table.expand = False
+ table.row_styles = ["dim", "none"]
+ table.show_lines = True
+ table.leading = 0
+ header("show_lines=True, row_styles=['dim', 'none']")
+ console.print(table, justify="center")
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/theme.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/theme.py
new file mode 100644
index 0000000000000000000000000000000000000000..471dfb2f9271c073f0713ca98f8db2f89c975071
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/theme.py
@@ -0,0 +1,115 @@
+import configparser
+from typing import Dict, List, IO, Mapping, Optional
+
+from .default_styles import DEFAULT_STYLES
+from .style import Style, StyleType
+
+
+class Theme:
+ """A container for style information, used by :class:`~rich.console.Console`.
+
+ Args:
+ styles (Dict[str, Style], optional): A mapping of style names on to styles. Defaults to None for a theme with no styles.
+ inherit (bool, optional): Inherit default styles. Defaults to True.
+ """
+
+ styles: Dict[str, Style]
+
+ def __init__(
+ self, styles: Optional[Mapping[str, StyleType]] = None, inherit: bool = True
+ ):
+ self.styles = DEFAULT_STYLES.copy() if inherit else {}
+ if styles is not None:
+ self.styles.update(
+ {
+ name: style if isinstance(style, Style) else Style.parse(style)
+ for name, style in styles.items()
+ }
+ )
+
+ @property
+ def config(self) -> str:
+ """Get contents of a config file for this theme."""
+ config = "[styles]\n" + "\n".join(
+ f"{name} = {style}" for name, style in sorted(self.styles.items())
+ )
+ return config
+
+ @classmethod
+ def from_file(
+ cls, config_file: IO[str], source: Optional[str] = None, inherit: bool = True
+ ) -> "Theme":
+ """Load a theme from a text mode file.
+
+ Args:
+ config_file (IO[str]): An open conf file.
+ source (str, optional): The filename of the open file. Defaults to None.
+ inherit (bool, optional): Inherit default styles. Defaults to True.
+
+ Returns:
+ Theme: A New theme instance.
+ """
+ config = configparser.ConfigParser()
+ config.read_file(config_file, source=source)
+ styles = {name: Style.parse(value) for name, value in config.items("styles")}
+ theme = Theme(styles, inherit=inherit)
+ return theme
+
+ @classmethod
+ def read(
+ cls, path: str, inherit: bool = True, encoding: Optional[str] = None
+ ) -> "Theme":
+ """Read a theme from a path.
+
+ Args:
+ path (str): Path to a config file readable by Python configparser module.
+ inherit (bool, optional): Inherit default styles. Defaults to True.
+ encoding (str, optional): Encoding of the config file. Defaults to None.
+
+ Returns:
+ Theme: A new theme instance.
+ """
+ with open(path, "rt", encoding=encoding) as config_file:
+ return cls.from_file(config_file, source=path, inherit=inherit)
+
+
+class ThemeStackError(Exception):
+ """Base exception for errors related to the theme stack."""
+
+
+class ThemeStack:
+ """A stack of themes.
+
+ Args:
+ theme (Theme): A theme instance
+ """
+
+ def __init__(self, theme: Theme) -> None:
+ self._entries: List[Dict[str, Style]] = [theme.styles]
+ self.get = self._entries[-1].get
+
+ def push_theme(self, theme: Theme, inherit: bool = True) -> None:
+ """Push a theme on the top of the stack.
+
+ Args:
+ theme (Theme): A Theme instance.
+ inherit (boolean, optional): Inherit styles from current top of stack.
+ """
+ styles: Dict[str, Style]
+ styles = (
+ {**self._entries[-1], **theme.styles} if inherit else theme.styles.copy()
+ )
+ self._entries.append(styles)
+ self.get = self._entries[-1].get
+
+ def pop_theme(self) -> None:
+ """Pop (and discard) the top-most theme."""
+ if len(self._entries) == 1:
+ raise ThemeStackError("Unable to pop base theme")
+ self._entries.pop()
+ self.get = self._entries[-1].get
+
+
+if __name__ == "__main__": # pragma: no cover
+ theme = Theme()
+ print(theme.config)
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/truststore/__init__.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/truststore/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e468bf8cebda1f507a30ff65584c13f6ba59d389
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/truststore/__init__.py
@@ -0,0 +1,36 @@
+"""Verify certificates using native system trust stores"""
+
+import sys as _sys
+
+if _sys.version_info < (3, 10):
+ raise ImportError("truststore requires Python 3.10 or later")
+
+# Detect Python runtimes which don't implement SSLObject.get_unverified_chain() API
+# This API only became public in Python 3.13 but was available in CPython and PyPy since 3.10.
+if _sys.version_info < (3, 13):
+ try:
+ import ssl as _ssl
+ except ImportError:
+ raise ImportError("truststore requires the 'ssl' module")
+ else:
+ _sslmem = _ssl.MemoryBIO()
+ _sslobj = _ssl.create_default_context().wrap_bio(
+ _sslmem,
+ _sslmem,
+ )
+ try:
+ while not hasattr(_sslobj, "get_unverified_chain"):
+ _sslobj = _sslobj._sslobj # type: ignore[attr-defined]
+ except AttributeError:
+ raise ImportError(
+ "truststore requires peer certificate chain APIs to be available"
+ ) from None
+
+ del _ssl, _sslobj, _sslmem # noqa: F821
+
+from ._api import SSLContext, extract_from_ssl, inject_into_ssl # noqa: E402
+
+del _api, _sys # type: ignore[name-defined] # noqa: F821
+
+__all__ = ["SSLContext", "inject_into_ssl", "extract_from_ssl"]
+__version__ = "0.10.0"
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/truststore/__pycache__/__init__.cpython-311.pyc b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/truststore/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5b57d409718ab5277e8bfb470cec40461727c906
Binary files /dev/null and b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/truststore/__pycache__/__init__.cpython-311.pyc differ
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/_guards.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/_guards.py
new file mode 100644
index 0000000000000000000000000000000000000000..d25a759988d4b3e81308aaf122df32d333f2a964
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/_guards.py
@@ -0,0 +1,879 @@
+from __future__ import annotations
+
+import contextlib
+
+import dataclasses
+import enum
+import functools
+import logging
+import threading
+import traceback
+import unittest.mock
+import weakref
+from abc import ABC, abstractmethod
+from contextlib import contextmanager
+from typing import (
+ Any,
+ Callable,
+ Dict,
+ Generic,
+ List,
+ NamedTuple,
+ Optional,
+ Set,
+ Tuple,
+ TYPE_CHECKING,
+ TypeVar,
+)
+
+import torch
+from torch.utils import _pytree as pytree
+from torch.utils._traceback import CapturedTraceback
+from torch.utils.weak import WeakTensorKeyDictionary
+
+log = logging.getLogger(__name__)
+
+
+if TYPE_CHECKING:
+ # Import the following modules during type checking to enable code intelligence features,
+ # such as auto-completion in tools like pylance, even when these modules are not explicitly
+ # imported in user code.
+
+ import sympy
+
+
+"""
+torch._guards is the definitional source of truth for general purpose guard structures.
+
+An important thing to keep in mind here is the preservation of layering. There should be no dynamo notions,
+and no guard installation notions here.
+"""
+
+
+class CompileId(NamedTuple):
+ frame_id: int
+ # This id is per-frame, and counts how many times we've compiled this
+ # frame. This could have been a global id but having this be per-frame
+ # gives you a better intuitive sense for how many recompiles have occurred
+ # so far.
+ frame_compile_id: int
+ # TODO: consider also tracking the recompilation count
+
+ def __str__(self):
+ return f"{self.frame_id}/{self.frame_compile_id}"
+
+
+class TraceId(NamedTuple):
+ compile_id: CompileId
+ # This starts off as 0, and every time we restart analysis it goes
+ # up by one
+ attempt: int
+
+ def __str__(self):
+ if self.attempt == 0:
+ return str(self.compile_id)
+ else:
+ return f"{self.compile_id}_{self.attempt}"
+
+
+class GuardSource(enum.Enum):
+ LOCAL = 0
+ GLOBAL = 1
+ LOCAL_NN_MODULE = 2
+ GLOBAL_NN_MODULE = 3
+ CONSTANT = 4
+ RANDOM_VALUE = 5
+ SHAPE_ENV = 6
+ LOCAL_FSDP_MODULE = 7
+ GLOBAL_FSDP_MODULE = 8
+ BACKWARD_STATE = 9
+ EPHEMERAL = 10
+ SYNTHETIC_LOCAL = 11
+
+ def is_fsdp_module(self) -> bool:
+ return self in (GuardSource.GLOBAL_FSDP_MODULE, GuardSource.LOCAL_FSDP_MODULE)
+
+ def is_nn_module(self) -> bool:
+ return (
+ self
+ in (
+ GuardSource.GLOBAL_NN_MODULE,
+ GuardSource.LOCAL_NN_MODULE,
+ )
+ or self.is_fsdp_module()
+ )
+
+ def is_local(self):
+ return self in (
+ GuardSource.LOCAL,
+ GuardSource.LOCAL_NN_MODULE,
+ GuardSource.LOCAL_FSDP_MODULE,
+ )
+
+
+"""
+Base class for a "GuardBuilder" role.
+
+The GuardBuilderBase role is to represent a scope within which to build a guard. The name is a little
+confusing, as its not a builder, but for the sake of avoiding a lot of renames and keeping the original reference
+to torchdynamo's GuardBuilder.
+
+Note: create_fn is invoked with a GuardBuilderBase and a Guard. A GuardBuilder is chosen based
+on GuardSource's select function.
+
+There is value in keeping this GuardBuilderBase empty to keep layering clean.
+"""
+
+
+class GuardBuilderBase:
+ pass
+
+
+class ShapeGuard(NamedTuple):
+ expr: sympy.Expr
+ stack: CapturedTraceback
+
+
+@dataclasses.dataclass
+class Guard:
+ # originating_source is the source that called the make_guard method to
+ # construct this guard object. The property name specifies what exactly it
+ # is the guard is guarding on. The meaning of the name is dependent on the
+ # create_fn; you must look at the use-site inside create_fn to know what
+ # name means.
+ #
+ # That being said, although you might think this is just a "name", name is
+ # usually an arbitrary Python expression that will be evaluated with all
+ # globals (and locals, if you create a LOCAL guard) to extract the Python
+ # object that we want to perform guard tests on. This evaluation
+ # typically happens in GuardBuilder.eval. In these cases, name is
+ # typically produced by originating_source.name() (not to be confused with
+ # GuardSource - the property source).
+ #
+ # Occasionally, name is not a valid Python expression; sometimes
+ # it is meaningless. Example create_fns that are like this include
+ # GRAD_MODE and SHAPE_ENV.
+ originating_source: Source
+ create_fn: Callable[[GuardBuilderBase, Guard], None]
+
+ # Export only. These values are written to at time of guard check_fn creation.
+ guard_types: Optional[List[str]] = None
+ code_list: Optional[List[str]] = None
+ obj_weakref: Optional[object] = None
+ guarded_class_weakref: Optional[type] = None
+
+ stack: Optional[CapturedTraceback] = None
+ user_stack: Optional[traceback.StackSummary] = None
+ _hash: Optional[int] = None
+
+ def __hash__(self):
+ if self._hash is None:
+ self._hash = hash((self.name, self.source, id(self.create_fn)))
+ return self._hash
+
+ def sort_key(self):
+ return (
+ self.source.value if self.source else -1,
+ len(self.name),
+ self.name,
+ self.inner_create_fn().__code__.co_firstlineno,
+ )
+
+ def __lt__(self, other):
+ return self.sort_key() < other.sort_key()
+
+ def inner_create_fn(self):
+ if isinstance(self.create_fn, functools.partial):
+ return self.create_fn.func
+ else:
+ return self.create_fn
+
+ @property
+ def name(self) -> str:
+ return self.originating_source.name()
+
+ @property
+ def source(self) -> GuardSource:
+ return self.originating_source.guard_source()
+
+ @staticmethod
+ def weakref_to_str(obj_weakref):
+ """
+ This is a workaround of a Python weakref bug.
+
+ `obj_weakref` is instance returned by `weakref.ref`,
+ `str(obj_weakref)` is buggy if the original obj overrides __getattr__, e.g:
+
+ class MyConfig(dict):
+ def __getattr__(self, x):
+ return self[x]
+
+ obj = MyConfig(offset=5)
+ obj_weakref = weakref.ref(obj)
+ str(obj_weakref) # raise error: KeyError: '__name__'
+ """
+ if isinstance(obj_weakref, weakref.ReferenceType):
+ obj = obj_weakref()
+ if obj is not None:
+ return f""
+ else:
+ return f""
+ else:
+ return str(obj_weakref)
+
+ def __repr__(self):
+ s = f"""
+ {self.source.name.lower() if self.source else ""} {repr(self.name)} {self.inner_create_fn().__name__}
+ {{
+ 'guard_types': {self.guard_types},
+ 'code': {self.code_list},
+ 'obj_weakref': {self.weakref_to_str(self.obj_weakref)}
+ 'guarded_class': {self.guarded_class_weakref}
+ }}
+ """
+ return s
+
+ def __str__(self):
+ output = f"Name: {repr(self.name)}\n"
+ source = self.source.name.lower() if self.source else ""
+ output += f" Source: {source}\n"
+ output += f" Create Function: {self.inner_create_fn().__name__}\n"
+ output += f" Guard Types: {self.guard_types}\n"
+ output += f" Code List: {self.code_list}\n"
+ output += f" Object Weakref: {self.weakref_to_str(self.obj_weakref)}\n"
+ output += f" Guarded Class Weakref: {self.guarded_class_weakref}\n"
+ return output
+
+ def create(self, builder: GuardBuilderBase):
+ try:
+ return self.create_fn(builder, self)
+ except Exception:
+ log.error("Error while creating guard:\n%s", str(self).rstrip())
+ if self.stack:
+ log.error("Created at:\n%s", "".join(self.stack.format()[-4:]).rstrip())
+ raise
+
+ def is_nn_module(self):
+ return self.source.is_nn_module()
+
+ def is_fsdp_module(self):
+ return self.source.is_fsdp_module()
+
+ def is_local(self):
+ return self.source.is_local()
+
+ def set_export_info(self, guard_type, guarded_class, code_list, obj_weakref):
+ if not self.guard_types:
+ self.guard_types = list()
+
+ self.guard_types.append(guard_type)
+
+ assert self.guarded_class_weakref in (
+ guarded_class,
+ None,
+ ), "Guarded class id must be identical, or None"
+ self.guarded_class_weakref = guarded_class
+
+ if not self.code_list:
+ self.code_list = code_list
+ else:
+ self.code_list.extend(code_list)
+
+ assert self.obj_weakref in (
+ obj_weakref,
+ None,
+ ), "Guarded object must be identical, or None"
+ self.obj_weakref = obj_weakref
+
+
+T = TypeVar("T")
+
+"""
+Parent structure for guard env expressions.
+A GuardEnvExpr can have any subtype.
+Note: All subtypes must be handled exhaustively in
+torch._dynamo.guards._parse_guard_env_guards to avoid a RuntimeError.
+"""
+
+
+@dataclasses.dataclass
+class GuardEnvExpr:
+ pass
+
+
+"""
+A class representing a pair of duplicate inputs.
+input_pos_a and input_pos_b are input positions we have deduped.
+"""
+
+
+@dataclasses.dataclass
+class DuplicateInputs(GuardEnvExpr):
+ input_source_a: Source
+ input_source_b: Source
+
+ def __post_init__(self):
+ assert self.input_source_a != self.input_source_b
+
+
+"""
+Checkpointable is an interface for driving state snapshotting, left purposely vague for now.
+
+copy_graphstate() -> T, a somewhat legacy name, is expected to emit a snapshot of any type that
+can also be taken in at restore_graphstate(T) calls.
+
+When to snapshot, is, at the moment, an implementation detail of upstream callers. Checkpointable
+does not provide any garuantees around consistency, idempotency, or safety of calling its APIs, yet.
+
+In the future, it will have a closer coupling to a generic Checkpoint management system.
+"""
+
+
+class Checkpointable(ABC, Generic[T]):
+ @abstractmethod
+ def copy_graphstate(self) -> T:
+ ...
+
+ @abstractmethod
+ def restore_graphstate(self, state: T):
+ ...
+
+
+class GuardsCheckpointState:
+ """
+ The GuardCheckpointState - it is the T of Checkpointable[T] for GuardsContext
+ """
+
+ dynamo_guards: Set[Guard] = set()
+
+ def __init__(self, dynamo_guards):
+ self.dynamo_guards = dynamo_guards
+
+ def diff(self, other):
+ """
+ Produces a delta against another GuardsCheckpointState.
+
+ Returns None if no delta is found, otherwise, return a set() of mismatched
+ Guard type objects.
+ """
+ r = self.dynamo_guards.difference(other.dynamo_guards)
+ if len(r) == 0:
+ return None
+ return r
+
+ def __eq__(self, other):
+ return self.diff(other) is None
+
+
+class ModuleContextCheckpointState:
+ nn_modules: Dict[str, torch.nn.Module] = {}
+
+ def __init__(self, nn_modules):
+ self.nn_modules = nn_modules
+
+ def diff(self, other):
+ """
+ Produces a delta against another ModuleContextCheckpointState.
+
+ Returns None if no delta is found, otherwise, return a set() of mismatched
+ module key names.
+ """
+ r = set(self.nn_modules.keys()).difference(set(other.nn_modules.keys()))
+ if len(r) == 0:
+ return None
+ return r
+
+ def __eq__(self, other):
+ return self.diff(other) is None
+
+
+class ModuleContext(Checkpointable[ModuleContextCheckpointState]):
+ def __init__(self):
+ self.nn_modules: Dict[str, Any] = {}
+
+ def copy_graphstate(self):
+ return ModuleContextCheckpointState(dict(self.nn_modules))
+
+ def restore_graphstate(self, state):
+ assert isinstance(state, ModuleContextCheckpointState)
+ self.nn_modules = state.nn_modules
+
+
+class GlobalContextCheckpointState:
+ global_state: Dict[str, Tuple[Callable, ...]] = {}
+
+ def __init__(self, global_states):
+ self.global_state = global_states
+
+ def diff(self, other):
+ """
+ Produces a delta against another GlobalContextCheckpointState.
+
+ Returns None if no delta is found, otherwise, return a set() of mismatched
+ global key names.
+ """
+ r = set(self.global_state.keys()).difference(set(other.global_state.keys()))
+ if len(r) == 0:
+ return None
+ return r
+
+ def __eq__(self, other):
+ return self.diff(other) is None
+
+
+class GlobalContext(Checkpointable[GlobalContextCheckpointState]):
+ """
+ This keeps track of the global torch state during tracing of a function.
+ For example, torch.is_grad_enabled.
+ """
+
+ _supported_global_states = {
+ "grad_enabled",
+ "torch_function_enabled",
+ "autocast_enabled",
+ "autocast_cpu_enabled",
+ "autocast_gpu_dtype",
+ "autocast_cpu_dtype",
+ "autocast_cache_enabled",
+ }
+
+ def __init__(self):
+ self.global_state: Dict[str, Tuple[Callable, ...]] = {}
+
+ def copy_graphstate(self):
+ return GlobalContextCheckpointState(dict(self.global_state))
+
+ def restore_graphstate(self, state):
+ assert isinstance(state, GlobalContextCheckpointState)
+ self.global_state = state.global_state
+ assert (
+ len(self.global_state) == len(self._supported_global_states)
+ and set(self.global_state.keys()) == self._supported_global_states
+ ), "Global state mismatch"
+ for func, args in self.global_state.values():
+ func(args)
+
+
+"""
+A GuardsContext is a checkpointable representation of all the guards in the current tracing
+context. It's lifecycle is bound 1:1 to the tracing context, and it should never be instantiated
+directly outside of it. For passing around internal state representations of this object,
+prefer to extract them with copy_graphstate to produce a GuardsCheckpointState.
+"""
+
+
+# Like a Set[Guard] but will record the user stack on all guards at the
+# time they were installed at their destination
+class GuardsSet:
+ def __init__(self, inner=None):
+ if inner is None:
+ inner = set()
+ self.inner = inner
+
+ def __iter__(self):
+ return iter(self.inner)
+
+ def __len__(self):
+ return len(self.inner)
+
+ # Subtraction along with bool is typically used to determine the delta of
+ # added guards between checkpoints for higher order ops
+ def __sub__(self, other):
+ return GuardsSet(self.inner - other.inner)
+
+ def __bool__(self):
+ return bool(self.inner)
+
+ def add(self, guard: Guard, *, collect_debug_stack=True, skip=0):
+ if guard in self.inner:
+ return
+ if collect_debug_stack:
+ if guard.stack is None:
+ guard.stack = CapturedTraceback.extract(skip=1 + skip)
+ if guard.user_stack is None:
+ guard.user_stack = TracingContext.extract_stack()
+ self.inner.add(guard)
+
+ def update(self, *others: Set[Guard]):
+ for o in others:
+ for g in o:
+ self.add(g, skip=1)
+
+ def remove_guards_with_source(self, source):
+ """Delete all guards with a given source"""
+ self.inner = {g for g in self.inner if g.originating_source != source}
+
+
+class GuardsContext(Checkpointable[GuardsCheckpointState]):
+ def __init__(self):
+ self.dynamo_guards: GuardsSet = GuardsSet()
+ self.aotautograd_guards: List[GuardEnvExpr] = []
+
+ def copy_graphstate(self):
+ return GuardsCheckpointState(set(self.dynamo_guards.inner))
+
+ def restore_graphstate(self, state):
+ # NB: "steals" the passed in state
+ assert isinstance(state, GuardsCheckpointState)
+ self.dynamo_guards = GuardsSet(state.dynamo_guards)
+
+
+_TLS = threading.local()
+
+"""
+TracingContext is the source of truth for all currently accumulated information
+needed to trace. Its lifecycle is kept 1:1 when using TorchDynamo, but other systems
+are open to managing their own TracingContext with that in mind.
+
+The purpose of TracingContext is not to be a dumping ground, or god object, but rather to avoid
+having to plumb complex subsystems across multiple verticals.
+
+Ex: A common example is guard accumulation between dynamo, shape_env, aot_autograd, and inductor.
+Accessing the current tracing context via
+TracingContext.get() allows users to accumulate their own guards for processing, without needing to know how
+to plumb objects back up to where frame interpretation happened.
+
+Note that you can end up with multiple TracingContext for a single compilation
+of a frame, as we reset the TracingContext whenever we restart analysis.
+CompileContext is a more overarching context that encompasses multiple restarts.
+"""
+
+
+class CompileContext:
+ @staticmethod
+ def get() -> CompileContext:
+ assert _TLS.compile_context is not None
+ return _TLS.compile_context
+
+ @staticmethod
+ def try_get() -> Optional[CompileContext]:
+ return getattr(_TLS, "compile_context", None)
+
+ def __init__(self, compile_id):
+ assert compile_id is None or isinstance(compile_id, CompileId)
+ self.compile_id: Optional[CompileId] = compile_id
+ self.attempt = 0
+
+ @staticmethod
+ def current_compile_id():
+ self = CompileContext.try_get()
+ if self is None:
+ return None
+ return self.compile_id
+
+ @staticmethod
+ def current_trace_id():
+ self = CompileContext.try_get()
+ if self is None:
+ return None
+ if self.compile_id is None:
+ return None
+ return TraceId(self.compile_id, self.attempt)
+
+
+class TracingContext:
+ """
+ Provides the currently installed TracingContext, or None.
+
+ Note that it is a staticmethod, and invocations outside of `with tracing()` (see below), are valid but
+ will return None.
+ """
+
+ @staticmethod
+ def try_get() -> Optional[TracingContext]:
+ return getattr(_TLS, "tracing_context", None)
+
+ @staticmethod
+ def get() -> TracingContext:
+ if ctx := TracingContext.try_get():
+ return ctx
+ raise RuntimeError(
+ "TracingContext.get() must be called within an ongoing trace."
+ )
+
+ def __init__(self, fake_mode):
+ self.guards_context = GuardsContext()
+ self.module_context = ModuleContext()
+ self.global_context = GlobalContext()
+ self.fake_mode = fake_mode
+ self.frame_summary_stack = []
+ # This is morally part of frame_summary_stack, but it is kept separate
+ # for clarity. As we process a frame, this variable gets updated
+ # to keep track of what line we are in the function. We make a
+ # function call, this gets cleared and the frame location is pushed
+ # to frame_summary_stack (prepping this variable for the inner frame's
+ # progress)
+ self.loc_in_frame = None
+ # this is only set after aot_autograd
+ self.fw_metadata = None
+ self.params_flat = None
+ # this is for extended return calling convention from backend
+ # compiler to aot_autograd
+ # Per output, what the compiler specified stride of the output is,
+ # or None if no stride is known. This is always the HINT, it
+ # is never a SymInt (it would be better if it was a SymInt, but
+ # I can't conveniently get this from Inductor atm. Also, be
+ # careful not to accidentally induce guards on the SymInt if
+ # you ever do change this in aot_autograd.py; you should check
+ # on permutations preferentially.)
+ self.output_strides: Optional[List[Optional[List[int]]]] = None
+ # When this is True, whenever we encounter an int in Dynamo tracing,
+ # we will (1) force unspec it and (2) force it as a size-like unbacked
+ # integer. This is currently used when processing certain lists of
+ # ints that are known to be size-like and may have 0/1 entries that we
+ # must not specialize on.
+ self.force_unspec_int_unbacked_size_like = False
+ # See note [Tensor Fakification and Symbol Caching]
+ self.tensor_to_context = WeakTensorKeyDictionary()
+
+ # If this true, Aot Autograd will return output Fake Tensors with appropiate
+ # meta on the first invocation
+ # see note: [Returning Fake Tensors on First AOT Autograd Call]
+ self.fakify_first_call = False
+
+ def clear(self):
+ # Look at the note in output_graph.py in function `save_global_state`
+ # for the context on clearing global context.
+ self.global_context.global_state = {}
+
+ @staticmethod
+ @contextmanager
+ def patch(**kwargs):
+ prior = {}
+ ctx = TracingContext.get()
+
+ for key in kwargs.keys():
+ # KeyError on invalid entry
+ prior[key] = getattr(ctx, key)
+ for key, val in kwargs.items():
+ setattr(ctx, key, val)
+ try:
+ yield
+ finally:
+ for key, val in prior.items():
+ setattr(ctx, key, val)
+
+ @staticmethod
+ def extract_stack():
+ self = TracingContext.try_get()
+ if self is None:
+ return traceback.StackSummary()
+ stack = self.frame_summary_stack
+ if self.loc_in_frame is not None:
+ stack = stack + [self.loc_in_frame]
+ return traceback.StackSummary.from_list(stack)
+
+ # Call this when you want to call into some code that isn't necessarily
+ # associated with the current frame state
+ @staticmethod
+ @contextlib.contextmanager
+ def clear_frame():
+ tc = TracingContext.get()
+ with unittest.mock.patch.object(
+ tc, "frame_summary_stack", []
+ ), unittest.mock.patch.object(tc, "loc_in_frame", None):
+ try:
+ yield
+ except Exception as e:
+ # Prevent real_stack from getting attached
+ #
+ # The invariant is that if an Exception as real_stack, we've
+ # appropriately attached a user stack and we no longer need to
+ # attach anything. Because we cannot conveniently interpose
+ # when an exception is thrown, we instead interpose everywhere
+ # we set what the user stack is set (using the context
+ # manager). However, our compiler stack does "tail calls"
+ # (when it calls into user compiler), at which point the
+ # parent exception frames would incorrectly attach an
+ # incorrect frame.
+ #
+ # However, if, somehow, someone raised an exception with this
+ # scope that had a stack (for example, because they are
+ # restoring the user stack state appropriately as they process
+ # node by node), we should respect it. Thus, we cannot
+ # unconditionally set None.
+ if not hasattr(e, "real_stack"):
+ e.real_stack = None # type: ignore[attr-defined]
+ raise
+
+ @staticmethod
+ @contextlib.contextmanager
+ def current_frame(frame_summary):
+ # frame_summary can be None to solely take advantage of real_stack
+ # attachment to thrown exceptions
+ tc = TracingContext.get()
+ if frame_summary is not None:
+ tc.frame_summary_stack.append(frame_summary)
+ old = tc.loc_in_frame
+ tc.loc_in_frame = None
+ try:
+ yield
+ except Exception as e:
+ if not hasattr(e, "real_stack"):
+ e.real_stack = tc.extract_stack() # type: ignore[attr-defined]
+ raise
+ finally:
+ if frame_summary is not None:
+ tc.frame_summary_stack.pop()
+ tc.loc_in_frame = old
+
+ @staticmethod
+ @contextlib.contextmanager
+ def report_output_strides():
+ tc = TracingContext.try_get()
+ if tc is None:
+ yield None
+ return
+ old_output_strides = tc.output_strides
+ tc.output_strides = []
+ try:
+ yield tc.output_strides
+ finally:
+ tc.output_strides = old_output_strides
+
+ @staticmethod
+ def set_current_loc(filename, lineno, frame_name):
+ TracingContext.get().loc_in_frame = traceback.FrameSummary(
+ filename, lineno, frame_name
+ )
+
+
+@contextmanager
+def compile_context(context: CompileContext):
+ old_context = getattr(_TLS, "compile_context", None)
+ _TLS.compile_context = context
+ try:
+ yield context
+ finally:
+ _TLS.compile_context = old_context
+
+
+@contextmanager
+def tracing(context: Optional[TracingContext]):
+ """
+ This function installs the passed in tracing context as a dynamic scoped
+ global variable.
+
+ Calls to TracingContext.get() while not under a `with tracing()` context
+ will return None.
+ """
+ old_context = getattr(_TLS, "tracing_context", None)
+ _TLS.tracing_context = context
+ try:
+ yield context
+ except Exception as e:
+ if not hasattr(e, "real_stack") and context is not None:
+ e.real_stack = context.extract_stack() # type: ignore[attr-defined]
+ raise
+ finally:
+ if (
+ context is not None
+ and context.fake_mode is not None
+ and context.fake_mode.shape_env is not None
+ ):
+ context.fake_mode.shape_env.cleanup()
+ _TLS.tracing_context = old_context
+
+
+# Subclasses can be found in torch/_dynamo/source.py
+# TODO(voz): Consider a toplevel torch/_source.py
+@dataclasses.dataclass(frozen=True)
+class Source:
+ def is_dict_key(self):
+ return False
+
+ def is_ephemeral(self):
+ return False
+
+ def reconstruct(self, codegen):
+ raise NotImplementedError()
+
+ def guard_source(self) -> GuardSource:
+ raise NotImplementedError()
+
+ def name(self) -> str:
+ raise NotImplementedError()
+
+ def make_guard(self, fn) -> Guard:
+ if self.guard_source() is GuardSource.CONSTANT:
+ raise NotImplementedError()
+ return Guard(self, fn)
+
+ def is_nn_module(self) -> bool:
+ return self.guard_source().is_nn_module()
+
+ def subguards_allowed(self):
+ """True if you can guard on attributes of this"""
+ return self.guard_source() != GuardSource.SYNTHETIC_LOCAL
+
+
+# Subclasses can be found in torch/_dynamo/source.py
+@dataclasses.dataclass(frozen=True)
+class ChainedSource(Source):
+ base: Source
+
+ def is_dict_key(self):
+ # Recurse until you either hit a ConstDictKey or a Source
+ return self.base.is_dict_key()
+
+ def is_ephemeral(self):
+ return self.base.is_ephemeral()
+
+
+def detect_fake_mode(inputs: Any = None):
+ """
+ Attempts to "detect" what the current fake mode is. If there is one ambiently
+ available from TracingContext, we preferentially use that. Otherwise, we
+ heuristically detect the fake mode via the following sources, in order of
+ priority:
+
+ - Currently active fake mode on stack
+ - Fake mode associated with passed in tensors (inputs does not
+ have to be flattened)
+ """
+ from torch._subclasses.fake_tensor import FakeTensor, FakeTensorMode
+
+ fake_modes = []
+
+ if context := TracingContext.try_get():
+ fake_mode = context.fake_mode
+ if fake_mode is not None:
+ fake_modes.append((fake_mode, "tracing context", 0))
+
+ from torch.utils._python_dispatch import _get_current_dispatch_mode_stack
+
+ for i, m in enumerate(reversed(_get_current_dispatch_mode_stack())):
+ if isinstance(m, FakeTensorMode):
+ fake_modes.append((m, "active fake mode", i))
+
+ flat_inputs = pytree.tree_leaves(inputs)
+ for i, flat_input in enumerate(flat_inputs):
+ if isinstance(flat_input, FakeTensor):
+ fake_modes.append((flat_input.fake_mode, "fake tensor input", i))
+
+ if fake_modes:
+ fake_mode, desc1, i1 = fake_modes[0]
+ for m, desc2, i2 in fake_modes[1:]:
+ assert fake_mode is m, (
+ f"fake mode ({fake_mode}) from {desc1} {i1} doesn't match mode ({m}) from {desc2} {i2}\n\n"
+ f"fake mode from {desc1} {i1} allocated at:\n{fake_mode.stack}\n"
+ f"fake mode from {desc2} {i2} allocated at:\n{m.stack}"
+ )
+ return fake_mode
+ else:
+ return None
+
+
+def active_fake_mode():
+ """
+ Inspects the dispatch mode stack for an active fake mode and returns it.
+ Returns None if no fake mode is active.
+ """
+ from torch._subclasses.fake_tensor import FakeTensorMode
+ from torch.utils._python_dispatch import _get_current_dispatch_mode_stack
+
+ for _, m in enumerate(reversed(_get_current_dispatch_mode_stack())):
+ if isinstance(m, FakeTensorMode):
+ return m
+
+ return None
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/_sources.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/_sources.py
new file mode 100644
index 0000000000000000000000000000000000000000..3f56bd8ef2473aa9c35ad6232448c9d5d44b8056
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/_sources.py
@@ -0,0 +1,137 @@
+import ast
+import functools
+import inspect
+from textwrap import dedent
+from typing import Any, List, NamedTuple, Optional, Tuple
+
+from torch._C import ErrorReport
+from torch._C._jit_tree_views import SourceRangeFactory
+
+
+def get_source_lines_and_file(
+ obj: Any,
+ error_msg: Optional[str] = None,
+) -> Tuple[List[str], int, Optional[str]]:
+ """
+ Wrapper around inspect.getsourcelines and inspect.getsourcefile.
+
+ Returns: (sourcelines, file_lino, filename)
+ """
+ filename = None # in case getsourcefile throws
+ try:
+ filename = inspect.getsourcefile(obj)
+ sourcelines, file_lineno = inspect.getsourcelines(obj)
+ except OSError as e:
+ msg = (
+ f"Can't get source for {obj}. TorchScript requires source access in "
+ "order to carry out compilation, make sure original .py files are "
+ "available."
+ )
+ if error_msg:
+ msg += "\n" + error_msg
+ raise OSError(msg) from e
+
+ return sourcelines, file_lineno, filename
+
+
+def normalize_source_lines(sourcelines: List[str]) -> List[str]:
+ """
+ This helper function accepts a list of source lines. It finds the
+ indentation level of the function definition (`def`), then it indents
+ all lines in the function body to a point at or greater than that
+ level. This allows for comments and continued string literals that
+ are at a lower indentation than the rest of the code.
+ Args:
+ sourcelines: function source code, separated into lines by
+ the '\n' character
+ Returns:
+ A list of source lines that have been correctly aligned
+ """
+
+ def remove_prefix(text, prefix):
+ return text[text.startswith(prefix) and len(prefix) :]
+
+ # Find the line and line number containing the function definition
+ idx = None
+ for i, l in enumerate(sourcelines):
+ if l.lstrip().startswith("def"):
+ idx = i
+ break
+
+ # This will happen when the function is a lambda- we won't find "def" anywhere in the source
+ # lines in that case. Currently trying to JIT compile a lambda will throw an error up in
+ # `parse_def()`, but we might want to handle this case in the future.
+ if idx is None:
+ return sourcelines
+
+ # Get a string representing the amount of leading whitespace
+ fn_def = sourcelines[idx]
+ whitespace = fn_def.split("def")[0]
+
+ # Add this leading whitespace to all lines before and after the `def`
+ aligned_prefix = [
+ whitespace + remove_prefix(s, whitespace) for s in sourcelines[:idx]
+ ]
+ aligned_suffix = [
+ whitespace + remove_prefix(s, whitespace) for s in sourcelines[idx + 1 :]
+ ]
+
+ # Put it together again
+ aligned_prefix.append(fn_def)
+ return aligned_prefix + aligned_suffix
+
+
+# Thin wrapper around SourceRangeFactory to store extra metadata
+# about the function-to-be-compiled.
+class SourceContext(SourceRangeFactory):
+ def __init__(
+ self,
+ source,
+ filename,
+ file_lineno,
+ leading_whitespace_len,
+ uses_true_division=True,
+ funcname=None,
+ ):
+ super().__init__(source, filename, file_lineno, leading_whitespace_len)
+ self.uses_true_division = uses_true_division
+ self.filename = filename
+ self.funcname = funcname
+
+
+@functools.lru_cache(maxsize=None)
+def make_source_context(*args):
+ return SourceContext(*args)
+
+
+def fake_range():
+ return SourceContext("", None, 0, 0).make_raw_range(0, 1)
+
+
+class ParsedDef(NamedTuple):
+ ast: ast.Module
+ ctx: SourceContext
+ source: str
+ filename: Optional[str]
+ file_lineno: int
+
+
+def parse_def(fn):
+ sourcelines, file_lineno, filename = get_source_lines_and_file(
+ fn, ErrorReport.call_stack()
+ )
+ sourcelines = normalize_source_lines(sourcelines)
+ source = "".join(sourcelines)
+ dedent_src = dedent(source)
+ py_ast = ast.parse(dedent_src)
+ if len(py_ast.body) != 1 or not isinstance(py_ast.body[0], ast.FunctionDef):
+ raise RuntimeError(
+ f"Expected a single top-level function: {filename}:{file_lineno}"
+ )
+ leading_whitespace_len = len(source.split("\n", 1)[0]) - len(
+ dedent_src.split("\n", 1)[0]
+ )
+ ctx = make_source_context(
+ source, filename, file_lineno, leading_whitespace_len, True, fn.__name__
+ )
+ return ParsedDef(py_ast, ctx, source, filename, file_lineno)
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/_tensor_docs.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/_tensor_docs.py
new file mode 100644
index 0000000000000000000000000000000000000000..2543177fdd4615f2afdea3ece5916639ff6dc0a6
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/_tensor_docs.py
@@ -0,0 +1,6976 @@
+"""Adds docstrings to Tensor functions"""
+
+import torch._C
+from torch._C import _add_docstr as add_docstr
+from torch._torch_docs import parse_kwargs, reproducibility_notes
+
+
+def add_docstr_all(method, docstr):
+ add_docstr(getattr(torch._C.TensorBase, method), docstr)
+
+
+common_args = parse_kwargs(
+ """
+ memory_format (:class:`torch.memory_format`, optional): the desired memory format of
+ returned Tensor. Default: ``torch.preserve_format``.
+"""
+)
+
+new_common_args = parse_kwargs(
+ """
+ size (int...): a list, tuple, or :class:`torch.Size` of integers defining the
+ shape of the output tensor.
+ dtype (:class:`torch.dtype`, optional): the desired type of returned tensor.
+ Default: if None, same :class:`torch.dtype` as this tensor.
+ device (:class:`torch.device`, optional): the desired device of returned tensor.
+ Default: if None, same :class:`torch.device` as this tensor.
+ requires_grad (bool, optional): If autograd should record operations on the
+ returned tensor. Default: ``False``.
+ pin_memory (bool, optional): If set, returned tensor would be allocated in
+ the pinned memory. Works only for CPU tensors. Default: ``False``.
+ layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
+ Default: ``torch.strided``.
+"""
+)
+
+add_docstr_all(
+ "new_tensor",
+ """
+new_tensor(data, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, \
+pin_memory=False) -> Tensor
+"""
+ + r"""
+
+Returns a new Tensor with :attr:`data` as the tensor data.
+By default, the returned Tensor has the same :class:`torch.dtype` and
+:class:`torch.device` as this tensor.
+
+.. warning::
+
+ :func:`new_tensor` always copies :attr:`data`. If you have a Tensor
+ ``data`` and want to avoid a copy, use :func:`torch.Tensor.requires_grad_`
+ or :func:`torch.Tensor.detach`.
+ If you have a numpy array and want to avoid a copy, use
+ :func:`torch.from_numpy`.
+
+.. warning::
+
+ When data is a tensor `x`, :func:`new_tensor()` reads out 'the data' from whatever it is passed,
+ and constructs a leaf variable. Therefore ``tensor.new_tensor(x)`` is equivalent to ``x.clone().detach()``
+ and ``tensor.new_tensor(x, requires_grad=True)`` is equivalent to ``x.clone().detach().requires_grad_(True)``.
+ The equivalents using ``clone()`` and ``detach()`` are recommended.
+
+Args:
+ data (array_like): The returned Tensor copies :attr:`data`.
+
+Keyword args:
+ {dtype}
+ {device}
+ {requires_grad}
+ {layout}
+ {pin_memory}
+
+Example::
+
+ >>> tensor = torch.ones((2,), dtype=torch.int8)
+ >>> data = [[0, 1], [2, 3]]
+ >>> tensor.new_tensor(data)
+ tensor([[ 0, 1],
+ [ 2, 3]], dtype=torch.int8)
+
+""".format(
+ **new_common_args
+ ),
+)
+
+add_docstr_all(
+ "new_full",
+ """
+new_full(size, fill_value, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, \
+pin_memory=False) -> Tensor
+"""
+ + r"""
+
+Returns a Tensor of size :attr:`size` filled with :attr:`fill_value`.
+By default, the returned Tensor has the same :class:`torch.dtype` and
+:class:`torch.device` as this tensor.
+
+Args:
+ fill_value (scalar): the number to fill the output tensor with.
+
+Keyword args:
+ {dtype}
+ {device}
+ {requires_grad}
+ {layout}
+ {pin_memory}
+
+Example::
+
+ >>> tensor = torch.ones((2,), dtype=torch.float64)
+ >>> tensor.new_full((3, 4), 3.141592)
+ tensor([[ 3.1416, 3.1416, 3.1416, 3.1416],
+ [ 3.1416, 3.1416, 3.1416, 3.1416],
+ [ 3.1416, 3.1416, 3.1416, 3.1416]], dtype=torch.float64)
+
+""".format(
+ **new_common_args
+ ),
+)
+
+add_docstr_all(
+ "new_empty",
+ """
+new_empty(size, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, \
+pin_memory=False) -> Tensor
+"""
+ + r"""
+
+Returns a Tensor of size :attr:`size` filled with uninitialized data.
+By default, the returned Tensor has the same :class:`torch.dtype` and
+:class:`torch.device` as this tensor.
+
+Args:
+ size (int...): a list, tuple, or :class:`torch.Size` of integers defining the
+ shape of the output tensor.
+
+Keyword args:
+ {dtype}
+ {device}
+ {requires_grad}
+ {layout}
+ {pin_memory}
+
+Example::
+
+ >>> tensor = torch.ones(())
+ >>> tensor.new_empty((2, 3))
+ tensor([[ 5.8182e-18, 4.5765e-41, -1.0545e+30],
+ [ 3.0949e-41, 4.4842e-44, 0.0000e+00]])
+
+""".format(
+ **new_common_args
+ ),
+)
+
+add_docstr_all(
+ "new_empty_strided",
+ """
+new_empty_strided(size, stride, dtype=None, device=None, requires_grad=False, layout=torch.strided, \
+pin_memory=False) -> Tensor
+"""
+ + r"""
+
+Returns a Tensor of size :attr:`size` and strides :attr:`stride` filled with
+uninitialized data. By default, the returned Tensor has the same
+:class:`torch.dtype` and :class:`torch.device` as this tensor.
+
+Args:
+ size (int...): a list, tuple, or :class:`torch.Size` of integers defining the
+ shape of the output tensor.
+
+Keyword args:
+ {dtype}
+ {device}
+ {requires_grad}
+ {layout}
+ {pin_memory}
+
+Example::
+
+ >>> tensor = torch.ones(())
+ >>> tensor.new_empty_strided((2, 3), (3, 1))
+ tensor([[ 5.8182e-18, 4.5765e-41, -1.0545e+30],
+ [ 3.0949e-41, 4.4842e-44, 0.0000e+00]])
+
+""".format(
+ **new_common_args
+ ),
+)
+
+add_docstr_all(
+ "new_ones",
+ """
+new_ones(size, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, \
+pin_memory=False) -> Tensor
+"""
+ + r"""
+
+Returns a Tensor of size :attr:`size` filled with ``1``.
+By default, the returned Tensor has the same :class:`torch.dtype` and
+:class:`torch.device` as this tensor.
+
+Args:
+ size (int...): a list, tuple, or :class:`torch.Size` of integers defining the
+ shape of the output tensor.
+
+Keyword args:
+ {dtype}
+ {device}
+ {requires_grad}
+ {layout}
+ {pin_memory}
+
+Example::
+
+ >>> tensor = torch.tensor((), dtype=torch.int32)
+ >>> tensor.new_ones((2, 3))
+ tensor([[ 1, 1, 1],
+ [ 1, 1, 1]], dtype=torch.int32)
+
+""".format(
+ **new_common_args
+ ),
+)
+
+add_docstr_all(
+ "new_zeros",
+ """
+new_zeros(size, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, \
+pin_memory=False) -> Tensor
+"""
+ + r"""
+
+Returns a Tensor of size :attr:`size` filled with ``0``.
+By default, the returned Tensor has the same :class:`torch.dtype` and
+:class:`torch.device` as this tensor.
+
+Args:
+ size (int...): a list, tuple, or :class:`torch.Size` of integers defining the
+ shape of the output tensor.
+
+Keyword args:
+ {dtype}
+ {device}
+ {requires_grad}
+ {layout}
+ {pin_memory}
+
+Example::
+
+ >>> tensor = torch.tensor((), dtype=torch.float64)
+ >>> tensor.new_zeros((2, 3))
+ tensor([[ 0., 0., 0.],
+ [ 0., 0., 0.]], dtype=torch.float64)
+
+""".format(
+ **new_common_args
+ ),
+)
+
+add_docstr_all(
+ "abs",
+ r"""
+abs() -> Tensor
+
+See :func:`torch.abs`
+""",
+)
+
+add_docstr_all(
+ "abs_",
+ r"""
+abs_() -> Tensor
+
+In-place version of :meth:`~Tensor.abs`
+""",
+)
+
+add_docstr_all(
+ "absolute",
+ r"""
+absolute() -> Tensor
+
+Alias for :func:`abs`
+""",
+)
+
+add_docstr_all(
+ "absolute_",
+ r"""
+absolute_() -> Tensor
+
+In-place version of :meth:`~Tensor.absolute`
+Alias for :func:`abs_`
+""",
+)
+
+add_docstr_all(
+ "acos",
+ r"""
+acos() -> Tensor
+
+See :func:`torch.acos`
+""",
+)
+
+add_docstr_all(
+ "acos_",
+ r"""
+acos_() -> Tensor
+
+In-place version of :meth:`~Tensor.acos`
+""",
+)
+
+add_docstr_all(
+ "arccos",
+ r"""
+arccos() -> Tensor
+
+See :func:`torch.arccos`
+""",
+)
+
+add_docstr_all(
+ "arccos_",
+ r"""
+arccos_() -> Tensor
+
+In-place version of :meth:`~Tensor.arccos`
+""",
+)
+
+add_docstr_all(
+ "acosh",
+ r"""
+acosh() -> Tensor
+
+See :func:`torch.acosh`
+""",
+)
+
+add_docstr_all(
+ "acosh_",
+ r"""
+acosh_() -> Tensor
+
+In-place version of :meth:`~Tensor.acosh`
+""",
+)
+
+add_docstr_all(
+ "arccosh",
+ r"""
+acosh() -> Tensor
+
+See :func:`torch.arccosh`
+""",
+)
+
+add_docstr_all(
+ "arccosh_",
+ r"""
+acosh_() -> Tensor
+
+In-place version of :meth:`~Tensor.arccosh`
+""",
+)
+
+add_docstr_all(
+ "add",
+ r"""
+add(other, *, alpha=1) -> Tensor
+
+Add a scalar or tensor to :attr:`self` tensor. If both :attr:`alpha`
+and :attr:`other` are specified, each element of :attr:`other` is scaled by
+:attr:`alpha` before being used.
+
+When :attr:`other` is a tensor, the shape of :attr:`other` must be
+:ref:`broadcastable ` with the shape of the underlying
+tensor
+
+See :func:`torch.add`
+""",
+)
+
+add_docstr_all(
+ "add_",
+ r"""
+add_(other, *, alpha=1) -> Tensor
+
+In-place version of :meth:`~Tensor.add`
+""",
+)
+
+add_docstr_all(
+ "addbmm",
+ r"""
+addbmm(batch1, batch2, *, beta=1, alpha=1) -> Tensor
+
+See :func:`torch.addbmm`
+""",
+)
+
+add_docstr_all(
+ "addbmm_",
+ r"""
+addbmm_(batch1, batch2, *, beta=1, alpha=1) -> Tensor
+
+In-place version of :meth:`~Tensor.addbmm`
+""",
+)
+
+add_docstr_all(
+ "addcdiv",
+ r"""
+addcdiv(tensor1, tensor2, *, value=1) -> Tensor
+
+See :func:`torch.addcdiv`
+""",
+)
+
+add_docstr_all(
+ "addcdiv_",
+ r"""
+addcdiv_(tensor1, tensor2, *, value=1) -> Tensor
+
+In-place version of :meth:`~Tensor.addcdiv`
+""",
+)
+
+add_docstr_all(
+ "addcmul",
+ r"""
+addcmul(tensor1, tensor2, *, value=1) -> Tensor
+
+See :func:`torch.addcmul`
+""",
+)
+
+add_docstr_all(
+ "addcmul_",
+ r"""
+addcmul_(tensor1, tensor2, *, value=1) -> Tensor
+
+In-place version of :meth:`~Tensor.addcmul`
+""",
+)
+
+add_docstr_all(
+ "addmm",
+ r"""
+addmm(mat1, mat2, *, beta=1, alpha=1) -> Tensor
+
+See :func:`torch.addmm`
+""",
+)
+
+add_docstr_all(
+ "addmm_",
+ r"""
+addmm_(mat1, mat2, *, beta=1, alpha=1) -> Tensor
+
+In-place version of :meth:`~Tensor.addmm`
+""",
+)
+
+add_docstr_all(
+ "addmv",
+ r"""
+addmv(mat, vec, *, beta=1, alpha=1) -> Tensor
+
+See :func:`torch.addmv`
+""",
+)
+
+add_docstr_all(
+ "addmv_",
+ r"""
+addmv_(mat, vec, *, beta=1, alpha=1) -> Tensor
+
+In-place version of :meth:`~Tensor.addmv`
+""",
+)
+
+add_docstr_all(
+ "sspaddmm",
+ r"""
+sspaddmm(mat1, mat2, *, beta=1, alpha=1) -> Tensor
+
+See :func:`torch.sspaddmm`
+""",
+)
+
+add_docstr_all(
+ "smm",
+ r"""
+smm(mat) -> Tensor
+
+See :func:`torch.smm`
+""",
+)
+
+add_docstr_all(
+ "addr",
+ r"""
+addr(vec1, vec2, *, beta=1, alpha=1) -> Tensor
+
+See :func:`torch.addr`
+""",
+)
+
+add_docstr_all(
+ "addr_",
+ r"""
+addr_(vec1, vec2, *, beta=1, alpha=1) -> Tensor
+
+In-place version of :meth:`~Tensor.addr`
+""",
+)
+
+add_docstr_all(
+ "align_as",
+ r"""
+align_as(other) -> Tensor
+
+Permutes the dimensions of the :attr:`self` tensor to match the dimension order
+in the :attr:`other` tensor, adding size-one dims for any new names.
+
+This operation is useful for explicit broadcasting by names (see examples).
+
+All of the dims of :attr:`self` must be named in order to use this method.
+The resulting tensor is a view on the original tensor.
+
+All dimension names of :attr:`self` must be present in ``other.names``.
+:attr:`other` may contain named dimensions that are not in ``self.names``;
+the output tensor has a size-one dimension for each of those new names.
+
+To align a tensor to a specific order, use :meth:`~Tensor.align_to`.
+
+Examples::
+
+ # Example 1: Applying a mask
+ >>> mask = torch.randint(2, [127, 128], dtype=torch.bool).refine_names('W', 'H')
+ >>> imgs = torch.randn(32, 128, 127, 3, names=('N', 'H', 'W', 'C'))
+ >>> imgs.masked_fill_(mask.align_as(imgs), 0)
+
+
+ # Example 2: Applying a per-channel-scale
+ >>> def scale_channels(input, scale):
+ >>> scale = scale.refine_names('C')
+ >>> return input * scale.align_as(input)
+
+ >>> num_channels = 3
+ >>> scale = torch.randn(num_channels, names=('C',))
+ >>> imgs = torch.rand(32, 128, 128, num_channels, names=('N', 'H', 'W', 'C'))
+ >>> more_imgs = torch.rand(32, num_channels, 128, 128, names=('N', 'C', 'H', 'W'))
+ >>> videos = torch.randn(3, num_channels, 128, 128, 128, names=('N', 'C', 'H', 'W', 'D'))
+
+ # scale_channels is agnostic to the dimension order of the input
+ >>> scale_channels(imgs, scale)
+ >>> scale_channels(more_imgs, scale)
+ >>> scale_channels(videos, scale)
+
+.. warning::
+ The named tensor API is experimental and subject to change.
+
+""",
+)
+
+add_docstr_all(
+ "all",
+ r"""
+all(dim=None, keepdim=False) -> Tensor
+
+See :func:`torch.all`
+""",
+)
+
+add_docstr_all(
+ "allclose",
+ r"""
+allclose(other, rtol=1e-05, atol=1e-08, equal_nan=False) -> Tensor
+
+See :func:`torch.allclose`
+""",
+)
+
+add_docstr_all(
+ "angle",
+ r"""
+angle() -> Tensor
+
+See :func:`torch.angle`
+""",
+)
+
+add_docstr_all(
+ "any",
+ r"""
+any(dim=None, keepdim=False) -> Tensor
+
+See :func:`torch.any`
+""",
+)
+
+add_docstr_all(
+ "apply_",
+ r"""
+apply_(callable) -> Tensor
+
+Applies the function :attr:`callable` to each element in the tensor, replacing
+each element with the value returned by :attr:`callable`.
+
+.. note::
+
+ This function only works with CPU tensors and should not be used in code
+ sections that require high performance.
+""",
+)
+
+add_docstr_all(
+ "asin",
+ r"""
+asin() -> Tensor
+
+See :func:`torch.asin`
+""",
+)
+
+add_docstr_all(
+ "asin_",
+ r"""
+asin_() -> Tensor
+
+In-place version of :meth:`~Tensor.asin`
+""",
+)
+
+add_docstr_all(
+ "arcsin",
+ r"""
+arcsin() -> Tensor
+
+See :func:`torch.arcsin`
+""",
+)
+
+add_docstr_all(
+ "arcsin_",
+ r"""
+arcsin_() -> Tensor
+
+In-place version of :meth:`~Tensor.arcsin`
+""",
+)
+
+add_docstr_all(
+ "asinh",
+ r"""
+asinh() -> Tensor
+
+See :func:`torch.asinh`
+""",
+)
+
+add_docstr_all(
+ "asinh_",
+ r"""
+asinh_() -> Tensor
+
+In-place version of :meth:`~Tensor.asinh`
+""",
+)
+
+add_docstr_all(
+ "arcsinh",
+ r"""
+arcsinh() -> Tensor
+
+See :func:`torch.arcsinh`
+""",
+)
+
+add_docstr_all(
+ "arcsinh_",
+ r"""
+arcsinh_() -> Tensor
+
+In-place version of :meth:`~Tensor.arcsinh`
+""",
+)
+
+add_docstr_all(
+ "as_strided",
+ r"""
+as_strided(size, stride, storage_offset=None) -> Tensor
+
+See :func:`torch.as_strided`
+""",
+)
+
+add_docstr_all(
+ "as_strided_",
+ r"""
+as_strided_(size, stride, storage_offset=None) -> Tensor
+
+In-place version of :meth:`~Tensor.as_strided`
+""",
+)
+
+add_docstr_all(
+ "atan",
+ r"""
+atan() -> Tensor
+
+See :func:`torch.atan`
+""",
+)
+
+add_docstr_all(
+ "atan_",
+ r"""
+atan_() -> Tensor
+
+In-place version of :meth:`~Tensor.atan`
+""",
+)
+
+add_docstr_all(
+ "arctan",
+ r"""
+arctan() -> Tensor
+
+See :func:`torch.arctan`
+""",
+)
+
+add_docstr_all(
+ "arctan_",
+ r"""
+arctan_() -> Tensor
+
+In-place version of :meth:`~Tensor.arctan`
+""",
+)
+
+add_docstr_all(
+ "atan2",
+ r"""
+atan2(other) -> Tensor
+
+See :func:`torch.atan2`
+""",
+)
+
+add_docstr_all(
+ "atan2_",
+ r"""
+atan2_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.atan2`
+""",
+)
+
+add_docstr_all(
+ "arctan2",
+ r"""
+arctan2(other) -> Tensor
+
+See :func:`torch.arctan2`
+""",
+)
+
+add_docstr_all(
+ "arctan2_",
+ r"""
+atan2_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.arctan2`
+""",
+)
+
+add_docstr_all(
+ "atanh",
+ r"""
+atanh() -> Tensor
+
+See :func:`torch.atanh`
+""",
+)
+
+add_docstr_all(
+ "atanh_",
+ r"""
+atanh_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.atanh`
+""",
+)
+
+add_docstr_all(
+ "arctanh",
+ r"""
+arctanh() -> Tensor
+
+See :func:`torch.arctanh`
+""",
+)
+
+add_docstr_all(
+ "arctanh_",
+ r"""
+arctanh_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.arctanh`
+""",
+)
+
+add_docstr_all(
+ "baddbmm",
+ r"""
+baddbmm(batch1, batch2, *, beta=1, alpha=1) -> Tensor
+
+See :func:`torch.baddbmm`
+""",
+)
+
+add_docstr_all(
+ "baddbmm_",
+ r"""
+baddbmm_(batch1, batch2, *, beta=1, alpha=1) -> Tensor
+
+In-place version of :meth:`~Tensor.baddbmm`
+""",
+)
+
+add_docstr_all(
+ "bernoulli",
+ r"""
+bernoulli(*, generator=None) -> Tensor
+
+Returns a result tensor where each :math:`\texttt{result[i]}` is independently
+sampled from :math:`\text{Bernoulli}(\texttt{self[i]})`. :attr:`self` must have
+floating point ``dtype``, and the result will have the same ``dtype``.
+
+See :func:`torch.bernoulli`
+""",
+)
+
+add_docstr_all(
+ "bernoulli_",
+ r"""
+bernoulli_(p=0.5, *, generator=None) -> Tensor
+
+Fills each location of :attr:`self` with an independent sample from
+:math:`\text{Bernoulli}(\texttt{p})`. :attr:`self` can have integral
+``dtype``.
+
+:attr:`p` should either be a scalar or tensor containing probabilities to be
+used for drawing the binary random number.
+
+If it is a tensor, the :math:`\text{i}^{th}` element of :attr:`self` tensor
+will be set to a value sampled from
+:math:`\text{Bernoulli}(\texttt{p\_tensor[i]})`. In this case `p` must have
+floating point ``dtype``.
+
+See also :meth:`~Tensor.bernoulli` and :func:`torch.bernoulli`
+""",
+)
+
+add_docstr_all(
+ "bincount",
+ r"""
+bincount(weights=None, minlength=0) -> Tensor
+
+See :func:`torch.bincount`
+""",
+)
+
+add_docstr_all(
+ "bitwise_not",
+ r"""
+bitwise_not() -> Tensor
+
+See :func:`torch.bitwise_not`
+""",
+)
+
+add_docstr_all(
+ "bitwise_not_",
+ r"""
+bitwise_not_() -> Tensor
+
+In-place version of :meth:`~Tensor.bitwise_not`
+""",
+)
+
+add_docstr_all(
+ "bitwise_and",
+ r"""
+bitwise_and() -> Tensor
+
+See :func:`torch.bitwise_and`
+""",
+)
+
+add_docstr_all(
+ "bitwise_and_",
+ r"""
+bitwise_and_() -> Tensor
+
+In-place version of :meth:`~Tensor.bitwise_and`
+""",
+)
+
+add_docstr_all(
+ "bitwise_or",
+ r"""
+bitwise_or() -> Tensor
+
+See :func:`torch.bitwise_or`
+""",
+)
+
+add_docstr_all(
+ "bitwise_or_",
+ r"""
+bitwise_or_() -> Tensor
+
+In-place version of :meth:`~Tensor.bitwise_or`
+""",
+)
+
+add_docstr_all(
+ "bitwise_xor",
+ r"""
+bitwise_xor() -> Tensor
+
+See :func:`torch.bitwise_xor`
+""",
+)
+
+add_docstr_all(
+ "bitwise_xor_",
+ r"""
+bitwise_xor_() -> Tensor
+
+In-place version of :meth:`~Tensor.bitwise_xor`
+""",
+)
+
+add_docstr_all(
+ "bitwise_left_shift",
+ r"""
+bitwise_left_shift(other) -> Tensor
+
+See :func:`torch.bitwise_left_shift`
+""",
+)
+
+add_docstr_all(
+ "bitwise_left_shift_",
+ r"""
+bitwise_left_shift_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.bitwise_left_shift`
+""",
+)
+
+add_docstr_all(
+ "bitwise_right_shift",
+ r"""
+bitwise_right_shift(other) -> Tensor
+
+See :func:`torch.bitwise_right_shift`
+""",
+)
+
+add_docstr_all(
+ "bitwise_right_shift_",
+ r"""
+bitwise_right_shift_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.bitwise_right_shift`
+""",
+)
+
+add_docstr_all(
+ "broadcast_to",
+ r"""
+broadcast_to(shape) -> Tensor
+
+See :func:`torch.broadcast_to`.
+""",
+)
+
+add_docstr_all(
+ "logical_and",
+ r"""
+logical_and() -> Tensor
+
+See :func:`torch.logical_and`
+""",
+)
+
+add_docstr_all(
+ "logical_and_",
+ r"""
+logical_and_() -> Tensor
+
+In-place version of :meth:`~Tensor.logical_and`
+""",
+)
+
+add_docstr_all(
+ "logical_not",
+ r"""
+logical_not() -> Tensor
+
+See :func:`torch.logical_not`
+""",
+)
+
+add_docstr_all(
+ "logical_not_",
+ r"""
+logical_not_() -> Tensor
+
+In-place version of :meth:`~Tensor.logical_not`
+""",
+)
+
+add_docstr_all(
+ "logical_or",
+ r"""
+logical_or() -> Tensor
+
+See :func:`torch.logical_or`
+""",
+)
+
+add_docstr_all(
+ "logical_or_",
+ r"""
+logical_or_() -> Tensor
+
+In-place version of :meth:`~Tensor.logical_or`
+""",
+)
+
+add_docstr_all(
+ "logical_xor",
+ r"""
+logical_xor() -> Tensor
+
+See :func:`torch.logical_xor`
+""",
+)
+
+add_docstr_all(
+ "logical_xor_",
+ r"""
+logical_xor_() -> Tensor
+
+In-place version of :meth:`~Tensor.logical_xor`
+""",
+)
+
+add_docstr_all(
+ "bmm",
+ r"""
+bmm(batch2) -> Tensor
+
+See :func:`torch.bmm`
+""",
+)
+
+add_docstr_all(
+ "cauchy_",
+ r"""
+cauchy_(median=0, sigma=1, *, generator=None) -> Tensor
+
+Fills the tensor with numbers drawn from the Cauchy distribution:
+
+.. math::
+
+ f(x) = \dfrac{1}{\pi} \dfrac{\sigma}{(x - \text{median})^2 + \sigma^2}
+
+.. note::
+ Sigma (:math:`\sigma`) is used to denote the scale parameter in Cauchy distribution.
+""",
+)
+
+add_docstr_all(
+ "ceil",
+ r"""
+ceil() -> Tensor
+
+See :func:`torch.ceil`
+""",
+)
+
+add_docstr_all(
+ "ceil_",
+ r"""
+ceil_() -> Tensor
+
+In-place version of :meth:`~Tensor.ceil`
+""",
+)
+
+add_docstr_all(
+ "cholesky",
+ r"""
+cholesky(upper=False) -> Tensor
+
+See :func:`torch.cholesky`
+""",
+)
+
+add_docstr_all(
+ "cholesky_solve",
+ r"""
+cholesky_solve(input2, upper=False) -> Tensor
+
+See :func:`torch.cholesky_solve`
+""",
+)
+
+add_docstr_all(
+ "cholesky_inverse",
+ r"""
+cholesky_inverse(upper=False) -> Tensor
+
+See :func:`torch.cholesky_inverse`
+""",
+)
+
+add_docstr_all(
+ "clamp",
+ r"""
+clamp(min=None, max=None) -> Tensor
+
+See :func:`torch.clamp`
+""",
+)
+
+add_docstr_all(
+ "clamp_",
+ r"""
+clamp_(min=None, max=None) -> Tensor
+
+In-place version of :meth:`~Tensor.clamp`
+""",
+)
+
+add_docstr_all(
+ "clip",
+ r"""
+clip(min=None, max=None) -> Tensor
+
+Alias for :meth:`~Tensor.clamp`.
+""",
+)
+
+add_docstr_all(
+ "clip_",
+ r"""
+clip_(min=None, max=None) -> Tensor
+
+Alias for :meth:`~Tensor.clamp_`.
+""",
+)
+
+add_docstr_all(
+ "clone",
+ r"""
+clone(*, memory_format=torch.preserve_format) -> Tensor
+
+See :func:`torch.clone`
+""".format(
+ **common_args
+ ),
+)
+
+add_docstr_all(
+ "coalesce",
+ r"""
+coalesce() -> Tensor
+
+Returns a coalesced copy of :attr:`self` if :attr:`self` is an
+:ref:`uncoalesced tensor `.
+
+Returns :attr:`self` if :attr:`self` is a coalesced tensor.
+
+.. warning::
+ Throws an error if :attr:`self` is not a sparse COO tensor.
+""",
+)
+
+add_docstr_all(
+ "contiguous",
+ r"""
+contiguous(memory_format=torch.contiguous_format) -> Tensor
+
+Returns a contiguous in memory tensor containing the same data as :attr:`self` tensor. If
+:attr:`self` tensor is already in the specified memory format, this function returns the
+:attr:`self` tensor.
+
+Args:
+ memory_format (:class:`torch.memory_format`, optional): the desired memory format of
+ returned Tensor. Default: ``torch.contiguous_format``.
+""",
+)
+
+add_docstr_all(
+ "copy_",
+ r"""
+copy_(src, non_blocking=False) -> Tensor
+
+Copies the elements from :attr:`src` into :attr:`self` tensor and returns
+:attr:`self`.
+
+The :attr:`src` tensor must be :ref:`broadcastable `
+with the :attr:`self` tensor. It may be of a different data type or reside on a
+different device.
+
+Args:
+ src (Tensor): the source tensor to copy from
+ non_blocking (bool): if ``True`` and this copy is between CPU and GPU,
+ the copy may occur asynchronously with respect to the host. For other
+ cases, this argument has no effect.
+""",
+)
+
+add_docstr_all(
+ "conj",
+ r"""
+conj() -> Tensor
+
+See :func:`torch.conj`
+""",
+)
+
+add_docstr_all(
+ "conj_physical",
+ r"""
+conj_physical() -> Tensor
+
+See :func:`torch.conj_physical`
+""",
+)
+
+add_docstr_all(
+ "conj_physical_",
+ r"""
+conj_physical_() -> Tensor
+
+In-place version of :meth:`~Tensor.conj_physical`
+""",
+)
+
+add_docstr_all(
+ "resolve_conj",
+ r"""
+resolve_conj() -> Tensor
+
+See :func:`torch.resolve_conj`
+""",
+)
+
+add_docstr_all(
+ "resolve_neg",
+ r"""
+resolve_neg() -> Tensor
+
+See :func:`torch.resolve_neg`
+""",
+)
+
+add_docstr_all(
+ "copysign",
+ r"""
+copysign(other) -> Tensor
+
+See :func:`torch.copysign`
+""",
+)
+
+add_docstr_all(
+ "copysign_",
+ r"""
+copysign_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.copysign`
+""",
+)
+
+add_docstr_all(
+ "cos",
+ r"""
+cos() -> Tensor
+
+See :func:`torch.cos`
+""",
+)
+
+add_docstr_all(
+ "cos_",
+ r"""
+cos_() -> Tensor
+
+In-place version of :meth:`~Tensor.cos`
+""",
+)
+
+add_docstr_all(
+ "cosh",
+ r"""
+cosh() -> Tensor
+
+See :func:`torch.cosh`
+""",
+)
+
+add_docstr_all(
+ "cosh_",
+ r"""
+cosh_() -> Tensor
+
+In-place version of :meth:`~Tensor.cosh`
+""",
+)
+
+add_docstr_all(
+ "cpu",
+ r"""
+cpu(memory_format=torch.preserve_format) -> Tensor
+
+Returns a copy of this object in CPU memory.
+
+If this object is already in CPU memory and on the correct device,
+then no copy is performed and the original object is returned.
+
+Args:
+ {memory_format}
+
+""".format(
+ **common_args
+ ),
+)
+
+add_docstr_all(
+ "count_nonzero",
+ r"""
+count_nonzero(dim=None) -> Tensor
+
+See :func:`torch.count_nonzero`
+""",
+)
+
+add_docstr_all(
+ "cov",
+ r"""
+cov(*, correction=1, fweights=None, aweights=None) -> Tensor
+
+See :func:`torch.cov`
+""",
+)
+
+add_docstr_all(
+ "corrcoef",
+ r"""
+corrcoef() -> Tensor
+
+See :func:`torch.corrcoef`
+""",
+)
+
+add_docstr_all(
+ "cross",
+ r"""
+cross(other, dim=None) -> Tensor
+
+See :func:`torch.cross`
+""",
+)
+
+add_docstr_all(
+ "cuda",
+ r"""
+cuda(device=None, non_blocking=False, memory_format=torch.preserve_format) -> Tensor
+
+Returns a copy of this object in CUDA memory.
+
+If this object is already in CUDA memory and on the correct device,
+then no copy is performed and the original object is returned.
+
+Args:
+ device (:class:`torch.device`): The destination GPU device.
+ Defaults to the current CUDA device.
+ non_blocking (bool): If ``True`` and the source is in pinned memory,
+ the copy will be asynchronous with respect to the host.
+ Otherwise, the argument has no effect. Default: ``False``.
+ {memory_format}
+""".format(
+ **common_args
+ ),
+)
+
+add_docstr_all(
+ "ipu",
+ r"""
+ipu(device=None, non_blocking=False, memory_format=torch.preserve_format) -> Tensor
+
+Returns a copy of this object in IPU memory.
+
+If this object is already in IPU memory and on the correct device,
+then no copy is performed and the original object is returned.
+
+Args:
+ device (:class:`torch.device`): The destination IPU device.
+ Defaults to the current IPU device.
+ non_blocking (bool): If ``True`` and the source is in pinned memory,
+ the copy will be asynchronous with respect to the host.
+ Otherwise, the argument has no effect. Default: ``False``.
+ {memory_format}
+""".format(
+ **common_args
+ ),
+)
+
+add_docstr_all(
+ "xpu",
+ r"""
+xpu(device=None, non_blocking=False, memory_format=torch.preserve_format) -> Tensor
+
+Returns a copy of this object in XPU memory.
+
+If this object is already in XPU memory and on the correct device,
+then no copy is performed and the original object is returned.
+
+Args:
+ device (:class:`torch.device`): The destination XPU device.
+ Defaults to the current XPU device.
+ non_blocking (bool): If ``True`` and the source is in pinned memory,
+ the copy will be asynchronous with respect to the host.
+ Otherwise, the argument has no effect. Default: ``False``.
+ {memory_format}
+""".format(
+ **common_args
+ ),
+)
+
+add_docstr_all(
+ "logcumsumexp",
+ r"""
+logcumsumexp(dim) -> Tensor
+
+See :func:`torch.logcumsumexp`
+""",
+)
+
+add_docstr_all(
+ "cummax",
+ r"""
+cummax(dim) -> (Tensor, Tensor)
+
+See :func:`torch.cummax`
+""",
+)
+
+add_docstr_all(
+ "cummin",
+ r"""
+cummin(dim) -> (Tensor, Tensor)
+
+See :func:`torch.cummin`
+""",
+)
+
+add_docstr_all(
+ "cumprod",
+ r"""
+cumprod(dim, dtype=None) -> Tensor
+
+See :func:`torch.cumprod`
+""",
+)
+
+add_docstr_all(
+ "cumprod_",
+ r"""
+cumprod_(dim, dtype=None) -> Tensor
+
+In-place version of :meth:`~Tensor.cumprod`
+""",
+)
+
+add_docstr_all(
+ "cumsum",
+ r"""
+cumsum(dim, dtype=None) -> Tensor
+
+See :func:`torch.cumsum`
+""",
+)
+
+add_docstr_all(
+ "cumsum_",
+ r"""
+cumsum_(dim, dtype=None) -> Tensor
+
+In-place version of :meth:`~Tensor.cumsum`
+""",
+)
+
+add_docstr_all(
+ "data_ptr",
+ r"""
+data_ptr() -> int
+
+Returns the address of the first element of :attr:`self` tensor.
+""",
+)
+
+add_docstr_all(
+ "dequantize",
+ r"""
+dequantize() -> Tensor
+
+Given a quantized Tensor, dequantize it and return the dequantized float Tensor.
+""",
+)
+
+add_docstr_all(
+ "dense_dim",
+ r"""
+dense_dim() -> int
+
+Return the number of dense dimensions in a :ref:`sparse tensor ` :attr:`self`.
+
+.. note::
+ Returns ``len(self.shape)`` if :attr:`self` is not a sparse tensor.
+
+See also :meth:`Tensor.sparse_dim` and :ref:`hybrid tensors `.
+""",
+)
+
+add_docstr_all(
+ "diag",
+ r"""
+diag(diagonal=0) -> Tensor
+
+See :func:`torch.diag`
+""",
+)
+
+add_docstr_all(
+ "diag_embed",
+ r"""
+diag_embed(offset=0, dim1=-2, dim2=-1) -> Tensor
+
+See :func:`torch.diag_embed`
+""",
+)
+
+add_docstr_all(
+ "diagflat",
+ r"""
+diagflat(offset=0) -> Tensor
+
+See :func:`torch.diagflat`
+""",
+)
+
+add_docstr_all(
+ "diagonal",
+ r"""
+diagonal(offset=0, dim1=0, dim2=1) -> Tensor
+
+See :func:`torch.diagonal`
+""",
+)
+
+add_docstr_all(
+ "diagonal_scatter",
+ r"""
+diagonal_scatter(src, offset=0, dim1=0, dim2=1) -> Tensor
+
+See :func:`torch.diagonal_scatter`
+""",
+)
+
+add_docstr_all(
+ "as_strided_scatter",
+ r"""
+as_strided_scatter(src, size, stride, storage_offset=None) -> Tensor
+
+See :func:`torch.as_strided_scatter`
+""",
+)
+
+add_docstr_all(
+ "fill_diagonal_",
+ r"""
+fill_diagonal_(fill_value, wrap=False) -> Tensor
+
+Fill the main diagonal of a tensor that has at least 2-dimensions.
+When dims>2, all dimensions of input must be of equal length.
+This function modifies the input tensor in-place, and returns the input tensor.
+
+Arguments:
+ fill_value (Scalar): the fill value
+ wrap (bool): the diagonal 'wrapped' after N columns for tall matrices.
+
+Example::
+
+ >>> a = torch.zeros(3, 3)
+ >>> a.fill_diagonal_(5)
+ tensor([[5., 0., 0.],
+ [0., 5., 0.],
+ [0., 0., 5.]])
+ >>> b = torch.zeros(7, 3)
+ >>> b.fill_diagonal_(5)
+ tensor([[5., 0., 0.],
+ [0., 5., 0.],
+ [0., 0., 5.],
+ [0., 0., 0.],
+ [0., 0., 0.],
+ [0., 0., 0.],
+ [0., 0., 0.]])
+ >>> c = torch.zeros(7, 3)
+ >>> c.fill_diagonal_(5, wrap=True)
+ tensor([[5., 0., 0.],
+ [0., 5., 0.],
+ [0., 0., 5.],
+ [0., 0., 0.],
+ [5., 0., 0.],
+ [0., 5., 0.],
+ [0., 0., 5.]])
+
+""",
+)
+
+add_docstr_all(
+ "floor_divide",
+ r"""
+floor_divide(value) -> Tensor
+
+See :func:`torch.floor_divide`
+""",
+)
+
+add_docstr_all(
+ "floor_divide_",
+ r"""
+floor_divide_(value) -> Tensor
+
+In-place version of :meth:`~Tensor.floor_divide`
+""",
+)
+
+add_docstr_all(
+ "diff",
+ r"""
+diff(n=1, dim=-1, prepend=None, append=None) -> Tensor
+
+See :func:`torch.diff`
+""",
+)
+
+add_docstr_all(
+ "digamma",
+ r"""
+digamma() -> Tensor
+
+See :func:`torch.digamma`
+""",
+)
+
+add_docstr_all(
+ "digamma_",
+ r"""
+digamma_() -> Tensor
+
+In-place version of :meth:`~Tensor.digamma`
+""",
+)
+
+add_docstr_all(
+ "dim",
+ r"""
+dim() -> int
+
+Returns the number of dimensions of :attr:`self` tensor.
+""",
+)
+
+add_docstr_all(
+ "dist",
+ r"""
+dist(other, p=2) -> Tensor
+
+See :func:`torch.dist`
+""",
+)
+
+add_docstr_all(
+ "div",
+ r"""
+div(value, *, rounding_mode=None) -> Tensor
+
+See :func:`torch.div`
+""",
+)
+
+add_docstr_all(
+ "div_",
+ r"""
+div_(value, *, rounding_mode=None) -> Tensor
+
+In-place version of :meth:`~Tensor.div`
+""",
+)
+
+add_docstr_all(
+ "divide",
+ r"""
+divide(value, *, rounding_mode=None) -> Tensor
+
+See :func:`torch.divide`
+""",
+)
+
+add_docstr_all(
+ "divide_",
+ r"""
+divide_(value, *, rounding_mode=None) -> Tensor
+
+In-place version of :meth:`~Tensor.divide`
+""",
+)
+
+add_docstr_all(
+ "dot",
+ r"""
+dot(other) -> Tensor
+
+See :func:`torch.dot`
+""",
+)
+
+add_docstr_all(
+ "element_size",
+ r"""
+element_size() -> int
+
+Returns the size in bytes of an individual element.
+
+Example::
+
+ >>> torch.tensor([]).element_size()
+ 4
+ >>> torch.tensor([], dtype=torch.uint8).element_size()
+ 1
+
+""",
+)
+
+add_docstr_all(
+ "eq",
+ r"""
+eq(other) -> Tensor
+
+See :func:`torch.eq`
+""",
+)
+
+add_docstr_all(
+ "eq_",
+ r"""
+eq_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.eq`
+""",
+)
+
+add_docstr_all(
+ "equal",
+ r"""
+equal(other) -> bool
+
+See :func:`torch.equal`
+""",
+)
+
+add_docstr_all(
+ "erf",
+ r"""
+erf() -> Tensor
+
+See :func:`torch.erf`
+""",
+)
+
+add_docstr_all(
+ "erf_",
+ r"""
+erf_() -> Tensor
+
+In-place version of :meth:`~Tensor.erf`
+""",
+)
+
+add_docstr_all(
+ "erfc",
+ r"""
+erfc() -> Tensor
+
+See :func:`torch.erfc`
+""",
+)
+
+add_docstr_all(
+ "erfc_",
+ r"""
+erfc_() -> Tensor
+
+In-place version of :meth:`~Tensor.erfc`
+""",
+)
+
+add_docstr_all(
+ "erfinv",
+ r"""
+erfinv() -> Tensor
+
+See :func:`torch.erfinv`
+""",
+)
+
+add_docstr_all(
+ "erfinv_",
+ r"""
+erfinv_() -> Tensor
+
+In-place version of :meth:`~Tensor.erfinv`
+""",
+)
+
+add_docstr_all(
+ "exp",
+ r"""
+exp() -> Tensor
+
+See :func:`torch.exp`
+""",
+)
+
+add_docstr_all(
+ "exp_",
+ r"""
+exp_() -> Tensor
+
+In-place version of :meth:`~Tensor.exp`
+""",
+)
+
+add_docstr_all(
+ "exp2",
+ r"""
+exp2() -> Tensor
+
+See :func:`torch.exp2`
+""",
+)
+
+add_docstr_all(
+ "exp2_",
+ r"""
+exp2_() -> Tensor
+
+In-place version of :meth:`~Tensor.exp2`
+""",
+)
+
+add_docstr_all(
+ "expm1",
+ r"""
+expm1() -> Tensor
+
+See :func:`torch.expm1`
+""",
+)
+
+add_docstr_all(
+ "expm1_",
+ r"""
+expm1_() -> Tensor
+
+In-place version of :meth:`~Tensor.expm1`
+""",
+)
+
+add_docstr_all(
+ "exponential_",
+ r"""
+exponential_(lambd=1, *, generator=None) -> Tensor
+
+Fills :attr:`self` tensor with elements drawn from the PDF (probability density function):
+
+.. math::
+
+ f(x) = \lambda e^{-\lambda x}, x > 0
+
+.. note::
+ In probability theory, exponential distribution is supported on interval [0, :math:`\inf`) (i.e., :math:`x >= 0`)
+ implying that zero can be sampled from the exponential distribution.
+ However, :func:`torch.Tensor.exponential_` does not sample zero,
+ which means that its actual support is the interval (0, :math:`\inf`).
+
+ Note that :func:`torch.distributions.exponential.Exponential` is supported on the interval [0, :math:`\inf`) and can sample zero.
+""",
+)
+
+add_docstr_all(
+ "fill_",
+ r"""
+fill_(value) -> Tensor
+
+Fills :attr:`self` tensor with the specified value.
+""",
+)
+
+add_docstr_all(
+ "floor",
+ r"""
+floor() -> Tensor
+
+See :func:`torch.floor`
+""",
+)
+
+add_docstr_all(
+ "flip",
+ r"""
+flip(dims) -> Tensor
+
+See :func:`torch.flip`
+""",
+)
+
+add_docstr_all(
+ "fliplr",
+ r"""
+fliplr() -> Tensor
+
+See :func:`torch.fliplr`
+""",
+)
+
+add_docstr_all(
+ "flipud",
+ r"""
+flipud() -> Tensor
+
+See :func:`torch.flipud`
+""",
+)
+
+add_docstr_all(
+ "roll",
+ r"""
+roll(shifts, dims) -> Tensor
+
+See :func:`torch.roll`
+""",
+)
+
+add_docstr_all(
+ "floor_",
+ r"""
+floor_() -> Tensor
+
+In-place version of :meth:`~Tensor.floor`
+""",
+)
+
+add_docstr_all(
+ "fmod",
+ r"""
+fmod(divisor) -> Tensor
+
+See :func:`torch.fmod`
+""",
+)
+
+add_docstr_all(
+ "fmod_",
+ r"""
+fmod_(divisor) -> Tensor
+
+In-place version of :meth:`~Tensor.fmod`
+""",
+)
+
+add_docstr_all(
+ "frac",
+ r"""
+frac() -> Tensor
+
+See :func:`torch.frac`
+""",
+)
+
+add_docstr_all(
+ "frac_",
+ r"""
+frac_() -> Tensor
+
+In-place version of :meth:`~Tensor.frac`
+""",
+)
+
+add_docstr_all(
+ "frexp",
+ r"""
+frexp(input) -> (Tensor mantissa, Tensor exponent)
+
+See :func:`torch.frexp`
+""",
+)
+
+add_docstr_all(
+ "flatten",
+ r"""
+flatten(start_dim=0, end_dim=-1) -> Tensor
+
+See :func:`torch.flatten`
+""",
+)
+
+add_docstr_all(
+ "gather",
+ r"""
+gather(dim, index) -> Tensor
+
+See :func:`torch.gather`
+""",
+)
+
+add_docstr_all(
+ "gcd",
+ r"""
+gcd(other) -> Tensor
+
+See :func:`torch.gcd`
+""",
+)
+
+add_docstr_all(
+ "gcd_",
+ r"""
+gcd_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.gcd`
+""",
+)
+
+add_docstr_all(
+ "ge",
+ r"""
+ge(other) -> Tensor
+
+See :func:`torch.ge`.
+""",
+)
+
+add_docstr_all(
+ "ge_",
+ r"""
+ge_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.ge`.
+""",
+)
+
+add_docstr_all(
+ "greater_equal",
+ r"""
+greater_equal(other) -> Tensor
+
+See :func:`torch.greater_equal`.
+""",
+)
+
+add_docstr_all(
+ "greater_equal_",
+ r"""
+greater_equal_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.greater_equal`.
+""",
+)
+
+add_docstr_all(
+ "geometric_",
+ r"""
+geometric_(p, *, generator=None) -> Tensor
+
+Fills :attr:`self` tensor with elements drawn from the geometric distribution:
+
+.. math::
+
+ P(X=k) = (1 - p)^{k - 1} p, k = 1, 2, ...
+
+.. note::
+ :func:`torch.Tensor.geometric_` `k`-th trial is the first success hence draws samples in :math:`\{1, 2, \ldots\}`, whereas
+ :func:`torch.distributions.geometric.Geometric` :math:`(k+1)`-th trial is the first success
+ hence draws samples in :math:`\{0, 1, \ldots\}`.
+""",
+)
+
+add_docstr_all(
+ "geqrf",
+ r"""
+geqrf() -> (Tensor, Tensor)
+
+See :func:`torch.geqrf`
+""",
+)
+
+add_docstr_all(
+ "ger",
+ r"""
+ger(vec2) -> Tensor
+
+See :func:`torch.ger`
+""",
+)
+
+add_docstr_all(
+ "inner",
+ r"""
+inner(other) -> Tensor
+
+See :func:`torch.inner`.
+""",
+)
+
+add_docstr_all(
+ "outer",
+ r"""
+outer(vec2) -> Tensor
+
+See :func:`torch.outer`.
+""",
+)
+
+add_docstr_all(
+ "hypot",
+ r"""
+hypot(other) -> Tensor
+
+See :func:`torch.hypot`
+""",
+)
+
+add_docstr_all(
+ "hypot_",
+ r"""
+hypot_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.hypot`
+""",
+)
+
+add_docstr_all(
+ "i0",
+ r"""
+i0() -> Tensor
+
+See :func:`torch.i0`
+""",
+)
+
+add_docstr_all(
+ "i0_",
+ r"""
+i0_() -> Tensor
+
+In-place version of :meth:`~Tensor.i0`
+""",
+)
+
+add_docstr_all(
+ "igamma",
+ r"""
+igamma(other) -> Tensor
+
+See :func:`torch.igamma`
+""",
+)
+
+add_docstr_all(
+ "igamma_",
+ r"""
+igamma_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.igamma`
+""",
+)
+
+add_docstr_all(
+ "igammac",
+ r"""
+igammac(other) -> Tensor
+See :func:`torch.igammac`
+""",
+)
+
+add_docstr_all(
+ "igammac_",
+ r"""
+igammac_(other) -> Tensor
+In-place version of :meth:`~Tensor.igammac`
+""",
+)
+
+add_docstr_all(
+ "indices",
+ r"""
+indices() -> Tensor
+
+Return the indices tensor of a :ref:`sparse COO tensor `.
+
+.. warning::
+ Throws an error if :attr:`self` is not a sparse COO tensor.
+
+See also :meth:`Tensor.values`.
+
+.. note::
+ This method can only be called on a coalesced sparse tensor. See
+ :meth:`Tensor.coalesce` for details.
+""",
+)
+
+add_docstr_all(
+ "get_device",
+ r"""
+get_device() -> Device ordinal (Integer)
+
+For CUDA tensors, this function returns the device ordinal of the GPU on which the tensor resides.
+For CPU tensors, this function returns `-1`.
+
+Example::
+
+ >>> x = torch.randn(3, 4, 5, device='cuda:0')
+ >>> x.get_device()
+ 0
+ >>> x.cpu().get_device()
+ -1
+""",
+)
+
+add_docstr_all(
+ "values",
+ r"""
+values() -> Tensor
+
+Return the values tensor of a :ref:`sparse COO tensor `.
+
+.. warning::
+ Throws an error if :attr:`self` is not a sparse COO tensor.
+
+See also :meth:`Tensor.indices`.
+
+.. note::
+ This method can only be called on a coalesced sparse tensor. See
+ :meth:`Tensor.coalesce` for details.
+""",
+)
+
+add_docstr_all(
+ "gt",
+ r"""
+gt(other) -> Tensor
+
+See :func:`torch.gt`.
+""",
+)
+
+add_docstr_all(
+ "gt_",
+ r"""
+gt_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.gt`.
+""",
+)
+
+add_docstr_all(
+ "greater",
+ r"""
+greater(other) -> Tensor
+
+See :func:`torch.greater`.
+""",
+)
+
+add_docstr_all(
+ "greater_",
+ r"""
+greater_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.greater`.
+""",
+)
+
+add_docstr_all(
+ "has_names",
+ r"""
+Is ``True`` if any of this tensor's dimensions are named. Otherwise, is ``False``.
+""",
+)
+
+add_docstr_all(
+ "hardshrink",
+ r"""
+hardshrink(lambd=0.5) -> Tensor
+
+See :func:`torch.nn.functional.hardshrink`
+""",
+)
+
+add_docstr_all(
+ "heaviside",
+ r"""
+heaviside(values) -> Tensor
+
+See :func:`torch.heaviside`
+""",
+)
+
+add_docstr_all(
+ "heaviside_",
+ r"""
+heaviside_(values) -> Tensor
+
+In-place version of :meth:`~Tensor.heaviside`
+""",
+)
+
+add_docstr_all(
+ "histc",
+ r"""
+histc(bins=100, min=0, max=0) -> Tensor
+
+See :func:`torch.histc`
+""",
+)
+
+add_docstr_all(
+ "histogram",
+ r"""
+histogram(input, bins, *, range=None, weight=None, density=False) -> (Tensor, Tensor)
+
+See :func:`torch.histogram`
+""",
+)
+
+add_docstr_all(
+ "index_add_",
+ r"""
+index_add_(dim, index, source, *, alpha=1) -> Tensor
+
+Accumulate the elements of :attr:`alpha` times ``source`` into the :attr:`self`
+tensor by adding to the indices in the order given in :attr:`index`. For example,
+if ``dim == 0``, ``index[i] == j``, and ``alpha=-1``, then the ``i``\ th row of
+``source`` is subtracted from the ``j``\ th row of :attr:`self`.
+
+The :attr:`dim`\ th dimension of ``source`` must have the same size as the
+length of :attr:`index` (which must be a vector), and all other dimensions must
+match :attr:`self`, or an error will be raised.
+
+For a 3-D tensor the output is given as::
+
+ self[index[i], :, :] += alpha * src[i, :, :] # if dim == 0
+ self[:, index[i], :] += alpha * src[:, i, :] # if dim == 1
+ self[:, :, index[i]] += alpha * src[:, :, i] # if dim == 2
+
+Note:
+ {forward_reproducibility_note}
+
+Args:
+ dim (int): dimension along which to index
+ index (Tensor): indices of ``source`` to select from,
+ should have dtype either `torch.int64` or `torch.int32`
+ source (Tensor): the tensor containing values to add
+
+Keyword args:
+ alpha (Number): the scalar multiplier for ``source``
+
+Example::
+
+ >>> x = torch.ones(5, 3)
+ >>> t = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float)
+ >>> index = torch.tensor([0, 4, 2])
+ >>> x.index_add_(0, index, t)
+ tensor([[ 2., 3., 4.],
+ [ 1., 1., 1.],
+ [ 8., 9., 10.],
+ [ 1., 1., 1.],
+ [ 5., 6., 7.]])
+ >>> x.index_add_(0, index, t, alpha=-1)
+ tensor([[ 1., 1., 1.],
+ [ 1., 1., 1.],
+ [ 1., 1., 1.],
+ [ 1., 1., 1.],
+ [ 1., 1., 1.]])
+""".format(
+ **reproducibility_notes
+ ),
+)
+
+add_docstr_all(
+ "index_copy_",
+ r"""
+index_copy_(dim, index, tensor) -> Tensor
+
+Copies the elements of :attr:`tensor` into the :attr:`self` tensor by selecting
+the indices in the order given in :attr:`index`. For example, if ``dim == 0``
+and ``index[i] == j``, then the ``i``\ th row of :attr:`tensor` is copied to the
+``j``\ th row of :attr:`self`.
+
+The :attr:`dim`\ th dimension of :attr:`tensor` must have the same size as the
+length of :attr:`index` (which must be a vector), and all other dimensions must
+match :attr:`self`, or an error will be raised.
+
+.. note::
+ If :attr:`index` contains duplicate entries, multiple elements from
+ :attr:`tensor` will be copied to the same index of :attr:`self`. The result
+ is nondeterministic since it depends on which copy occurs last.
+
+Args:
+ dim (int): dimension along which to index
+ index (LongTensor): indices of :attr:`tensor` to select from
+ tensor (Tensor): the tensor containing values to copy
+
+Example::
+
+ >>> x = torch.zeros(5, 3)
+ >>> t = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float)
+ >>> index = torch.tensor([0, 4, 2])
+ >>> x.index_copy_(0, index, t)
+ tensor([[ 1., 2., 3.],
+ [ 0., 0., 0.],
+ [ 7., 8., 9.],
+ [ 0., 0., 0.],
+ [ 4., 5., 6.]])
+""",
+)
+
+add_docstr_all(
+ "index_fill_",
+ r"""
+index_fill_(dim, index, value) -> Tensor
+
+Fills the elements of the :attr:`self` tensor with value :attr:`value` by
+selecting the indices in the order given in :attr:`index`.
+
+Args:
+ dim (int): dimension along which to index
+ index (LongTensor): indices of :attr:`self` tensor to fill in
+ value (float): the value to fill with
+
+Example::
+ >>> x = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float)
+ >>> index = torch.tensor([0, 2])
+ >>> x.index_fill_(1, index, -1)
+ tensor([[-1., 2., -1.],
+ [-1., 5., -1.],
+ [-1., 8., -1.]])
+""",
+)
+
+add_docstr_all(
+ "index_put_",
+ r"""
+index_put_(indices, values, accumulate=False) -> Tensor
+
+Puts values from the tensor :attr:`values` into the tensor :attr:`self` using
+the indices specified in :attr:`indices` (which is a tuple of Tensors). The
+expression ``tensor.index_put_(indices, values)`` is equivalent to
+``tensor[indices] = values``. Returns :attr:`self`.
+
+If :attr:`accumulate` is ``True``, the elements in :attr:`values` are added to
+:attr:`self`. If accumulate is ``False``, the behavior is undefined if indices
+contain duplicate elements.
+
+Args:
+ indices (tuple of LongTensor): tensors used to index into `self`.
+ values (Tensor): tensor of same dtype as `self`.
+ accumulate (bool): whether to accumulate into self
+""",
+)
+
+add_docstr_all(
+ "index_put",
+ r"""
+index_put(indices, values, accumulate=False) -> Tensor
+
+Out-place version of :meth:`~Tensor.index_put_`.
+""",
+)
+
+add_docstr_all(
+ "index_reduce_",
+ r"""
+index_reduce_(dim, index, source, reduce, *, include_self=True) -> Tensor
+
+Accumulate the elements of ``source`` into the :attr:`self`
+tensor by accumulating to the indices in the order given in :attr:`index`
+using the reduction given by the ``reduce`` argument. For example, if ``dim == 0``,
+``index[i] == j``, ``reduce == prod`` and ``include_self == True`` then the ``i``\ th
+row of ``source`` is multiplied by the ``j``\ th row of :attr:`self`. If
+:obj:`include_self="True"`, the values in the :attr:`self` tensor are included
+in the reduction, otherwise, rows in the :attr:`self` tensor that are accumulated
+to are treated as if they were filled with the reduction identites.
+
+The :attr:`dim`\ th dimension of ``source`` must have the same size as the
+length of :attr:`index` (which must be a vector), and all other dimensions must
+match :attr:`self`, or an error will be raised.
+
+For a 3-D tensor with :obj:`reduce="prod"` and :obj:`include_self=True` the
+output is given as::
+
+ self[index[i], :, :] *= src[i, :, :] # if dim == 0
+ self[:, index[i], :] *= src[:, i, :] # if dim == 1
+ self[:, :, index[i]] *= src[:, :, i] # if dim == 2
+
+Note:
+ {forward_reproducibility_note}
+
+.. note::
+
+ This function only supports floating point tensors.
+
+.. warning::
+
+ This function is in beta and may change in the near future.
+
+Args:
+ dim (int): dimension along which to index
+ index (Tensor): indices of ``source`` to select from,
+ should have dtype either `torch.int64` or `torch.int32`
+ source (FloatTensor): the tensor containing values to accumulate
+ reduce (str): the reduction operation to apply
+ (:obj:`"prod"`, :obj:`"mean"`, :obj:`"amax"`, :obj:`"amin"`)
+
+Keyword args:
+ include_self (bool): whether the elements from the ``self`` tensor are
+ included in the reduction
+
+Example::
+
+ >>> x = torch.empty(5, 3).fill_(2)
+ >>> t = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]], dtype=torch.float)
+ >>> index = torch.tensor([0, 4, 2, 0])
+ >>> x.index_reduce_(0, index, t, 'prod')
+ tensor([[20., 44., 72.],
+ [ 2., 2., 2.],
+ [14., 16., 18.],
+ [ 2., 2., 2.],
+ [ 8., 10., 12.]])
+ >>> x = torch.empty(5, 3).fill_(2)
+ >>> x.index_reduce_(0, index, t, 'prod', include_self=False)
+ tensor([[10., 22., 36.],
+ [ 2., 2., 2.],
+ [ 7., 8., 9.],
+ [ 2., 2., 2.],
+ [ 4., 5., 6.]])
+""".format(
+ **reproducibility_notes
+ ),
+)
+
+add_docstr_all(
+ "index_select",
+ r"""
+index_select(dim, index) -> Tensor
+
+See :func:`torch.index_select`
+""",
+)
+
+add_docstr_all(
+ "sparse_mask",
+ r"""
+sparse_mask(mask) -> Tensor
+
+Returns a new :ref:`sparse tensor ` with values from a
+strided tensor :attr:`self` filtered by the indices of the sparse
+tensor :attr:`mask`. The values of :attr:`mask` sparse tensor are
+ignored. :attr:`self` and :attr:`mask` tensors must have the same
+shape.
+
+.. note::
+
+ The returned sparse tensor might contain duplicate values if :attr:`mask`
+ is not coalesced. It is therefore advisable to pass ``mask.coalesce()``
+ if such behavior is not desired.
+
+.. note::
+
+ The returned sparse tensor has the same indices as the sparse tensor
+ :attr:`mask`, even when the corresponding values in :attr:`self` are
+ zeros.
+
+Args:
+ mask (Tensor): a sparse tensor whose indices are used as a filter
+
+Example::
+
+ >>> nse = 5
+ >>> dims = (5, 5, 2, 2)
+ >>> I = torch.cat([torch.randint(0, dims[0], size=(nse,)),
+ ... torch.randint(0, dims[1], size=(nse,))], 0).reshape(2, nse)
+ >>> V = torch.randn(nse, dims[2], dims[3])
+ >>> S = torch.sparse_coo_tensor(I, V, dims).coalesce()
+ >>> D = torch.randn(dims)
+ >>> D.sparse_mask(S)
+ tensor(indices=tensor([[0, 0, 0, 2],
+ [0, 1, 4, 3]]),
+ values=tensor([[[ 1.6550, 0.2397],
+ [-0.1611, -0.0779]],
+
+ [[ 0.2326, -1.0558],
+ [ 1.4711, 1.9678]],
+
+ [[-0.5138, -0.0411],
+ [ 1.9417, 0.5158]],
+
+ [[ 0.0793, 0.0036],
+ [-0.2569, -0.1055]]]),
+ size=(5, 5, 2, 2), nnz=4, layout=torch.sparse_coo)
+""",
+)
+
+add_docstr_all(
+ "inverse",
+ r"""
+inverse() -> Tensor
+
+See :func:`torch.inverse`
+""",
+)
+
+add_docstr_all(
+ "isnan",
+ r"""
+isnan() -> Tensor
+
+See :func:`torch.isnan`
+""",
+)
+
+add_docstr_all(
+ "isinf",
+ r"""
+isinf() -> Tensor
+
+See :func:`torch.isinf`
+""",
+)
+
+add_docstr_all(
+ "isposinf",
+ r"""
+isposinf() -> Tensor
+
+See :func:`torch.isposinf`
+""",
+)
+
+add_docstr_all(
+ "isneginf",
+ r"""
+isneginf() -> Tensor
+
+See :func:`torch.isneginf`
+""",
+)
+
+add_docstr_all(
+ "isfinite",
+ r"""
+isfinite() -> Tensor
+
+See :func:`torch.isfinite`
+""",
+)
+
+add_docstr_all(
+ "isclose",
+ r"""
+isclose(other, rtol=1e-05, atol=1e-08, equal_nan=False) -> Tensor
+
+See :func:`torch.isclose`
+""",
+)
+
+add_docstr_all(
+ "isreal",
+ r"""
+isreal() -> Tensor
+
+See :func:`torch.isreal`
+""",
+)
+
+add_docstr_all(
+ "is_coalesced",
+ r"""
+is_coalesced() -> bool
+
+Returns ``True`` if :attr:`self` is a :ref:`sparse COO tensor
+` that is coalesced, ``False`` otherwise.
+
+.. warning::
+ Throws an error if :attr:`self` is not a sparse COO tensor.
+
+See :meth:`coalesce` and :ref:`uncoalesced tensors `.
+""",
+)
+
+add_docstr_all(
+ "is_contiguous",
+ r"""
+is_contiguous(memory_format=torch.contiguous_format) -> bool
+
+Returns True if :attr:`self` tensor is contiguous in memory in the order specified
+by memory format.
+
+Args:
+ memory_format (:class:`torch.memory_format`, optional): Specifies memory allocation
+ order. Default: ``torch.contiguous_format``.
+""",
+)
+
+add_docstr_all(
+ "is_pinned",
+ r"""
+Returns true if this tensor resides in pinned memory.
+""",
+)
+
+add_docstr_all(
+ "is_floating_point",
+ r"""
+is_floating_point() -> bool
+
+Returns True if the data type of :attr:`self` is a floating point data type.
+""",
+)
+
+add_docstr_all(
+ "is_complex",
+ r"""
+is_complex() -> bool
+
+Returns True if the data type of :attr:`self` is a complex data type.
+""",
+)
+
+add_docstr_all(
+ "is_inference",
+ r"""
+is_inference() -> bool
+
+See :func:`torch.is_inference`
+""",
+)
+
+add_docstr_all(
+ "is_conj",
+ r"""
+is_conj() -> bool
+
+Returns True if the conjugate bit of :attr:`self` is set to true.
+""",
+)
+
+add_docstr_all(
+ "is_neg",
+ r"""
+is_neg() -> bool
+
+Returns True if the negative bit of :attr:`self` is set to true.
+""",
+)
+
+add_docstr_all(
+ "is_signed",
+ r"""
+is_signed() -> bool
+
+Returns True if the data type of :attr:`self` is a signed data type.
+""",
+)
+
+add_docstr_all(
+ "is_set_to",
+ r"""
+is_set_to(tensor) -> bool
+
+Returns True if both tensors are pointing to the exact same memory (same
+storage, offset, size and stride).
+""",
+)
+
+add_docstr_all(
+ "item",
+ r"""
+item() -> number
+
+Returns the value of this tensor as a standard Python number. This only works
+for tensors with one element. For other cases, see :meth:`~Tensor.tolist`.
+
+This operation is not differentiable.
+
+Example::
+
+ >>> x = torch.tensor([1.0])
+ >>> x.item()
+ 1.0
+
+""",
+)
+
+add_docstr_all(
+ "kron",
+ r"""
+kron(other) -> Tensor
+
+See :func:`torch.kron`
+""",
+)
+
+add_docstr_all(
+ "kthvalue",
+ r"""
+kthvalue(k, dim=None, keepdim=False) -> (Tensor, LongTensor)
+
+See :func:`torch.kthvalue`
+""",
+)
+
+add_docstr_all(
+ "ldexp",
+ r"""
+ldexp(other) -> Tensor
+
+See :func:`torch.ldexp`
+""",
+)
+
+add_docstr_all(
+ "ldexp_",
+ r"""
+ldexp_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.ldexp`
+""",
+)
+
+add_docstr_all(
+ "lcm",
+ r"""
+lcm(other) -> Tensor
+
+See :func:`torch.lcm`
+""",
+)
+
+add_docstr_all(
+ "lcm_",
+ r"""
+lcm_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.lcm`
+""",
+)
+
+add_docstr_all(
+ "le",
+ r"""
+le(other) -> Tensor
+
+See :func:`torch.le`.
+""",
+)
+
+add_docstr_all(
+ "le_",
+ r"""
+le_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.le`.
+""",
+)
+
+add_docstr_all(
+ "less_equal",
+ r"""
+less_equal(other) -> Tensor
+
+See :func:`torch.less_equal`.
+""",
+)
+
+add_docstr_all(
+ "less_equal_",
+ r"""
+less_equal_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.less_equal`.
+""",
+)
+
+add_docstr_all(
+ "lerp",
+ r"""
+lerp(end, weight) -> Tensor
+
+See :func:`torch.lerp`
+""",
+)
+
+add_docstr_all(
+ "lerp_",
+ r"""
+lerp_(end, weight) -> Tensor
+
+In-place version of :meth:`~Tensor.lerp`
+""",
+)
+
+add_docstr_all(
+ "lgamma",
+ r"""
+lgamma() -> Tensor
+
+See :func:`torch.lgamma`
+""",
+)
+
+add_docstr_all(
+ "lgamma_",
+ r"""
+lgamma_() -> Tensor
+
+In-place version of :meth:`~Tensor.lgamma`
+""",
+)
+
+add_docstr_all(
+ "log",
+ r"""
+log() -> Tensor
+
+See :func:`torch.log`
+""",
+)
+
+add_docstr_all(
+ "log_",
+ r"""
+log_() -> Tensor
+
+In-place version of :meth:`~Tensor.log`
+""",
+)
+
+add_docstr_all(
+ "log10",
+ r"""
+log10() -> Tensor
+
+See :func:`torch.log10`
+""",
+)
+
+add_docstr_all(
+ "log10_",
+ r"""
+log10_() -> Tensor
+
+In-place version of :meth:`~Tensor.log10`
+""",
+)
+
+add_docstr_all(
+ "log1p",
+ r"""
+log1p() -> Tensor
+
+See :func:`torch.log1p`
+""",
+)
+
+add_docstr_all(
+ "log1p_",
+ r"""
+log1p_() -> Tensor
+
+In-place version of :meth:`~Tensor.log1p`
+""",
+)
+
+add_docstr_all(
+ "log2",
+ r"""
+log2() -> Tensor
+
+See :func:`torch.log2`
+""",
+)
+
+add_docstr_all(
+ "log2_",
+ r"""
+log2_() -> Tensor
+
+In-place version of :meth:`~Tensor.log2`
+""",
+)
+
+add_docstr_all(
+ "logaddexp",
+ r"""
+logaddexp(other) -> Tensor
+
+See :func:`torch.logaddexp`
+""",
+)
+
+add_docstr_all(
+ "logaddexp2",
+ r"""
+logaddexp2(other) -> Tensor
+
+See :func:`torch.logaddexp2`
+""",
+)
+
+add_docstr_all(
+ "log_normal_",
+ r"""
+log_normal_(mean=1, std=2, *, generator=None)
+
+Fills :attr:`self` tensor with numbers samples from the log-normal distribution
+parameterized by the given mean :math:`\mu` and standard deviation
+:math:`\sigma`. Note that :attr:`mean` and :attr:`std` are the mean and
+standard deviation of the underlying normal distribution, and not of the
+returned distribution:
+
+.. math::
+
+ f(x) = \dfrac{1}{x \sigma \sqrt{2\pi}}\ e^{-\frac{(\ln x - \mu)^2}{2\sigma^2}}
+""",
+)
+
+add_docstr_all(
+ "logsumexp",
+ r"""
+logsumexp(dim, keepdim=False) -> Tensor
+
+See :func:`torch.logsumexp`
+""",
+)
+
+add_docstr_all(
+ "lt",
+ r"""
+lt(other) -> Tensor
+
+See :func:`torch.lt`.
+""",
+)
+
+add_docstr_all(
+ "lt_",
+ r"""
+lt_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.lt`.
+""",
+)
+
+add_docstr_all(
+ "less",
+ r"""
+lt(other) -> Tensor
+
+See :func:`torch.less`.
+""",
+)
+
+add_docstr_all(
+ "less_",
+ r"""
+less_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.less`.
+""",
+)
+
+add_docstr_all(
+ "lu_solve",
+ r"""
+lu_solve(LU_data, LU_pivots) -> Tensor
+
+See :func:`torch.lu_solve`
+""",
+)
+
+add_docstr_all(
+ "map_",
+ r"""
+map_(tensor, callable)
+
+Applies :attr:`callable` for each element in :attr:`self` tensor and the given
+:attr:`tensor` and stores the results in :attr:`self` tensor. :attr:`self` tensor and
+the given :attr:`tensor` must be :ref:`broadcastable `.
+
+The :attr:`callable` should have the signature::
+
+ def callable(a, b) -> number
+""",
+)
+
+add_docstr_all(
+ "masked_scatter_",
+ r"""
+masked_scatter_(mask, source)
+
+Copies elements from :attr:`source` into :attr:`self` tensor at positions where
+the :attr:`mask` is True. Elements from :attr:`source` are copied into :attr:`self`
+starting at position 0 of :attr:`source` and continuing in order one-by-one for each
+occurrence of :attr:`mask` being True.
+The shape of :attr:`mask` must be :ref:`broadcastable `
+with the shape of the underlying tensor. The :attr:`source` should have at least
+as many elements as the number of ones in :attr:`mask`.
+
+Args:
+ mask (BoolTensor): the boolean mask
+ source (Tensor): the tensor to copy from
+
+.. note::
+
+ The :attr:`mask` operates on the :attr:`self` tensor, not on the given
+ :attr:`source` tensor.
+
+Example:
+
+ >>> self = torch.tensor([[0, 0, 0, 0, 0], [0, 0, 0, 0, 0]])
+ >>> mask = torch.tensor([[0, 0, 0, 1, 1], [1, 1, 0, 1, 1]])
+ >>> source = torch.tensor([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]])
+ >>> self.masked_scatter_(mask, source)
+ tensor([[0, 0, 0, 0, 1],
+ [2, 3, 0, 4, 5]])
+
+""",
+)
+
+add_docstr_all(
+ "masked_fill_",
+ r"""
+masked_fill_(mask, value)
+
+Fills elements of :attr:`self` tensor with :attr:`value` where :attr:`mask` is
+True. The shape of :attr:`mask` must be
+:ref:`broadcastable ` with the shape of the underlying
+tensor.
+
+Args:
+ mask (BoolTensor): the boolean mask
+ value (float): the value to fill in with
+""",
+)
+
+add_docstr_all(
+ "masked_select",
+ r"""
+masked_select(mask) -> Tensor
+
+See :func:`torch.masked_select`
+""",
+)
+
+add_docstr_all(
+ "matrix_power",
+ r"""
+matrix_power(n) -> Tensor
+
+.. note:: :meth:`~Tensor.matrix_power` is deprecated, use :func:`torch.linalg.matrix_power` instead.
+
+Alias for :func:`torch.linalg.matrix_power`
+""",
+)
+
+add_docstr_all(
+ "matrix_exp",
+ r"""
+matrix_exp() -> Tensor
+
+See :func:`torch.matrix_exp`
+""",
+)
+
+add_docstr_all(
+ "max",
+ r"""
+max(dim=None, keepdim=False) -> Tensor or (Tensor, Tensor)
+
+See :func:`torch.max`
+""",
+)
+
+add_docstr_all(
+ "amax",
+ r"""
+amax(dim=None, keepdim=False) -> Tensor
+
+See :func:`torch.amax`
+""",
+)
+
+add_docstr_all(
+ "maximum",
+ r"""
+maximum(other) -> Tensor
+
+See :func:`torch.maximum`
+""",
+)
+
+add_docstr_all(
+ "fmax",
+ r"""
+fmax(other) -> Tensor
+
+See :func:`torch.fmax`
+""",
+)
+
+add_docstr_all(
+ "argmax",
+ r"""
+argmax(dim=None, keepdim=False) -> LongTensor
+
+See :func:`torch.argmax`
+""",
+)
+
+add_docstr_all(
+ "argwhere",
+ r"""
+argwhere() -> Tensor
+
+See :func:`torch.argwhere`
+""",
+)
+
+add_docstr_all(
+ "mean",
+ r"""
+mean(dim=None, keepdim=False, *, dtype=None) -> Tensor
+
+See :func:`torch.mean`
+""",
+)
+
+add_docstr_all(
+ "nanmean",
+ r"""
+nanmean(dim=None, keepdim=False, *, dtype=None) -> Tensor
+
+See :func:`torch.nanmean`
+""",
+)
+
+add_docstr_all(
+ "median",
+ r"""
+median(dim=None, keepdim=False) -> (Tensor, LongTensor)
+
+See :func:`torch.median`
+""",
+)
+
+add_docstr_all(
+ "nanmedian",
+ r"""
+nanmedian(dim=None, keepdim=False) -> (Tensor, LongTensor)
+
+See :func:`torch.nanmedian`
+""",
+)
+
+add_docstr_all(
+ "min",
+ r"""
+min(dim=None, keepdim=False) -> Tensor or (Tensor, Tensor)
+
+See :func:`torch.min`
+""",
+)
+
+add_docstr_all(
+ "amin",
+ r"""
+amin(dim=None, keepdim=False) -> Tensor
+
+See :func:`torch.amin`
+""",
+)
+
+add_docstr_all(
+ "minimum",
+ r"""
+minimum(other) -> Tensor
+
+See :func:`torch.minimum`
+""",
+)
+
+add_docstr_all(
+ "aminmax",
+ r"""
+aminmax(*, dim=None, keepdim=False) -> (Tensor min, Tensor max)
+
+See :func:`torch.aminmax`
+""",
+)
+
+add_docstr_all(
+ "fmin",
+ r"""
+fmin(other) -> Tensor
+
+See :func:`torch.fmin`
+""",
+)
+
+add_docstr_all(
+ "argmin",
+ r"""
+argmin(dim=None, keepdim=False) -> LongTensor
+
+See :func:`torch.argmin`
+""",
+)
+
+add_docstr_all(
+ "mm",
+ r"""
+mm(mat2) -> Tensor
+
+See :func:`torch.mm`
+""",
+)
+
+add_docstr_all(
+ "mode",
+ r"""
+mode(dim=None, keepdim=False) -> (Tensor, LongTensor)
+
+See :func:`torch.mode`
+""",
+)
+
+add_docstr_all(
+ "movedim",
+ r"""
+movedim(source, destination) -> Tensor
+
+See :func:`torch.movedim`
+""",
+)
+
+add_docstr_all(
+ "moveaxis",
+ r"""
+moveaxis(source, destination) -> Tensor
+
+See :func:`torch.moveaxis`
+""",
+)
+
+add_docstr_all(
+ "mul",
+ r"""
+mul(value) -> Tensor
+
+See :func:`torch.mul`.
+""",
+)
+
+add_docstr_all(
+ "mul_",
+ r"""
+mul_(value) -> Tensor
+
+In-place version of :meth:`~Tensor.mul`.
+""",
+)
+
+add_docstr_all(
+ "multiply",
+ r"""
+multiply(value) -> Tensor
+
+See :func:`torch.multiply`.
+""",
+)
+
+add_docstr_all(
+ "multiply_",
+ r"""
+multiply_(value) -> Tensor
+
+In-place version of :meth:`~Tensor.multiply`.
+""",
+)
+
+add_docstr_all(
+ "multinomial",
+ r"""
+multinomial(num_samples, replacement=False, *, generator=None) -> Tensor
+
+See :func:`torch.multinomial`
+""",
+)
+
+add_docstr_all(
+ "mv",
+ r"""
+mv(vec) -> Tensor
+
+See :func:`torch.mv`
+""",
+)
+
+add_docstr_all(
+ "mvlgamma",
+ r"""
+mvlgamma(p) -> Tensor
+
+See :func:`torch.mvlgamma`
+""",
+)
+
+add_docstr_all(
+ "mvlgamma_",
+ r"""
+mvlgamma_(p) -> Tensor
+
+In-place version of :meth:`~Tensor.mvlgamma`
+""",
+)
+
+add_docstr_all(
+ "narrow",
+ r"""
+narrow(dimension, start, length) -> Tensor
+
+See :func:`torch.narrow`.
+""",
+)
+
+add_docstr_all(
+ "narrow_copy",
+ r"""
+narrow_copy(dimension, start, length) -> Tensor
+
+See :func:`torch.narrow_copy`.
+""",
+)
+
+add_docstr_all(
+ "ndimension",
+ r"""
+ndimension() -> int
+
+Alias for :meth:`~Tensor.dim()`
+""",
+)
+
+add_docstr_all(
+ "nan_to_num",
+ r"""
+nan_to_num(nan=0.0, posinf=None, neginf=None) -> Tensor
+
+See :func:`torch.nan_to_num`.
+""",
+)
+
+add_docstr_all(
+ "nan_to_num_",
+ r"""
+nan_to_num_(nan=0.0, posinf=None, neginf=None) -> Tensor
+
+In-place version of :meth:`~Tensor.nan_to_num`.
+""",
+)
+
+add_docstr_all(
+ "ne",
+ r"""
+ne(other) -> Tensor
+
+See :func:`torch.ne`.
+""",
+)
+
+add_docstr_all(
+ "ne_",
+ r"""
+ne_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.ne`.
+""",
+)
+
+add_docstr_all(
+ "not_equal",
+ r"""
+not_equal(other) -> Tensor
+
+See :func:`torch.not_equal`.
+""",
+)
+
+add_docstr_all(
+ "not_equal_",
+ r"""
+not_equal_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.not_equal`.
+""",
+)
+
+add_docstr_all(
+ "neg",
+ r"""
+neg() -> Tensor
+
+See :func:`torch.neg`
+""",
+)
+
+add_docstr_all(
+ "negative",
+ r"""
+negative() -> Tensor
+
+See :func:`torch.negative`
+""",
+)
+
+add_docstr_all(
+ "neg_",
+ r"""
+neg_() -> Tensor
+
+In-place version of :meth:`~Tensor.neg`
+""",
+)
+
+add_docstr_all(
+ "negative_",
+ r"""
+negative_() -> Tensor
+
+In-place version of :meth:`~Tensor.negative`
+""",
+)
+
+add_docstr_all(
+ "nelement",
+ r"""
+nelement() -> int
+
+Alias for :meth:`~Tensor.numel`
+""",
+)
+
+add_docstr_all(
+ "nextafter",
+ r"""
+nextafter(other) -> Tensor
+See :func:`torch.nextafter`
+""",
+)
+
+add_docstr_all(
+ "nextafter_",
+ r"""
+nextafter_(other) -> Tensor
+In-place version of :meth:`~Tensor.nextafter`
+""",
+)
+
+add_docstr_all(
+ "nonzero",
+ r"""
+nonzero() -> LongTensor
+
+See :func:`torch.nonzero`
+""",
+)
+
+add_docstr_all(
+ "nonzero_static",
+ r"""
+nonzero_static(input, *, size, fill_value=-1) -> Tensor
+
+Returns a 2-D tensor where each row is the index for a non-zero value.
+The returned Tensor has the same `torch.dtype` as `torch.nonzero()`.
+
+Args:
+ input (Tensor): the input tensor to count non-zero elements.
+
+Keyword args:
+ size (int): the size of non-zero elements expected to be included in the out
+ tensor. Pad the out tensor with `fill_value` if the `size` is larger
+ than total number of non-zero elements, truncate out tensor if `size`
+ is smaller. The size must be a non-negative integer.
+ fill_value (int): the value to fill the output tensor with when `size` is larger
+ than the total number of non-zero elements. Default is `-1` to represent
+ invalid index.
+
+Example:
+
+ # Example 1: Padding
+ >>> input_tensor = torch.tensor([[1, 0], [3, 2]])
+ >>> static_size = 4
+ >>> t = torch.nonzero_static(input_tensor, size = static_size)
+ tensor([[ 0, 0],
+ [ 1, 0],
+ [ 1, 1],
+ [ -1, -1]], dtype=torch.int64)
+
+ # Example 2: Truncating
+ >>> input_tensor = torch.tensor([[1, 0], [3, 2]])
+ >>> static_size = 2
+ >>> t = torch.nonzero_static(input_tensor, size = static_size)
+ tensor([[ 0, 0],
+ [ 1, 0]], dtype=torch.int64)
+
+ # Example 3: 0 size
+ >>> input_tensor = torch.tensor([10])
+ >>> static_size = 0
+ >>> t = torch.nonzero_static(input_tensor, size = static_size)
+ tensor([], size=(0, 1), dtype=torch.int64)
+
+ # Example 4: 0 rank input
+ >>> input_tensor = torch.tensor(10)
+ >>> static_size = 2
+ >>> t = torch.nonzero_static(input_tensor, size = static_size)
+ tensor([], size=(2, 0), dtype=torch.int64)
+""",
+)
+
+add_docstr_all(
+ "norm",
+ r"""
+norm(p=2, dim=None, keepdim=False) -> Tensor
+
+See :func:`torch.norm`
+""",
+)
+
+add_docstr_all(
+ "normal_",
+ r"""
+normal_(mean=0, std=1, *, generator=None) -> Tensor
+
+Fills :attr:`self` tensor with elements samples from the normal distribution
+parameterized by :attr:`mean` and :attr:`std`.
+""",
+)
+
+add_docstr_all(
+ "numel",
+ r"""
+numel() -> int
+
+See :func:`torch.numel`
+""",
+)
+
+add_docstr_all(
+ "numpy",
+ r"""
+numpy(*, force=False) -> numpy.ndarray
+
+Returns the tensor as a NumPy :class:`ndarray`.
+
+If :attr:`force` is ``False`` (the default), the conversion
+is performed only if the tensor is on the CPU, does not require grad,
+does not have its conjugate bit set, and is a dtype and layout that
+NumPy supports. The returned ndarray and the tensor will share their
+storage, so changes to the tensor will be reflected in the ndarray
+and vice versa.
+
+If :attr:`force` is ``True`` this is equivalent to
+calling ``t.detach().cpu().resolve_conj().resolve_neg().numpy()``.
+If the tensor isn't on the CPU or the conjugate or negative bit is set,
+the tensor won't share its storage with the returned ndarray.
+Setting :attr:`force` to ``True`` can be a useful shorthand.
+
+Args:
+ force (bool): if ``True``, the ndarray may be a copy of the tensor
+ instead of always sharing memory, defaults to ``False``.
+""",
+)
+
+add_docstr_all(
+ "orgqr",
+ r"""
+orgqr(input2) -> Tensor
+
+See :func:`torch.orgqr`
+""",
+)
+
+add_docstr_all(
+ "ormqr",
+ r"""
+ormqr(input2, input3, left=True, transpose=False) -> Tensor
+
+See :func:`torch.ormqr`
+""",
+)
+
+add_docstr_all(
+ "permute",
+ r"""
+permute(*dims) -> Tensor
+
+See :func:`torch.permute`
+""",
+)
+
+add_docstr_all(
+ "polygamma",
+ r"""
+polygamma(n) -> Tensor
+
+See :func:`torch.polygamma`
+""",
+)
+
+add_docstr_all(
+ "polygamma_",
+ r"""
+polygamma_(n) -> Tensor
+
+In-place version of :meth:`~Tensor.polygamma`
+""",
+)
+
+add_docstr_all(
+ "positive",
+ r"""
+positive() -> Tensor
+
+See :func:`torch.positive`
+""",
+)
+
+add_docstr_all(
+ "pow",
+ r"""
+pow(exponent) -> Tensor
+
+See :func:`torch.pow`
+""",
+)
+
+add_docstr_all(
+ "pow_",
+ r"""
+pow_(exponent) -> Tensor
+
+In-place version of :meth:`~Tensor.pow`
+""",
+)
+
+add_docstr_all(
+ "float_power",
+ r"""
+float_power(exponent) -> Tensor
+
+See :func:`torch.float_power`
+""",
+)
+
+add_docstr_all(
+ "float_power_",
+ r"""
+float_power_(exponent) -> Tensor
+
+In-place version of :meth:`~Tensor.float_power`
+""",
+)
+
+add_docstr_all(
+ "prod",
+ r"""
+prod(dim=None, keepdim=False, dtype=None) -> Tensor
+
+See :func:`torch.prod`
+""",
+)
+
+add_docstr_all(
+ "put_",
+ r"""
+put_(index, source, accumulate=False) -> Tensor
+
+Copies the elements from :attr:`source` into the positions specified by
+:attr:`index`. For the purpose of indexing, the :attr:`self` tensor is treated as if
+it were a 1-D tensor.
+
+:attr:`index` and :attr:`source` need to have the same number of elements, but not necessarily
+the same shape.
+
+If :attr:`accumulate` is ``True``, the elements in :attr:`source` are added to
+:attr:`self`. If accumulate is ``False``, the behavior is undefined if :attr:`index`
+contain duplicate elements.
+
+Args:
+ index (LongTensor): the indices into self
+ source (Tensor): the tensor containing values to copy from
+ accumulate (bool): whether to accumulate into self
+
+Example::
+
+ >>> src = torch.tensor([[4, 3, 5],
+ ... [6, 7, 8]])
+ >>> src.put_(torch.tensor([1, 3]), torch.tensor([9, 10]))
+ tensor([[ 4, 9, 5],
+ [ 10, 7, 8]])
+""",
+)
+
+add_docstr_all(
+ "put",
+ r"""
+put(input, index, source, accumulate=False) -> Tensor
+
+Out-of-place version of :meth:`torch.Tensor.put_`.
+`input` corresponds to `self` in :meth:`torch.Tensor.put_`.
+""",
+)
+
+add_docstr_all(
+ "qr",
+ r"""
+qr(some=True) -> (Tensor, Tensor)
+
+See :func:`torch.qr`
+""",
+)
+
+add_docstr_all(
+ "qscheme",
+ r"""
+qscheme() -> torch.qscheme
+
+Returns the quantization scheme of a given QTensor.
+""",
+)
+
+add_docstr_all(
+ "quantile",
+ r"""
+quantile(q, dim=None, keepdim=False, *, interpolation='linear') -> Tensor
+
+See :func:`torch.quantile`
+""",
+)
+
+add_docstr_all(
+ "nanquantile",
+ r"""
+nanquantile(q, dim=None, keepdim=False, *, interpolation='linear') -> Tensor
+
+See :func:`torch.nanquantile`
+""",
+)
+
+add_docstr_all(
+ "q_scale",
+ r"""
+q_scale() -> float
+
+Given a Tensor quantized by linear(affine) quantization,
+returns the scale of the underlying quantizer().
+""",
+)
+
+add_docstr_all(
+ "q_zero_point",
+ r"""
+q_zero_point() -> int
+
+Given a Tensor quantized by linear(affine) quantization,
+returns the zero_point of the underlying quantizer().
+""",
+)
+
+add_docstr_all(
+ "q_per_channel_scales",
+ r"""
+q_per_channel_scales() -> Tensor
+
+Given a Tensor quantized by linear (affine) per-channel quantization,
+returns a Tensor of scales of the underlying quantizer. It has the number of
+elements that matches the corresponding dimensions (from q_per_channel_axis) of
+the tensor.
+""",
+)
+
+add_docstr_all(
+ "q_per_channel_zero_points",
+ r"""
+q_per_channel_zero_points() -> Tensor
+
+Given a Tensor quantized by linear (affine) per-channel quantization,
+returns a tensor of zero_points of the underlying quantizer. It has the number of
+elements that matches the corresponding dimensions (from q_per_channel_axis) of
+the tensor.
+""",
+)
+
+add_docstr_all(
+ "q_per_channel_axis",
+ r"""
+q_per_channel_axis() -> int
+
+Given a Tensor quantized by linear (affine) per-channel quantization,
+returns the index of dimension on which per-channel quantization is applied.
+""",
+)
+
+add_docstr_all(
+ "random_",
+ r"""
+random_(from=0, to=None, *, generator=None) -> Tensor
+
+Fills :attr:`self` tensor with numbers sampled from the discrete uniform
+distribution over ``[from, to - 1]``. If not specified, the values are usually
+only bounded by :attr:`self` tensor's data type. However, for floating point
+types, if unspecified, range will be ``[0, 2^mantissa]`` to ensure that every
+value is representable. For example, `torch.tensor(1, dtype=torch.double).random_()`
+will be uniform in ``[0, 2^53]``.
+""",
+)
+
+add_docstr_all(
+ "rad2deg",
+ r"""
+rad2deg() -> Tensor
+
+See :func:`torch.rad2deg`
+""",
+)
+
+add_docstr_all(
+ "rad2deg_",
+ r"""
+rad2deg_() -> Tensor
+
+In-place version of :meth:`~Tensor.rad2deg`
+""",
+)
+
+add_docstr_all(
+ "deg2rad",
+ r"""
+deg2rad() -> Tensor
+
+See :func:`torch.deg2rad`
+""",
+)
+
+add_docstr_all(
+ "deg2rad_",
+ r"""
+deg2rad_() -> Tensor
+
+In-place version of :meth:`~Tensor.deg2rad`
+""",
+)
+
+add_docstr_all(
+ "ravel",
+ r"""
+ravel() -> Tensor
+
+see :func:`torch.ravel`
+""",
+)
+
+add_docstr_all(
+ "reciprocal",
+ r"""
+reciprocal() -> Tensor
+
+See :func:`torch.reciprocal`
+""",
+)
+
+add_docstr_all(
+ "reciprocal_",
+ r"""
+reciprocal_() -> Tensor
+
+In-place version of :meth:`~Tensor.reciprocal`
+""",
+)
+
+add_docstr_all(
+ "record_stream",
+ r"""
+record_stream(stream)
+
+Marks the tensor as having been used by this stream. When the tensor
+is deallocated, ensure the tensor memory is not reused for another tensor
+until all work queued on :attr:`stream` at the time of deallocation is
+complete.
+
+.. note::
+
+ The caching allocator is aware of only the stream where a tensor was
+ allocated. Due to the awareness, it already correctly manages the life
+ cycle of tensors on only one stream. But if a tensor is used on a stream
+ different from the stream of origin, the allocator might reuse the memory
+ unexpectedly. Calling this method lets the allocator know which streams
+ have used the tensor.
+
+.. warning::
+
+ This method is most suitable for use cases where you are providing a
+ function that created a tensor on a side stream, and want users to be able
+ to make use of the tensor without having to think carefully about stream
+ safety when making use of them. These safety guarantees come at some
+ performance and predictability cost (analogous to the tradeoff between GC
+ and manual memory management), so if you are in a situation where
+ you manage the full lifetime of your tensors, you may consider instead
+ manually managing CUDA events so that calling this method is not necessary.
+ In particular, when you call this method, on later allocations the
+ allocator will poll the recorded stream to see if all operations have
+ completed yet; you can potentially race with side stream computation and
+ non-deterministically reuse or fail to reuse memory for an allocation.
+
+ You can safely use tensors allocated on side streams without
+ :meth:`~Tensor.record_stream`; you must manually ensure that
+ any non-creation stream uses of a tensor are synced back to the creation
+ stream before you deallocate the tensor. As the CUDA caching allocator
+ guarantees that the memory will only be reused with the same creation stream,
+ this is sufficient to ensure that writes to future reallocations of the
+ memory will be delayed until non-creation stream uses are done.
+ (Counterintuitively, you may observe that on the CPU side we have already
+ reallocated the tensor, even though CUDA kernels on the old tensor are
+ still in progress. This is fine, because CUDA operations on the new
+ tensor will appropriately wait for the old operations to complete, as they
+ are all on the same stream.)
+
+ Concretely, this looks like this::
+
+ with torch.cuda.stream(s0):
+ x = torch.zeros(N)
+
+ s1.wait_stream(s0)
+ with torch.cuda.stream(s1):
+ y = some_comm_op(x)
+
+ ... some compute on s0 ...
+
+ # synchronize creation stream s0 to side stream s1
+ # before deallocating x
+ s0.wait_stream(s1)
+ del x
+
+ Note that some discretion is required when deciding when to perform
+ ``s0.wait_stream(s1)``. In particular, if we were to wait immediately
+ after ``some_comm_op``, there wouldn't be any point in having the side
+ stream; it would be equivalent to have run ``some_comm_op`` on ``s0``.
+ Instead, the synchronization must be placed at some appropriate, later
+ point in time where you expect the side stream ``s1`` to have finished
+ work. This location is typically identified via profiling, e.g., using
+ Chrome traces produced
+ :meth:`torch.autograd.profiler.profile.export_chrome_trace`. If you
+ place the wait too early, work on s0 will block until ``s1`` has finished,
+ preventing further overlapping of communication and computation. If you
+ place the wait too late, you will use more memory than is strictly
+ necessary (as you are keeping ``x`` live for longer.) For a concrete
+ example of how this guidance can be applied in practice, see this post:
+ `FSDP and CUDACachingAllocator
+ `_.
+""",
+)
+
+add_docstr_all(
+ "remainder",
+ r"""
+remainder(divisor) -> Tensor
+
+See :func:`torch.remainder`
+""",
+)
+
+add_docstr_all(
+ "remainder_",
+ r"""
+remainder_(divisor) -> Tensor
+
+In-place version of :meth:`~Tensor.remainder`
+""",
+)
+
+add_docstr_all(
+ "renorm",
+ r"""
+renorm(p, dim, maxnorm) -> Tensor
+
+See :func:`torch.renorm`
+""",
+)
+
+add_docstr_all(
+ "renorm_",
+ r"""
+renorm_(p, dim, maxnorm) -> Tensor
+
+In-place version of :meth:`~Tensor.renorm`
+""",
+)
+
+add_docstr_all(
+ "repeat",
+ r"""
+repeat(*sizes) -> Tensor
+
+Repeats this tensor along the specified dimensions.
+
+Unlike :meth:`~Tensor.expand`, this function copies the tensor's data.
+
+.. warning::
+
+ :meth:`~Tensor.repeat` behaves differently from
+ `numpy.repeat `_,
+ but is more similar to
+ `numpy.tile `_.
+ For the operator similar to `numpy.repeat`, see :func:`torch.repeat_interleave`.
+
+Args:
+ sizes (torch.Size or int...): The number of times to repeat this tensor along each
+ dimension
+
+Example::
+
+ >>> x = torch.tensor([1, 2, 3])
+ >>> x.repeat(4, 2)
+ tensor([[ 1, 2, 3, 1, 2, 3],
+ [ 1, 2, 3, 1, 2, 3],
+ [ 1, 2, 3, 1, 2, 3],
+ [ 1, 2, 3, 1, 2, 3]])
+ >>> x.repeat(4, 2, 1).size()
+ torch.Size([4, 2, 3])
+""",
+)
+
+add_docstr_all(
+ "repeat_interleave",
+ r"""
+repeat_interleave(repeats, dim=None, *, output_size=None) -> Tensor
+
+See :func:`torch.repeat_interleave`.
+""",
+)
+
+add_docstr_all(
+ "requires_grad_",
+ r"""
+requires_grad_(requires_grad=True) -> Tensor
+
+Change if autograd should record operations on this tensor: sets this tensor's
+:attr:`requires_grad` attribute in-place. Returns this tensor.
+
+:func:`requires_grad_`'s main use case is to tell autograd to begin recording
+operations on a Tensor ``tensor``. If ``tensor`` has ``requires_grad=False``
+(because it was obtained through a DataLoader, or required preprocessing or
+initialization), ``tensor.requires_grad_()`` makes it so that autograd will
+begin to record operations on ``tensor``.
+
+Args:
+ requires_grad (bool): If autograd should record operations on this tensor.
+ Default: ``True``.
+
+Example::
+
+ >>> # Let's say we want to preprocess some saved weights and use
+ >>> # the result as new weights.
+ >>> saved_weights = [0.1, 0.2, 0.3, 0.25]
+ >>> loaded_weights = torch.tensor(saved_weights)
+ >>> weights = preprocess(loaded_weights) # some function
+ >>> weights
+ tensor([-0.5503, 0.4926, -2.1158, -0.8303])
+
+ >>> # Now, start to record operations done to weights
+ >>> weights.requires_grad_()
+ >>> out = weights.pow(2).sum()
+ >>> out.backward()
+ >>> weights.grad
+ tensor([-1.1007, 0.9853, -4.2316, -1.6606])
+
+""",
+)
+
+add_docstr_all(
+ "reshape",
+ r"""
+reshape(*shape) -> Tensor
+
+Returns a tensor with the same data and number of elements as :attr:`self`
+but with the specified shape. This method returns a view if :attr:`shape` is
+compatible with the current shape. See :meth:`torch.Tensor.view` on when it is
+possible to return a view.
+
+See :func:`torch.reshape`
+
+Args:
+ shape (tuple of ints or int...): the desired shape
+
+""",
+)
+
+add_docstr_all(
+ "reshape_as",
+ r"""
+reshape_as(other) -> Tensor
+
+Returns this tensor as the same shape as :attr:`other`.
+``self.reshape_as(other)`` is equivalent to ``self.reshape(other.sizes())``.
+This method returns a view if ``other.sizes()`` is compatible with the current
+shape. See :meth:`torch.Tensor.view` on when it is possible to return a view.
+
+Please see :meth:`reshape` for more information about ``reshape``.
+
+Args:
+ other (:class:`torch.Tensor`): The result tensor has the same shape
+ as :attr:`other`.
+""",
+)
+
+add_docstr_all(
+ "resize_",
+ r"""
+resize_(*sizes, memory_format=torch.contiguous_format) -> Tensor
+
+Resizes :attr:`self` tensor to the specified size. If the number of elements is
+larger than the current storage size, then the underlying storage is resized
+to fit the new number of elements. If the number of elements is smaller, the
+underlying storage is not changed. Existing elements are preserved but any new
+memory is uninitialized.
+
+.. warning::
+
+ This is a low-level method. The storage is reinterpreted as C-contiguous,
+ ignoring the current strides (unless the target size equals the current
+ size, in which case the tensor is left unchanged). For most purposes, you
+ will instead want to use :meth:`~Tensor.view()`, which checks for
+ contiguity, or :meth:`~Tensor.reshape()`, which copies data if needed. To
+ change the size in-place with custom strides, see :meth:`~Tensor.set_()`.
+
+.. note::
+
+ If :func:`torch.use_deterministic_algorithms()` and
+ :attr:`torch.utils.deterministic.fill_uninitialized_memory` are both set to
+ ``True``, new elements are initialized to prevent nondeterministic behavior
+ from using the result as an input to an operation. Floating point and
+ complex values are set to NaN, and integer values are set to the maximum
+ value.
+
+Args:
+ sizes (torch.Size or int...): the desired size
+ memory_format (:class:`torch.memory_format`, optional): the desired memory format of
+ Tensor. Default: ``torch.contiguous_format``. Note that memory format of
+ :attr:`self` is going to be unaffected if ``self.size()`` matches ``sizes``.
+
+Example::
+
+ >>> x = torch.tensor([[1, 2], [3, 4], [5, 6]])
+ >>> x.resize_(2, 2)
+ tensor([[ 1, 2],
+ [ 3, 4]])
+""",
+)
+
+add_docstr_all(
+ "resize_as_",
+ r"""
+resize_as_(tensor, memory_format=torch.contiguous_format) -> Tensor
+
+Resizes the :attr:`self` tensor to be the same size as the specified
+:attr:`tensor`. This is equivalent to ``self.resize_(tensor.size())``.
+
+Args:
+ memory_format (:class:`torch.memory_format`, optional): the desired memory format of
+ Tensor. Default: ``torch.contiguous_format``. Note that memory format of
+ :attr:`self` is going to be unaffected if ``self.size()`` matches ``tensor.size()``.
+
+""",
+)
+
+add_docstr_all(
+ "rot90",
+ r"""
+rot90(k, dims) -> Tensor
+
+See :func:`torch.rot90`
+""",
+)
+
+add_docstr_all(
+ "round",
+ r"""
+round(decimals=0) -> Tensor
+
+See :func:`torch.round`
+""",
+)
+
+add_docstr_all(
+ "round_",
+ r"""
+round_(decimals=0) -> Tensor
+
+In-place version of :meth:`~Tensor.round`
+""",
+)
+
+add_docstr_all(
+ "rsqrt",
+ r"""
+rsqrt() -> Tensor
+
+See :func:`torch.rsqrt`
+""",
+)
+
+add_docstr_all(
+ "rsqrt_",
+ r"""
+rsqrt_() -> Tensor
+
+In-place version of :meth:`~Tensor.rsqrt`
+""",
+)
+
+add_docstr_all(
+ "scatter_",
+ r"""
+scatter_(dim, index, src, *, reduce=None) -> Tensor
+
+Writes all values from the tensor :attr:`src` into :attr:`self` at the indices
+specified in the :attr:`index` tensor. For each value in :attr:`src`, its output
+index is specified by its index in :attr:`src` for ``dimension != dim`` and by
+the corresponding value in :attr:`index` for ``dimension = dim``.
+
+For a 3-D tensor, :attr:`self` is updated as::
+
+ self[index[i][j][k]][j][k] = src[i][j][k] # if dim == 0
+ self[i][index[i][j][k]][k] = src[i][j][k] # if dim == 1
+ self[i][j][index[i][j][k]] = src[i][j][k] # if dim == 2
+
+This is the reverse operation of the manner described in :meth:`~Tensor.gather`.
+
+:attr:`self`, :attr:`index` and :attr:`src` (if it is a Tensor) should all have
+the same number of dimensions. It is also required that
+``index.size(d) <= src.size(d)`` for all dimensions ``d``, and that
+``index.size(d) <= self.size(d)`` for all dimensions ``d != dim``.
+Note that ``index`` and ``src`` do not broadcast.
+
+Moreover, as for :meth:`~Tensor.gather`, the values of :attr:`index` must be
+between ``0`` and ``self.size(dim) - 1`` inclusive.
+
+.. warning::
+
+ When indices are not unique, the behavior is non-deterministic (one of the
+ values from ``src`` will be picked arbitrarily) and the gradient will be
+ incorrect (it will be propagated to all locations in the source that
+ correspond to the same index)!
+
+.. note::
+
+ The backward pass is implemented only for ``src.shape == index.shape``.
+
+Additionally accepts an optional :attr:`reduce` argument that allows
+specification of an optional reduction operation, which is applied to all
+values in the tensor :attr:`src` into :attr:`self` at the indices
+specified in the :attr:`index`. For each value in :attr:`src`, the reduction
+operation is applied to an index in :attr:`self` which is specified by
+its index in :attr:`src` for ``dimension != dim`` and by the corresponding
+value in :attr:`index` for ``dimension = dim``.
+
+Given a 3-D tensor and reduction using the multiplication operation, :attr:`self`
+is updated as::
+
+ self[index[i][j][k]][j][k] *= src[i][j][k] # if dim == 0
+ self[i][index[i][j][k]][k] *= src[i][j][k] # if dim == 1
+ self[i][j][index[i][j][k]] *= src[i][j][k] # if dim == 2
+
+Reducing with the addition operation is the same as using
+:meth:`~torch.Tensor.scatter_add_`.
+
+.. warning::
+ The reduce argument with Tensor ``src`` is deprecated and will be removed in
+ a future PyTorch release. Please use :meth:`~torch.Tensor.scatter_reduce_`
+ instead for more reduction options.
+
+Args:
+ dim (int): the axis along which to index
+ index (LongTensor): the indices of elements to scatter, can be either empty
+ or of the same dimensionality as ``src``. When empty, the operation
+ returns ``self`` unchanged.
+ src (Tensor): the source element(s) to scatter.
+
+Keyword args:
+ reduce (str, optional): reduction operation to apply, can be either
+ ``'add'`` or ``'multiply'``.
+
+Example::
+
+ >>> src = torch.arange(1, 11).reshape((2, 5))
+ >>> src
+ tensor([[ 1, 2, 3, 4, 5],
+ [ 6, 7, 8, 9, 10]])
+ >>> index = torch.tensor([[0, 1, 2, 0]])
+ >>> torch.zeros(3, 5, dtype=src.dtype).scatter_(0, index, src)
+ tensor([[1, 0, 0, 4, 0],
+ [0, 2, 0, 0, 0],
+ [0, 0, 3, 0, 0]])
+ >>> index = torch.tensor([[0, 1, 2], [0, 1, 4]])
+ >>> torch.zeros(3, 5, dtype=src.dtype).scatter_(1, index, src)
+ tensor([[1, 2, 3, 0, 0],
+ [6, 7, 0, 0, 8],
+ [0, 0, 0, 0, 0]])
+
+ >>> torch.full((2, 4), 2.).scatter_(1, torch.tensor([[2], [3]]),
+ ... 1.23, reduce='multiply')
+ tensor([[2.0000, 2.0000, 2.4600, 2.0000],
+ [2.0000, 2.0000, 2.0000, 2.4600]])
+ >>> torch.full((2, 4), 2.).scatter_(1, torch.tensor([[2], [3]]),
+ ... 1.23, reduce='add')
+ tensor([[2.0000, 2.0000, 3.2300, 2.0000],
+ [2.0000, 2.0000, 2.0000, 3.2300]])
+
+.. function:: scatter_(dim, index, value, *, reduce=None) -> Tensor:
+ :noindex:
+
+Writes the value from :attr:`value` into :attr:`self` at the indices
+specified in the :attr:`index` tensor. This operation is equivalent to the previous version,
+with the :attr:`src` tensor filled entirely with :attr:`value`.
+
+Args:
+ dim (int): the axis along which to index
+ index (LongTensor): the indices of elements to scatter, can be either empty
+ or of the same dimensionality as ``src``. When empty, the operation
+ returns ``self`` unchanged.
+ value (Scalar): the value to scatter.
+
+Keyword args:
+ reduce (str, optional): reduction operation to apply, can be either
+ ``'add'`` or ``'multiply'``.
+
+Example::
+
+ >>> index = torch.tensor([[0, 1]])
+ >>> value = 2
+ >>> torch.zeros(3, 5).scatter_(0, index, value)
+ tensor([[2., 0., 0., 0., 0.],
+ [0., 2., 0., 0., 0.],
+ [0., 0., 0., 0., 0.]])
+""",
+)
+
+add_docstr_all(
+ "scatter_add_",
+ r"""
+scatter_add_(dim, index, src) -> Tensor
+
+Adds all values from the tensor :attr:`src` into :attr:`self` at the indices
+specified in the :attr:`index` tensor in a similar fashion as
+:meth:`~torch.Tensor.scatter_`. For each value in :attr:`src`, it is added to
+an index in :attr:`self` which is specified by its index in :attr:`src`
+for ``dimension != dim`` and by the corresponding value in :attr:`index` for
+``dimension = dim``.
+
+For a 3-D tensor, :attr:`self` is updated as::
+
+ self[index[i][j][k]][j][k] += src[i][j][k] # if dim == 0
+ self[i][index[i][j][k]][k] += src[i][j][k] # if dim == 1
+ self[i][j][index[i][j][k]] += src[i][j][k] # if dim == 2
+
+:attr:`self`, :attr:`index` and :attr:`src` should have same number of
+dimensions. It is also required that ``index.size(d) <= src.size(d)`` for all
+dimensions ``d``, and that ``index.size(d) <= self.size(d)`` for all dimensions
+``d != dim``. Note that ``index`` and ``src`` do not broadcast.
+
+Note:
+ {forward_reproducibility_note}
+
+.. note::
+
+ The backward pass is implemented only for ``src.shape == index.shape``.
+
+Args:
+ dim (int): the axis along which to index
+ index (LongTensor): the indices of elements to scatter and add, can be
+ either empty or of the same dimensionality as ``src``. When empty, the
+ operation returns ``self`` unchanged.
+ src (Tensor): the source elements to scatter and add
+
+Example::
+
+ >>> src = torch.ones((2, 5))
+ >>> index = torch.tensor([[0, 1, 2, 0, 0]])
+ >>> torch.zeros(3, 5, dtype=src.dtype).scatter_add_(0, index, src)
+ tensor([[1., 0., 0., 1., 1.],
+ [0., 1., 0., 0., 0.],
+ [0., 0., 1., 0., 0.]])
+ >>> index = torch.tensor([[0, 1, 2, 0, 0], [0, 1, 2, 2, 2]])
+ >>> torch.zeros(3, 5, dtype=src.dtype).scatter_add_(0, index, src)
+ tensor([[2., 0., 0., 1., 1.],
+ [0., 2., 0., 0., 0.],
+ [0., 0., 2., 1., 1.]])
+
+""".format(
+ **reproducibility_notes
+ ),
+)
+
+add_docstr_all(
+ "scatter_reduce_",
+ r"""
+scatter_reduce_(dim, index, src, reduce, *, include_self=True) -> Tensor
+
+Reduces all values from the :attr:`src` tensor to the indices specified in
+the :attr:`index` tensor in the :attr:`self` tensor using the applied reduction
+defined via the :attr:`reduce` argument (:obj:`"sum"`, :obj:`"prod"`, :obj:`"mean"`,
+:obj:`"amax"`, :obj:`"amin"`). For each value in :attr:`src`, it is reduced to an
+index in :attr:`self` which is specified by its index in :attr:`src` for
+``dimension != dim`` and by the corresponding value in :attr:`index` for
+``dimension = dim``. If :obj:`include_self="True"`, the values in the :attr:`self`
+tensor are included in the reduction.
+
+:attr:`self`, :attr:`index` and :attr:`src` should all have
+the same number of dimensions. It is also required that
+``index.size(d) <= src.size(d)`` for all dimensions ``d``, and that
+``index.size(d) <= self.size(d)`` for all dimensions ``d != dim``.
+Note that ``index`` and ``src`` do not broadcast.
+
+For a 3-D tensor with :obj:`reduce="sum"` and :obj:`include_self=True` the
+output is given as::
+
+ self[index[i][j][k]][j][k] += src[i][j][k] # if dim == 0
+ self[i][index[i][j][k]][k] += src[i][j][k] # if dim == 1
+ self[i][j][index[i][j][k]] += src[i][j][k] # if dim == 2
+
+Note:
+ {forward_reproducibility_note}
+
+.. note::
+
+ The backward pass is implemented only for ``src.shape == index.shape``.
+
+.. warning::
+
+ This function is in beta and may change in the near future.
+
+Args:
+ dim (int): the axis along which to index
+ index (LongTensor): the indices of elements to scatter and reduce.
+ src (Tensor): the source elements to scatter and reduce
+ reduce (str): the reduction operation to apply for non-unique indices
+ (:obj:`"sum"`, :obj:`"prod"`, :obj:`"mean"`, :obj:`"amax"`, :obj:`"amin"`)
+ include_self (bool): whether elements from the :attr:`self` tensor are
+ included in the reduction
+
+Example::
+
+ >>> src = torch.tensor([1., 2., 3., 4., 5., 6.])
+ >>> index = torch.tensor([0, 1, 0, 1, 2, 1])
+ >>> input = torch.tensor([1., 2., 3., 4.])
+ >>> input.scatter_reduce(0, index, src, reduce="sum")
+ tensor([5., 14., 8., 4.])
+ >>> input.scatter_reduce(0, index, src, reduce="sum", include_self=False)
+ tensor([4., 12., 5., 4.])
+ >>> input2 = torch.tensor([5., 4., 3., 2.])
+ >>> input2.scatter_reduce(0, index, src, reduce="amax")
+ tensor([5., 6., 5., 2.])
+ >>> input2.scatter_reduce(0, index, src, reduce="amax", include_self=False)
+ tensor([3., 6., 5., 2.])
+
+
+""".format(
+ **reproducibility_notes
+ ),
+)
+
+add_docstr_all(
+ "select",
+ r"""
+select(dim, index) -> Tensor
+
+See :func:`torch.select`
+""",
+)
+
+add_docstr_all(
+ "select_scatter",
+ r"""
+select_scatter(src, dim, index) -> Tensor
+
+See :func:`torch.select_scatter`
+""",
+)
+
+add_docstr_all(
+ "slice_scatter",
+ r"""
+slice_scatter(src, dim=0, start=None, end=None, step=1) -> Tensor
+
+See :func:`torch.slice_scatter`
+""",
+)
+
+add_docstr_all(
+ "set_",
+ r"""
+set_(source=None, storage_offset=0, size=None, stride=None) -> Tensor
+
+Sets the underlying storage, size, and strides. If :attr:`source` is a tensor,
+:attr:`self` tensor will share the same storage and have the same size and
+strides as :attr:`source`. Changes to elements in one tensor will be reflected
+in the other.
+
+If :attr:`source` is a :class:`~torch.Storage`, the method sets the underlying
+storage, offset, size, and stride.
+
+Args:
+ source (Tensor or Storage): the tensor or storage to use
+ storage_offset (int, optional): the offset in the storage
+ size (torch.Size, optional): the desired size. Defaults to the size of the source.
+ stride (tuple, optional): the desired stride. Defaults to C-contiguous strides.
+""",
+)
+
+add_docstr_all(
+ "sigmoid",
+ r"""
+sigmoid() -> Tensor
+
+See :func:`torch.sigmoid`
+""",
+)
+
+add_docstr_all(
+ "sigmoid_",
+ r"""
+sigmoid_() -> Tensor
+
+In-place version of :meth:`~Tensor.sigmoid`
+""",
+)
+
+add_docstr_all(
+ "logit",
+ r"""
+logit() -> Tensor
+
+See :func:`torch.logit`
+""",
+)
+
+add_docstr_all(
+ "logit_",
+ r"""
+logit_() -> Tensor
+
+In-place version of :meth:`~Tensor.logit`
+""",
+)
+
+add_docstr_all(
+ "sign",
+ r"""
+sign() -> Tensor
+
+See :func:`torch.sign`
+""",
+)
+
+add_docstr_all(
+ "sign_",
+ r"""
+sign_() -> Tensor
+
+In-place version of :meth:`~Tensor.sign`
+""",
+)
+
+add_docstr_all(
+ "signbit",
+ r"""
+signbit() -> Tensor
+
+See :func:`torch.signbit`
+""",
+)
+
+add_docstr_all(
+ "sgn",
+ r"""
+sgn() -> Tensor
+
+See :func:`torch.sgn`
+""",
+)
+
+add_docstr_all(
+ "sgn_",
+ r"""
+sgn_() -> Tensor
+
+In-place version of :meth:`~Tensor.sgn`
+""",
+)
+
+add_docstr_all(
+ "sin",
+ r"""
+sin() -> Tensor
+
+See :func:`torch.sin`
+""",
+)
+
+add_docstr_all(
+ "sin_",
+ r"""
+sin_() -> Tensor
+
+In-place version of :meth:`~Tensor.sin`
+""",
+)
+
+add_docstr_all(
+ "sinc",
+ r"""
+sinc() -> Tensor
+
+See :func:`torch.sinc`
+""",
+)
+
+add_docstr_all(
+ "sinc_",
+ r"""
+sinc_() -> Tensor
+
+In-place version of :meth:`~Tensor.sinc`
+""",
+)
+
+add_docstr_all(
+ "sinh",
+ r"""
+sinh() -> Tensor
+
+See :func:`torch.sinh`
+""",
+)
+
+add_docstr_all(
+ "sinh_",
+ r"""
+sinh_() -> Tensor
+
+In-place version of :meth:`~Tensor.sinh`
+""",
+)
+
+add_docstr_all(
+ "size",
+ r"""
+size(dim=None) -> torch.Size or int
+
+Returns the size of the :attr:`self` tensor. If ``dim`` is not specified,
+the returned value is a :class:`torch.Size`, a subclass of :class:`tuple`.
+If ``dim`` is specified, returns an int holding the size of that dimension.
+
+Args:
+ dim (int, optional): The dimension for which to retrieve the size.
+
+Example::
+
+ >>> t = torch.empty(3, 4, 5)
+ >>> t.size()
+ torch.Size([3, 4, 5])
+ >>> t.size(dim=1)
+ 4
+
+""",
+)
+
+add_docstr_all(
+ "shape",
+ r"""
+shape() -> torch.Size
+
+Returns the size of the :attr:`self` tensor. Alias for :attr:`size`.
+
+See also :meth:`Tensor.size`.
+
+Example::
+
+ >>> t = torch.empty(3, 4, 5)
+ >>> t.size()
+ torch.Size([3, 4, 5])
+ >>> t.shape
+ torch.Size([3, 4, 5])
+
+""",
+)
+
+add_docstr_all(
+ "sort",
+ r"""
+sort(dim=-1, descending=False) -> (Tensor, LongTensor)
+
+See :func:`torch.sort`
+""",
+)
+
+add_docstr_all(
+ "msort",
+ r"""
+msort() -> Tensor
+
+See :func:`torch.msort`
+""",
+)
+
+add_docstr_all(
+ "argsort",
+ r"""
+argsort(dim=-1, descending=False) -> LongTensor
+
+See :func:`torch.argsort`
+""",
+)
+
+add_docstr_all(
+ "sparse_dim",
+ r"""
+sparse_dim() -> int
+
+Return the number of sparse dimensions in a :ref:`sparse tensor ` :attr:`self`.
+
+.. note::
+ Returns ``0`` if :attr:`self` is not a sparse tensor.
+
+See also :meth:`Tensor.dense_dim` and :ref:`hybrid tensors `.
+""",
+)
+
+add_docstr_all(
+ "sparse_resize_",
+ r"""
+sparse_resize_(size, sparse_dim, dense_dim) -> Tensor
+
+Resizes :attr:`self` :ref:`sparse tensor ` to the desired
+size and the number of sparse and dense dimensions.
+
+.. note::
+ If the number of specified elements in :attr:`self` is zero, then
+ :attr:`size`, :attr:`sparse_dim`, and :attr:`dense_dim` can be any
+ size and positive integers such that ``len(size) == sparse_dim +
+ dense_dim``.
+
+ If :attr:`self` specifies one or more elements, however, then each
+ dimension in :attr:`size` must not be smaller than the corresponding
+ dimension of :attr:`self`, :attr:`sparse_dim` must equal the number
+ of sparse dimensions in :attr:`self`, and :attr:`dense_dim` must
+ equal the number of dense dimensions in :attr:`self`.
+
+.. warning::
+ Throws an error if :attr:`self` is not a sparse tensor.
+
+Args:
+ size (torch.Size): the desired size. If :attr:`self` is non-empty
+ sparse tensor, the desired size cannot be smaller than the
+ original size.
+ sparse_dim (int): the number of sparse dimensions
+ dense_dim (int): the number of dense dimensions
+""",
+)
+
+add_docstr_all(
+ "sparse_resize_and_clear_",
+ r"""
+sparse_resize_and_clear_(size, sparse_dim, dense_dim) -> Tensor
+
+Removes all specified elements from a :ref:`sparse tensor
+` :attr:`self` and resizes :attr:`self` to the desired
+size and the number of sparse and dense dimensions.
+
+.. warning:
+ Throws an error if :attr:`self` is not a sparse tensor.
+
+Args:
+ size (torch.Size): the desired size.
+ sparse_dim (int): the number of sparse dimensions
+ dense_dim (int): the number of dense dimensions
+""",
+)
+
+add_docstr_all(
+ "sqrt",
+ r"""
+sqrt() -> Tensor
+
+See :func:`torch.sqrt`
+""",
+)
+
+add_docstr_all(
+ "sqrt_",
+ r"""
+sqrt_() -> Tensor
+
+In-place version of :meth:`~Tensor.sqrt`
+""",
+)
+
+add_docstr_all(
+ "square",
+ r"""
+square() -> Tensor
+
+See :func:`torch.square`
+""",
+)
+
+add_docstr_all(
+ "square_",
+ r"""
+square_() -> Tensor
+
+In-place version of :meth:`~Tensor.square`
+""",
+)
+
+add_docstr_all(
+ "squeeze",
+ r"""
+squeeze(dim=None) -> Tensor
+
+See :func:`torch.squeeze`
+""",
+)
+
+add_docstr_all(
+ "squeeze_",
+ r"""
+squeeze_(dim=None) -> Tensor
+
+In-place version of :meth:`~Tensor.squeeze`
+""",
+)
+
+add_docstr_all(
+ "std",
+ r"""
+std(dim=None, *, correction=1, keepdim=False) -> Tensor
+
+See :func:`torch.std`
+""",
+)
+
+add_docstr_all(
+ "storage_offset",
+ r"""
+storage_offset() -> int
+
+Returns :attr:`self` tensor's offset in the underlying storage in terms of
+number of storage elements (not bytes).
+
+Example::
+
+ >>> x = torch.tensor([1, 2, 3, 4, 5])
+ >>> x.storage_offset()
+ 0
+ >>> x[3:].storage_offset()
+ 3
+
+""",
+)
+
+add_docstr_all(
+ "untyped_storage",
+ r"""
+untyped_storage() -> torch.UntypedStorage
+
+Returns the underlying :class:`UntypedStorage`.
+""",
+)
+
+add_docstr_all(
+ "stride",
+ r"""
+stride(dim) -> tuple or int
+
+Returns the stride of :attr:`self` tensor.
+
+Stride is the jump necessary to go from one element to the next one in the
+specified dimension :attr:`dim`. A tuple of all strides is returned when no
+argument is passed in. Otherwise, an integer value is returned as the stride in
+the particular dimension :attr:`dim`.
+
+Args:
+ dim (int, optional): the desired dimension in which stride is required
+
+Example::
+
+ >>> x = torch.tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
+ >>> x.stride()
+ (5, 1)
+ >>> x.stride(0)
+ 5
+ >>> x.stride(-1)
+ 1
+
+""",
+)
+
+add_docstr_all(
+ "sub",
+ r"""
+sub(other, *, alpha=1) -> Tensor
+
+See :func:`torch.sub`.
+""",
+)
+
+add_docstr_all(
+ "sub_",
+ r"""
+sub_(other, *, alpha=1) -> Tensor
+
+In-place version of :meth:`~Tensor.sub`
+""",
+)
+
+add_docstr_all(
+ "subtract",
+ r"""
+subtract(other, *, alpha=1) -> Tensor
+
+See :func:`torch.subtract`.
+""",
+)
+
+add_docstr_all(
+ "subtract_",
+ r"""
+subtract_(other, *, alpha=1) -> Tensor
+
+In-place version of :meth:`~Tensor.subtract`.
+""",
+)
+
+add_docstr_all(
+ "sum",
+ r"""
+sum(dim=None, keepdim=False, dtype=None) -> Tensor
+
+See :func:`torch.sum`
+""",
+)
+
+add_docstr_all(
+ "nansum",
+ r"""
+nansum(dim=None, keepdim=False, dtype=None) -> Tensor
+
+See :func:`torch.nansum`
+""",
+)
+
+add_docstr_all(
+ "svd",
+ r"""
+svd(some=True, compute_uv=True) -> (Tensor, Tensor, Tensor)
+
+See :func:`torch.svd`
+""",
+)
+
+add_docstr_all(
+ "swapdims",
+ r"""
+swapdims(dim0, dim1) -> Tensor
+
+See :func:`torch.swapdims`
+""",
+)
+
+add_docstr_all(
+ "swapdims_",
+ r"""
+swapdims_(dim0, dim1) -> Tensor
+
+In-place version of :meth:`~Tensor.swapdims`
+""",
+)
+
+add_docstr_all(
+ "swapaxes",
+ r"""
+swapaxes(axis0, axis1) -> Tensor
+
+See :func:`torch.swapaxes`
+""",
+)
+
+add_docstr_all(
+ "swapaxes_",
+ r"""
+swapaxes_(axis0, axis1) -> Tensor
+
+In-place version of :meth:`~Tensor.swapaxes`
+""",
+)
+
+add_docstr_all(
+ "t",
+ r"""
+t() -> Tensor
+
+See :func:`torch.t`
+""",
+)
+
+add_docstr_all(
+ "t_",
+ r"""
+t_() -> Tensor
+
+In-place version of :meth:`~Tensor.t`
+""",
+)
+
+add_docstr_all(
+ "tile",
+ r"""
+tile(dims) -> Tensor
+
+See :func:`torch.tile`
+""",
+)
+
+add_docstr_all(
+ "to",
+ r"""
+to(*args, **kwargs) -> Tensor
+
+Performs Tensor dtype and/or device conversion. A :class:`torch.dtype` and :class:`torch.device` are
+inferred from the arguments of ``self.to(*args, **kwargs)``.
+
+.. note::
+
+ If the ``self`` Tensor already
+ has the correct :class:`torch.dtype` and :class:`torch.device`, then ``self`` is returned.
+ Otherwise, the returned tensor is a copy of ``self`` with the desired
+ :class:`torch.dtype` and :class:`torch.device`.
+
+Here are the ways to call ``to``:
+
+.. method:: to(dtype, non_blocking=False, copy=False, memory_format=torch.preserve_format) -> Tensor
+ :noindex:
+
+ Returns a Tensor with the specified :attr:`dtype`
+
+ Args:
+ {memory_format}
+
+.. method:: to(device=None, dtype=None, non_blocking=False, copy=False, memory_format=torch.preserve_format) -> Tensor
+ :noindex:
+
+ Returns a Tensor with the specified :attr:`device` and (optional)
+ :attr:`dtype`. If :attr:`dtype` is ``None`` it is inferred to be ``self.dtype``.
+ When :attr:`non_blocking`, tries to convert asynchronously with respect to
+ the host if possible, e.g., converting a CPU Tensor with pinned memory to a
+ CUDA Tensor.
+ When :attr:`copy` is set, a new Tensor is created even when the Tensor
+ already matches the desired conversion.
+
+ Args:
+ {memory_format}
+
+.. method:: to(other, non_blocking=False, copy=False) -> Tensor
+ :noindex:
+
+ Returns a Tensor with same :class:`torch.dtype` and :class:`torch.device` as
+ the Tensor :attr:`other`. When :attr:`non_blocking`, tries to convert
+ asynchronously with respect to the host if possible, e.g., converting a CPU
+ Tensor with pinned memory to a CUDA Tensor.
+ When :attr:`copy` is set, a new Tensor is created even when the Tensor
+ already matches the desired conversion.
+
+Example::
+
+ >>> tensor = torch.randn(2, 2) # Initially dtype=float32, device=cpu
+ >>> tensor.to(torch.float64)
+ tensor([[-0.5044, 0.0005],
+ [ 0.3310, -0.0584]], dtype=torch.float64)
+
+ >>> cuda0 = torch.device('cuda:0')
+ >>> tensor.to(cuda0)
+ tensor([[-0.5044, 0.0005],
+ [ 0.3310, -0.0584]], device='cuda:0')
+
+ >>> tensor.to(cuda0, dtype=torch.float64)
+ tensor([[-0.5044, 0.0005],
+ [ 0.3310, -0.0584]], dtype=torch.float64, device='cuda:0')
+
+ >>> other = torch.randn((), dtype=torch.float64, device=cuda0)
+ >>> tensor.to(other, non_blocking=True)
+ tensor([[-0.5044, 0.0005],
+ [ 0.3310, -0.0584]], dtype=torch.float64, device='cuda:0')
+""".format(
+ **common_args
+ ),
+)
+
+add_docstr_all(
+ "byte",
+ r"""
+byte(memory_format=torch.preserve_format) -> Tensor
+
+``self.byte()`` is equivalent to ``self.to(torch.uint8)``. See :func:`to`.
+
+Args:
+ {memory_format}
+""".format(
+ **common_args
+ ),
+)
+
+add_docstr_all(
+ "bool",
+ r"""
+bool(memory_format=torch.preserve_format) -> Tensor
+
+``self.bool()`` is equivalent to ``self.to(torch.bool)``. See :func:`to`.
+
+Args:
+ {memory_format}
+""".format(
+ **common_args
+ ),
+)
+
+add_docstr_all(
+ "char",
+ r"""
+char(memory_format=torch.preserve_format) -> Tensor
+
+``self.char()`` is equivalent to ``self.to(torch.int8)``. See :func:`to`.
+
+Args:
+ {memory_format}
+""".format(
+ **common_args
+ ),
+)
+
+add_docstr_all(
+ "bfloat16",
+ r"""
+bfloat16(memory_format=torch.preserve_format) -> Tensor
+``self.bfloat16()`` is equivalent to ``self.to(torch.bfloat16)``. See :func:`to`.
+
+Args:
+ {memory_format}
+""".format(
+ **common_args
+ ),
+)
+
+add_docstr_all(
+ "double",
+ r"""
+double(memory_format=torch.preserve_format) -> Tensor
+
+``self.double()`` is equivalent to ``self.to(torch.float64)``. See :func:`to`.
+
+Args:
+ {memory_format}
+""".format(
+ **common_args
+ ),
+)
+
+add_docstr_all(
+ "float",
+ r"""
+float(memory_format=torch.preserve_format) -> Tensor
+
+``self.float()`` is equivalent to ``self.to(torch.float32)``. See :func:`to`.
+
+Args:
+ {memory_format}
+""".format(
+ **common_args
+ ),
+)
+
+add_docstr_all(
+ "cdouble",
+ r"""
+cdouble(memory_format=torch.preserve_format) -> Tensor
+
+``self.cdouble()`` is equivalent to ``self.to(torch.complex128)``. See :func:`to`.
+
+Args:
+ {memory_format}
+""".format(
+ **common_args
+ ),
+)
+
+add_docstr_all(
+ "cfloat",
+ r"""
+cfloat(memory_format=torch.preserve_format) -> Tensor
+
+``self.cfloat()`` is equivalent to ``self.to(torch.complex64)``. See :func:`to`.
+
+Args:
+ {memory_format}
+""".format(
+ **common_args
+ ),
+)
+
+add_docstr_all(
+ "chalf",
+ r"""
+chalf(memory_format=torch.preserve_format) -> Tensor
+
+``self.chalf()`` is equivalent to ``self.to(torch.complex32)``. See :func:`to`.
+
+Args:
+ {memory_format}
+ """.format(
+ **common_args
+ ),
+)
+
+add_docstr_all(
+ "half",
+ r"""
+half(memory_format=torch.preserve_format) -> Tensor
+
+``self.half()`` is equivalent to ``self.to(torch.float16)``. See :func:`to`.
+
+Args:
+ {memory_format}
+""".format(
+ **common_args
+ ),
+)
+
+add_docstr_all(
+ "int",
+ r"""
+int(memory_format=torch.preserve_format) -> Tensor
+
+``self.int()`` is equivalent to ``self.to(torch.int32)``. See :func:`to`.
+
+Args:
+ {memory_format}
+""".format(
+ **common_args
+ ),
+)
+
+add_docstr_all(
+ "int_repr",
+ r"""
+int_repr() -> Tensor
+
+Given a quantized Tensor,
+``self.int_repr()`` returns a CPU Tensor with uint8_t as data type that stores the
+underlying uint8_t values of the given Tensor.
+""",
+)
+
+
+add_docstr_all(
+ "long",
+ r"""
+long(memory_format=torch.preserve_format) -> Tensor
+
+``self.long()`` is equivalent to ``self.to(torch.int64)``. See :func:`to`.
+
+Args:
+ {memory_format}
+""".format(
+ **common_args
+ ),
+)
+
+add_docstr_all(
+ "short",
+ r"""
+short(memory_format=torch.preserve_format) -> Tensor
+
+``self.short()`` is equivalent to ``self.to(torch.int16)``. See :func:`to`.
+
+Args:
+ {memory_format}
+""".format(
+ **common_args
+ ),
+)
+
+add_docstr_all(
+ "take",
+ r"""
+take(indices) -> Tensor
+
+See :func:`torch.take`
+""",
+)
+
+add_docstr_all(
+ "take_along_dim",
+ r"""
+take_along_dim(indices, dim) -> Tensor
+
+See :func:`torch.take_along_dim`
+""",
+)
+
+add_docstr_all(
+ "tan",
+ r"""
+tan() -> Tensor
+
+See :func:`torch.tan`
+""",
+)
+
+add_docstr_all(
+ "tan_",
+ r"""
+tan_() -> Tensor
+
+In-place version of :meth:`~Tensor.tan`
+""",
+)
+
+add_docstr_all(
+ "tanh",
+ r"""
+tanh() -> Tensor
+
+See :func:`torch.tanh`
+""",
+)
+
+add_docstr_all(
+ "softmax",
+ r"""
+softmax(dim) -> Tensor
+
+Alias for :func:`torch.nn.functional.softmax`.
+""",
+)
+
+add_docstr_all(
+ "tanh_",
+ r"""
+tanh_() -> Tensor
+
+In-place version of :meth:`~Tensor.tanh`
+""",
+)
+
+add_docstr_all(
+ "tolist",
+ r"""
+tolist() -> list or number
+
+Returns the tensor as a (nested) list. For scalars, a standard
+Python number is returned, just like with :meth:`~Tensor.item`.
+Tensors are automatically moved to the CPU first if necessary.
+
+This operation is not differentiable.
+
+Examples::
+
+ >>> a = torch.randn(2, 2)
+ >>> a.tolist()
+ [[0.012766935862600803, 0.5415473580360413],
+ [-0.08909505605697632, 0.7729271650314331]]
+ >>> a[0,0].tolist()
+ 0.012766935862600803
+""",
+)
+
+add_docstr_all(
+ "topk",
+ r"""
+topk(k, dim=None, largest=True, sorted=True) -> (Tensor, LongTensor)
+
+See :func:`torch.topk`
+""",
+)
+
+add_docstr_all(
+ "to_dense",
+ r"""
+to_dense(dtype=None, *, masked_grad=True) -> Tensor
+
+Creates a strided copy of :attr:`self` if :attr:`self` is not a strided tensor, otherwise returns :attr:`self`.
+
+Keyword args:
+ {dtype}
+ masked_grad (bool, optional): If set to ``True`` (default) and
+ :attr:`self` has a sparse layout then the backward of
+ :meth:`to_dense` returns ``grad.sparse_mask(self)``.
+
+Example::
+
+ >>> s = torch.sparse_coo_tensor(
+ ... torch.tensor([[1, 1],
+ ... [0, 2]]),
+ ... torch.tensor([9, 10]),
+ ... size=(3, 3))
+ >>> s.to_dense()
+ tensor([[ 0, 0, 0],
+ [ 9, 0, 10],
+ [ 0, 0, 0]])
+""",
+)
+
+add_docstr_all(
+ "to_sparse",
+ r"""
+to_sparse(sparseDims) -> Tensor
+
+Returns a sparse copy of the tensor. PyTorch supports sparse tensors in
+:ref:`coordinate format `.
+
+Args:
+ sparseDims (int, optional): the number of sparse dimensions to include in the new sparse tensor
+
+Example::
+
+ >>> d = torch.tensor([[0, 0, 0], [9, 0, 10], [0, 0, 0]])
+ >>> d
+ tensor([[ 0, 0, 0],
+ [ 9, 0, 10],
+ [ 0, 0, 0]])
+ >>> d.to_sparse()
+ tensor(indices=tensor([[1, 1],
+ [0, 2]]),
+ values=tensor([ 9, 10]),
+ size=(3, 3), nnz=2, layout=torch.sparse_coo)
+ >>> d.to_sparse(1)
+ tensor(indices=tensor([[1]]),
+ values=tensor([[ 9, 0, 10]]),
+ size=(3, 3), nnz=1, layout=torch.sparse_coo)
+
+.. method:: to_sparse(*, layout=None, blocksize=None, dense_dim=None) -> Tensor
+ :noindex:
+
+Returns a sparse tensor with the specified layout and blocksize. If
+the :attr:`self` is strided, the number of dense dimensions could be
+specified, and a hybrid sparse tensor will be created, with
+`dense_dim` dense dimensions and `self.dim() - 2 - dense_dim` batch
+dimension.
+
+.. note:: If the :attr:`self` layout and blocksize parameters match
+ with the specified layout and blocksize, return
+ :attr:`self`. Otherwise, return a sparse tensor copy of
+ :attr:`self`.
+
+Args:
+
+ layout (:class:`torch.layout`, optional): The desired sparse
+ layout. One of ``torch.sparse_coo``, ``torch.sparse_csr``,
+ ``torch.sparse_csc``, ``torch.sparse_bsr``, or
+ ``torch.sparse_bsc``. Default: if ``None``,
+ ``torch.sparse_coo``.
+
+ blocksize (list, tuple, :class:`torch.Size`, optional): Block size
+ of the resulting BSR or BSC tensor. For other layouts,
+ specifying the block size that is not ``None`` will result in a
+ RuntimeError exception. A block size must be a tuple of length
+ two such that its items evenly divide the two sparse dimensions.
+
+ dense_dim (int, optional): Number of dense dimensions of the
+ resulting CSR, CSC, BSR or BSC tensor. This argument should be
+ used only if :attr:`self` is a strided tensor, and must be a
+ value between 0 and dimension of :attr:`self` tensor minus two.
+
+Example::
+
+ >>> x = torch.tensor([[1, 0], [0, 0], [2, 3]])
+ >>> x.to_sparse(layout=torch.sparse_coo)
+ tensor(indices=tensor([[0, 2, 2],
+ [0, 0, 1]]),
+ values=tensor([1, 2, 3]),
+ size=(3, 2), nnz=3, layout=torch.sparse_coo)
+ >>> x.to_sparse(layout=torch.sparse_bsr, blocksize=(1, 2))
+ tensor(crow_indices=tensor([0, 1, 1, 2]),
+ col_indices=tensor([0, 0]),
+ values=tensor([[[1, 0]],
+ [[2, 3]]]), size=(3, 2), nnz=2, layout=torch.sparse_bsr)
+ >>> x.to_sparse(layout=torch.sparse_bsr, blocksize=(2, 1))
+ RuntimeError: Tensor size(-2) 3 needs to be divisible by blocksize[0] 2
+ >>> x.to_sparse(layout=torch.sparse_csr, blocksize=(3, 1))
+ RuntimeError: to_sparse for Strided to SparseCsr conversion does not use specified blocksize
+
+ >>> x = torch.tensor([[[1], [0]], [[0], [0]], [[2], [3]]])
+ >>> x.to_sparse(layout=torch.sparse_csr, dense_dim=1)
+ tensor(crow_indices=tensor([0, 1, 1, 3]),
+ col_indices=tensor([0, 0, 1]),
+ values=tensor([[1],
+ [2],
+ [3]]), size=(3, 2, 1), nnz=3, layout=torch.sparse_csr)
+
+""",
+)
+
+add_docstr_all(
+ "to_sparse_csr",
+ r"""
+to_sparse_csr(dense_dim=None) -> Tensor
+
+Convert a tensor to compressed row storage format (CSR). Except for
+strided tensors, only works with 2D tensors. If the :attr:`self` is
+strided, then the number of dense dimensions could be specified, and a
+hybrid CSR tensor will be created, with `dense_dim` dense dimensions
+and `self.dim() - 2 - dense_dim` batch dimension.
+
+Args:
+
+ dense_dim (int, optional): Number of dense dimensions of the
+ resulting CSR tensor. This argument should be used only if
+ :attr:`self` is a strided tensor, and must be a value between 0
+ and dimension of :attr:`self` tensor minus two.
+
+Example::
+
+ >>> dense = torch.randn(5, 5)
+ >>> sparse = dense.to_sparse_csr()
+ >>> sparse._nnz()
+ 25
+
+ >>> dense = torch.zeros(3, 3, 1, 1)
+ >>> dense[0, 0] = dense[1, 2] = dense[2, 1] = 1
+ >>> dense.to_sparse_csr(dense_dim=2)
+ tensor(crow_indices=tensor([0, 1, 2, 3]),
+ col_indices=tensor([0, 2, 1]),
+ values=tensor([[[1.]],
+
+ [[1.]],
+
+ [[1.]]]), size=(3, 3, 1, 1), nnz=3,
+ layout=torch.sparse_csr)
+
+""",
+)
+
+add_docstr_all(
+ "to_sparse_csc",
+ r"""
+to_sparse_csc() -> Tensor
+
+Convert a tensor to compressed column storage (CSC) format. Except
+for strided tensors, only works with 2D tensors. If the :attr:`self`
+is strided, then the number of dense dimensions could be specified,
+and a hybrid CSC tensor will be created, with `dense_dim` dense
+dimensions and `self.dim() - 2 - dense_dim` batch dimension.
+
+Args:
+
+ dense_dim (int, optional): Number of dense dimensions of the
+ resulting CSC tensor. This argument should be used only if
+ :attr:`self` is a strided tensor, and must be a value between 0
+ and dimension of :attr:`self` tensor minus two.
+
+Example::
+
+ >>> dense = torch.randn(5, 5)
+ >>> sparse = dense.to_sparse_csc()
+ >>> sparse._nnz()
+ 25
+
+ >>> dense = torch.zeros(3, 3, 1, 1)
+ >>> dense[0, 0] = dense[1, 2] = dense[2, 1] = 1
+ >>> dense.to_sparse_csc(dense_dim=2)
+ tensor(ccol_indices=tensor([0, 1, 2, 3]),
+ row_indices=tensor([0, 2, 1]),
+ values=tensor([[[1.]],
+
+ [[1.]],
+
+ [[1.]]]), size=(3, 3, 1, 1), nnz=3,
+ layout=torch.sparse_csc)
+
+""",
+)
+
+add_docstr_all(
+ "to_sparse_bsr",
+ r"""
+to_sparse_bsr(blocksize, dense_dim) -> Tensor
+
+Convert a tensor to a block sparse row (BSR) storage format of given
+blocksize. If the :attr:`self` is strided, then the number of dense
+dimensions could be specified, and a hybrid BSR tensor will be
+created, with `dense_dim` dense dimensions and `self.dim() - 2 -
+dense_dim` batch dimension.
+
+Args:
+
+ blocksize (list, tuple, :class:`torch.Size`, optional): Block size
+ of the resulting BSR tensor. A block size must be a tuple of
+ length two such that its items evenly divide the two sparse
+ dimensions.
+
+ dense_dim (int, optional): Number of dense dimensions of the
+ resulting BSR tensor. This argument should be used only if
+ :attr:`self` is a strided tensor, and must be a value between 0
+ and dimension of :attr:`self` tensor minus two.
+
+Example::
+
+ >>> dense = torch.randn(10, 10)
+ >>> sparse = dense.to_sparse_csr()
+ >>> sparse_bsr = sparse.to_sparse_bsr((5, 5))
+ >>> sparse_bsr.col_indices()
+ tensor([0, 1, 0, 1])
+
+ >>> dense = torch.zeros(4, 3, 1)
+ >>> dense[0:2, 0] = dense[0:2, 2] = dense[2:4, 1] = 1
+ >>> dense.to_sparse_bsr((2, 1), 1)
+ tensor(crow_indices=tensor([0, 2, 3]),
+ col_indices=tensor([0, 2, 1]),
+ values=tensor([[[[1.]],
+
+ [[1.]]],
+
+
+ [[[1.]],
+
+ [[1.]]],
+
+
+ [[[1.]],
+
+ [[1.]]]]), size=(4, 3, 1), nnz=3,
+ layout=torch.sparse_bsr)
+
+""",
+)
+
+add_docstr_all(
+ "to_sparse_bsc",
+ r"""
+to_sparse_bsc(blocksize, dense_dim) -> Tensor
+
+Convert a tensor to a block sparse column (BSC) storage format of
+given blocksize. If the :attr:`self` is strided, then the number of
+dense dimensions could be specified, and a hybrid BSC tensor will be
+created, with `dense_dim` dense dimensions and `self.dim() - 2 -
+dense_dim` batch dimension.
+
+Args:
+
+ blocksize (list, tuple, :class:`torch.Size`, optional): Block size
+ of the resulting BSC tensor. A block size must be a tuple of
+ length two such that its items evenly divide the two sparse
+ dimensions.
+
+ dense_dim (int, optional): Number of dense dimensions of the
+ resulting BSC tensor. This argument should be used only if
+ :attr:`self` is a strided tensor, and must be a value between 0
+ and dimension of :attr:`self` tensor minus two.
+
+Example::
+
+ >>> dense = torch.randn(10, 10)
+ >>> sparse = dense.to_sparse_csr()
+ >>> sparse_bsc = sparse.to_sparse_bsc((5, 5))
+ >>> sparse_bsc.row_indices()
+ tensor([0, 1, 0, 1])
+
+ >>> dense = torch.zeros(4, 3, 1)
+ >>> dense[0:2, 0] = dense[0:2, 2] = dense[2:4, 1] = 1
+ >>> dense.to_sparse_bsc((2, 1), 1)
+ tensor(ccol_indices=tensor([0, 1, 2, 3]),
+ row_indices=tensor([0, 1, 0]),
+ values=tensor([[[[1.]],
+
+ [[1.]]],
+
+
+ [[[1.]],
+
+ [[1.]]],
+
+
+ [[[1.]],
+
+ [[1.]]]]), size=(4, 3, 1), nnz=3,
+ layout=torch.sparse_bsc)
+
+""",
+)
+
+add_docstr_all(
+ "to_mkldnn",
+ r"""
+to_mkldnn() -> Tensor
+Returns a copy of the tensor in ``torch.mkldnn`` layout.
+
+""",
+)
+
+add_docstr_all(
+ "trace",
+ r"""
+trace() -> Tensor
+
+See :func:`torch.trace`
+""",
+)
+
+add_docstr_all(
+ "transpose",
+ r"""
+transpose(dim0, dim1) -> Tensor
+
+See :func:`torch.transpose`
+""",
+)
+
+add_docstr_all(
+ "transpose_",
+ r"""
+transpose_(dim0, dim1) -> Tensor
+
+In-place version of :meth:`~Tensor.transpose`
+""",
+)
+
+add_docstr_all(
+ "triangular_solve",
+ r"""
+triangular_solve(A, upper=True, transpose=False, unitriangular=False) -> (Tensor, Tensor)
+
+See :func:`torch.triangular_solve`
+""",
+)
+
+add_docstr_all(
+ "tril",
+ r"""
+tril(diagonal=0) -> Tensor
+
+See :func:`torch.tril`
+""",
+)
+
+add_docstr_all(
+ "tril_",
+ r"""
+tril_(diagonal=0) -> Tensor
+
+In-place version of :meth:`~Tensor.tril`
+""",
+)
+
+add_docstr_all(
+ "triu",
+ r"""
+triu(diagonal=0) -> Tensor
+
+See :func:`torch.triu`
+""",
+)
+
+add_docstr_all(
+ "triu_",
+ r"""
+triu_(diagonal=0) -> Tensor
+
+In-place version of :meth:`~Tensor.triu`
+""",
+)
+
+add_docstr_all(
+ "true_divide",
+ r"""
+true_divide(value) -> Tensor
+
+See :func:`torch.true_divide`
+""",
+)
+
+add_docstr_all(
+ "true_divide_",
+ r"""
+true_divide_(value) -> Tensor
+
+In-place version of :meth:`~Tensor.true_divide_`
+""",
+)
+
+add_docstr_all(
+ "trunc",
+ r"""
+trunc() -> Tensor
+
+See :func:`torch.trunc`
+""",
+)
+
+add_docstr_all(
+ "fix",
+ r"""
+fix() -> Tensor
+
+See :func:`torch.fix`.
+""",
+)
+
+add_docstr_all(
+ "trunc_",
+ r"""
+trunc_() -> Tensor
+
+In-place version of :meth:`~Tensor.trunc`
+""",
+)
+
+add_docstr_all(
+ "fix_",
+ r"""
+fix_() -> Tensor
+
+In-place version of :meth:`~Tensor.fix`
+""",
+)
+
+add_docstr_all(
+ "type",
+ r"""
+type(dtype=None, non_blocking=False, **kwargs) -> str or Tensor
+Returns the type if `dtype` is not provided, else casts this object to
+the specified type.
+
+If this is already of the correct type, no copy is performed and the
+original object is returned.
+
+Args:
+ dtype (dtype or string): The desired type
+ non_blocking (bool): If ``True``, and the source is in pinned memory
+ and destination is on the GPU or vice versa, the copy is performed
+ asynchronously with respect to the host. Otherwise, the argument
+ has no effect.
+ **kwargs: For compatibility, may contain the key ``async`` in place of
+ the ``non_blocking`` argument. The ``async`` arg is deprecated.
+""",
+)
+
+add_docstr_all(
+ "type_as",
+ r"""
+type_as(tensor) -> Tensor
+
+Returns this tensor cast to the type of the given tensor.
+
+This is a no-op if the tensor is already of the correct type. This is
+equivalent to ``self.type(tensor.type())``
+
+Args:
+ tensor (Tensor): the tensor which has the desired type
+""",
+)
+
+add_docstr_all(
+ "unfold",
+ r"""
+unfold(dimension, size, step) -> Tensor
+
+Returns a view of the original tensor which contains all slices of size :attr:`size` from
+:attr:`self` tensor in the dimension :attr:`dimension`.
+
+Step between two slices is given by :attr:`step`.
+
+If `sizedim` is the size of dimension :attr:`dimension` for :attr:`self`, the size of
+dimension :attr:`dimension` in the returned tensor will be
+`(sizedim - size) / step + 1`.
+
+An additional dimension of size :attr:`size` is appended in the returned tensor.
+
+Args:
+ dimension (int): dimension in which unfolding happens
+ size (int): the size of each slice that is unfolded
+ step (int): the step between each slice
+
+Example::
+
+ >>> x = torch.arange(1., 8)
+ >>> x
+ tensor([ 1., 2., 3., 4., 5., 6., 7.])
+ >>> x.unfold(0, 2, 1)
+ tensor([[ 1., 2.],
+ [ 2., 3.],
+ [ 3., 4.],
+ [ 4., 5.],
+ [ 5., 6.],
+ [ 6., 7.]])
+ >>> x.unfold(0, 2, 2)
+ tensor([[ 1., 2.],
+ [ 3., 4.],
+ [ 5., 6.]])
+""",
+)
+
+add_docstr_all(
+ "uniform_",
+ r"""
+uniform_(from=0, to=1, *, generator=None) -> Tensor
+
+Fills :attr:`self` tensor with numbers sampled from the continuous uniform
+distribution:
+
+.. math::
+ f(x) = \dfrac{1}{\text{to} - \text{from}}
+""",
+)
+
+add_docstr_all(
+ "unsqueeze",
+ r"""
+unsqueeze(dim) -> Tensor
+
+See :func:`torch.unsqueeze`
+""",
+)
+
+add_docstr_all(
+ "unsqueeze_",
+ r"""
+unsqueeze_(dim) -> Tensor
+
+In-place version of :meth:`~Tensor.unsqueeze`
+""",
+)
+
+add_docstr_all(
+ "var",
+ r"""
+var(dim=None, *, correction=1, keepdim=False) -> Tensor
+
+See :func:`torch.var`
+""",
+)
+
+add_docstr_all(
+ "vdot",
+ r"""
+vdot(other) -> Tensor
+
+See :func:`torch.vdot`
+""",
+)
+
+add_docstr_all(
+ "view",
+ r"""
+view(*shape) -> Tensor
+
+Returns a new tensor with the same data as the :attr:`self` tensor but of a
+different :attr:`shape`.
+
+The returned tensor shares the same data and must have the same number
+of elements, but may have a different size. For a tensor to be viewed, the new
+view size must be compatible with its original size and stride, i.e., each new
+view dimension must either be a subspace of an original dimension, or only span
+across original dimensions :math:`d, d+1, \dots, d+k` that satisfy the following
+contiguity-like condition that :math:`\forall i = d, \dots, d+k-1`,
+
+.. math::
+
+ \text{stride}[i] = \text{stride}[i+1] \times \text{size}[i+1]
+
+Otherwise, it will not be possible to view :attr:`self` tensor as :attr:`shape`
+without copying it (e.g., via :meth:`contiguous`). When it is unclear whether a
+:meth:`view` can be performed, it is advisable to use :meth:`reshape`, which
+returns a view if the shapes are compatible, and copies (equivalent to calling
+:meth:`contiguous`) otherwise.
+
+Args:
+ shape (torch.Size or int...): the desired size
+
+Example::
+
+ >>> x = torch.randn(4, 4)
+ >>> x.size()
+ torch.Size([4, 4])
+ >>> y = x.view(16)
+ >>> y.size()
+ torch.Size([16])
+ >>> z = x.view(-1, 8) # the size -1 is inferred from other dimensions
+ >>> z.size()
+ torch.Size([2, 8])
+
+ >>> a = torch.randn(1, 2, 3, 4)
+ >>> a.size()
+ torch.Size([1, 2, 3, 4])
+ >>> b = a.transpose(1, 2) # Swaps 2nd and 3rd dimension
+ >>> b.size()
+ torch.Size([1, 3, 2, 4])
+ >>> c = a.view(1, 3, 2, 4) # Does not change tensor layout in memory
+ >>> c.size()
+ torch.Size([1, 3, 2, 4])
+ >>> torch.equal(b, c)
+ False
+
+
+.. method:: view(dtype) -> Tensor
+ :noindex:
+
+Returns a new tensor with the same data as the :attr:`self` tensor but of a
+different :attr:`dtype`.
+
+If the element size of :attr:`dtype` is different than that of ``self.dtype``,
+then the size of the last dimension of the output will be scaled
+proportionally. For instance, if :attr:`dtype` element size is twice that of
+``self.dtype``, then each pair of elements in the last dimension of
+:attr:`self` will be combined, and the size of the last dimension of the output
+will be half that of :attr:`self`. If :attr:`dtype` element size is half that
+of ``self.dtype``, then each element in the last dimension of :attr:`self` will
+be split in two, and the size of the last dimension of the output will be
+double that of :attr:`self`. For this to be possible, the following conditions
+must be true:
+
+ * ``self.dim()`` must be greater than 0.
+ * ``self.stride(-1)`` must be 1.
+
+Additionally, if the element size of :attr:`dtype` is greater than that of
+``self.dtype``, the following conditions must be true as well:
+
+ * ``self.size(-1)`` must be divisible by the ratio between the element
+ sizes of the dtypes.
+ * ``self.storage_offset()`` must be divisible by the ratio between the
+ element sizes of the dtypes.
+ * The strides of all dimensions, except the last dimension, must be
+ divisible by the ratio between the element sizes of the dtypes.
+
+If any of the above conditions are not met, an error is thrown.
+
+.. warning::
+
+ This overload is not supported by TorchScript, and using it in a Torchscript
+ program will cause undefined behavior.
+
+
+Args:
+ dtype (:class:`torch.dtype`): the desired dtype
+
+Example::
+
+ >>> x = torch.randn(4, 4)
+ >>> x
+ tensor([[ 0.9482, -0.0310, 1.4999, -0.5316],
+ [-0.1520, 0.7472, 0.5617, -0.8649],
+ [-2.4724, -0.0334, -0.2976, -0.8499],
+ [-0.2109, 1.9913, -0.9607, -0.6123]])
+ >>> x.dtype
+ torch.float32
+
+ >>> y = x.view(torch.int32)
+ >>> y
+ tensor([[ 1064483442, -1124191867, 1069546515, -1089989247],
+ [-1105482831, 1061112040, 1057999968, -1084397505],
+ [-1071760287, -1123489973, -1097310419, -1084649136],
+ [-1101533110, 1073668768, -1082790149, -1088634448]],
+ dtype=torch.int32)
+ >>> y[0, 0] = 1000000000
+ >>> x
+ tensor([[ 0.0047, -0.0310, 1.4999, -0.5316],
+ [-0.1520, 0.7472, 0.5617, -0.8649],
+ [-2.4724, -0.0334, -0.2976, -0.8499],
+ [-0.2109, 1.9913, -0.9607, -0.6123]])
+
+ >>> x.view(torch.cfloat)
+ tensor([[ 0.0047-0.0310j, 1.4999-0.5316j],
+ [-0.1520+0.7472j, 0.5617-0.8649j],
+ [-2.4724-0.0334j, -0.2976-0.8499j],
+ [-0.2109+1.9913j, -0.9607-0.6123j]])
+ >>> x.view(torch.cfloat).size()
+ torch.Size([4, 2])
+
+ >>> x.view(torch.uint8)
+ tensor([[ 0, 202, 154, 59, 182, 243, 253, 188, 185, 252, 191, 63, 240, 22,
+ 8, 191],
+ [227, 165, 27, 190, 128, 72, 63, 63, 146, 203, 15, 63, 22, 106,
+ 93, 191],
+ [205, 59, 30, 192, 112, 206, 8, 189, 7, 95, 152, 190, 12, 147,
+ 89, 191],
+ [ 43, 246, 87, 190, 235, 226, 254, 63, 111, 240, 117, 191, 177, 191,
+ 28, 191]], dtype=torch.uint8)
+ >>> x.view(torch.uint8).size()
+ torch.Size([4, 16])
+""",
+)
+
+add_docstr_all(
+ "view_as",
+ r"""
+view_as(other) -> Tensor
+
+View this tensor as the same size as :attr:`other`.
+``self.view_as(other)`` is equivalent to ``self.view(other.size())``.
+
+Please see :meth:`~Tensor.view` for more information about ``view``.
+
+Args:
+ other (:class:`torch.Tensor`): The result tensor has the same size
+ as :attr:`other`.
+""",
+)
+
+add_docstr_all(
+ "expand",
+ r"""
+expand(*sizes) -> Tensor
+
+Returns a new view of the :attr:`self` tensor with singleton dimensions expanded
+to a larger size.
+
+Passing -1 as the size for a dimension means not changing the size of
+that dimension.
+
+Tensor can be also expanded to a larger number of dimensions, and the
+new ones will be appended at the front. For the new dimensions, the
+size cannot be set to -1.
+
+Expanding a tensor does not allocate new memory, but only creates a
+new view on the existing tensor where a dimension of size one is
+expanded to a larger size by setting the ``stride`` to 0. Any dimension
+of size 1 can be expanded to an arbitrary value without allocating new
+memory.
+
+Args:
+ *sizes (torch.Size or int...): the desired expanded size
+
+.. warning::
+
+ More than one element of an expanded tensor may refer to a single
+ memory location. As a result, in-place operations (especially ones that
+ are vectorized) may result in incorrect behavior. If you need to write
+ to the tensors, please clone them first.
+
+Example::
+
+ >>> x = torch.tensor([[1], [2], [3]])
+ >>> x.size()
+ torch.Size([3, 1])
+ >>> x.expand(3, 4)
+ tensor([[ 1, 1, 1, 1],
+ [ 2, 2, 2, 2],
+ [ 3, 3, 3, 3]])
+ >>> x.expand(-1, 4) # -1 means not changing the size of that dimension
+ tensor([[ 1, 1, 1, 1],
+ [ 2, 2, 2, 2],
+ [ 3, 3, 3, 3]])
+""",
+)
+
+add_docstr_all(
+ "expand_as",
+ r"""
+expand_as(other) -> Tensor
+
+Expand this tensor to the same size as :attr:`other`.
+``self.expand_as(other)`` is equivalent to ``self.expand(other.size())``.
+
+Please see :meth:`~Tensor.expand` for more information about ``expand``.
+
+Args:
+ other (:class:`torch.Tensor`): The result tensor has the same size
+ as :attr:`other`.
+""",
+)
+
+add_docstr_all(
+ "sum_to_size",
+ r"""
+sum_to_size(*size) -> Tensor
+
+Sum ``this`` tensor to :attr:`size`.
+:attr:`size` must be broadcastable to ``this`` tensor size.
+
+Args:
+ size (int...): a sequence of integers defining the shape of the output tensor.
+""",
+)
+
+
+add_docstr_all(
+ "zero_",
+ r"""
+zero_() -> Tensor
+
+Fills :attr:`self` tensor with zeros.
+""",
+)
+
+add_docstr_all(
+ "matmul",
+ r"""
+matmul(tensor2) -> Tensor
+
+See :func:`torch.matmul`
+""",
+)
+
+add_docstr_all(
+ "chunk",
+ r"""
+chunk(chunks, dim=0) -> List of Tensors
+
+See :func:`torch.chunk`
+""",
+)
+
+add_docstr_all(
+ "unsafe_chunk",
+ r"""
+unsafe_chunk(chunks, dim=0) -> List of Tensors
+
+See :func:`torch.unsafe_chunk`
+""",
+)
+
+add_docstr_all(
+ "unsafe_split",
+ r"""
+unsafe_split(split_size, dim=0) -> List of Tensors
+
+See :func:`torch.unsafe_split`
+""",
+)
+
+add_docstr_all(
+ "tensor_split",
+ r"""
+tensor_split(indices_or_sections, dim=0) -> List of Tensors
+
+See :func:`torch.tensor_split`
+""",
+)
+
+add_docstr_all(
+ "hsplit",
+ r"""
+hsplit(split_size_or_sections) -> List of Tensors
+
+See :func:`torch.hsplit`
+""",
+)
+
+add_docstr_all(
+ "vsplit",
+ r"""
+vsplit(split_size_or_sections) -> List of Tensors
+
+See :func:`torch.vsplit`
+""",
+)
+
+add_docstr_all(
+ "dsplit",
+ r"""
+dsplit(split_size_or_sections) -> List of Tensors
+
+See :func:`torch.dsplit`
+""",
+)
+
+add_docstr_all(
+ "stft",
+ r"""
+stft(frame_length, hop, fft_size=None, return_onesided=True, window=None, pad_end=0) -> Tensor
+
+See :func:`torch.stft`
+""",
+)
+
+add_docstr_all(
+ "istft",
+ r"""
+istft(n_fft, hop_length=None, win_length=None, window=None,
+ center=True, normalized=False, onesided=True, length=None) -> Tensor
+
+See :func:`torch.istft`
+""",
+)
+
+add_docstr_all(
+ "det",
+ r"""
+det() -> Tensor
+
+See :func:`torch.det`
+""",
+)
+
+add_docstr_all(
+ "where",
+ r"""
+where(condition, y) -> Tensor
+
+``self.where(condition, y)`` is equivalent to ``torch.where(condition, self, y)``.
+See :func:`torch.where`
+""",
+)
+
+add_docstr_all(
+ "logdet",
+ r"""
+logdet() -> Tensor
+
+See :func:`torch.logdet`
+""",
+)
+
+add_docstr_all(
+ "slogdet",
+ r"""
+slogdet() -> (Tensor, Tensor)
+
+See :func:`torch.slogdet`
+""",
+)
+
+add_docstr_all(
+ "unbind",
+ r"""
+unbind(dim=0) -> seq
+
+See :func:`torch.unbind`
+""",
+)
+
+add_docstr_all(
+ "pin_memory",
+ r"""
+pin_memory() -> Tensor
+
+Copies the tensor to pinned memory, if it's not already pinned.
+""",
+)
+
+add_docstr_all(
+ "pinverse",
+ r"""
+pinverse() -> Tensor
+
+See :func:`torch.pinverse`
+""",
+)
+
+add_docstr_all(
+ "index_add",
+ r"""
+index_add(dim, index, source, *, alpha=1) -> Tensor
+
+Out-of-place version of :meth:`torch.Tensor.index_add_`.
+""",
+)
+
+add_docstr_all(
+ "index_copy",
+ r"""
+index_copy(dim, index, tensor2) -> Tensor
+
+Out-of-place version of :meth:`torch.Tensor.index_copy_`.
+""",
+)
+
+add_docstr_all(
+ "index_fill",
+ r"""
+index_fill(dim, index, value) -> Tensor
+
+Out-of-place version of :meth:`torch.Tensor.index_fill_`.
+""",
+)
+
+add_docstr_all(
+ "scatter",
+ r"""
+scatter(dim, index, src) -> Tensor
+
+Out-of-place version of :meth:`torch.Tensor.scatter_`
+""",
+)
+
+add_docstr_all(
+ "scatter_add",
+ r"""
+scatter_add(dim, index, src) -> Tensor
+
+Out-of-place version of :meth:`torch.Tensor.scatter_add_`
+""",
+)
+
+add_docstr_all(
+ "scatter_reduce",
+ r"""
+scatter_reduce(dim, index, src, reduce, *, include_self=True) -> Tensor
+
+Out-of-place version of :meth:`torch.Tensor.scatter_reduce_`
+""",
+)
+
+add_docstr_all(
+ "masked_scatter",
+ r"""
+masked_scatter(mask, tensor) -> Tensor
+
+Out-of-place version of :meth:`torch.Tensor.masked_scatter_`
+
+.. note::
+
+ The inputs :attr:`self` and :attr:`mask`
+ :ref:`broadcast `.
+
+Example:
+
+ >>> self = torch.tensor([0, 0, 0, 0, 0])
+ >>> mask = torch.tensor([[0, 0, 0, 1, 1], [1, 1, 0, 1, 1]])
+ >>> source = torch.tensor([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]])
+ >>> self.masked_scatter(mask, source)
+ tensor([[0, 0, 0, 0, 1],
+ [2, 3, 0, 4, 5]])
+
+""",
+)
+
+add_docstr_all(
+ "xlogy",
+ r"""
+xlogy(other) -> Tensor
+
+See :func:`torch.xlogy`
+""",
+)
+
+add_docstr_all(
+ "xlogy_",
+ r"""
+xlogy_(other) -> Tensor
+
+In-place version of :meth:`~Tensor.xlogy`
+""",
+)
+
+add_docstr_all(
+ "masked_fill",
+ r"""
+masked_fill(mask, value) -> Tensor
+
+Out-of-place version of :meth:`torch.Tensor.masked_fill_`
+""",
+)
+
+add_docstr_all(
+ "grad",
+ r"""
+This attribute is ``None`` by default and becomes a Tensor the first time a call to
+:func:`backward` computes gradients for ``self``.
+The attribute will then contain the gradients computed and future calls to
+:func:`backward` will accumulate (add) gradients into it.
+""",
+)
+
+add_docstr_all(
+ "retain_grad",
+ r"""
+retain_grad() -> None
+
+Enables this Tensor to have their :attr:`grad` populated during
+:func:`backward`. This is a no-op for leaf tensors.
+""",
+)
+
+add_docstr_all(
+ "retains_grad",
+ r"""
+Is ``True`` if this Tensor is non-leaf and its :attr:`grad` is enabled to be
+populated during :func:`backward`, ``False`` otherwise.
+""",
+)
+
+add_docstr_all(
+ "requires_grad",
+ r"""
+Is ``True`` if gradients need to be computed for this Tensor, ``False`` otherwise.
+
+.. note::
+
+ The fact that gradients need to be computed for a Tensor do not mean that the :attr:`grad`
+ attribute will be populated, see :attr:`is_leaf` for more details.
+
+""",
+)
+
+add_docstr_all(
+ "is_leaf",
+ r"""
+All Tensors that have :attr:`requires_grad` which is ``False`` will be leaf Tensors by convention.
+
+For Tensors that have :attr:`requires_grad` which is ``True``, they will be leaf Tensors if they were
+created by the user. This means that they are not the result of an operation and so
+:attr:`grad_fn` is None.
+
+Only leaf Tensors will have their :attr:`grad` populated during a call to :func:`backward`.
+To get :attr:`grad` populated for non-leaf Tensors, you can use :func:`retain_grad`.
+
+Example::
+
+ >>> a = torch.rand(10, requires_grad=True)
+ >>> a.is_leaf
+ True
+ >>> b = torch.rand(10, requires_grad=True).cuda()
+ >>> b.is_leaf
+ False
+ # b was created by the operation that cast a cpu Tensor into a cuda Tensor
+ >>> c = torch.rand(10, requires_grad=True) + 2
+ >>> c.is_leaf
+ False
+ # c was created by the addition operation
+ >>> d = torch.rand(10).cuda()
+ >>> d.is_leaf
+ True
+ # d does not require gradients and so has no operation creating it (that is tracked by the autograd engine)
+ >>> e = torch.rand(10).cuda().requires_grad_()
+ >>> e.is_leaf
+ True
+ # e requires gradients and has no operations creating it
+ >>> f = torch.rand(10, requires_grad=True, device="cuda")
+ >>> f.is_leaf
+ True
+ # f requires grad, has no operation creating it
+
+
+""",
+)
+
+add_docstr_all(
+ "names",
+ r"""
+Stores names for each of this tensor's dimensions.
+
+``names[idx]`` corresponds to the name of tensor dimension ``idx``.
+Names are either a string if the dimension is named or ``None`` if the
+dimension is unnamed.
+
+Dimension names may contain characters or underscore. Furthermore, a dimension
+name must be a valid Python variable name (i.e., does not start with underscore).
+
+Tensors may not have two named dimensions with the same name.
+
+.. warning::
+ The named tensor API is experimental and subject to change.
+
+""",
+)
+
+add_docstr_all(
+ "is_cuda",
+ r"""
+Is ``True`` if the Tensor is stored on the GPU, ``False`` otherwise.
+""",
+)
+
+add_docstr_all(
+ "is_cpu",
+ r"""
+Is ``True`` if the Tensor is stored on the CPU, ``False`` otherwise.
+""",
+)
+
+add_docstr_all(
+ "is_xla",
+ r"""
+Is ``True`` if the Tensor is stored on an XLA device, ``False`` otherwise.
+""",
+)
+
+add_docstr_all(
+ "is_ipu",
+ r"""
+Is ``True`` if the Tensor is stored on the IPU, ``False`` otherwise.
+""",
+)
+
+add_docstr_all(
+ "is_xpu",
+ r"""
+Is ``True`` if the Tensor is stored on the XPU, ``False`` otherwise.
+""",
+)
+
+add_docstr_all(
+ "is_quantized",
+ r"""
+Is ``True`` if the Tensor is quantized, ``False`` otherwise.
+""",
+)
+
+add_docstr_all(
+ "is_meta",
+ r"""
+Is ``True`` if the Tensor is a meta tensor, ``False`` otherwise. Meta tensors
+are like normal tensors, but they carry no data.
+""",
+)
+
+add_docstr_all(
+ "is_mps",
+ r"""
+Is ``True`` if the Tensor is stored on the MPS device, ``False`` otherwise.
+""",
+)
+
+add_docstr_all(
+ "is_sparse",
+ r"""
+Is ``True`` if the Tensor uses sparse COO storage layout, ``False`` otherwise.
+""",
+)
+
+add_docstr_all(
+ "is_sparse_csr",
+ r"""
+Is ``True`` if the Tensor uses sparse CSR storage layout, ``False`` otherwise.
+""",
+)
+
+add_docstr_all(
+ "device",
+ r"""
+Is the :class:`torch.device` where this Tensor is.
+""",
+)
+
+add_docstr_all(
+ "ndim",
+ r"""
+Alias for :meth:`~Tensor.dim()`
+""",
+)
+
+add_docstr_all(
+ "itemsize",
+ r"""
+Alias for :meth:`~Tensor.element_size()`
+""",
+)
+
+add_docstr_all(
+ "nbytes",
+ r"""
+Returns the number of bytes consumed by the "view" of elements of the Tensor
+if the Tensor does not use sparse storage layout.
+Defined to be :meth:`~Tensor.numel()` * :meth:`~Tensor.element_size()`
+""",
+)
+
+add_docstr_all(
+ "T",
+ r"""
+Returns a view of this tensor with its dimensions reversed.
+
+If ``n`` is the number of dimensions in ``x``,
+``x.T`` is equivalent to ``x.permute(n-1, n-2, ..., 0)``.
+
+.. warning::
+ The use of :func:`Tensor.T` on tensors of dimension other than 2 to reverse their shape
+ is deprecated and it will throw an error in a future release. Consider :attr:`~.Tensor.mT`
+ to transpose batches of matrices or `x.permute(*torch.arange(x.ndim - 1, -1, -1))` to reverse
+ the dimensions of a tensor.
+""",
+)
+
+add_docstr_all(
+ "H",
+ r"""
+Returns a view of a matrix (2-D tensor) conjugated and transposed.
+
+``x.H`` is equivalent to ``x.transpose(0, 1).conj()`` for complex matrices and
+``x.transpose(0, 1)`` for real matrices.
+
+.. seealso::
+
+ :attr:`~.Tensor.mH`: An attribute that also works on batches of matrices.
+""",
+)
+
+add_docstr_all(
+ "mT",
+ r"""
+Returns a view of this tensor with the last two dimensions transposed.
+
+``x.mT`` is equivalent to ``x.transpose(-2, -1)``.
+""",
+)
+
+add_docstr_all(
+ "mH",
+ r"""
+Accessing this property is equivalent to calling :func:`adjoint`.
+""",
+)
+
+add_docstr_all(
+ "adjoint",
+ r"""
+adjoint() -> Tensor
+
+Alias for :func:`adjoint`
+""",
+)
+
+add_docstr_all(
+ "real",
+ r"""
+Returns a new tensor containing real values of the :attr:`self` tensor for a complex-valued input tensor.
+The returned tensor and :attr:`self` share the same underlying storage.
+
+Returns :attr:`self` if :attr:`self` is a real-valued tensor tensor.
+
+Example::
+ >>> x=torch.randn(4, dtype=torch.cfloat)
+ >>> x
+ tensor([(0.3100+0.3553j), (-0.5445-0.7896j), (-1.6492-0.0633j), (-0.0638-0.8119j)])
+ >>> x.real
+ tensor([ 0.3100, -0.5445, -1.6492, -0.0638])
+
+""",
+)
+
+add_docstr_all(
+ "imag",
+ r"""
+Returns a new tensor containing imaginary values of the :attr:`self` tensor.
+The returned tensor and :attr:`self` share the same underlying storage.
+
+.. warning::
+ :func:`imag` is only supported for tensors with complex dtypes.
+
+Example::
+ >>> x=torch.randn(4, dtype=torch.cfloat)
+ >>> x
+ tensor([(0.3100+0.3553j), (-0.5445-0.7896j), (-1.6492-0.0633j), (-0.0638-0.8119j)])
+ >>> x.imag
+ tensor([ 0.3553, -0.7896, -0.0633, -0.8119])
+
+""",
+)
+
+add_docstr_all(
+ "as_subclass",
+ r"""
+as_subclass(cls) -> Tensor
+
+Makes a ``cls`` instance with the same data pointer as ``self``. Changes
+in the output mirror changes in ``self``, and the output stays attached
+to the autograd graph. ``cls`` must be a subclass of ``Tensor``.
+""",
+)
+
+add_docstr_all(
+ "crow_indices",
+ r"""
+crow_indices() -> IntTensor
+
+Returns the tensor containing the compressed row indices of the :attr:`self`
+tensor when :attr:`self` is a sparse CSR tensor of layout ``sparse_csr``.
+The ``crow_indices`` tensor is strictly of shape (:attr:`self`.size(0) + 1)
+and of type ``int32`` or ``int64``. When using MKL routines such as sparse
+matrix multiplication, it is necessary to use ``int32`` indexing in order
+to avoid downcasting and potentially losing information.
+
+Example::
+ >>> csr = torch.eye(5,5).to_sparse_csr()
+ >>> csr.crow_indices()
+ tensor([0, 1, 2, 3, 4, 5], dtype=torch.int32)
+
+""",
+)
+
+add_docstr_all(
+ "col_indices",
+ r"""
+col_indices() -> IntTensor
+
+Returns the tensor containing the column indices of the :attr:`self`
+tensor when :attr:`self` is a sparse CSR tensor of layout ``sparse_csr``.
+The ``col_indices`` tensor is strictly of shape (:attr:`self`.nnz())
+and of type ``int32`` or ``int64``. When using MKL routines such as sparse
+matrix multiplication, it is necessary to use ``int32`` indexing in order
+to avoid downcasting and potentially losing information.
+
+Example::
+ >>> csr = torch.eye(5,5).to_sparse_csr()
+ >>> csr.col_indices()
+ tensor([0, 1, 2, 3, 4], dtype=torch.int32)
+
+""",
+)
+
+add_docstr_all(
+ "to_padded_tensor",
+ r"""
+to_padded_tensor(padding, output_size=None) -> Tensor
+See :func:`to_padded_tensor`
+""",
+)
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/_utils.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..409dc8e42c59f53e637fb2e0e1cd19ac9e9163ef
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/_utils.py
@@ -0,0 +1,937 @@
+import copyreg
+import functools
+import sys
+import traceback
+import warnings
+from collections import defaultdict
+from typing import Any, DefaultDict, List, Optional
+
+import torch
+
+
+def _type(self, dtype=None, non_blocking=False, **kwargs):
+ """Returns the type if `dtype` is not provided, else casts this object to
+ the specified type.
+
+ If this is already of the correct type, no copy is performed and the
+ original object is returned.
+
+ Args:
+ dtype (type or string): The desired type
+ non_blocking (bool): If ``True``, and the source is in pinned memory
+ and destination is on the GPU or vice versa, the copy is performed
+ asynchronously with respect to the host. Otherwise, the argument
+ has no effect.
+ **kwargs: For compatibility, may contain the key ``async`` in place of
+ the ``non_blocking`` argument. The ``async`` arg is deprecated.
+ """
+ non_blocking = _get_async_or_non_blocking("type", non_blocking, kwargs)
+ if dtype is None:
+ return self.__module__ + "." + self.__class__.__name__
+
+ if isinstance(dtype, str):
+ dtype = _import_dotted_name(dtype)
+ if dtype == type(self):
+ return self
+ if self.is_sparse:
+ if not dtype.is_sparse:
+ raise RuntimeError("Cannot cast sparse tensor to dense tensor")
+ new_module_name = dtype.__module__.replace(".sparse", "")
+ new_values_type_name = new_module_name + "." + dtype.__name__
+ new_values = torch.Tensor._values(self).type(new_values_type_name, non_blocking)
+ new_indices_type_name = new_module_name + ".LongTensor"
+ new_indices = torch.Tensor._indices(self).type(
+ new_indices_type_name, non_blocking
+ )
+ return dtype(new_indices, new_values, self.size())
+ if dtype.is_sparse:
+ raise RuntimeError("Cannot cast dense tensor to sparse tensor")
+ return dtype(self.size()).copy_(self, non_blocking)
+
+
+def _hpu(self, device=None, non_blocking=False, **kwargs):
+ """Returns a copy of this object in HPU memory.
+
+ If this object is already in HPU memory and on the correct device, then
+ no copy is performed and the original object is returned.
+
+ Args:
+ device (int): The destination HPU id. Defaults to the current device.
+ non_blocking (bool): If ``True`` and the source is in pinned memory,
+ the copy will be asynchronous with respect to the host. Otherwise,
+ the argument has no effect.
+ **kwargs: For compatibility, may contain the key ``async`` in place of
+ the ``non_blocking`` argument.
+ """
+ non_blocking = _get_async_or_non_blocking("hpu", non_blocking, kwargs)
+ hpu = getattr(torch, "hpu", None)
+ assert hpu is not None, "HPU device module is not loaded"
+ if self.is_hpu:
+ if device is None:
+ device = hpu.current_device()
+ if self.get_device() == device:
+ return self
+ else:
+ if device is None:
+ device = -1
+ with hpu.device(device):
+ assert not self.is_sparse, "sparse storage is not supported for HPU tensors"
+ untyped_storage = torch.UntypedStorage(self.size(), device=torch.device("hpu"))
+ untyped_storage.copy_(self, non_blocking)
+ return untyped_storage
+
+
+def _cuda(self, device=None, non_blocking=False, **kwargs):
+ """Returns a copy of this object in CUDA memory.
+
+ If this object is already in CUDA memory and on the correct device, then
+ no copy is performed and the original object is returned.
+
+ Args:
+ device (int): The destination GPU id. Defaults to the current device.
+ non_blocking (bool): If ``True`` and the source is in pinned memory,
+ the copy will be asynchronous with respect to the host. Otherwise,
+ the argument has no effect.
+ **kwargs: For compatibility, may contain the key ``async`` in place of
+ the ``non_blocking`` argument.
+ """
+ non_blocking = _get_async_or_non_blocking("cuda", non_blocking, kwargs)
+ if self.is_cuda:
+ if device is None:
+ device = torch.cuda.current_device()
+ if self.get_device() == device:
+ return self
+ else:
+ if device is None:
+ device = -1
+ with torch.cuda.device(device):
+ if self.is_sparse:
+ new_type = getattr(torch.cuda.sparse, self.__class__.__name__)
+ indices = torch.Tensor._indices(self).cuda(device, non_blocking)
+ values = torch.Tensor._values(self).cuda(device, non_blocking)
+ return new_type(indices, values, self.size())
+ else:
+ untyped_storage = torch.UntypedStorage(
+ self.size(), device=torch.device("cuda")
+ )
+ untyped_storage.copy_(self, non_blocking)
+ return untyped_storage
+
+
+def _get_async_or_non_blocking(function_name, non_blocking, kwargs):
+ """Return the non-blocking flag given the function name and kwargs.
+
+ Args:
+ function_name (str): the name of the function being used.
+ non_blocking (bool): the default value.
+ **kwargs (dict): the kwargs passed to the function.
+ """
+ if not kwargs:
+ return non_blocking
+ if len(kwargs) != 1 or "async" not in kwargs:
+ message = "{}() got an unexpected keyword argument '{}'"
+ argument = list(kwargs.keys()).pop()
+ raise TypeError(message.format(function_name, argument))
+ warnings.warn("'async' is deprecated; use 'non_blocking'")
+ return kwargs["async"]
+
+
+# Note [Don't serialize hooks]
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Since time immemorial, we have serialized the backward hooks associated with
+# variables. This kind of half-worked--Python can pickle global functions
+# (but not closures!)--but there were problems.
+#
+# - It's fragile. If you serialize a backward hook into a saved
+# model, and then you rename the function associated with the hook,
+# now your saved model is broken and you can't load it anymore.
+#
+# - It's not actually used. The standard recommendation is to
+# serialize the *state_dict* of a model, not the model itself
+# (since this is more stable to code changes affecting the model
+# serialization), and the state dict saves "data" only, thus
+# stripping the backward hooks. In some cases, hooks are
+# essential to the well-functioning of a model (e.g., DDP),
+# but DDP already manages readding the hooks!
+#
+# - We didn't serialize them in many cases. Prior to #10220, we
+# were dropping backward hooks in ForkingPickler. We "fixed" this
+# to be convenient with other serialization sites, but lack of
+# serializing backward hooks wasn't actually the root cause of
+# the bug.
+#
+# With these cases in mind, we have decided that a better strategy
+# is to just NOT serialize hooks at all.
+#
+# Since this is a BC-breaking change, we should warn when we previously
+# serialized a hook, but no longer do so. This will be done by adding a special
+# sentinel property to hooks will be used to suppress this warning. If a hook
+# has the property _torch_serialize_ignore, we will not emit a warning if we
+# attempt to serialize a Tensor with this hook attached to it.
+#
+# By the way, when _backward_hooks is skipped, we must give an EMPTY
+# OrderedDict(), if you pass a None you'll run afoul #12219.
+
+
+# TODO: Once we decide to break serialization FC, `storage` no longer needs to
+# be a TypedStorage
+def _rebuild_tensor(storage, storage_offset, size, stride):
+ # first construct a tensor with the correct dtype/device
+ t = torch.empty((0,), dtype=storage.dtype, device=storage._untyped_storage.device)
+ return t.set_(storage._untyped_storage, storage_offset, size, stride)
+
+
+def get_tensor_metadata(tensor):
+ # Tensor's Metadata for serializing.
+ # Currently, this only returns a dict[string, bool] specifing whether
+ # `conj` or `neg` bit is set.
+ assert isinstance(tensor, torch.Tensor)
+ return torch._C._get_tensor_metadata(tensor) # type: ignore[attr-defined]
+
+
+def set_tensor_metadata(tensor, metadata):
+ # See `get_tensor_metadata` above
+ assert isinstance(metadata, dict)
+ assert isinstance(tensor, torch.Tensor)
+ torch._C._set_tensor_metadata(tensor, metadata) # type: ignore[attr-defined]
+
+
+def _rebuild_tensor_v2(
+ storage, storage_offset, size, stride, requires_grad, backward_hooks, metadata=None
+):
+ tensor = _rebuild_tensor(storage, storage_offset, size, stride)
+ tensor.requires_grad = requires_grad
+ if metadata:
+ set_tensor_metadata(tensor, metadata)
+
+ # NB: This line exists only for backwards compatibility; the
+ # general expectation is that backward_hooks is an empty
+ # OrderedDict. See Note [Don't serialize hooks]
+ tensor._backward_hooks = backward_hooks
+ return tensor
+
+
+def _rebuild_tensor_v3(
+ storage,
+ storage_offset,
+ size,
+ stride,
+ requires_grad,
+ backward_hooks,
+ dtype,
+ metadata=None,
+):
+ t = torch.empty(
+ (0,),
+ dtype=dtype,
+ device=storage._untyped_storage.device,
+ requires_grad=requires_grad,
+ )
+ t.set_(storage._untyped_storage, storage_offset, size, stride)
+ if metadata:
+ set_tensor_metadata(t, metadata)
+ t._backward_hooks = backward_hooks
+ return t
+
+
+_sparse_tensors_to_validate: List["torch.Tensor"] = []
+
+
+# In _legacy_load() in serialization.py we unpickle storages after the sparse
+# tensors have been already unpickled. Those storages contain data necessary for
+# validating sparse tensors: indices and values. That's why sparse tensors are
+# first unpickled without any validation, and then this function is called just
+# before _legacy_load() returns, so that all the sparse tensors can be validated
+# in bulk.
+#
+# The same procedure must be followed by _load() in serialization.py because due
+# to Pickler semantics, we have to use the same (non-validating) function for
+# unpickling sparse tensors, regardless of the caller.
+def _validate_loaded_sparse_tensors():
+ try:
+ for t in _sparse_tensors_to_validate:
+ if t.layout is torch.sparse_coo:
+ torch._validate_sparse_coo_tensor_args(
+ t._indices(), t._values(), t.size(), t.is_coalesced()
+ )
+ elif t.layout in {
+ torch.sparse_csr,
+ torch.sparse_csc,
+ torch.sparse_bsr,
+ torch.sparse_bsc,
+ }:
+ # TODO: Validation currently involves an expensive traversal
+ # on CPU, which may include a device transfer.
+ if t.layout in {torch.sparse_csr, torch.sparse_bsr}:
+ compressed_indices, plain_indices = (
+ t.crow_indices(),
+ t.col_indices(),
+ )
+ else:
+ compressed_indices, plain_indices = (
+ t.ccol_indices(),
+ t.row_indices(),
+ )
+ torch._validate_sparse_compressed_tensor_args(
+ compressed_indices, plain_indices, t.values(), t.size(), t.layout
+ )
+ else:
+ raise NotImplementedError(
+ f"_validate_loaded_sparse_tensors for layout `{t.layout}`"
+ )
+
+ finally:
+ _sparse_tensors_to_validate.clear()
+
+
+def _rebuild_sparse_tensor(layout, data):
+ """
+ Rebuilds a sparse tensor from its sparse storage representation.
+
+ Args:
+ layout (str): The sparse storage layout of the tensor.
+ data (tuple): The tensor's sparse storage representation.
+ """
+ if layout == torch.sparse_coo:
+ if len(data) == 3:
+ # For BC:
+ indices, values, size = data
+ is_coalesced = None
+ else:
+ indices, values, size, is_coalesced = data
+ result = torch.sparse_coo_tensor(
+ indices, values, size, check_invariants=False, is_coalesced=is_coalesced
+ )
+ _sparse_tensors_to_validate.append(result)
+ return result
+
+ elif layout in {
+ torch.sparse_csr,
+ torch.sparse_csc,
+ torch.sparse_bsr,
+ torch.sparse_bsc,
+ }:
+ compressed_indices, plain_indices, values, size = data
+ result = torch.sparse_compressed_tensor(
+ compressed_indices,
+ plain_indices,
+ values,
+ size,
+ layout=layout,
+ check_invariants=False,
+ )
+ _sparse_tensors_to_validate.append(result)
+ return result
+
+ raise NotImplementedError(f"rebuilding sparse tensor for layout {layout}")
+
+
+def _rebuild_nested_tensor(buffer, sizes, strides, storage_offsets):
+ return torch._nested_view_from_buffer(buffer, sizes, strides, storage_offsets)
+
+
+def _rebuild_device_tensor_from_numpy(data, dtype, device, requires_grad):
+ tensor = torch.from_numpy(data).to(dtype=dtype, device=device)
+ tensor.requires_grad = requires_grad
+ return tensor
+
+
+# Should not be used, only here to be able to load Tensors serialized with older versions of pytorch
+_rebuild_xla_tensor = _rebuild_device_tensor_from_numpy
+
+
+def _rebuild_meta_tensor_no_storage(dtype, size, stride, requires_grad):
+ return torch.empty_strided(
+ size, stride, dtype=dtype, device="meta", requires_grad=requires_grad
+ )
+
+
+def _rebuild_wrapper_subclass(
+ cls, dtype, size, stride, storage_offset, layout, device, requires_grad
+):
+ return torch.Tensor._make_wrapper_subclass( # type: ignore[attr-defined]
+ cls,
+ size,
+ strides=stride,
+ storage_offset=storage_offset,
+ layout=layout,
+ device=device,
+ requires_grad=requires_grad,
+ )
+
+
+# TODO: Once we decide to break serialization FC, `storage` no longer needs to
+# be a TypedStorage
+def _rebuild_qtensor(
+ storage,
+ storage_offset,
+ size,
+ stride,
+ quantizer_params,
+ requires_grad,
+ backward_hooks,
+):
+ qscheme = quantizer_params[0]
+ if qscheme == torch.per_tensor_affine:
+ _, scale, zero_point = quantizer_params
+ tensor = torch._empty_affine_quantized(
+ size,
+ scale=scale,
+ zero_point=zero_point,
+ dtype=storage.dtype,
+ device=storage.device,
+ )
+ elif qscheme in (torch.per_channel_affine, torch.per_channel_affine_float_qparams):
+ _, scales, zero_points, axis = quantizer_params
+ if type(scales) is list and type(zero_points) is list:
+ if qscheme == torch.per_channel_affine:
+ scales = torch.tensor(scales, dtype=torch.double, device=storage.device)
+ zero_points = torch.tensor(
+ zero_points, dtype=torch.long, device=storage.device
+ )
+ else:
+ scales = torch.tensor(scales, dtype=torch.float, device=storage.device)
+ zero_points = torch.tensor(
+ zero_points, dtype=torch.float, device=storage.device
+ )
+ tensor = torch._empty_per_channel_affine_quantized(
+ size,
+ scales=scales,
+ zero_points=zero_points,
+ axis=axis,
+ dtype=storage.dtype,
+ device=storage.device,
+ )
+ else:
+ raise RuntimeError(f"Can't deserialize quantized tensor with qscheme {qscheme}")
+ tensor.set_(storage, storage_offset, size, stride)
+ tensor.requires_grad = requires_grad
+ # NB: This line exists only for backwards compatibility; the
+ # general expectation is that backward_hooks is an empty
+ # OrderedDict. See Note [Don't serialize hooks]
+ tensor._backward_hooks = backward_hooks
+ return tensor
+
+
+def _rebuild_parameter(data, requires_grad, backward_hooks):
+ param = torch.nn.Parameter(data, requires_grad)
+ # NB: This line exists only for backwards compatibility; the
+ # general expectation is that backward_hooks is an empty
+ # OrderedDict. See Note [Don't serialize hooks]
+ param._backward_hooks = backward_hooks
+
+ return param
+
+
+def _rebuild_parameter_with_state(data, requires_grad, backward_hooks, state):
+ param = torch.nn.Parameter(data, requires_grad)
+ # NB: This line exists only for backwards compatibility; the
+ # general expectation is that backward_hooks is an empty
+ # OrderedDict. See Note [Don't serialize hooks]
+ param._backward_hooks = backward_hooks
+
+ # Restore state on Parameter like python attr.
+ param = _set_obj_state(param, state)
+ return param
+
+
+def _get_obj_state(obj):
+ # Get the state of the python subclass
+ # This loosely mimicks the function on the object class but since Tensor do not inherit
+ # from it, we cannot call that function directly
+ # https://github.com/python/cpython/blob/c83919bd635f4433f1c6ae8504996a9fe3c215e5/Objects/typeobject.c#L4891
+ # Note that starting with Python 3.11, this `__getstate__` is always defined and thus
+ # the else branch will never be taken.
+ getstate_fn = getattr(obj, "__getstate__", None)
+ if getstate_fn:
+ state = getstate_fn()
+ else:
+ slots_to_save = copyreg._slotnames(obj.__class__) # type: ignore[attr-defined]
+ if slots_to_save:
+ state = (
+ obj.__dict__,
+ {
+ name: getattr(obj, name)
+ for name in slots_to_save
+ if hasattr(obj, name)
+ },
+ )
+ else:
+ state = obj.__dict__
+
+ return state
+
+
+def _set_obj_state(obj, state):
+ if isinstance(state, tuple):
+ if not len(state) == 2:
+ raise RuntimeError(f"Invalid serialized state: {state}")
+ dict_state = state[0]
+ slots_state = state[1]
+ else:
+ dict_state = state
+ slots_state = None
+
+ # Starting with Python 3.11, the __dict__ attribute is lazily created
+ # and is serialized as None when not needed.
+ if dict_state:
+ for k, v in dict_state.items():
+ setattr(obj, k, v)
+
+ if slots_state:
+ for k, v in slots_state.items():
+ setattr(obj, k, v)
+ return obj
+
+
+def _import_dotted_name(name):
+ components = name.split(".")
+ obj = __import__(components[0])
+ for component in components[1:]:
+ obj = getattr(obj, component)
+ return obj
+
+
+def _flatten_dense_tensors(tensors):
+ """Flatten dense tensors into a contiguous 1D buffer. Assume tensors are of
+ same dense type.
+
+ Since inputs are dense, the resulting tensor will be a concatenated 1D
+ buffer. Element-wise operation on this buffer will be equivalent to
+ operating individually.
+
+ Args:
+ tensors (Iterable[Tensor]): dense tensors to flatten.
+
+ Returns:
+ A contiguous 1D buffer containing input tensors.
+ """
+ return torch._C._nn.flatten_dense_tensors(tensors)
+
+
+def _flatten_sparse_tensors(tensors):
+ """Flatten sparse tensors into two contiguous 1D buffers, one of indices and
+ one of values. Assume tensors are of same sparse type.
+
+ Args:
+ tensors (Iterable[Tensor]): sparse tensors to flatten.
+
+ Returns:
+ A tuple of two contiguous 1D buffers, one containing input tensors'
+ indices and the other containing the values.
+ """
+ flat_indices = torch._C._nn.flatten_dense_tensors(
+ [torch.Tensor._indices(t) for t in tensors]
+ )
+ flat_values = torch._C._nn.flatten_dense_tensors(
+ [torch.Tensor._values(t) for t in tensors]
+ )
+ return flat_indices, flat_values
+
+
+def _unflatten_dense_tensors(flat, tensors):
+ """View a flat buffer using the sizes of tensors. Assume that tensors are of
+ same dense type, and that flat is given by _flatten_dense_tensors.
+
+ Args:
+ flat (Tensor): flattened dense tensors to unflatten.
+ tensors (Iterable[Tensor]): dense tensors whose sizes will be used to
+ unflatten flat.
+
+ Returns:
+ Unflattened dense tensors with sizes same as tensors and values from
+ flat.
+ """
+ return torch._C._nn.unflatten_dense_tensors(flat, tensors)
+
+
+def _unflatten_sparse_tensors(flat, tensors):
+ """View flat buffer (containing indices and values) using the sizes of
+ tensors. Assume that tensors are of same sparse type, and that flat is given
+ by _flatten_sparse_tensors.
+
+ Args:
+ flat (tuple(Tensor, Tensor)): flattened indices and values of sparse
+ tensors to unflatten.
+ tensors (Iterable[Tensor]): sparse tensors whose sizes will be used to
+ unflatten flat.
+
+ Returns:
+ Unflattened sparse tensors with sizes same as tensors and values from
+ flat.
+ """
+ flat_indices, flat_values = flat
+ indices = torch._C._nn.unflatten_dense_tensors(
+ flat_indices, [torch.Tensor._indices(t) for t in tensors]
+ )
+ values = torch._C._nn.unflatten_dense_tensors(
+ flat_values, [torch.Tensor._values(t) for t in tensors]
+ )
+ outputs = []
+ for t, i, v in zip(tensors, indices, values):
+ outputs.append(t.new(i, v, t.size()))
+ return tuple(outputs)
+
+
+def _reorder_tensors_as(tensors, ordered_tensors):
+ """Assume that tensors are of same order as ordered_tensors within their
+ types, e.g., from _take_tensors. Reorder them to be of same order as
+ ordered_tensors.
+
+ Args:
+ tensors (Iterable[Tensor]): tensors to be reordered. They should be of
+ the same order as ordered_tensors within their own types.
+ ordered_tensors (Iterable[Tensor]): tensors whose order will be the
+ reference.
+
+ Returns:
+ Ordered tuple of tensors with contents from tensors and order of
+ ordered_tensors.
+ """
+ type_dict = defaultdict(list)
+ for tensor in tensors:
+ type_dict[tensor.type()].append(tensor)
+ type_dict_ = {t: iter(coll) for t, coll in type_dict.items()}
+ return tuple(next(type_dict_[tensor.type()]) for tensor in ordered_tensors)
+
+
+def _take_tensors(tensors, size_limit):
+ """Group tensors into chunks. This generator yields a chunk at each time,
+ each containing tensors of same type up to certain byte limit in total size.
+
+ Args:
+ tensors (Sequence): A sequence of tensors to be separated into chunks.
+ size_limit (int): The limit of each chunk in bytes.
+
+ Yields:
+ Blocks of tensors of same type and within size_limit. The yielded
+ tensors are only ordered as the original sequence within its types.
+ """
+ buf_dict: DefaultDict[str, List] = defaultdict(lambda: [[], 0])
+ for tensor in tensors:
+ t = tensor.type()
+ if tensor.is_sparse:
+ indices = torch.Tensor._indices(tensor)
+ values = torch.Tensor._values(tensor)
+ size = (
+ indices.numel() * indices.element_size()
+ + values.numel() * values.element_size()
+ )
+ else:
+ size = tensor.numel() * tensor.element_size()
+ buf_and_size = buf_dict[t]
+ if buf_and_size[1] + size > size_limit and buf_and_size[1] > 0:
+ yield buf_and_size[0]
+ buf_and_size = buf_dict[t] = [[], 0]
+ buf_and_size[0].append(tensor)
+ buf_and_size[1] += size
+ for buf, _ in buf_dict.values():
+ if len(buf) > 0:
+ yield buf
+
+
+# annotation decorator to get annotations in a way that is compatible
+# with both Python 2 and 3
+def annotate(ret, **kwargs):
+ def dec(fun):
+ fun.__annotations__ = dict(kwargs)
+ fun.__annotations__["return"] = ret
+ return fun
+
+ return dec
+
+
+def render_call(fn, args, kwargs):
+ str_fn = torch.overrides.resolve_name(fn)
+ if str_fn is None:
+ str_fn = str(fn)
+
+ str_args: List[str] = []
+ with torch._tensor_str.printoptions(threshold=0, edgeitems=0):
+ str_args.extend(repr(a) for a in args)
+ str_args.extend(f"{k}={repr(v)}" for k, v in kwargs.items())
+ r = f"{str_fn}({', '.join(str_args)})"
+ return r
+
+
+# NOTE [ Python Traceback Reference Cycle Problem ]
+#
+# When using sys.exc_info(), it is important to **not** store the exc_info[2],
+# which is the traceback, because otherwise you will run into the traceback
+# reference cycle problem, i.e., the traceback holding reference to the frame,
+# and the frame (which holds reference to all the object in its temporary scope)
+# holding reference the traceback.
+
+
+class KeyErrorMessage(str):
+ r"""str subclass that returns itself in repr"""
+
+ def __repr__(self):
+ return self
+
+
+class ExceptionWrapper:
+ r"""Wraps an exception plus traceback to communicate across threads"""
+
+ def __init__(self, exc_info=None, where="in background"):
+ # It is important that we don't store exc_info, see
+ # NOTE [ Python Traceback Reference Cycle Problem ]
+ if exc_info is None:
+ exc_info = sys.exc_info()
+ self.exc_type = exc_info[0]
+ self.exc_msg = "".join(traceback.format_exception(*exc_info))
+ self.where = where
+
+ def reraise(self):
+ r"""Reraises the wrapped exception in the current thread"""
+ # Format a message such as: "Caught ValueError in DataLoader worker
+ # process 2. Original Traceback:", followed by the traceback.
+ msg = f"Caught {self.exc_type.__name__} {self.where}.\nOriginal {self.exc_msg}"
+ if self.exc_type == KeyError:
+ # KeyError calls repr() on its argument (usually a dict key). This
+ # makes stack traces unreadable. It will not be changed in Python
+ # (https://bugs.python.org/issue2651), so we work around it.
+ msg = KeyErrorMessage(msg)
+ elif getattr(self.exc_type, "message", None):
+ # Some exceptions have first argument as non-str but explicitly
+ # have message field
+ raise self.exc_type(message=msg)
+ try:
+ exception = self.exc_type(msg)
+ except TypeError:
+ # If the exception takes multiple arguments, don't try to
+ # instantiate since we don't know how to
+ raise RuntimeError(msg) from None
+ raise exception
+
+
+def _get_available_device_type():
+ if torch.cuda.is_available():
+ return "cuda"
+ if hasattr(torch, "xpu") and torch.xpu.is_available(): # type: ignore[attr-defined]
+ return "xpu"
+ custom_backend_name = torch._C._get_privateuse1_backend_name()
+ custom_device_mod = getattr(torch, custom_backend_name, None)
+ if custom_device_mod and custom_device_mod.is_available():
+ return custom_backend_name
+ # add more available device types here
+ return None
+
+
+def _get_device_attr(get_member):
+ device_type = _get_available_device_type()
+ if device_type and device_type.lower() == "cuda":
+ return get_member(torch.cuda)
+ if device_type and device_type.lower() == "xpu":
+ return get_member(torch.xpu) # type: ignore[attr-defined]
+ if device_type == torch._C._get_privateuse1_backend_name():
+ return get_member(getattr(torch, device_type))
+ # add more available device types here
+ return None
+
+
+def _get_current_device_index():
+ # current device index
+ return _get_device_attr(lambda m: m.current_device())
+
+
+def _get_all_device_indices():
+ # all device index
+ return _get_device_attr(lambda m: list(range(m.device_count())))
+
+
+def _get_devices_properties(device_ids):
+ # all device properties
+ return [_get_device_attr(lambda m: m.get_device_properties(i)) for i in device_ids]
+
+
+def get_current_device_index() -> int:
+ r"""Checks if there are CUDA devices available and
+ returns the device index of the current default CUDA device.
+ Returns -1 in case there are no CUDA devices available.
+ Arguments: ``None``
+ """
+ if torch.cuda.device_count() > 0:
+ return torch.cuda.current_device()
+ return -1
+
+
+def _get_device_index(
+ device: Any, optional: bool = False, allow_cpu: bool = False
+) -> int:
+ r"""Gets the device index from :attr:`device`, which can be a torch.device
+ object, a Python integer, or ``None``.
+
+ If :attr:`device` is a torch.device object, returns the device index if it
+ has index. Note that for a device without a specified index,
+ i.e., ``torch.device('xxx')``, this will return the current default
+ device of that type if :attr:`optional` is ``True``. If :attr:`allow_cpu` is ``True``,
+ CPU devices will be accepted and ``-1`` will be returned in this case.
+
+ If :attr:`device` is a Python integer, it is returned as is.
+
+ If :attr:`device` is ``None``, this will return the current default
+ device of the supported runtime platform if :attr:`optional` is ``True``.
+ i.e., the current default CUDA device will be returned if CUDA runtime is supported.
+ """
+ if isinstance(device, str):
+ device = torch.device(device)
+ device_idx: Optional[int] = None
+ if isinstance(device, torch.device):
+ if not allow_cpu and device.type == "cpu":
+ raise ValueError(f"Expected a non cpu device, but got: {device}")
+ device_idx = -1 if device.type == "cpu" else device.index
+ if isinstance(device, int):
+ device_idx = device
+ if device_idx is None:
+ if optional:
+ # The eager API _get_current_device_index uses `lambda` functions which are
+ # not supported in JIT and hence not scriptable. The JIT equivalent API to get
+ # the current device index is `get_current_device_index()` which can
+ # be scripted. We use is_scripting to check the mode we are in and call the
+ # appropriate API.
+ if torch.jit.is_scripting():
+ device_idx = get_current_device_index()
+ else:
+ device_idx = _get_current_device_index()
+ else:
+ raise ValueError(
+ f"Expected a torch.device with a specified index or an integer, but got:{device}"
+ )
+ return device_idx
+
+
+def _handle_complex(tensor):
+ """
+ Returns a real view of a tensor if complex dtype else just the tensor
+ need to check if a UninitializedParameter because otherwise checking is_complex is an error for a LazyModule
+ """
+ return (
+ torch.view_as_real(tensor)
+ if not isinstance(tensor, torch.nn.UninitializedParameter)
+ and tensor.is_complex()
+ else tensor
+ )
+
+
+def _element_size(dtype):
+ """
+ Returns the element size for a dtype, in bytes
+ """
+ if not isinstance(dtype, torch.dtype):
+ raise RuntimeError(f"expected torch.dtype, but got {type(dtype)}")
+
+ if dtype.is_complex:
+ return torch.finfo(dtype).bits >> 2
+ elif dtype.is_floating_point:
+ return torch.finfo(dtype).bits >> 3
+ elif dtype == torch.bool:
+ # NOTE: torch.bool is not supported in torch.iinfo()
+ return 1
+ else:
+ return torch.iinfo(dtype).bits >> 3
+
+
+class _ClassPropertyDescriptor:
+ def __init__(self, fget, fset=None):
+ self.fget = fget
+
+ def __get__(self, instance, owner=None):
+ if owner is None:
+ owner = type(instance)
+ return self.fget.__get__(instance, owner)()
+
+
+def classproperty(func):
+ if not isinstance(func, (classmethod, staticmethod)):
+ func = classmethod(func)
+ return _ClassPropertyDescriptor(func)
+
+
+def is_compiling() -> bool:
+ """
+ Indicates whether we are tracing/compiling with torch.compile() or torch.export().
+
+ TODO(khabinov): we should deprecate this function and use torch.compiler.is_compiling().
+ """
+ return torch.compiler.is_compiling()
+
+
+def _functionalize_sync(t):
+ # This code lives in python instead of C++ since conditioning on a certain python subclass
+ # is much more of a pain in C++.
+ from torch._subclasses.functional_tensor import FunctionalTensor
+
+ if isinstance(t, FunctionalTensor):
+ # If a FunctionalTensorMode is active while syncing, we don't want it to intercept any ops that get called
+ # when we sync our inner tensor.
+ # Why?
+ # (1) If there are input mutations in the graph, then they will be re-applied during
+ # AOTAutograd when we call _sync() from inside of our functionalization kernels.
+ # (2) _sync() causes us to regenerate our updated the tensor from the updated base,
+ # which dispatches to a bunch of view ops
+ # (3) The input to these view ops is our inner FunctionalTensorWrapper
+ # (since the sync was called from C++), not the python FunctionalTensor
+ # (4) if a python FunctionalTensorMode is active, it will complain when it intercepts
+ # the view op, since it will see an input that is a C++ FunctionalTensorWrapper
+ # (aka a normal torch.Tensor) instead of a python `FunctionalTensor).
+ maybe_functional_mode = torch._C._unset_dispatch_mode(
+ torch._C._TorchDispatchModeKey.FUNCTIONAL
+ )
+ try:
+ torch._functionalize_sync(t.elem) # type: ignore[attr-defined]
+ finally:
+ if maybe_functional_mode is not None:
+ torch._C._set_dispatch_mode(maybe_functional_mode)
+ else:
+ torch._functionalize_sync(t) # type: ignore[attr-defined]
+
+
+@functools.lru_cache(2)
+def _get_device_module(device_type: str):
+ device_module = getattr(torch, device_type, None)
+ if device_module is None:
+ raise RuntimeError(
+ f"Device '{device_type}' does not have a corresponding module registered as 'torch.{device_type}'."
+ )
+ return device_module
+
+
+def _dummy_type(name: str) -> type:
+ def get_err_fn(is_init: bool):
+ def err_fn(obj, *args, **kwargs):
+ if is_init:
+ class_name = obj.__class__.__name__
+ else:
+ class_name = obj.__name__
+ raise RuntimeError(f"Tried to instantiate dummy base class {class_name}")
+
+ return err_fn
+
+ return type(
+ name, (object,), {"__init__": get_err_fn(True), "__new__": get_err_fn(False)}
+ )
+
+
+class _LazySeedTracker:
+ # Since seeding is memory-less, only track the latest seed.
+ # Note: `manual_seed_all` followed by `manual_seed` overwrites
+ # the seed on current device. We track the order of **latest**
+ # calls between these two API.
+ def __init__(self):
+ self.manual_seed_all_cb = None
+ self.manual_seed_cb = None
+ self.call_order = []
+
+ def queue_seed_all(self, cb, traceback):
+ self.manual_seed_all_cb = (cb, traceback)
+ # update seed_all to be latest
+ self.call_order = [self.manual_seed_cb, self.manual_seed_all_cb]
+
+ def queue_seed(self, cb, traceback):
+ self.manual_seed_cb = (cb, traceback)
+ # update seed to be latest
+ self.call_order = [self.manual_seed_all_cb, self.manual_seed_cb]
+
+ def get_calls(self) -> List:
+ return self.call_order
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/torch_version.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/torch_version.py
new file mode 100644
index 0000000000000000000000000000000000000000..f73a0b71c1a815be6b15d1972fed8350004d6721
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/torch_version.py
@@ -0,0 +1,58 @@
+# mypy: ignore-errors
+
+from typing import Any, Iterable
+from .version import __version__ as internal_version
+from ._vendor.packaging.version import Version, InvalidVersion
+
+__all__ = ['TorchVersion']
+
+
+class TorchVersion(str):
+ """A string with magic powers to compare to both Version and iterables!
+ Prior to 1.10.0 torch.__version__ was stored as a str and so many did
+ comparisons against torch.__version__ as if it were a str. In order to not
+ break them we have TorchVersion which masquerades as a str while also
+ having the ability to compare against both packaging.version.Version as
+ well as tuples of values, eg. (1, 2, 1)
+ Examples:
+ Comparing a TorchVersion object to a Version object
+ TorchVersion('1.10.0a') > Version('1.10.0a')
+ Comparing a TorchVersion object to a Tuple object
+ TorchVersion('1.10.0a') > (1, 2) # 1.2
+ TorchVersion('1.10.0a') > (1, 2, 1) # 1.2.1
+ Comparing a TorchVersion object against a string
+ TorchVersion('1.10.0a') > '1.2'
+ TorchVersion('1.10.0a') > '1.2.1'
+ """
+ # fully qualified type names here to appease mypy
+ def _convert_to_version(self, inp: Any) -> Any:
+ if isinstance(inp, Version):
+ return inp
+ elif isinstance(inp, str):
+ return Version(inp)
+ elif isinstance(inp, Iterable):
+ # Ideally this should work for most cases by attempting to group
+ # the version tuple, assuming the tuple looks (MAJOR, MINOR, ?PATCH)
+ # Examples:
+ # * (1) -> Version("1")
+ # * (1, 20) -> Version("1.20")
+ # * (1, 20, 1) -> Version("1.20.1")
+ return Version('.'.join(str(item) for item in inp))
+ else:
+ raise InvalidVersion(inp)
+
+ def _cmp_wrapper(self, cmp: Any, method: str) -> bool:
+ try:
+ return getattr(Version(self), method)(self._convert_to_version(cmp))
+ except BaseException as e:
+ if not isinstance(e, InvalidVersion):
+ raise
+ # Fall back to regular string comparison if dealing with an invalid
+ # version like 'parrot'
+ return getattr(super(), method)(cmp)
+
+
+for cmp_method in ["__gt__", "__lt__", "__eq__", "__ge__", "__le__"]:
+ setattr(TorchVersion, cmp_method, lambda x, y, method=cmp_method: x._cmp_wrapper(y, method))
+
+__version__ = TorchVersion(internal_version)
diff --git a/tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/version.py b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/version.py
new file mode 100644
index 0000000000000000000000000000000000000000..d3fa8b448f04f6bf16c695252e12dbc1bab046a1
--- /dev/null
+++ b/tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/version.py
@@ -0,0 +1,8 @@
+from typing import Optional
+
+__all__ = ['__version__', 'debug', 'cuda', 'git_version', 'hip']
+__version__ = '2.3.0+cu118'
+debug = False
+cuda: Optional[str] = '11.8'
+git_version = '97ff6cfd9c86c5c09d7ce775ab64ec5c99230f5d'
+hip: Optional[str] = None