diff --git a/.gitattributes b/.gitattributes index e6a0802fc8e3b62cdcb7602b71a8684e854e6c57..11ab7637e2e57c6e0836620c99c67ae285ec2a45 100644 --- a/.gitattributes +++ b/.gitattributes @@ -404,3 +404,6 @@ tuning-competition-baseline/.venv/lib/python3.11/site-packages/nvidia/cudnn/lib/ .venv/lib/python3.11/site-packages/aiohttp/_http_writer.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text .venv/lib/python3.11/site-packages/aiohttp/_http_parser.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text .venv/lib/python3.11/site-packages/mpmath/tests/__pycache__/test_functions2.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.11/site-packages/aiohttp/_websocket/mask.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.11/site-packages/mpmath/tests/__pycache__/test_fp.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.11/site-packages/aiohttp/_websocket/reader_c.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/__init__.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6af77705be067533a7c896bf4fb92d9f40c682f1 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/__init__.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/abc.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/abc.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d1e82df59dd9befe25675e8ccf1532e391ae6106 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/abc.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/base_protocol.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/base_protocol.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..20cfc7a198212ea07c5f736b4da4f15f3e703869 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/base_protocol.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/client.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/client.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..580bb57ef5c7131a6e214b2fe2549dd726a6d551 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/client.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/compression_utils.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/compression_utils.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..18d45e29ce6eec935c0f3a697e21b1c62f1f8009 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/compression_utils.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/cookiejar.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/cookiejar.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..16332dc5d286e7f50dbd67cafeb5aea397b757ec Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/cookiejar.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/formdata.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/formdata.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2d2e0bd5f390a05a1ac73c50f10f8441b2d88f80 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/formdata.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/hdrs.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/hdrs.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0d333167119cd2f9d2ce66bd901f5f6509730304 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/hdrs.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/helpers.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/helpers.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..10a36b53dfa6615819033051e5f89bb23fd737a1 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/helpers.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/http.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/http.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cdc495a96dcd705837e8336512c1f3fdd69809fc Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/http.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/http_exceptions.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/http_exceptions.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1d35647cabdf5881a8322db5b583a9fdfcb3aba5 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/http_exceptions.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/http_parser.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/http_parser.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5cfe01d014859f86d006cb369fe490e09417101c Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/http_parser.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/http_writer.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/http_writer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..29895e78a18ac265f94a0fc87dadbeb1d765e7f0 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/http_writer.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/log.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/log.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..44672cc8f94fd2139653342ce076771df96d22a6 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/log.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/payload.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/payload.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..58f3a8d44274ab741044c4c3c0fe74a56b13ca99 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/payload.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/pytest_plugin.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/pytest_plugin.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6b04b7cf919f4404c2be17ed1bd96f2e0df28635 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/pytest_plugin.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/resolver.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/resolver.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b706750d480f3df3d33c928af469c4920bc9fa7c Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/resolver.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/streams.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/streams.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8b77868efb4c77a31d86506dfee61a0815e28c5f Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/streams.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/test_utils.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/test_utils.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..013766ab819de74c26369495a4d3141e39d2f4b7 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/test_utils.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/tracing.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/tracing.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..82692d51a0a3f04e7206b6491ead39ba2ea3aa3d Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/tracing.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/typedefs.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/typedefs.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f820472d12259552634c30215533e4fd458e301f Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/typedefs.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0577e979f066a4e4dfeb5873d2b1fc7391cad036 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_exceptions.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_exceptions.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eeb699fbe67992892819dede8c77b53bc82dbed9 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_exceptions.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_middlewares.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_middlewares.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..02ed1f32ad42b13859b31bca36380b60b2109479 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_middlewares.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_protocol.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_protocol.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3162cb70efea6eda3753b389abdd252556a3a294 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_protocol.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_request.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_request.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..398d04a62e1075b16a9d68b97407e375c7ac7bf9 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_request.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_routedef.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_routedef.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bceac137722a934ca8b8ed20524f9c6e6e21c098 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_routedef.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_server.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_server.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ba80eabae47531ee7f14d16c044190024c2f2a2f Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_server.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_ws.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_ws.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef9f9371c063fb706e54b92731a98254104b4aad Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp/__pycache__/web_ws.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp/_websocket/mask.cpython-311-x86_64-linux-gnu.so b/.venv/lib/python3.11/site-packages/aiohttp/_websocket/mask.cpython-311-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..7fffed17f39df50bd8c9ca134674b92d0b2626c2 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/aiohttp/_websocket/mask.cpython-311-x86_64-linux-gnu.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:86adda1dee59565e4434546d6978d9712adb4be213070a868049de195a61635c +size 245952 diff --git a/.venv/lib/python3.11/site-packages/aiohttp/_websocket/reader_c.cpython-311-x86_64-linux-gnu.so b/.venv/lib/python3.11/site-packages/aiohttp/_websocket/reader_c.cpython-311-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..38caf98345750690d32e4b454dafe8b0c88dd7f3 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/aiohttp/_websocket/reader_c.cpython-311-x86_64-linux-gnu.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6e71133a69b8812c4a91aaccebcb0012106349dfdb42dd068030f65bb57c7144 +size 1906008 diff --git a/.venv/lib/python3.11/site-packages/cachetools/__init__.py b/.venv/lib/python3.11/site-packages/cachetools/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ad30175861265c64cdd376ff9507d29660a01588 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/cachetools/__init__.py @@ -0,0 +1,859 @@ +"""Extensible memoizing collections and decorators.""" + +__all__ = ( + "Cache", + "FIFOCache", + "LFUCache", + "LRUCache", + "MRUCache", + "RRCache", + "TLRUCache", + "TTLCache", + "cached", + "cachedmethod", +) + +__version__ = "5.5.1" + +import collections +import collections.abc +import functools +import heapq +import random +import time + +from . import keys + + +class _DefaultSize: + __slots__ = () + + def __getitem__(self, _): + return 1 + + def __setitem__(self, _, value): + assert value == 1 + + def pop(self, _): + return 1 + + +class Cache(collections.abc.MutableMapping): + """Mutable mapping to serve as a simple cache or cache base class.""" + + __marker = object() + + __size = _DefaultSize() + + def __init__(self, maxsize, getsizeof=None): + if getsizeof: + self.getsizeof = getsizeof + if self.getsizeof is not Cache.getsizeof: + self.__size = dict() + self.__data = dict() + self.__currsize = 0 + self.__maxsize = maxsize + + def __repr__(self): + return "%s(%s, maxsize=%r, currsize=%r)" % ( + self.__class__.__name__, + repr(self.__data), + self.__maxsize, + self.__currsize, + ) + + def __getitem__(self, key): + try: + return self.__data[key] + except KeyError: + return self.__missing__(key) + + def __setitem__(self, key, value): + maxsize = self.__maxsize + size = self.getsizeof(value) + if size > maxsize: + raise ValueError("value too large") + if key not in self.__data or self.__size[key] < size: + while self.__currsize + size > maxsize: + self.popitem() + if key in self.__data: + diffsize = size - self.__size[key] + else: + diffsize = size + self.__data[key] = value + self.__size[key] = size + self.__currsize += diffsize + + def __delitem__(self, key): + size = self.__size.pop(key) + del self.__data[key] + self.__currsize -= size + + def __contains__(self, key): + return key in self.__data + + def __missing__(self, key): + raise KeyError(key) + + def __iter__(self): + return iter(self.__data) + + def __len__(self): + return len(self.__data) + + def get(self, key, default=None): + if key in self: + return self[key] + else: + return default + + def pop(self, key, default=__marker): + if key in self: + value = self[key] + del self[key] + elif default is self.__marker: + raise KeyError(key) + else: + value = default + return value + + def setdefault(self, key, default=None): + if key in self: + value = self[key] + else: + self[key] = value = default + return value + + @property + def maxsize(self): + """The maximum size of the cache.""" + return self.__maxsize + + @property + def currsize(self): + """The current size of the cache.""" + return self.__currsize + + @staticmethod + def getsizeof(value): + """Return the size of a cache element's value.""" + return 1 + + +class FIFOCache(Cache): + """First In First Out (FIFO) cache implementation.""" + + def __init__(self, maxsize, getsizeof=None): + Cache.__init__(self, maxsize, getsizeof) + self.__order = collections.OrderedDict() + + def __setitem__(self, key, value, cache_setitem=Cache.__setitem__): + cache_setitem(self, key, value) + try: + self.__order.move_to_end(key) + except KeyError: + self.__order[key] = None + + def __delitem__(self, key, cache_delitem=Cache.__delitem__): + cache_delitem(self, key) + del self.__order[key] + + def popitem(self): + """Remove and return the `(key, value)` pair first inserted.""" + try: + key = next(iter(self.__order)) + except StopIteration: + raise KeyError("%s is empty" % type(self).__name__) from None + else: + return (key, self.pop(key)) + + +class LFUCache(Cache): + """Least Frequently Used (LFU) cache implementation.""" + + def __init__(self, maxsize, getsizeof=None): + Cache.__init__(self, maxsize, getsizeof) + self.__counter = collections.Counter() + + def __getitem__(self, key, cache_getitem=Cache.__getitem__): + value = cache_getitem(self, key) + if key in self: # __missing__ may not store item + self.__counter[key] -= 1 + return value + + def __setitem__(self, key, value, cache_setitem=Cache.__setitem__): + cache_setitem(self, key, value) + self.__counter[key] -= 1 + + def __delitem__(self, key, cache_delitem=Cache.__delitem__): + cache_delitem(self, key) + del self.__counter[key] + + def popitem(self): + """Remove and return the `(key, value)` pair least frequently used.""" + try: + ((key, _),) = self.__counter.most_common(1) + except ValueError: + raise KeyError("%s is empty" % type(self).__name__) from None + else: + return (key, self.pop(key)) + + +class LRUCache(Cache): + """Least Recently Used (LRU) cache implementation.""" + + def __init__(self, maxsize, getsizeof=None): + Cache.__init__(self, maxsize, getsizeof) + self.__order = collections.OrderedDict() + + def __getitem__(self, key, cache_getitem=Cache.__getitem__): + value = cache_getitem(self, key) + if key in self: # __missing__ may not store item + self.__update(key) + return value + + def __setitem__(self, key, value, cache_setitem=Cache.__setitem__): + cache_setitem(self, key, value) + self.__update(key) + + def __delitem__(self, key, cache_delitem=Cache.__delitem__): + cache_delitem(self, key) + del self.__order[key] + + def popitem(self): + """Remove and return the `(key, value)` pair least recently used.""" + try: + key = next(iter(self.__order)) + except StopIteration: + raise KeyError("%s is empty" % type(self).__name__) from None + else: + return (key, self.pop(key)) + + def __update(self, key): + try: + self.__order.move_to_end(key) + except KeyError: + self.__order[key] = None + + +class MRUCache(Cache): + """Most Recently Used (MRU) cache implementation.""" + + def __init__(self, maxsize, getsizeof=None): + from warnings import warn + + warn("MRUCache is deprecated", DeprecationWarning, stacklevel=2) + + Cache.__init__(self, maxsize, getsizeof) + self.__order = collections.OrderedDict() + + def __getitem__(self, key, cache_getitem=Cache.__getitem__): + value = cache_getitem(self, key) + if key in self: # __missing__ may not store item + self.__update(key) + return value + + def __setitem__(self, key, value, cache_setitem=Cache.__setitem__): + cache_setitem(self, key, value) + self.__update(key) + + def __delitem__(self, key, cache_delitem=Cache.__delitem__): + cache_delitem(self, key) + del self.__order[key] + + def popitem(self): + """Remove and return the `(key, value)` pair most recently used.""" + try: + key = next(iter(self.__order)) + except StopIteration: + raise KeyError("%s is empty" % type(self).__name__) from None + else: + return (key, self.pop(key)) + + def __update(self, key): + try: + self.__order.move_to_end(key, last=False) + except KeyError: + self.__order[key] = None + + +class RRCache(Cache): + """Random Replacement (RR) cache implementation.""" + + def __init__(self, maxsize, choice=random.choice, getsizeof=None): + Cache.__init__(self, maxsize, getsizeof) + self.__choice = choice + + @property + def choice(self): + """The `choice` function used by the cache.""" + return self.__choice + + def popitem(self): + """Remove and return a random `(key, value)` pair.""" + try: + key = self.__choice(list(self)) + except IndexError: + raise KeyError("%s is empty" % type(self).__name__) from None + else: + return (key, self.pop(key)) + + +class _TimedCache(Cache): + """Base class for time aware cache implementations.""" + + class _Timer: + def __init__(self, timer): + self.__timer = timer + self.__nesting = 0 + + def __call__(self): + if self.__nesting == 0: + return self.__timer() + else: + return self.__time + + def __enter__(self): + if self.__nesting == 0: + self.__time = time = self.__timer() + else: + time = self.__time + self.__nesting += 1 + return time + + def __exit__(self, *exc): + self.__nesting -= 1 + + def __reduce__(self): + return _TimedCache._Timer, (self.__timer,) + + def __getattr__(self, name): + return getattr(self.__timer, name) + + def __init__(self, maxsize, timer=time.monotonic, getsizeof=None): + Cache.__init__(self, maxsize, getsizeof) + self.__timer = _TimedCache._Timer(timer) + + def __repr__(self, cache_repr=Cache.__repr__): + with self.__timer as time: + self.expire(time) + return cache_repr(self) + + def __len__(self, cache_len=Cache.__len__): + with self.__timer as time: + self.expire(time) + return cache_len(self) + + @property + def currsize(self): + with self.__timer as time: + self.expire(time) + return super().currsize + + @property + def timer(self): + """The timer function used by the cache.""" + return self.__timer + + def clear(self): + with self.__timer as time: + self.expire(time) + Cache.clear(self) + + def get(self, *args, **kwargs): + with self.__timer: + return Cache.get(self, *args, **kwargs) + + def pop(self, *args, **kwargs): + with self.__timer: + return Cache.pop(self, *args, **kwargs) + + def setdefault(self, *args, **kwargs): + with self.__timer: + return Cache.setdefault(self, *args, **kwargs) + + +class TTLCache(_TimedCache): + """LRU Cache implementation with per-item time-to-live (TTL) value.""" + + class _Link: + __slots__ = ("key", "expires", "next", "prev") + + def __init__(self, key=None, expires=None): + self.key = key + self.expires = expires + + def __reduce__(self): + return TTLCache._Link, (self.key, self.expires) + + def unlink(self): + next = self.next + prev = self.prev + prev.next = next + next.prev = prev + + def __init__(self, maxsize, ttl, timer=time.monotonic, getsizeof=None): + _TimedCache.__init__(self, maxsize, timer, getsizeof) + self.__root = root = TTLCache._Link() + root.prev = root.next = root + self.__links = collections.OrderedDict() + self.__ttl = ttl + + def __contains__(self, key): + try: + link = self.__links[key] # no reordering + except KeyError: + return False + else: + return self.timer() < link.expires + + def __getitem__(self, key, cache_getitem=Cache.__getitem__): + try: + link = self.__getlink(key) + except KeyError: + expired = False + else: + expired = not (self.timer() < link.expires) + if expired: + return self.__missing__(key) + else: + return cache_getitem(self, key) + + def __setitem__(self, key, value, cache_setitem=Cache.__setitem__): + with self.timer as time: + self.expire(time) + cache_setitem(self, key, value) + try: + link = self.__getlink(key) + except KeyError: + self.__links[key] = link = TTLCache._Link(key) + else: + link.unlink() + link.expires = time + self.__ttl + link.next = root = self.__root + link.prev = prev = root.prev + prev.next = root.prev = link + + def __delitem__(self, key, cache_delitem=Cache.__delitem__): + cache_delitem(self, key) + link = self.__links.pop(key) + link.unlink() + if not (self.timer() < link.expires): + raise KeyError(key) + + def __iter__(self): + root = self.__root + curr = root.next + while curr is not root: + # "freeze" time for iterator access + with self.timer as time: + if time < curr.expires: + yield curr.key + curr = curr.next + + def __setstate__(self, state): + self.__dict__.update(state) + root = self.__root + root.prev = root.next = root + for link in sorted(self.__links.values(), key=lambda obj: obj.expires): + link.next = root + link.prev = prev = root.prev + prev.next = root.prev = link + self.expire(self.timer()) + + @property + def ttl(self): + """The time-to-live value of the cache's items.""" + return self.__ttl + + def expire(self, time=None): + """Remove expired items from the cache and return an iterable of the + expired `(key, value)` pairs. + + """ + if time is None: + time = self.timer() + root = self.__root + curr = root.next + links = self.__links + expired = [] + cache_delitem = Cache.__delitem__ + cache_getitem = Cache.__getitem__ + while curr is not root and not (time < curr.expires): + expired.append((curr.key, cache_getitem(self, curr.key))) + cache_delitem(self, curr.key) + del links[curr.key] + next = curr.next + curr.unlink() + curr = next + return expired + + def popitem(self): + """Remove and return the `(key, value)` pair least recently used that + has not already expired. + + """ + with self.timer as time: + self.expire(time) + try: + key = next(iter(self.__links)) + except StopIteration: + raise KeyError("%s is empty" % type(self).__name__) from None + else: + return (key, self.pop(key)) + + def __getlink(self, key): + value = self.__links[key] + self.__links.move_to_end(key) + return value + + +class TLRUCache(_TimedCache): + """Time aware Least Recently Used (TLRU) cache implementation.""" + + @functools.total_ordering + class _Item: + __slots__ = ("key", "expires", "removed") + + def __init__(self, key=None, expires=None): + self.key = key + self.expires = expires + self.removed = False + + def __lt__(self, other): + return self.expires < other.expires + + def __init__(self, maxsize, ttu, timer=time.monotonic, getsizeof=None): + _TimedCache.__init__(self, maxsize, timer, getsizeof) + self.__items = collections.OrderedDict() + self.__order = [] + self.__ttu = ttu + + def __contains__(self, key): + try: + item = self.__items[key] # no reordering + except KeyError: + return False + else: + return self.timer() < item.expires + + def __getitem__(self, key, cache_getitem=Cache.__getitem__): + try: + item = self.__getitem(key) + except KeyError: + expired = False + else: + expired = not (self.timer() < item.expires) + if expired: + return self.__missing__(key) + else: + return cache_getitem(self, key) + + def __setitem__(self, key, value, cache_setitem=Cache.__setitem__): + with self.timer as time: + expires = self.__ttu(key, value, time) + if not (time < expires): + return # skip expired items + self.expire(time) + cache_setitem(self, key, value) + # removing an existing item would break the heap structure, so + # only mark it as removed for now + try: + self.__getitem(key).removed = True + except KeyError: + pass + self.__items[key] = item = TLRUCache._Item(key, expires) + heapq.heappush(self.__order, item) + + def __delitem__(self, key, cache_delitem=Cache.__delitem__): + with self.timer as time: + # no self.expire() for performance reasons, e.g. self.clear() [#67] + cache_delitem(self, key) + item = self.__items.pop(key) + item.removed = True + if not (time < item.expires): + raise KeyError(key) + + def __iter__(self): + for curr in self.__order: + # "freeze" time for iterator access + with self.timer as time: + if time < curr.expires and not curr.removed: + yield curr.key + + @property + def ttu(self): + """The local time-to-use function used by the cache.""" + return self.__ttu + + def expire(self, time=None): + """Remove expired items from the cache and return an iterable of the + expired `(key, value)` pairs. + + """ + if time is None: + time = self.timer() + items = self.__items + order = self.__order + # clean up the heap if too many items are marked as removed + if len(order) > len(items) * 2: + self.__order = order = [item for item in order if not item.removed] + heapq.heapify(order) + expired = [] + cache_delitem = Cache.__delitem__ + cache_getitem = Cache.__getitem__ + while order and (order[0].removed or not (time < order[0].expires)): + item = heapq.heappop(order) + if not item.removed: + expired.append((item.key, cache_getitem(self, item.key))) + cache_delitem(self, item.key) + del items[item.key] + return expired + + def popitem(self): + """Remove and return the `(key, value)` pair least recently used that + has not already expired. + + """ + with self.timer as time: + self.expire(time) + try: + key = next(iter(self.__items)) + except StopIteration: + raise KeyError("%s is empty" % self.__class__.__name__) from None + else: + return (key, self.pop(key)) + + def __getitem(self, key): + value = self.__items[key] + self.__items.move_to_end(key) + return value + + +_CacheInfo = collections.namedtuple( + "CacheInfo", ["hits", "misses", "maxsize", "currsize"] +) + + +def cached(cache, key=keys.hashkey, lock=None, info=False): + """Decorator to wrap a function with a memoizing callable that saves + results in a cache. + + """ + + def decorator(func): + if info: + hits = misses = 0 + + if isinstance(cache, Cache): + + def getinfo(): + nonlocal hits, misses + return _CacheInfo(hits, misses, cache.maxsize, cache.currsize) + + elif isinstance(cache, collections.abc.Mapping): + + def getinfo(): + nonlocal hits, misses + return _CacheInfo(hits, misses, None, len(cache)) + + else: + + def getinfo(): + nonlocal hits, misses + return _CacheInfo(hits, misses, 0, 0) + + if cache is None: + + def wrapper(*args, **kwargs): + nonlocal misses + misses += 1 + return func(*args, **kwargs) + + def cache_clear(): + nonlocal hits, misses + hits = misses = 0 + + cache_info = getinfo + + elif lock is None: + + def wrapper(*args, **kwargs): + nonlocal hits, misses + k = key(*args, **kwargs) + try: + result = cache[k] + hits += 1 + return result + except KeyError: + misses += 1 + v = func(*args, **kwargs) + try: + cache[k] = v + except ValueError: + pass # value too large + return v + + def cache_clear(): + nonlocal hits, misses + cache.clear() + hits = misses = 0 + + cache_info = getinfo + + else: + + def wrapper(*args, **kwargs): + nonlocal hits, misses + k = key(*args, **kwargs) + try: + with lock: + result = cache[k] + hits += 1 + return result + except KeyError: + with lock: + misses += 1 + v = func(*args, **kwargs) + # in case of a race, prefer the item already in the cache + try: + with lock: + return cache.setdefault(k, v) + except ValueError: + return v # value too large + + def cache_clear(): + nonlocal hits, misses + with lock: + cache.clear() + hits = misses = 0 + + def cache_info(): + with lock: + return getinfo() + + else: + if cache is None: + + def wrapper(*args, **kwargs): + return func(*args, **kwargs) + + def cache_clear(): + pass + + elif lock is None: + + def wrapper(*args, **kwargs): + k = key(*args, **kwargs) + try: + return cache[k] + except KeyError: + pass # key not found + v = func(*args, **kwargs) + try: + cache[k] = v + except ValueError: + pass # value too large + return v + + def cache_clear(): + cache.clear() + + else: + + def wrapper(*args, **kwargs): + k = key(*args, **kwargs) + try: + with lock: + return cache[k] + except KeyError: + pass # key not found + v = func(*args, **kwargs) + # in case of a race, prefer the item already in the cache + try: + with lock: + return cache.setdefault(k, v) + except ValueError: + return v # value too large + + def cache_clear(): + with lock: + cache.clear() + + cache_info = None + + wrapper.cache = cache + wrapper.cache_key = key + wrapper.cache_lock = lock + wrapper.cache_clear = cache_clear + wrapper.cache_info = cache_info + + return functools.update_wrapper(wrapper, func) + + return decorator + + +def cachedmethod(cache, key=keys.methodkey, lock=None): + """Decorator to wrap a class or instance method with a memoizing + callable that saves results in a cache. + + """ + + def decorator(method): + if lock is None: + + def wrapper(self, *args, **kwargs): + c = cache(self) + if c is None: + return method(self, *args, **kwargs) + k = key(self, *args, **kwargs) + try: + return c[k] + except KeyError: + pass # key not found + v = method(self, *args, **kwargs) + try: + c[k] = v + except ValueError: + pass # value too large + return v + + def clear(self): + c = cache(self) + if c is not None: + c.clear() + + else: + + def wrapper(self, *args, **kwargs): + c = cache(self) + if c is None: + return method(self, *args, **kwargs) + k = key(self, *args, **kwargs) + try: + with lock(self): + return c[k] + except KeyError: + pass # key not found + v = method(self, *args, **kwargs) + # in case of a race, prefer the item already in the cache + try: + with lock(self): + return c.setdefault(k, v) + except ValueError: + return v # value too large + + def clear(self): + c = cache(self) + if c is not None: + with lock(self): + c.clear() + + wrapper.cache = cache + wrapper.cache_key = key + wrapper.cache_lock = lock + wrapper.cache_clear = clear + + return functools.update_wrapper(wrapper, method) + + return decorator diff --git a/.venv/lib/python3.11/site-packages/cachetools/__pycache__/__init__.cpython-311.pyc b/.venv/lib/python3.11/site-packages/cachetools/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a6379dad9921f5b5c25a01b2eb91db721ea78376 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/cachetools/__pycache__/__init__.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/cachetools/__pycache__/func.cpython-311.pyc b/.venv/lib/python3.11/site-packages/cachetools/__pycache__/func.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..28273f11852f51b315c7fdb1546da06bc8a67a3d Binary files /dev/null and b/.venv/lib/python3.11/site-packages/cachetools/__pycache__/func.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/cachetools/__pycache__/keys.cpython-311.pyc b/.venv/lib/python3.11/site-packages/cachetools/__pycache__/keys.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e3f9451a47a6a455f70b07c2f5d78cea8a66151c Binary files /dev/null and b/.venv/lib/python3.11/site-packages/cachetools/__pycache__/keys.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/cachetools/func.py b/.venv/lib/python3.11/site-packages/cachetools/func.py new file mode 100644 index 0000000000000000000000000000000000000000..3eafddf1135444be1dcce7ad2e546e174a6c97e4 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/cachetools/func.py @@ -0,0 +1,121 @@ +"""`functools.lru_cache` compatible memoizing function decorators.""" + +__all__ = ("fifo_cache", "lfu_cache", "lru_cache", "mru_cache", "rr_cache", "ttl_cache") + +import math +import random +import time + +try: + from threading import RLock +except ImportError: # pragma: no cover + from dummy_threading import RLock + +from . import FIFOCache, LFUCache, LRUCache, MRUCache, RRCache, TTLCache +from . import cached +from . import keys + + +class _UnboundTTLCache(TTLCache): + def __init__(self, ttl, timer): + TTLCache.__init__(self, math.inf, ttl, timer) + + @property + def maxsize(self): + return None + + +def _cache(cache, maxsize, typed): + def decorator(func): + key = keys.typedkey if typed else keys.hashkey + wrapper = cached(cache=cache, key=key, lock=RLock(), info=True)(func) + wrapper.cache_parameters = lambda: {"maxsize": maxsize, "typed": typed} + return wrapper + + return decorator + + +def fifo_cache(maxsize=128, typed=False): + """Decorator to wrap a function with a memoizing callable that saves + up to `maxsize` results based on a First In First Out (FIFO) + algorithm. + + """ + if maxsize is None: + return _cache({}, None, typed) + elif callable(maxsize): + return _cache(FIFOCache(128), 128, typed)(maxsize) + else: + return _cache(FIFOCache(maxsize), maxsize, typed) + + +def lfu_cache(maxsize=128, typed=False): + """Decorator to wrap a function with a memoizing callable that saves + up to `maxsize` results based on a Least Frequently Used (LFU) + algorithm. + + """ + if maxsize is None: + return _cache({}, None, typed) + elif callable(maxsize): + return _cache(LFUCache(128), 128, typed)(maxsize) + else: + return _cache(LFUCache(maxsize), maxsize, typed) + + +def lru_cache(maxsize=128, typed=False): + """Decorator to wrap a function with a memoizing callable that saves + up to `maxsize` results based on a Least Recently Used (LRU) + algorithm. + + """ + if maxsize is None: + return _cache({}, None, typed) + elif callable(maxsize): + return _cache(LRUCache(128), 128, typed)(maxsize) + else: + return _cache(LRUCache(maxsize), maxsize, typed) + + +def mru_cache(maxsize=128, typed=False): + """Decorator to wrap a function with a memoizing callable that saves + up to `maxsize` results based on a Most Recently Used (MRU) + algorithm. + """ + from warnings import warn + + warn("@mru_cache is deprecated", DeprecationWarning, stacklevel=2) + + if maxsize is None: + return _cache({}, None, typed) + elif callable(maxsize): + return _cache(MRUCache(128), 128, typed)(maxsize) + else: + return _cache(MRUCache(maxsize), maxsize, typed) + + +def rr_cache(maxsize=128, choice=random.choice, typed=False): + """Decorator to wrap a function with a memoizing callable that saves + up to `maxsize` results based on a Random Replacement (RR) + algorithm. + + """ + if maxsize is None: + return _cache({}, None, typed) + elif callable(maxsize): + return _cache(RRCache(128, choice), 128, typed)(maxsize) + else: + return _cache(RRCache(maxsize, choice), maxsize, typed) + + +def ttl_cache(maxsize=128, ttl=600, timer=time.monotonic, typed=False): + """Decorator to wrap a function with a memoizing callable that saves + up to `maxsize` results based on a Least Recently Used (LRU) + algorithm with a per-item time-to-live (TTL) value. + """ + if maxsize is None: + return _cache(_UnboundTTLCache(ttl, timer), None, typed) + elif callable(maxsize): + return _cache(TTLCache(128, ttl, timer), 128, typed)(maxsize) + else: + return _cache(TTLCache(maxsize, ttl, timer), maxsize, typed) diff --git a/.venv/lib/python3.11/site-packages/cachetools/keys.py b/.venv/lib/python3.11/site-packages/cachetools/keys.py new file mode 100644 index 0000000000000000000000000000000000000000..8689b17b9da1040bcc3f4eda30c090e10bae4bc0 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/cachetools/keys.py @@ -0,0 +1,62 @@ +"""Key functions for memoizing decorators.""" + +__all__ = ("hashkey", "methodkey", "typedkey", "typedmethodkey") + + +class _HashedTuple(tuple): + """A tuple that ensures that hash() will be called no more than once + per element, since cache decorators will hash the key multiple + times on a cache miss. See also _HashedSeq in the standard + library functools implementation. + + """ + + __hashvalue = None + + def __hash__(self, hash=tuple.__hash__): + hashvalue = self.__hashvalue + if hashvalue is None: + self.__hashvalue = hashvalue = hash(self) + return hashvalue + + def __add__(self, other, add=tuple.__add__): + return _HashedTuple(add(self, other)) + + def __radd__(self, other, add=tuple.__add__): + return _HashedTuple(add(other, self)) + + def __getstate__(self): + return {} + + +# used for separating keyword arguments; we do not use an object +# instance here so identity is preserved when pickling/unpickling +_kwmark = (_HashedTuple,) + + +def hashkey(*args, **kwargs): + """Return a cache key for the specified hashable arguments.""" + + if kwargs: + return _HashedTuple(args + sum(sorted(kwargs.items()), _kwmark)) + else: + return _HashedTuple(args) + + +def methodkey(self, *args, **kwargs): + """Return a cache key for use with cached methods.""" + return hashkey(*args, **kwargs) + + +def typedkey(*args, **kwargs): + """Return a typed cache key for the specified hashable arguments.""" + + key = hashkey(*args, **kwargs) + key += tuple(type(v) for v in args) + key += tuple(type(v) for _, v in sorted(kwargs.items())) + return key + + +def typedmethodkey(self, *args, **kwargs): + """Return a typed cache key for use with cached methods.""" + return typedkey(*args, **kwargs) diff --git a/.venv/lib/python3.11/site-packages/httplib2/error.py b/.venv/lib/python3.11/site-packages/httplib2/error.py new file mode 100644 index 0000000000000000000000000000000000000000..0e68c12a852c88cace86d476b5cb9a8151196a6c --- /dev/null +++ b/.venv/lib/python3.11/site-packages/httplib2/error.py @@ -0,0 +1,48 @@ +# All exceptions raised here derive from HttpLib2Error +class HttpLib2Error(Exception): + pass + + +# Some exceptions can be caught and optionally +# be turned back into responses. +class HttpLib2ErrorWithResponse(HttpLib2Error): + def __init__(self, desc, response, content): + self.response = response + self.content = content + HttpLib2Error.__init__(self, desc) + + +class RedirectMissingLocation(HttpLib2ErrorWithResponse): + pass + + +class RedirectLimit(HttpLib2ErrorWithResponse): + pass + + +class FailedToDecompressContent(HttpLib2ErrorWithResponse): + pass + + +class UnimplementedDigestAuthOptionError(HttpLib2ErrorWithResponse): + pass + + +class UnimplementedHmacDigestAuthOptionError(HttpLib2ErrorWithResponse): + pass + + +class MalformedHeader(HttpLib2Error): + pass + + +class RelativeURIError(HttpLib2Error): + pass + + +class ServerNotFoundError(HttpLib2Error): + pass + + +class ProxiesUnavailableError(HttpLib2Error): + pass diff --git a/.venv/lib/python3.11/site-packages/httplib2/iri2uri.py b/.venv/lib/python3.11/site-packages/httplib2/iri2uri.py new file mode 100644 index 0000000000000000000000000000000000000000..86e361e62ae8dd603d2a982b22bd79ee8653a726 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/httplib2/iri2uri.py @@ -0,0 +1,124 @@ +# -*- coding: utf-8 -*- +"""Converts an IRI to a URI.""" + +__author__ = "Joe Gregorio (joe@bitworking.org)" +__copyright__ = "Copyright 2006, Joe Gregorio" +__contributors__ = [] +__version__ = "1.0.0" +__license__ = "MIT" + +import urllib.parse + +# Convert an IRI to a URI following the rules in RFC 3987 +# +# The characters we need to enocde and escape are defined in the spec: +# +# iprivate = %xE000-F8FF / %xF0000-FFFFD / %x100000-10FFFD +# ucschar = %xA0-D7FF / %xF900-FDCF / %xFDF0-FFEF +# / %x10000-1FFFD / %x20000-2FFFD / %x30000-3FFFD +# / %x40000-4FFFD / %x50000-5FFFD / %x60000-6FFFD +# / %x70000-7FFFD / %x80000-8FFFD / %x90000-9FFFD +# / %xA0000-AFFFD / %xB0000-BFFFD / %xC0000-CFFFD +# / %xD0000-DFFFD / %xE1000-EFFFD + +escape_range = [ + (0xA0, 0xD7FF), + (0xE000, 0xF8FF), + (0xF900, 0xFDCF), + (0xFDF0, 0xFFEF), + (0x10000, 0x1FFFD), + (0x20000, 0x2FFFD), + (0x30000, 0x3FFFD), + (0x40000, 0x4FFFD), + (0x50000, 0x5FFFD), + (0x60000, 0x6FFFD), + (0x70000, 0x7FFFD), + (0x80000, 0x8FFFD), + (0x90000, 0x9FFFD), + (0xA0000, 0xAFFFD), + (0xB0000, 0xBFFFD), + (0xC0000, 0xCFFFD), + (0xD0000, 0xDFFFD), + (0xE1000, 0xEFFFD), + (0xF0000, 0xFFFFD), + (0x100000, 0x10FFFD), +] + + +def encode(c): + retval = c + i = ord(c) + for low, high in escape_range: + if i < low: + break + if i >= low and i <= high: + retval = "".join(["%%%2X" % o for o in c.encode("utf-8")]) + break + return retval + + +def iri2uri(uri): + """Convert an IRI to a URI. Note that IRIs must be + passed in a unicode strings. That is, do not utf-8 encode + the IRI before passing it into the function.""" + if isinstance(uri, str): + (scheme, authority, path, query, fragment) = urllib.parse.urlsplit(uri) + authority = authority.encode("idna").decode("utf-8") + # For each character in 'ucschar' or 'iprivate' + # 1. encode as utf-8 + # 2. then %-encode each octet of that utf-8 + uri = urllib.parse.urlunsplit((scheme, authority, path, query, fragment)) + uri = "".join([encode(c) for c in uri]) + return uri + + +if __name__ == "__main__": + import unittest + + class Test(unittest.TestCase): + def test_uris(self): + """Test that URIs are invariant under the transformation.""" + invariant = [ + "ftp://ftp.is.co.za/rfc/rfc1808.txt", + "http://www.ietf.org/rfc/rfc2396.txt", + "ldap://[2001:db8::7]/c=GB?objectClass?one", + "mailto:John.Doe@example.com", + "news:comp.infosystems.www.servers.unix", + "tel:+1-816-555-1212", + "telnet://192.0.2.16:80/", + "urn:oasis:names:specification:docbook:dtd:xml:4.1.2", + ] + for uri in invariant: + self.assertEqual(uri, iri2uri(uri)) + + def test_iri(self): + """Test that the right type of escaping is done for each part of the URI.""" + self.assertEqual( + "http://xn--o3h.com/%E2%98%84", + iri2uri("http://\N{COMET}.com/\N{COMET}"), + ) + self.assertEqual( + "http://bitworking.org/?fred=%E2%98%84", + iri2uri("http://bitworking.org/?fred=\N{COMET}"), + ) + self.assertEqual( + "http://bitworking.org/#%E2%98%84", + iri2uri("http://bitworking.org/#\N{COMET}"), + ) + self.assertEqual("#%E2%98%84", iri2uri("#\N{COMET}")) + self.assertEqual( + "/fred?bar=%E2%98%9A#%E2%98%84", + iri2uri("/fred?bar=\N{BLACK LEFT POINTING INDEX}#\N{COMET}"), + ) + self.assertEqual( + "/fred?bar=%E2%98%9A#%E2%98%84", + iri2uri(iri2uri("/fred?bar=\N{BLACK LEFT POINTING INDEX}#\N{COMET}")), + ) + self.assertNotEqual( + "/fred?bar=%E2%98%9A#%E2%98%84", + iri2uri( + "/fred?bar=\N{BLACK LEFT POINTING INDEX}#\N{COMET}".encode("utf-8") + ), + ) + + unittest.main() diff --git a/.venv/lib/python3.11/site-packages/httplib2/socks.py b/.venv/lib/python3.11/site-packages/httplib2/socks.py new file mode 100644 index 0000000000000000000000000000000000000000..cc68e634c7def34dbf2dd0be8b0cca17970a73f9 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/httplib2/socks.py @@ -0,0 +1,518 @@ +"""SocksiPy - Python SOCKS module. + +Version 1.00 + +Copyright 2006 Dan-Haim. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. +3. Neither the name of Dan Haim nor the names of his contributors may be used + to endorse or promote products derived from this software without specific + prior written permission. + +THIS SOFTWARE IS PROVIDED BY DAN HAIM "AS IS" AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO +EVENT SHALL DAN HAIM OR HIS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA +OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT +OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMANGE. + +This module provides a standard socket-like interface for Python +for tunneling connections through SOCKS proxies. + +Minor modifications made by Christopher Gilbert (http://motomastyle.com/) for +use in PyLoris (http://pyloris.sourceforge.net/). + +Minor modifications made by Mario Vilas (http://breakingcode.wordpress.com/) +mainly to merge bug fixes found in Sourceforge. +""" + +import base64 +import socket +import struct +import sys + +if getattr(socket, "socket", None) is None: + raise ImportError("socket.socket missing, proxy support unusable") + +PROXY_TYPE_SOCKS4 = 1 +PROXY_TYPE_SOCKS5 = 2 +PROXY_TYPE_HTTP = 3 +PROXY_TYPE_HTTP_NO_TUNNEL = 4 + +_defaultproxy = None +_orgsocket = socket.socket + + +class ProxyError(Exception): + pass + + +class GeneralProxyError(ProxyError): + pass + + +class Socks5AuthError(ProxyError): + pass + + +class Socks5Error(ProxyError): + pass + + +class Socks4Error(ProxyError): + pass + + +class HTTPError(ProxyError): + pass + + +_generalerrors = ( + "success", + "invalid data", + "not connected", + "not available", + "bad proxy type", + "bad input", +) + +_socks5errors = ( + "succeeded", + "general SOCKS server failure", + "connection not allowed by ruleset", + "Network unreachable", + "Host unreachable", + "Connection refused", + "TTL expired", + "Command not supported", + "Address type not supported", + "Unknown error", +) + +_socks5autherrors = ( + "succeeded", + "authentication is required", + "all offered authentication methods were rejected", + "unknown username or invalid password", + "unknown error", +) + +_socks4errors = ( + "request granted", + "request rejected or failed", + "request rejected because SOCKS server cannot connect to identd on the client", + "request rejected because the client program and identd report different " + "user-ids", + "unknown error", +) + + +def setdefaultproxy( + proxytype=None, addr=None, port=None, rdns=True, username=None, password=None +): + """setdefaultproxy(proxytype, addr[, port[, rdns[, username[, password]]]]) + Sets a default proxy which all further socksocket objects will use, + unless explicitly changed. + """ + global _defaultproxy + _defaultproxy = (proxytype, addr, port, rdns, username, password) + + +def wrapmodule(module): + """wrapmodule(module) + + Attempts to replace a module's socket library with a SOCKS socket. Must set + a default proxy using setdefaultproxy(...) first. + This will only work on modules that import socket directly into the + namespace; + most of the Python Standard Library falls into this category. + """ + if _defaultproxy != None: + module.socket.socket = socksocket + else: + raise GeneralProxyError((4, "no proxy specified")) + + +class socksocket(socket.socket): + """socksocket([family[, type[, proto]]]) -> socket object + Open a SOCKS enabled socket. The parameters are the same as + those of the standard socket init. In order for SOCKS to work, + you must specify family=AF_INET, type=SOCK_STREAM and proto=0. + """ + + def __init__( + self, family=socket.AF_INET, type=socket.SOCK_STREAM, proto=0, _sock=None + ): + _orgsocket.__init__(self, family, type, proto, _sock) + if _defaultproxy != None: + self.__proxy = _defaultproxy + else: + self.__proxy = (None, None, None, None, None, None) + self.__proxysockname = None + self.__proxypeername = None + self.__httptunnel = True + + def __recvall(self, count): + """__recvall(count) -> data + Receive EXACTLY the number of bytes requested from the socket. + Blocks until the required number of bytes have been received. + """ + data = self.recv(count) + while len(data) < count: + d = self.recv(count - len(data)) + if not d: + raise GeneralProxyError((0, "connection closed unexpectedly")) + data = data + d + return data + + def sendall(self, content, *args): + """ override socket.socket.sendall method to rewrite the header + for non-tunneling proxies if needed + """ + if not self.__httptunnel: + content = self.__rewriteproxy(content) + return super(socksocket, self).sendall(content, *args) + + def __rewriteproxy(self, header): + """ rewrite HTTP request headers to support non-tunneling proxies + (i.e. those which do not support the CONNECT method). + This only works for HTTP (not HTTPS) since HTTPS requires tunneling. + """ + host, endpt = None, None + hdrs = header.split("\r\n") + for hdr in hdrs: + if hdr.lower().startswith("host:"): + host = hdr + elif hdr.lower().startswith("get") or hdr.lower().startswith("post"): + endpt = hdr + if host and endpt: + hdrs.remove(host) + hdrs.remove(endpt) + host = host.split(" ")[1] + endpt = endpt.split(" ") + if self.__proxy[4] != None and self.__proxy[5] != None: + hdrs.insert(0, self.__getauthheader()) + hdrs.insert(0, "Host: %s" % host) + hdrs.insert(0, "%s http://%s%s %s" % (endpt[0], host, endpt[1], endpt[2])) + return "\r\n".join(hdrs) + + def __getauthheader(self): + auth = self.__proxy[4] + b":" + self.__proxy[5] + return "Proxy-Authorization: Basic " + base64.b64encode(auth).decode() + + def setproxy( + self, + proxytype=None, + addr=None, + port=None, + rdns=True, + username=None, + password=None, + headers=None, + ): + """setproxy(proxytype, addr[, port[, rdns[, username[, password]]]]) + + Sets the proxy to be used. + proxytype - The type of the proxy to be used. Three types + are supported: PROXY_TYPE_SOCKS4 (including socks4a), + PROXY_TYPE_SOCKS5 and PROXY_TYPE_HTTP + addr - The address of the server (IP or DNS). + port - The port of the server. Defaults to 1080 for SOCKS + servers and 8080 for HTTP proxy servers. + rdns - Should DNS queries be preformed on the remote side + (rather than the local side). The default is True. + Note: This has no effect with SOCKS4 servers. + username - Username to authenticate with to the server. + The default is no authentication. + password - Password to authenticate with to the server. + Only relevant when username is also provided. + headers - Additional or modified headers for the proxy connect + request. + """ + self.__proxy = ( + proxytype, + addr, + port, + rdns, + username.encode() if username else None, + password.encode() if password else None, + headers, + ) + + def __negotiatesocks5(self, destaddr, destport): + """__negotiatesocks5(self,destaddr,destport) + Negotiates a connection through a SOCKS5 server. + """ + # First we'll send the authentication packages we support. + if (self.__proxy[4] != None) and (self.__proxy[5] != None): + # The username/password details were supplied to the + # setproxy method so we support the USERNAME/PASSWORD + # authentication (in addition to the standard none). + self.sendall(struct.pack("BBBB", 0x05, 0x02, 0x00, 0x02)) + else: + # No username/password were entered, therefore we + # only support connections with no authentication. + self.sendall(struct.pack("BBB", 0x05, 0x01, 0x00)) + # We'll receive the server's response to determine which + # method was selected + chosenauth = self.__recvall(2) + if chosenauth[0:1] != chr(0x05).encode(): + self.close() + raise GeneralProxyError((1, _generalerrors[1])) + # Check the chosen authentication method + if chosenauth[1:2] == chr(0x00).encode(): + # No authentication is required + pass + elif chosenauth[1:2] == chr(0x02).encode(): + # Okay, we need to perform a basic username/password + # authentication. + packet = bytearray() + packet.append(0x01) + packet.append(len(self.__proxy[4])) + packet.extend(self.__proxy[4]) + packet.append(len(self.__proxy[5])) + packet.extend(self.__proxy[5]) + self.sendall(packet) + authstat = self.__recvall(2) + if authstat[0:1] != chr(0x01).encode(): + # Bad response + self.close() + raise GeneralProxyError((1, _generalerrors[1])) + if authstat[1:2] != chr(0x00).encode(): + # Authentication failed + self.close() + raise Socks5AuthError((3, _socks5autherrors[3])) + # Authentication succeeded + else: + # Reaching here is always bad + self.close() + if chosenauth[1] == chr(0xFF).encode(): + raise Socks5AuthError((2, _socks5autherrors[2])) + else: + raise GeneralProxyError((1, _generalerrors[1])) + # Now we can request the actual connection + req = struct.pack("BBB", 0x05, 0x01, 0x00) + # If the given destination address is an IP address, we'll + # use the IPv4 address request even if remote resolving was specified. + try: + ipaddr = socket.inet_aton(destaddr) + req = req + chr(0x01).encode() + ipaddr + except socket.error: + # Well it's not an IP number, so it's probably a DNS name. + if self.__proxy[3]: + # Resolve remotely + ipaddr = None + req = ( + req + + chr(0x03).encode() + + chr(len(destaddr)).encode() + + destaddr.encode() + ) + else: + # Resolve locally + ipaddr = socket.inet_aton(socket.gethostbyname(destaddr)) + req = req + chr(0x01).encode() + ipaddr + req = req + struct.pack(">H", destport) + self.sendall(req) + # Get the response + resp = self.__recvall(4) + if resp[0:1] != chr(0x05).encode(): + self.close() + raise GeneralProxyError((1, _generalerrors[1])) + elif resp[1:2] != chr(0x00).encode(): + # Connection failed + self.close() + if ord(resp[1:2]) <= 8: + raise Socks5Error((ord(resp[1:2]), _socks5errors[ord(resp[1:2])])) + else: + raise Socks5Error((9, _socks5errors[9])) + # Get the bound address/port + elif resp[3:4] == chr(0x01).encode(): + boundaddr = self.__recvall(4) + elif resp[3:4] == chr(0x03).encode(): + resp = resp + self.recv(1) + boundaddr = self.__recvall(ord(resp[4:5])) + else: + self.close() + raise GeneralProxyError((1, _generalerrors[1])) + boundport = struct.unpack(">H", self.__recvall(2))[0] + self.__proxysockname = (boundaddr, boundport) + if ipaddr != None: + self.__proxypeername = (socket.inet_ntoa(ipaddr), destport) + else: + self.__proxypeername = (destaddr, destport) + + def getproxysockname(self): + """getsockname() -> address info + Returns the bound IP address and port number at the proxy. + """ + return self.__proxysockname + + def getproxypeername(self): + """getproxypeername() -> address info + Returns the IP and port number of the proxy. + """ + return _orgsocket.getpeername(self) + + def getpeername(self): + """getpeername() -> address info + Returns the IP address and port number of the destination + machine (note: getproxypeername returns the proxy) + """ + return self.__proxypeername + + def __negotiatesocks4(self, destaddr, destport): + """__negotiatesocks4(self,destaddr,destport) + Negotiates a connection through a SOCKS4 server. + """ + # Check if the destination address provided is an IP address + rmtrslv = False + try: + ipaddr = socket.inet_aton(destaddr) + except socket.error: + # It's a DNS name. Check where it should be resolved. + if self.__proxy[3]: + ipaddr = struct.pack("BBBB", 0x00, 0x00, 0x00, 0x01) + rmtrslv = True + else: + ipaddr = socket.inet_aton(socket.gethostbyname(destaddr)) + # Construct the request packet + req = struct.pack(">BBH", 0x04, 0x01, destport) + ipaddr + # The username parameter is considered userid for SOCKS4 + if self.__proxy[4] != None: + req = req + self.__proxy[4] + req = req + chr(0x00).encode() + # DNS name if remote resolving is required + # NOTE: This is actually an extension to the SOCKS4 protocol + # called SOCKS4A and may not be supported in all cases. + if rmtrslv: + req = req + destaddr + chr(0x00).encode() + self.sendall(req) + # Get the response from the server + resp = self.__recvall(8) + if resp[0:1] != chr(0x00).encode(): + # Bad data + self.close() + raise GeneralProxyError((1, _generalerrors[1])) + if resp[1:2] != chr(0x5A).encode(): + # Server returned an error + self.close() + if ord(resp[1:2]) in (91, 92, 93): + self.close() + raise Socks4Error((ord(resp[1:2]), _socks4errors[ord(resp[1:2]) - 90])) + else: + raise Socks4Error((94, _socks4errors[4])) + # Get the bound address/port + self.__proxysockname = ( + socket.inet_ntoa(resp[4:]), + struct.unpack(">H", resp[2:4])[0], + ) + if rmtrslv != None: + self.__proxypeername = (socket.inet_ntoa(ipaddr), destport) + else: + self.__proxypeername = (destaddr, destport) + + def __negotiatehttp(self, destaddr, destport): + """__negotiatehttp(self,destaddr,destport) + Negotiates a connection through an HTTP server. + """ + # If we need to resolve locally, we do this now + if not self.__proxy[3]: + addr = socket.gethostbyname(destaddr) + else: + addr = destaddr + headers = ["CONNECT ", addr, ":", str(destport), " HTTP/1.1\r\n"] + wrote_host_header = False + wrote_auth_header = False + if self.__proxy[6] != None: + for key, val in self.__proxy[6].iteritems(): + headers += [key, ": ", val, "\r\n"] + wrote_host_header = key.lower() == "host" + wrote_auth_header = key.lower() == "proxy-authorization" + if not wrote_host_header: + headers += ["Host: ", destaddr, "\r\n"] + if not wrote_auth_header: + if self.__proxy[4] != None and self.__proxy[5] != None: + headers += [self.__getauthheader(), "\r\n"] + headers.append("\r\n") + self.sendall("".join(headers).encode()) + # We read the response until we get the string "\r\n\r\n" + resp = self.recv(1) + while resp.find("\r\n\r\n".encode()) == -1: + resp = resp + self.recv(1) + # We just need the first line to check if the connection + # was successful + statusline = resp.splitlines()[0].split(" ".encode(), 2) + if statusline[0] not in ("HTTP/1.0".encode(), "HTTP/1.1".encode()): + self.close() + raise GeneralProxyError((1, _generalerrors[1])) + try: + statuscode = int(statusline[1]) + except ValueError: + self.close() + raise GeneralProxyError((1, _generalerrors[1])) + if statuscode != 200: + self.close() + raise HTTPError((statuscode, statusline[2])) + self.__proxysockname = ("0.0.0.0", 0) + self.__proxypeername = (addr, destport) + + def connect(self, destpair): + """connect(self, despair) + Connects to the specified destination through a proxy. + destpar - A tuple of the IP/DNS address and the port number. + (identical to socket's connect). + To select the proxy server use setproxy(). + """ + # Do a minimal input check first + if ( + (not type(destpair) in (list, tuple)) + or (len(destpair) < 2) + or (not isinstance(destpair[0], (str, bytes))) + or (type(destpair[1]) != int) + ): + raise GeneralProxyError((5, _generalerrors[5])) + if self.__proxy[0] == PROXY_TYPE_SOCKS5: + if self.__proxy[2] != None: + portnum = self.__proxy[2] + else: + portnum = 1080 + _orgsocket.connect(self, (self.__proxy[1], portnum)) + self.__negotiatesocks5(destpair[0], destpair[1]) + elif self.__proxy[0] == PROXY_TYPE_SOCKS4: + if self.__proxy[2] != None: + portnum = self.__proxy[2] + else: + portnum = 1080 + _orgsocket.connect(self, (self.__proxy[1], portnum)) + self.__negotiatesocks4(destpair[0], destpair[1]) + elif self.__proxy[0] == PROXY_TYPE_HTTP: + if self.__proxy[2] != None: + portnum = self.__proxy[2] + else: + portnum = 8080 + _orgsocket.connect(self, (self.__proxy[1], portnum)) + self.__negotiatehttp(destpair[0], destpair[1]) + elif self.__proxy[0] == PROXY_TYPE_HTTP_NO_TUNNEL: + if self.__proxy[2] != None: + portnum = self.__proxy[2] + else: + portnum = 8080 + _orgsocket.connect(self, (self.__proxy[1], portnum)) + if destpair[1] == 443: + self.__negotiatehttp(destpair[0], destpair[1]) + else: + self.__httptunnel = False + elif self.__proxy[0] == None: + _orgsocket.connect(self, (destpair[0], destpair[1])) + else: + raise GeneralProxyError((4, _generalerrors[4])) diff --git a/.venv/lib/python3.11/site-packages/mpmath/tests/__pycache__/test_fp.cpython-311.pyc b/.venv/lib/python3.11/site-packages/mpmath/tests/__pycache__/test_fp.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a71dfbaac1d99cf8113b11783fae30be1ab65411 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/mpmath/tests/__pycache__/test_fp.cpython-311.pyc @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5f6b76f33b790aadce04c15aa44a83a4a865757f2e425cdb8e5aa751631a87b4 +size 142531 diff --git a/.venv/lib/python3.11/site-packages/nvidia_nvjitlink_cu12-12.4.127.dist-info/INSTALLER b/.venv/lib/python3.11/site-packages/nvidia_nvjitlink_cu12-12.4.127.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/nvidia_nvjitlink_cu12-12.4.127.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/.venv/lib/python3.11/site-packages/nvidia_nvjitlink_cu12-12.4.127.dist-info/License.txt b/.venv/lib/python3.11/site-packages/nvidia_nvjitlink_cu12-12.4.127.dist-info/License.txt new file mode 100644 index 0000000000000000000000000000000000000000..b491c70e0aef319022ded661e111ddbd45b8a17f --- /dev/null +++ b/.venv/lib/python3.11/site-packages/nvidia_nvjitlink_cu12-12.4.127.dist-info/License.txt @@ -0,0 +1,1568 @@ +End User License Agreement +-------------------------- + + +Preface +------- + +The Software License Agreement in Chapter 1 and the Supplement +in Chapter 2 contain license terms and conditions that govern +the use of NVIDIA software. By accepting this agreement, you +agree to comply with all the terms and conditions applicable +to the product(s) included herein. + + +NVIDIA Driver + + +Description + +This package contains the operating system driver and +fundamental system software components for NVIDIA GPUs. + + +NVIDIA CUDA Toolkit + + +Description + +The NVIDIA CUDA Toolkit provides command-line and graphical +tools for building, debugging and optimizing the performance +of applications accelerated by NVIDIA GPUs, runtime and math +libraries, and documentation including programming guides, +user manuals, and API references. + + +Default Install Location of CUDA Toolkit + +Windows platform: + +%ProgramFiles%\NVIDIA GPU Computing Toolkit\CUDA\v#.# + +Linux platform: + +/usr/local/cuda-#.# + +Mac platform: + +/Developer/NVIDIA/CUDA-#.# + + +NVIDIA CUDA Samples + + +Description + +This package includes over 100+ CUDA examples that demonstrate +various CUDA programming principles, and efficient CUDA +implementation of algorithms in specific application domains. + + +Default Install Location of CUDA Samples + +Windows platform: + +%ProgramData%\NVIDIA Corporation\CUDA Samples\v#.# + +Linux platform: + +/usr/local/cuda-#.#/samples + +and + +$HOME/NVIDIA_CUDA-#.#_Samples + +Mac platform: + +/Developer/NVIDIA/CUDA-#.#/samples + + +NVIDIA Nsight Visual Studio Edition (Windows only) + + +Description + +NVIDIA Nsight Development Platform, Visual Studio Edition is a +development environment integrated into Microsoft Visual +Studio that provides tools for debugging, profiling, analyzing +and optimizing your GPU computing and graphics applications. + + +Default Install Location of Nsight Visual Studio Edition + +Windows platform: + +%ProgramFiles(x86)%\NVIDIA Corporation\Nsight Visual Studio Edition #.# + + +1. License Agreement for NVIDIA Software Development Kits +--------------------------------------------------------- + + +Release Date: July 26, 2018 +--------------------------- + + +Important NoticeRead before downloading, installing, +copying or using the licensed software: +------------------------------------------------------- + +This license agreement, including exhibits attached +("Agreement”) is a legal agreement between you and NVIDIA +Corporation ("NVIDIA") and governs your use of a NVIDIA +software development kit (“SDK”). + +Each SDK has its own set of software and materials, but here +is a description of the types of items that may be included in +a SDK: source code, header files, APIs, data sets and assets +(examples include images, textures, models, scenes, videos, +native API input/output files), binary software, sample code, +libraries, utility programs, programming code and +documentation. + +This Agreement can be accepted only by an adult of legal age +of majority in the country in which the SDK is used. + +If you are entering into this Agreement on behalf of a company +or other legal entity, you represent that you have the legal +authority to bind the entity to this Agreement, in which case +“you” will mean the entity you represent. + +If you don’t have the required age or authority to accept +this Agreement, or if you don’t accept all the terms and +conditions of this Agreement, do not download, install or use +the SDK. + +You agree to use the SDK only for purposes that are permitted +by (a) this Agreement, and (b) any applicable law, regulation +or generally accepted practices or guidelines in the relevant +jurisdictions. + + +1.1. License + + +1.1.1. License Grant + +Subject to the terms of this Agreement, NVIDIA hereby grants +you a non-exclusive, non-transferable license, without the +right to sublicense (except as expressly provided in this +Agreement) to: + + 1. Install and use the SDK, + + 2. Modify and create derivative works of sample source code + delivered in the SDK, and + + 3. Distribute those portions of the SDK that are identified + in this Agreement as distributable, as incorporated in + object code format into a software application that meets + the distribution requirements indicated in this Agreement. + + +1.1.2. Distribution Requirements + +These are the distribution requirements for you to exercise +the distribution grant: + + 1. Your application must have material additional + functionality, beyond the included portions of the SDK. + + 2. The distributable portions of the SDK shall only be + accessed by your application. + + 3. The following notice shall be included in modifications + and derivative works of sample source code distributed: + “This software contains source code provided by NVIDIA + Corporation.” + + 4. Unless a developer tool is identified in this Agreement + as distributable, it is delivered for your internal use + only. + + 5. The terms under which you distribute your application + must be consistent with the terms of this Agreement, + including (without limitation) terms relating to the + license grant and license restrictions and protection of + NVIDIA’s intellectual property rights. Additionally, you + agree that you will protect the privacy, security and + legal rights of your application users. + + 6. You agree to notify NVIDIA in writing of any known or + suspected distribution or use of the SDK not in compliance + with the requirements of this Agreement, and to enforce + the terms of your agreements with respect to distributed + SDK. + + +1.1.3. Authorized Users + +You may allow employees and contractors of your entity or of +your subsidiary(ies) to access and use the SDK from your +secure network to perform work on your behalf. + +If you are an academic institution you may allow users +enrolled or employed by the academic institution to access and +use the SDK from your secure network. + +You are responsible for the compliance with the terms of this +Agreement by your authorized users. If you become aware that +your authorized users didn’t follow the terms of this +Agreement, you agree to take reasonable steps to resolve the +non-compliance and prevent new occurrences. + + +1.1.4. Pre-Release SDK + +The SDK versions identified as alpha, beta, preview or +otherwise as pre-release, may not be fully functional, may +contain errors or design flaws, and may have reduced or +different security, privacy, accessibility, availability, and +reliability standards relative to commercial versions of +NVIDIA software and materials. Use of a pre-release SDK may +result in unexpected results, loss of data, project delays or +other unpredictable damage or loss. + +You may use a pre-release SDK at your own risk, understanding +that pre-release SDKs are not intended for use in production +or business-critical systems. + +NVIDIA may choose not to make available a commercial version +of any pre-release SDK. NVIDIA may also choose to abandon +development and terminate the availability of a pre-release +SDK at any time without liability. + + +1.1.5. Updates + +NVIDIA may, at its option, make available patches, workarounds +or other updates to this SDK. Unless the updates are provided +with their separate governing terms, they are deemed part of +the SDK licensed to you as provided in this Agreement. You +agree that the form and content of the SDK that NVIDIA +provides may change without prior notice to you. While NVIDIA +generally maintains compatibility between versions, NVIDIA may +in some cases make changes that introduce incompatibilities in +future versions of the SDK. + + +1.1.6. Third Party Licenses + +The SDK may come bundled with, or otherwise include or be +distributed with, third party software licensed by a NVIDIA +supplier and/or open source software provided under an open +source license. Use of third party software is subject to the +third-party license terms, or in the absence of third party +terms, the terms of this Agreement. Copyright to third party +software is held by the copyright holders indicated in the +third-party software or license. + + +1.1.7. Reservation of Rights + +NVIDIA reserves all rights, title, and interest in and to the +SDK, not expressly granted to you under this Agreement. + + +1.2. Limitations + +The following license limitations apply to your use of the +SDK: + + 1. You may not reverse engineer, decompile or disassemble, + or remove copyright or other proprietary notices from any + portion of the SDK or copies of the SDK. + + 2. Except as expressly provided in this Agreement, you may + not copy, sell, rent, sublicense, transfer, distribute, + modify, or create derivative works of any portion of the + SDK. For clarity, you may not distribute or sublicense the + SDK as a stand-alone product. + + 3. Unless you have an agreement with NVIDIA for this + purpose, you may not indicate that an application created + with the SDK is sponsored or endorsed by NVIDIA. + + 4. You may not bypass, disable, or circumvent any + encryption, security, digital rights management or + authentication mechanism in the SDK. + + 5. You may not use the SDK in any manner that would cause it + to become subject to an open source software license. As + examples, licenses that require as a condition of use, + modification, and/or distribution that the SDK be: + + a. Disclosed or distributed in source code form; + + b. Licensed for the purpose of making derivative works; + or + + c. Redistributable at no charge. + + 6. Unless you have an agreement with NVIDIA for this + purpose, you may not use the SDK with any system or + application where the use or failure of the system or + application can reasonably be expected to threaten or + result in personal injury, death, or catastrophic loss. + Examples include use in avionics, navigation, military, + medical, life support or other life critical applications. + NVIDIA does not design, test or manufacture the SDK for + these critical uses and NVIDIA shall not be liable to you + or any third party, in whole or in part, for any claims or + damages arising from such uses. + + 7. You agree to defend, indemnify and hold harmless NVIDIA + and its affiliates, and their respective employees, + contractors, agents, officers and directors, from and + against any and all claims, damages, obligations, losses, + liabilities, costs or debt, fines, restitutions and + expenses (including but not limited to attorney’s fees + and costs incident to establishing the right of + indemnification) arising out of or related to your use of + the SDK outside of the scope of this Agreement, or not in + compliance with its terms. + + +1.3. Ownership + + 1. NVIDIA or its licensors hold all rights, title and + interest in and to the SDK and its modifications and + derivative works, including their respective intellectual + property rights, subject to your rights described in this + section. This SDK may include software and materials from + NVIDIA’s licensors, and these licensors are intended + third party beneficiaries that may enforce this Agreement + with respect to their intellectual property rights. + + 2. You hold all rights, title and interest in and to your + applications and your derivative works of the sample + source code delivered in the SDK, including their + respective intellectual property rights, subject to + NVIDIA’s rights described in this section. + + 3. You may, but don’t have to, provide to NVIDIA + suggestions, feature requests or other feedback regarding + the SDK, including possible enhancements or modifications + to the SDK. For any feedback that you voluntarily provide, + you hereby grant NVIDIA and its affiliates a perpetual, + non-exclusive, worldwide, irrevocable license to use, + reproduce, modify, license, sublicense (through multiple + tiers of sublicensees), and distribute (through multiple + tiers of distributors) it without the payment of any + royalties or fees to you. NVIDIA will use feedback at its + choice. NVIDIA is constantly looking for ways to improve + its products, so you may send feedback to NVIDIA through + the developer portal at https://developer.nvidia.com. + + +1.4. No Warranties + +THE SDK IS PROVIDED BY NVIDIA “AS IS” AND “WITH ALL +FAULTS.” TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND +ITS AFFILIATES EXPRESSLY DISCLAIM ALL WARRANTIES OF ANY KIND +OR NATURE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, +BUT NOT LIMITED TO, ANY WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE, TITLE, NON-INFRINGEMENT, OR THE +ABSENCE OF ANY DEFECTS THEREIN, WHETHER LATENT OR PATENT. NO +WARRANTY IS MADE ON THE BASIS OF TRADE USAGE, COURSE OF +DEALING OR COURSE OF TRADE. + + +1.5. Limitation of Liability + +TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND ITS +AFFILIATES SHALL NOT BE LIABLE FOR ANY SPECIAL, INCIDENTAL, +PUNITIVE OR CONSEQUENTIAL DAMAGES, OR ANY LOST PROFITS, LOSS +OF USE, LOSS OF DATA OR LOSS OF GOODWILL, OR THE COSTS OF +PROCURING SUBSTITUTE PRODUCTS, ARISING OUT OF OR IN CONNECTION +WITH THIS AGREEMENT OR THE USE OR PERFORMANCE OF THE SDK, +WHETHER SUCH LIABILITY ARISES FROM ANY CLAIM BASED UPON BREACH +OF CONTRACT, BREACH OF WARRANTY, TORT (INCLUDING NEGLIGENCE), +PRODUCT LIABILITY OR ANY OTHER CAUSE OF ACTION OR THEORY OF +LIABILITY. IN NO EVENT WILL NVIDIA’S AND ITS AFFILIATES +TOTAL CUMULATIVE LIABILITY UNDER OR ARISING OUT OF THIS +AGREEMENT EXCEED US$10.00. THE NATURE OF THE LIABILITY OR THE +NUMBER OF CLAIMS OR SUITS SHALL NOT ENLARGE OR EXTEND THIS +LIMIT. + +These exclusions and limitations of liability shall apply +regardless if NVIDIA or its affiliates have been advised of +the possibility of such damages, and regardless of whether a +remedy fails its essential purpose. These exclusions and +limitations of liability form an essential basis of the +bargain between the parties, and, absent any of these +exclusions or limitations of liability, the provisions of this +Agreement, including, without limitation, the economic terms, +would be substantially different. + + +1.6. Termination + + 1. This Agreement will continue to apply until terminated by + either you or NVIDIA as described below. + + 2. If you want to terminate this Agreement, you may do so by + stopping to use the SDK. + + 3. NVIDIA may, at any time, terminate this Agreement if: + + a. (i) you fail to comply with any term of this + Agreement and the non-compliance is not fixed within + thirty (30) days following notice from NVIDIA (or + immediately if you violate NVIDIA’s intellectual + property rights); + + b. (ii) you commence or participate in any legal + proceeding against NVIDIA with respect to the SDK; or + + c. (iii) NVIDIA decides to no longer provide the SDK in + a country or, in NVIDIA’s sole discretion, the + continued use of it is no longer commercially viable. + + 4. Upon any termination of this Agreement, you agree to + promptly discontinue use of the SDK and destroy all copies + in your possession or control. Your prior distributions in + accordance with this Agreement are not affected by the + termination of this Agreement. Upon written request, you + will certify in writing that you have complied with your + commitments under this section. Upon any termination of + this Agreement all provisions survive except for the + license grant provisions. + + +1.7. General + +If you wish to assign this Agreement or your rights and +obligations, including by merger, consolidation, dissolution +or operation of law, contact NVIDIA to ask for permission. Any +attempted assignment not approved by NVIDIA in writing shall +be void and of no effect. NVIDIA may assign, delegate or +transfer this Agreement and its rights and obligations, and if +to a non-affiliate you will be notified. + +You agree to cooperate with NVIDIA and provide reasonably +requested information to verify your compliance with this +Agreement. + +This Agreement will be governed in all respects by the laws of +the United States and of the State of Delaware as those laws +are applied to contracts entered into and performed entirely +within Delaware by Delaware residents, without regard to the +conflicts of laws principles. The United Nations Convention on +Contracts for the International Sale of Goods is specifically +disclaimed. You agree to all terms of this Agreement in the +English language. + +The state or federal courts residing in Santa Clara County, +California shall have exclusive jurisdiction over any dispute +or claim arising out of this Agreement. Notwithstanding this, +you agree that NVIDIA shall still be allowed to apply for +injunctive remedies or an equivalent type of urgent legal +relief in any jurisdiction. + +If any court of competent jurisdiction determines that any +provision of this Agreement is illegal, invalid or +unenforceable, such provision will be construed as limited to +the extent necessary to be consistent with and fully +enforceable under the law and the remaining provisions will +remain in full force and effect. Unless otherwise specified, +remedies are cumulative. + +Each party acknowledges and agrees that the other is an +independent contractor in the performance of this Agreement. + +The SDK has been developed entirely at private expense and is +“commercial items” consisting of “commercial computer +software” and “commercial computer software +documentation” provided with RESTRICTED RIGHTS. Use, +duplication or disclosure by the U.S. Government or a U.S. +Government subcontractor is subject to the restrictions in +this Agreement pursuant to DFARS 227.7202-3(a) or as set forth +in subparagraphs (c)(1) and (2) of the Commercial Computer +Software - Restricted Rights clause at FAR 52.227-19, as +applicable. Contractor/manufacturer is NVIDIA, 2788 San Tomas +Expressway, Santa Clara, CA 95051. + +The SDK is subject to United States export laws and +regulations. You agree that you will not ship, transfer or +export the SDK into any country, or use the SDK in any manner, +prohibited by the United States Bureau of Industry and +Security or economic sanctions regulations administered by the +U.S. Department of Treasury’s Office of Foreign Assets +Control (OFAC), or any applicable export laws, restrictions or +regulations. These laws include restrictions on destinations, +end users and end use. By accepting this Agreement, you +confirm that you are not a resident or citizen of any country +currently embargoed by the U.S. and that you are not otherwise +prohibited from receiving the SDK. + +Any notice delivered by NVIDIA to you under this Agreement +will be delivered via mail, email or fax. You agree that any +notices that NVIDIA sends you electronically will satisfy any +legal communication requirements. Please direct your legal +notices or other correspondence to NVIDIA Corporation, 2788 +San Tomas Expressway, Santa Clara, California 95051, United +States of America, Attention: Legal Department. + +This Agreement and any exhibits incorporated into this +Agreement constitute the entire agreement of the parties with +respect to the subject matter of this Agreement and supersede +all prior negotiations or documentation exchanged between the +parties relating to this SDK license. Any additional and/or +conflicting terms on documents issued by you are null, void, +and invalid. Any amendment or waiver under this Agreement +shall be in writing and signed by representatives of both +parties. + + +2. CUDA Toolkit Supplement to Software License Agreement for +NVIDIA Software Development Kits +------------------------------------------------------------ + + +Release date: August 16, 2018 +----------------------------- + +The terms in this supplement govern your use of the NVIDIA +CUDA Toolkit SDK under the terms of your license agreement +(“Agreement”) as modified by this supplement. Capitalized +terms used but not defined below have the meaning assigned to +them in the Agreement. + +This supplement is an exhibit to the Agreement and is +incorporated as an integral part of the Agreement. In the +event of conflict between the terms in this supplement and the +terms in the Agreement, the terms in this supplement govern. + + +2.1. License Scope + +The SDK is licensed for you to develop applications only for +use in systems with NVIDIA GPUs. + + +2.2. Distribution + +The portions of the SDK that are distributable under the +Agreement are listed in Attachment A. + + +2.3. Operating Systems + +Those portions of the SDK designed exclusively for use on the +Linux or FreeBSD operating systems, or other operating systems +derived from the source code to these operating systems, may +be copied and redistributed for use in accordance with this +Agreement, provided that the object code files are not +modified in any way (except for unzipping of compressed +files). + + +2.4. Audio and Video Encoders and Decoders + +You acknowledge and agree that it is your sole responsibility +to obtain any additional third-party licenses required to +make, have made, use, have used, sell, import, and offer for +sale your products or services that include or incorporate any +third-party software and content relating to audio and/or +video encoders and decoders from, including but not limited +to, Microsoft, Thomson, Fraunhofer IIS, Sisvel S.p.A., +MPEG-LA, and Coding Technologies. NVIDIA does not grant to you +under this Agreement any necessary patent or other rights with +respect to any audio and/or video encoders and decoders. + + +2.5. Licensing + +If the distribution terms in this Agreement are not suitable +for your organization, or for any questions regarding this +Agreement, please contact NVIDIA at +nvidia-compute-license-questions@nvidia.com. + + +2.6. Attachment A + +The following portions of the SDK are distributable under the +Agreement: + +Component + +CUDA Runtime + +Windows + +cudart.dll, cudart_static.lib, cudadevrt.lib + +Mac OSX + +libcudart.dylib, libcudart_static.a, libcudadevrt.a + +Linux + +libcudart.so, libcudart_static.a, libcudadevrt.a + +Android + +libcudart.so, libcudart_static.a, libcudadevrt.a + +Component + +CUDA FFT Library + +Windows + +cufft.dll, cufftw.dll, cufft.lib, cufftw.lib + +Mac OSX + +libcufft.dylib, libcufft_static.a, libcufftw.dylib, +libcufftw_static.a + +Linux + +libcufft.so, libcufft_static.a, libcufftw.so, +libcufftw_static.a + +Android + +libcufft.so, libcufft_static.a, libcufftw.so, +libcufftw_static.a + +Component + +CUDA BLAS Library + +Windows + +cublas.dll, cublasLt.dll + +Mac OSX + +libcublas.dylib, libcublasLt.dylib, libcublas_static.a, +libcublasLt_static.a + +Linux + +libcublas.so, libcublasLt.so, libcublas_static.a, +libcublasLt_static.a + +Android + +libcublas.so, libcublasLt.so, libcublas_static.a, +libcublasLt_static.a + +Component + +NVIDIA "Drop-in" BLAS Library + +Windows + +nvblas.dll + +Mac OSX + +libnvblas.dylib + +Linux + +libnvblas.so + +Component + +CUDA Sparse Matrix Library + +Windows + +cusparse.dll, cusparse.lib + +Mac OSX + +libcusparse.dylib, libcusparse_static.a + +Linux + +libcusparse.so, libcusparse_static.a + +Android + +libcusparse.so, libcusparse_static.a + +Component + +CUDA Linear Solver Library + +Windows + +cusolver.dll, cusolver.lib + +Mac OSX + +libcusolver.dylib, libcusolver_static.a + +Linux + +libcusolver.so, libcusolver_static.a + +Android + +libcusolver.so, libcusolver_static.a + +Component + +CUDA Random Number Generation Library + +Windows + +curand.dll, curand.lib + +Mac OSX + +libcurand.dylib, libcurand_static.a + +Linux + +libcurand.so, libcurand_static.a + +Android + +libcurand.so, libcurand_static.a + +Component + +CUDA Accelerated Graph Library + +Component + +NVIDIA Performance Primitives Library + +Windows + +nppc.dll, nppc.lib, nppial.dll, nppial.lib, nppicc.dll, +nppicc.lib, nppicom.dll, nppicom.lib, nppidei.dll, +nppidei.lib, nppif.dll, nppif.lib, nppig.dll, nppig.lib, +nppim.dll, nppim.lib, nppist.dll, nppist.lib, nppisu.dll, +nppisu.lib, nppitc.dll, nppitc.lib, npps.dll, npps.lib + +Mac OSX + +libnppc.dylib, libnppc_static.a, libnppial.dylib, +libnppial_static.a, libnppicc.dylib, libnppicc_static.a, +libnppicom.dylib, libnppicom_static.a, libnppidei.dylib, +libnppidei_static.a, libnppif.dylib, libnppif_static.a, +libnppig.dylib, libnppig_static.a, libnppim.dylib, +libnppisu_static.a, libnppitc.dylib, libnppitc_static.a, +libnpps.dylib, libnpps_static.a + +Linux + +libnppc.so, libnppc_static.a, libnppial.so, +libnppial_static.a, libnppicc.so, libnppicc_static.a, +libnppicom.so, libnppicom_static.a, libnppidei.so, +libnppidei_static.a, libnppif.so, libnppif_static.a +libnppig.so, libnppig_static.a, libnppim.so, +libnppim_static.a, libnppist.so, libnppist_static.a, +libnppisu.so, libnppisu_static.a, libnppitc.so +libnppitc_static.a, libnpps.so, libnpps_static.a + +Android + +libnppc.so, libnppc_static.a, libnppial.so, +libnppial_static.a, libnppicc.so, libnppicc_static.a, +libnppicom.so, libnppicom_static.a, libnppidei.so, +libnppidei_static.a, libnppif.so, libnppif_static.a +libnppig.so, libnppig_static.a, libnppim.so, +libnppim_static.a, libnppist.so, libnppist_static.a, +libnppisu.so, libnppisu_static.a, libnppitc.so +libnppitc_static.a, libnpps.so, libnpps_static.a + +Component + +NVIDIA JPEG Library + +Linux + +libnvjpeg.so, libnvjpeg_static.a + +Component + +Internal common library required for statically linking to +cuBLAS, cuSPARSE, cuFFT, cuRAND, nvJPEG and NPP + +Mac OSX + +libculibos.a + +Linux + +libculibos.a + +Component + +NVIDIA Runtime Compilation Library and Header + +All + +nvrtc.h + +Windows + +nvrtc.dll, nvrtc-builtins.dll + +Mac OSX + +libnvrtc.dylib, libnvrtc-builtins.dylib + +Linux + +libnvrtc.so, libnvrtc-builtins.so + +Component + +NVIDIA Optimizing Compiler Library + +Windows + +nvvm.dll + +Mac OSX + +libnvvm.dylib + +Linux + +libnvvm.so + +Component + +NVIDIA Common Device Math Functions Library + +Windows + +libdevice.10.bc + +Mac OSX + +libdevice.10.bc + +Linux + +libdevice.10.bc + +Component + +CUDA Occupancy Calculation Header Library + +All + +cuda_occupancy.h + +Component + +CUDA Half Precision Headers + +All + +cuda_fp16.h, cuda_fp16.hpp + +Component + +CUDA Profiling Tools Interface (CUPTI) Library + +Windows + +cupti.dll + +Mac OSX + +libcupti.dylib + +Linux + +libcupti.so + +Component + +NVIDIA Tools Extension Library + +Windows + +nvToolsExt.dll, nvToolsExt.lib + +Mac OSX + +libnvToolsExt.dylib + +Linux + +libnvToolsExt.so + +Component + +NVIDIA CUDA Driver Libraries + +Linux + +libcuda.so, libnvidia-fatbinaryloader.so, +libnvidia-ptxjitcompiler.so + +The NVIDIA CUDA Driver Libraries are only distributable in +applications that meet this criteria: + + 1. The application was developed starting from a NVIDIA CUDA + container obtained from Docker Hub or the NVIDIA GPU + Cloud, and + + 2. The resulting application is packaged as a Docker + container and distributed to users on Docker Hub or the + NVIDIA GPU Cloud only. + + +2.7. Attachment B + + +Additional Licensing Obligations + +The following third party components included in the SOFTWARE +are licensed to Licensee pursuant to the following terms and +conditions: + + 1. Licensee's use of the GDB third party component is + subject to the terms and conditions of GNU GPL v3: + + This product includes copyrighted third-party software licensed + under the terms of the GNU General Public License v3 ("GPL v3"). + All third-party software packages are copyright by their respective + authors. GPL v3 terms and conditions are hereby incorporated into + the Agreement by this reference: http://www.gnu.org/licenses/gpl.txt + + Consistent with these licensing requirements, the software + listed below is provided under the terms of the specified + open source software licenses. To obtain source code for + software provided under licenses that require + redistribution of source code, including the GNU General + Public License (GPL) and GNU Lesser General Public License + (LGPL), contact oss-requests@nvidia.com. This offer is + valid for a period of three (3) years from the date of the + distribution of this product by NVIDIA CORPORATION. + + Component License + CUDA-GDB GPL v3 + + 2. Licensee represents and warrants that any and all third + party licensing and/or royalty payment obligations in + connection with Licensee's use of the H.264 video codecs + are solely the responsibility of Licensee. + + 3. Licensee's use of the Thrust library is subject to the + terms and conditions of the Apache License Version 2.0. + All third-party software packages are copyright by their + respective authors. Apache License Version 2.0 terms and + conditions are hereby incorporated into the Agreement by + this reference. + http://www.apache.org/licenses/LICENSE-2.0.html + + In addition, Licensee acknowledges the following notice: + Thrust includes source code from the Boost Iterator, + Tuple, System, and Random Number libraries. + + Boost Software License - Version 1.0 - August 17th, 2003 + . . . . + + Permission is hereby granted, free of charge, to any person or + organization obtaining a copy of the software and accompanying + documentation covered by this license (the "Software") to use, + reproduce, display, distribute, execute, and transmit the Software, + and to prepare derivative works of the Software, and to permit + third-parties to whom the Software is furnished to do so, all + subject to the following: + + The copyright notices in the Software and this entire statement, + including the above license grant, this restriction and the following + disclaimer, must be included in all copies of the Software, in whole + or in part, and all derivative works of the Software, unless such + copies or derivative works are solely in the form of machine-executable + object code generated by a source language processor. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND + NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR + ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR + OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + OTHER DEALINGS IN THE SOFTWARE. + + 4. Licensee's use of the LLVM third party component is + subject to the following terms and conditions: + + ====================================================== + LLVM Release License + ====================================================== + University of Illinois/NCSA + Open Source License + + Copyright (c) 2003-2010 University of Illinois at Urbana-Champaign. + All rights reserved. + + Developed by: + + LLVM Team + + University of Illinois at Urbana-Champaign + + http://llvm.org + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to + deal with the Software without restriction, including without limitation the + rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + sell copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimers. + + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimers in the + documentation and/or other materials provided with the distribution. + + * Neither the names of the LLVM Team, University of Illinois at Urbana- + Champaign, nor the names of its contributors may be used to endorse or + promote products derived from this Software without specific prior + written permission. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS WITH THE SOFTWARE. + + 5. Licensee's use (e.g. nvprof) of the PCRE third party + component is subject to the following terms and + conditions: + + ------------ + PCRE LICENCE + ------------ + PCRE is a library of functions to support regular expressions whose syntax + and semantics are as close as possible to those of the Perl 5 language. + Release 8 of PCRE is distributed under the terms of the "BSD" licence, as + specified below. The documentation for PCRE, supplied in the "doc" + directory, is distributed under the same terms as the software itself. The + basic library functions are written in C and are freestanding. Also + included in the distribution is a set of C++ wrapper functions, and a just- + in-time compiler that can be used to optimize pattern matching. These are + both optional features that can be omitted when the library is built. + + THE BASIC LIBRARY FUNCTIONS + --------------------------- + Written by: Philip Hazel + Email local part: ph10 + Email domain: cam.ac.uk + University of Cambridge Computing Service, + Cambridge, England. + Copyright (c) 1997-2012 University of Cambridge + All rights reserved. + + PCRE JUST-IN-TIME COMPILATION SUPPORT + ------------------------------------- + Written by: Zoltan Herczeg + Email local part: hzmester + Emain domain: freemail.hu + Copyright(c) 2010-2012 Zoltan Herczeg + All rights reserved. + + STACK-LESS JUST-IN-TIME COMPILER + -------------------------------- + Written by: Zoltan Herczeg + Email local part: hzmester + Emain domain: freemail.hu + Copyright(c) 2009-2012 Zoltan Herczeg + All rights reserved. + + THE C++ WRAPPER FUNCTIONS + ------------------------- + Contributed by: Google Inc. + Copyright (c) 2007-2012, Google Inc. + All rights reserved. + + THE "BSD" LICENCE + ----------------- + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + * Neither the name of the University of Cambridge nor the name of Google + Inc. nor the names of their contributors may be used to endorse or + promote products derived from this software without specific prior + written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + + 6. Some of the cuBLAS library routines were written by or + derived from code written by Vasily Volkov and are subject + to the Modified Berkeley Software Distribution License as + follows: + + Copyright (c) 2007-2009, Regents of the University of California + + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of the University of California, Berkeley nor + the names of its contributors may be used to endorse or promote + products derived from this software without specific prior + written permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR + IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING + IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + + 7. Some of the cuBLAS library routines were written by or + derived from code written by Davide Barbieri and are + subject to the Modified Berkeley Software Distribution + License as follows: + + Copyright (c) 2008-2009 Davide Barbieri @ University of Rome Tor Vergata. + + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * The name of the author may not be used to endorse or promote + products derived from this software without specific prior + written permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR + IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING + IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + + 8. Some of the cuBLAS library routines were derived from + code developed by the University of Tennessee and are + subject to the Modified Berkeley Software Distribution + License as follows: + + Copyright (c) 2010 The University of Tennessee. + + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer listed in this license in the documentation and/or + other materials provided with the distribution. + * Neither the name of the copyright holders nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + 9. Some of the cuBLAS library routines were written by or + derived from code written by Jonathan Hogg and are subject + to the Modified Berkeley Software Distribution License as + follows: + + Copyright (c) 2012, The Science and Technology Facilities Council (STFC). + + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of the STFC nor the names of its contributors + may be used to endorse or promote products derived from this + software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE STFC BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + 10. Some of the cuBLAS library routines were written by or + derived from code written by Ahmad M. Abdelfattah, David + Keyes, and Hatem Ltaief, and are subject to the Apache + License, Version 2.0, as follows: + + -- (C) Copyright 2013 King Abdullah University of Science and Technology + Authors: + Ahmad Abdelfattah (ahmad.ahmad@kaust.edu.sa) + David Keyes (david.keyes@kaust.edu.sa) + Hatem Ltaief (hatem.ltaief@kaust.edu.sa) + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of the King Abdullah University of Science and + Technology nor the names of its contributors may be used to endorse + or promote products derived from this software without specific prior + written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE + + 11. Some of the cuSPARSE library routines were written by or + derived from code written by Li-Wen Chang and are subject + to the NCSA Open Source License as follows: + + Copyright (c) 2012, University of Illinois. + + All rights reserved. + + Developed by: IMPACT Group, University of Illinois, http://impact.crhc.illinois.edu + + Permission is hereby granted, free of charge, to any person obtaining + a copy of this software and associated documentation files (the + "Software"), to deal with the Software without restriction, including + without limitation the rights to use, copy, modify, merge, publish, + distribute, sublicense, and/or sell copies of the Software, and to + permit persons to whom the Software is furnished to do so, subject to + the following conditions: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimers in the documentation and/or other materials provided + with the distribution. + * Neither the names of IMPACT Group, University of Illinois, nor + the names of its contributors may be used to endorse or promote + products derived from this Software without specific prior + written permission. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT + HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR + IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE + SOFTWARE. + + 12. Some of the cuRAND library routines were written by or + derived from code written by Mutsuo Saito and Makoto + Matsumoto and are subject to the following license: + + Copyright (c) 2009, 2010 Mutsuo Saito, Makoto Matsumoto and Hiroshima + University. All rights reserved. + + Copyright (c) 2011 Mutsuo Saito, Makoto Matsumoto, Hiroshima + University and University of Tokyo. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of the Hiroshima University nor the names of + its contributors may be used to endorse or promote products + derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + 13. Some of the cuRAND library routines were derived from + code developed by D. E. Shaw Research and are subject to + the following license: + + Copyright 2010-2011, D. E. Shaw Research. + + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions, and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions, and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of D. E. Shaw Research nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + 14. Some of the Math library routines were written by or + derived from code developed by Norbert Juffa and are + subject to the following license: + + Copyright (c) 2015-2017, Norbert Juffa + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + 15. Licensee's use of the lz4 third party component is + subject to the following terms and conditions: + + Copyright (C) 2011-2013, Yann Collet. + BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimer + in the documentation and/or other materials provided with the + distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + 16. The NPP library uses code from the Boost Math Toolkit, + and is subject to the following license: + + Boost Software License - Version 1.0 - August 17th, 2003 + . . . . + + Permission is hereby granted, free of charge, to any person or + organization obtaining a copy of the software and accompanying + documentation covered by this license (the "Software") to use, + reproduce, display, distribute, execute, and transmit the Software, + and to prepare derivative works of the Software, and to permit + third-parties to whom the Software is furnished to do so, all + subject to the following: + + The copyright notices in the Software and this entire statement, + including the above license grant, this restriction and the following + disclaimer, must be included in all copies of the Software, in whole + or in part, and all derivative works of the Software, unless such + copies or derivative works are solely in the form of machine-executable + object code generated by a source language processor. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND + NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR + ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR + OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + OTHER DEALINGS IN THE SOFTWARE. + + 17. Portions of the Nsight Eclipse Edition is subject to the + following license: + + The Eclipse Foundation makes available all content in this plug-in + ("Content"). Unless otherwise indicated below, the Content is provided + to you under the terms and conditions of the Eclipse Public License + Version 1.0 ("EPL"). A copy of the EPL is available at http:// + www.eclipse.org/legal/epl-v10.html. For purposes of the EPL, "Program" + will mean the Content. + + If you did not receive this Content directly from the Eclipse + Foundation, the Content is being redistributed by another party + ("Redistributor") and different terms and conditions may apply to your + use of any object code in the Content. Check the Redistributor's + license that was provided with the Content. If no such license exists, + contact the Redistributor. Unless otherwise indicated below, the terms + and conditions of the EPL still apply to any source code in the + Content and such source code may be obtained at http://www.eclipse.org. + + 18. Some of the cuBLAS library routines uses code from + OpenAI, which is subject to the following license: + + License URL + https://github.com/openai/openai-gemm/blob/master/LICENSE + + License Text + The MIT License + + Copyright (c) 2016 OpenAI (http://openai.com), 2016 Google Inc. + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. + + 19. Licensee's use of the Visual Studio Setup Configuration + Samples is subject to the following license: + + The MIT License (MIT) + Copyright (C) Microsoft Corporation. All rights reserved. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation + files (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be included + in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + 20. Licensee's use of linmath.h header for CPU functions for + GL vector/matrix operations from lunarG is subject to the + Apache License Version 2.0. + + 21. The DX12-CUDA sample uses the d3dx12.h header, which is + subject to the MIT license . + +----------------- diff --git a/.venv/lib/python3.11/site-packages/nvidia_nvjitlink_cu12-12.4.127.dist-info/METADATA b/.venv/lib/python3.11/site-packages/nvidia_nvjitlink_cu12-12.4.127.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..c36b3c91708c206398b57e017ff425b087739ed7 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/nvidia_nvjitlink_cu12-12.4.127.dist-info/METADATA @@ -0,0 +1,35 @@ +Metadata-Version: 2.1 +Name: nvidia-nvjitlink-cu12 +Version: 12.4.127 +Summary: Nvidia JIT LTO Library +Home-page: https://developer.nvidia.com/cuda-zone +Author: Nvidia CUDA Installer Team +Author-email: cuda_installer@nvidia.com +License: NVIDIA Proprietary Software +Keywords: cuda,nvidia,runtime,machine learning,deep learning +Classifier: Development Status :: 4 - Beta +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Education +Classifier: Intended Audience :: Science/Research +Classifier: License :: Other/Proprietary License +Classifier: Natural Language :: English +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Topic :: Scientific/Engineering +Classifier: Topic :: Scientific/Engineering :: Mathematics +Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence +Classifier: Topic :: Software Development +Classifier: Topic :: Software Development :: Libraries +Classifier: Operating System :: Microsoft :: Windows +Classifier: Operating System :: POSIX :: Linux +Requires-Python: >=3 +License-File: License.txt + +NVIDIA compiler library for JIT LTO functionality. diff --git a/.venv/lib/python3.11/site-packages/nvidia_nvjitlink_cu12-12.4.127.dist-info/RECORD b/.venv/lib/python3.11/site-packages/nvidia_nvjitlink_cu12-12.4.127.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..2a4963c52f1c8eb095c688d990a7c718fa4a2f3d --- /dev/null +++ b/.venv/lib/python3.11/site-packages/nvidia_nvjitlink_cu12-12.4.127.dist-info/RECORD @@ -0,0 +1,16 @@ +nvidia/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +nvidia/__pycache__/__init__.cpython-311.pyc,, +nvidia/nvjitlink/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +nvidia/nvjitlink/__pycache__/__init__.cpython-311.pyc,, +nvidia/nvjitlink/include/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +nvidia/nvjitlink/include/__pycache__/__init__.cpython-311.pyc,, +nvidia/nvjitlink/include/nvJitLink.h,sha256=6P2KtTBXDDOsbxIi0Nr9Ot8_fh9XvsSAaDhaElJwLQU,16496 +nvidia/nvjitlink/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +nvidia/nvjitlink/lib/__pycache__/__init__.cpython-311.pyc,, +nvidia/nvjitlink/lib/libnvJitLink.so.12,sha256=y9FIi774K41kwt1Rqbau8_awvDp6gKmCG-SNHAf3AOc,53594512 +nvidia_nvjitlink_cu12-12.4.127.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +nvidia_nvjitlink_cu12-12.4.127.dist-info/License.txt,sha256=rW9YU_ugyg0VnQ9Y1JrkmDDC-Mk_epJki5zpCttMbM0,59262 +nvidia_nvjitlink_cu12-12.4.127.dist-info/METADATA,sha256=Tkm9zx69iT4wHTNBYxiPi30271awlBpcUiAg1itXbn0,1518 +nvidia_nvjitlink_cu12-12.4.127.dist-info/RECORD,, +nvidia_nvjitlink_cu12-12.4.127.dist-info/WHEEL,sha256=XDTs3wIbcE-BcRO08VJlZpA6z9OaC1mOKPCGGGwuM2g,109 +nvidia_nvjitlink_cu12-12.4.127.dist-info/top_level.txt,sha256=fTkAtiFuL16nUrB9ytDDtpytz2t0B4NvYTnRzwAhO14,7 diff --git a/.venv/lib/python3.11/site-packages/nvidia_nvjitlink_cu12-12.4.127.dist-info/WHEEL b/.venv/lib/python3.11/site-packages/nvidia_nvjitlink_cu12-12.4.127.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..e6c30e957cfb045017a9fef3430bb8ee87c4a074 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/nvidia_nvjitlink_cu12-12.4.127.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.42.0) +Root-Is-Purelib: true +Tag: py3-none-manylinux2014_x86_64 + diff --git a/.venv/lib/python3.11/site-packages/nvidia_nvjitlink_cu12-12.4.127.dist-info/top_level.txt b/.venv/lib/python3.11/site-packages/nvidia_nvjitlink_cu12-12.4.127.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..862f7abf232cdfbb928609856247292e81c9decb --- /dev/null +++ b/.venv/lib/python3.11/site-packages/nvidia_nvjitlink_cu12-12.4.127.dist-info/top_level.txt @@ -0,0 +1 @@ +nvidia diff --git a/.venv/lib/python3.11/site-packages/ray-2.42.0.dist-info/INSTALLER b/.venv/lib/python3.11/site-packages/ray-2.42.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/ray-2.42.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/.venv/lib/python3.11/site-packages/ray-2.42.0.dist-info/RECORD b/.venv/lib/python3.11/site-packages/ray-2.42.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..9c5d705710ff11b87aca4216487288c9768e6e53 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/ray-2.42.0.dist-info/RECORD @@ -0,0 +1,4281 @@ +../../../bin/ray,sha256=a1lfVQvDrM3dmedFkEJ_fiLWtiQEvp-qbv7forVkaqY,236 +../../../bin/serve,sha256=Jr7lW38YNN34i2uyM1y-kuMSo5yYBEojlEdsu9QAhlg,232 +../../../bin/tune,sha256=-uyAZJaU0AgKH3ufGDF9V6CRtvPsCYXnHpxOSfk44Sw,235 +ray-2.42.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +ray-2.42.0.dist-info/METADATA,sha256=aFn9bcaKYPXdnlroLKCP1JmF_lQIACqf8Ts6BKSTmKg,18478 +ray-2.42.0.dist-info/RECORD,, +ray-2.42.0.dist-info/WHEEL,sha256=pEID_Xj-6vkRnSRSCXy0o5VATDYSq5gw5LrHWQfIsEY,104 +ray-2.42.0.dist-info/entry_points.txt,sha256=HzQIZGspUzWojBmR9Xvb28m4bPhi-yJjV1U1pdlRkyY,111 +ray-2.42.0.dist-info/top_level.txt,sha256=GJvmpjCEmVfQsBskWDIj2hraOPW3F8A46rlbd9c3vc0,4 +ray/__init__.py,sha256=UWE3NG4n50ZSd3YKQTwgTGNEc2bE9EUNPUVTO9LPAYM,7369 +ray/__pycache__/__init__.cpython-311.pyc,, +ray/__pycache__/_version.cpython-311.pyc,, +ray/__pycache__/actor.cpython-311.pyc,, +ray/__pycache__/client_builder.cpython-311.pyc,, +ray/__pycache__/cluster_utils.cpython-311.pyc,, +ray/__pycache__/cross_language.cpython-311.pyc,, +ray/__pycache__/exceptions.cpython-311.pyc,, +ray/__pycache__/job_config.cpython-311.pyc,, +ray/__pycache__/remote_function.cpython-311.pyc,, +ray/__pycache__/runtime_context.cpython-311.pyc,, +ray/__pycache__/setup-dev.cpython-311.pyc,, +ray/__pycache__/types.cpython-311.pyc,, +ray/_private/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/_private/__pycache__/__init__.cpython-311.pyc,, +ray/_private/__pycache__/arrow_serialization.cpython-311.pyc,, +ray/_private/__pycache__/async_compat.cpython-311.pyc,, +ray/_private/__pycache__/async_utils.cpython-311.pyc,, +ray/_private/__pycache__/auto_init_hook.cpython-311.pyc,, +ray/_private/__pycache__/client_mode_hook.cpython-311.pyc,, +ray/_private/__pycache__/collections_utils.cpython-311.pyc,, +ray/_private/__pycache__/compat.cpython-311.pyc,, +ray/_private/__pycache__/conftest_utils.cpython-311.pyc,, +ray/_private/__pycache__/dict.cpython-311.pyc,, +ray/_private/__pycache__/external_storage.cpython-311.pyc,, +ray/_private/__pycache__/function_manager.cpython-311.pyc,, +ray/_private/__pycache__/gcs_aio_client.cpython-311.pyc,, +ray/_private/__pycache__/gcs_pubsub.cpython-311.pyc,, +ray/_private/__pycache__/gcs_utils.cpython-311.pyc,, +ray/_private/__pycache__/inspect_util.cpython-311.pyc,, +ray/_private/__pycache__/internal_api.cpython-311.pyc,, +ray/_private/__pycache__/log.cpython-311.pyc,, +ray/_private/__pycache__/log_monitor.cpython-311.pyc,, +ray/_private/__pycache__/logging_utils.cpython-311.pyc,, +ray/_private/__pycache__/memory_monitor.cpython-311.pyc,, +ray/_private/__pycache__/metrics_agent.cpython-311.pyc,, +ray/_private/__pycache__/node.cpython-311.pyc,, +ray/_private/__pycache__/parameter.cpython-311.pyc,, +ray/_private/__pycache__/process_watcher.cpython-311.pyc,, +ray/_private/__pycache__/profiling.cpython-311.pyc,, +ray/_private/__pycache__/prometheus_exporter.cpython-311.pyc,, +ray/_private/__pycache__/protobuf_compat.cpython-311.pyc,, +ray/_private/__pycache__/pydantic_compat.cpython-311.pyc,, +ray/_private/__pycache__/ray_client_microbenchmark.cpython-311.pyc,, +ray/_private/__pycache__/ray_cluster_perf.cpython-311.pyc,, +ray/_private/__pycache__/ray_constants.cpython-311.pyc,, +ray/_private/__pycache__/ray_experimental_perf.cpython-311.pyc,, +ray/_private/__pycache__/ray_microbenchmark_helpers.cpython-311.pyc,, +ray/_private/__pycache__/ray_option_utils.cpython-311.pyc,, +ray/_private/__pycache__/ray_perf.cpython-311.pyc,, +ray/_private/__pycache__/ray_process_reaper.cpython-311.pyc,, +ray/_private/__pycache__/resource_spec.cpython-311.pyc,, +ray/_private/__pycache__/serialization.cpython-311.pyc,, +ray/_private/__pycache__/services.cpython-311.pyc,, +ray/_private/__pycache__/signature.cpython-311.pyc,, +ray/_private/__pycache__/state.cpython-311.pyc,, +ray/_private/__pycache__/state_api_test_utils.cpython-311.pyc,, +ray/_private/__pycache__/storage.cpython-311.pyc,, +ray/_private/__pycache__/test_utils.cpython-311.pyc,, +ray/_private/__pycache__/tls_utils.cpython-311.pyc,, +ray/_private/__pycache__/utils.cpython-311.pyc,, +ray/_private/__pycache__/worker.cpython-311.pyc,, +ray/_private/accelerators/__init__.py,sha256=JkvAIP8KGtEu4cedSfz_olptxJdLde32FkyVT5Dqjaw,3033 +ray/_private/accelerators/__pycache__/__init__.cpython-311.pyc,, +ray/_private/accelerators/__pycache__/accelerator.cpython-311.pyc,, +ray/_private/accelerators/__pycache__/amd_gpu.cpython-311.pyc,, +ray/_private/accelerators/__pycache__/hpu.cpython-311.pyc,, +ray/_private/accelerators/__pycache__/intel_gpu.cpython-311.pyc,, +ray/_private/accelerators/__pycache__/neuron.cpython-311.pyc,, +ray/_private/accelerators/__pycache__/npu.cpython-311.pyc,, +ray/_private/accelerators/__pycache__/nvidia_gpu.cpython-311.pyc,, +ray/_private/accelerators/__pycache__/tpu.cpython-311.pyc,, +ray/_private/accelerators/accelerator.py,sha256=4K_N2hnQdFk0G2HHNKME1HUPFYDkPrSqSYksxBqjjqk,4798 +ray/_private/accelerators/amd_gpu.py,sha256=eXA48Q_MN2Cvq0VhuGjs9fcL9kqSf0ctZr1BImddN78,3918 +ray/_private/accelerators/hpu.py,sha256=n5YMifTfHinRs_ks20wyie__TD9lpZFKsLc59PqepIA,3701 +ray/_private/accelerators/intel_gpu.py,sha256=pUn09s8OEqaZkvmTuJfjewKT6ypVSIc5da16x_K-edk,3176 +ray/_private/accelerators/neuron.py,sha256=hd3U6v5VIYn_80VyNOF8twwU79eWrUJDMl71wAbplwY,4503 +ray/_private/accelerators/npu.py,sha256=G-3cVz9yvc5wzDvHTQhd3cCWcQwlWJ6v4-8zFDGYI6Q,2879 +ray/_private/accelerators/nvidia_gpu.py,sha256=qHw5Tut7CpOQXwkgYDIUQkoDy_IcrZRLnv5m5GZXOCo,4087 +ray/_private/accelerators/tpu.py,sha256=YhaoNuQxDSgiHIo4zgdTH_phILrVQrl-Ms7-HLRK-rg,14650 +ray/_private/arrow_serialization.py,sha256=JVygEx_qCUgAizV95fi77229hZE6Y5ByvF0DfHjguEE,29287 +ray/_private/async_compat.py,sha256=jNst_-bEM6Ax7A5xBrxBpRXEDaguNGdgY9gplqHEgIA,1261 +ray/_private/async_utils.py,sha256=DZqhwdDs6uHX3pCSadX5faDrZX81ve3kF18pbEAITfc,1883 +ray/_private/auto_init_hook.py,sha256=wE4ReMKmQtsWTwzh6Ya12myt6EpIvJWHSnWhpIF0Z6E,792 +ray/_private/client_mode_hook.py,sha256=-vVBtU9jNTiK36v0dCTxx9x0qRIXq6KImzd6ZwPIWgo,6449 +ray/_private/collections_utils.py,sha256=kEYj_UQUw6MDFBllSNHiUDbyX2Qy-hYrm3fqOIKx9qA,277 +ray/_private/compat.py,sha256=UnC8qxGUeAU4hWqhF1nGecRrBkYC-8yUsidlKMz5v7g,1343 +ray/_private/conftest_utils.py,sha256=BlBuVjvXI0IQrdWoYwd_TKutbkhYCcTnwdYCZr95BkQ,416 +ray/_private/dict.py,sha256=FACFqxBCWLeOG_dQ-m080ykso0dfWSf5ilYO4mJzhh8,8463 +ray/_private/event/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/_private/event/__pycache__/__init__.cpython-311.pyc,, +ray/_private/event/__pycache__/event_logger.cpython-311.pyc,, +ray/_private/event/__pycache__/export_event_logger.cpython-311.pyc,, +ray/_private/event/event_logger.py,sha256=OyiKdSoj7zo1_lzmmLOk9PGShc9d9Nw7DrIYFwkdIfU,6185 +ray/_private/event/export_event_logger.py,sha256=VmgB2KfladPztErP5qL069Y0xCZJPA6zAdWnvdbX9qk,5906 +ray/_private/external_storage.py,sha256=LqWFYMuPLAocp08pFWI92DQl7NZe82El3Tp4uMxmreU,26991 +ray/_private/function_manager.py,sha256=FY513fD4Sa-E6aoIYg_fwQx25ajpTOKsGtxS6eP0hxU,29598 +ray/_private/gcs_aio_client.py,sha256=b6DigO9-vbkMjAXj8SiJ7lW7jYPRpty3k5YdwTLtd38,1889 +ray/_private/gcs_pubsub.py,sha256=yIfIvShX31yT6U74ZoTf8pkW_setde3dOT23l0hy01s,10924 +ray/_private/gcs_utils.py,sha256=RSXMeYI8ROeVPOgezT_yAsdPltUxYXhzcw2qM_8e8bs,4472 +ray/_private/inspect_util.py,sha256=Qyqz0xhcpPobIpAq1yXATbAf8dgD3i9lGjVG1cp0fJU,1560 +ray/_private/internal_api.py,sha256=BJPTpCndrNVIk7jfAPe-jnD-8FUZ6s7-qxykl_9F_Xc,8866 +ray/_private/log.py,sha256=Km88nI3FAxnPH8qbSE_NdS1V6VWsdC6rol8AsUI4Omk,3792 +ray/_private/log_monitor.py,sha256=MFRzmc5toqNR8X7gt1OQMNwIyAK1Pr7EjmsXW1ijA78,23189 +ray/_private/logging_utils.py,sha256=AXk8_BIaqTToUqC1tFxk1DZ4UImS1uClxCcoC8JB8Q4,1011 +ray/_private/memory_monitor.py,sha256=WVg8cO4TZgcJwUtWh7cg-F_xSHfulli7mrprDJwCSWc,6025 +ray/_private/metrics_agent.py,sha256=XDQR2MJTnJsvIV5FihQMaGxpxQ9BggyUo5c0n4VlvKs,26797 +ray/_private/node.py,sha256=jM3IW95D2SZH2pxD6I_4UXh01hOWsBWSfGqyzvfTKQc,73625 +ray/_private/parameter.py,sha256=7h8fJf6ET7r7IdGgK-ZQKn6epn3KISil-zsVKTbs9-4,22779 +ray/_private/process_watcher.py,sha256=4vjlgeV1cxgHDULXsFHcF8d3b24Fvk3hwat7i2zyxHw,7506 +ray/_private/profiling.py,sha256=gIO7awFEWAX0JiYUwSLElkR7hf-K0bB9nDbPxHEnw3g,8786 +ray/_private/prometheus_exporter.py,sha256=CQRQ35B_Jn8dZUuUUrkFY4AwarH33ECx6ZQMEx0yKO4,13550 +ray/_private/protobuf_compat.py,sha256=cAJNmUXUrBTwrYIwsbnl4Tg4huqdx_BkylbJTyWchqM,1753 +ray/_private/pydantic_compat.py,sha256=818OJn_pmwdL2GJQCZaR8jEjOEnmore6nK7PDJcj6YI,3067 +ray/_private/ray_client_microbenchmark.py,sha256=esQe1nj8DLMsAHnV6P14wYSVtRFr1RXahcbA0ARgFhM,2901 +ray/_private/ray_cluster_perf.py,sha256=5SaBCx-Fv46dQo97sZVEt6GeRMvAabsv9dufxV50Fe8,1207 +ray/_private/ray_constants.py,sha256=Cn_r-eOBj_zxV4fuoKkz1DnkE6LcLnxnabHlYjHzozE,22125 +ray/_private/ray_experimental_perf.py,sha256=RmoJihxGgTg0KNxHEsvUm-B9dnR14ce2rIIyyMlSDw8,10944 +ray/_private/ray_logging/__init__.py,sha256=jgQBAn7NBziiwRxOTLqmukDdk1SK9wGURaRcWz4vZQM,13054 +ray/_private/ray_logging/__pycache__/__init__.cpython-311.pyc,, +ray/_private/ray_logging/__pycache__/constants.cpython-311.pyc,, +ray/_private/ray_logging/__pycache__/default_impl.cpython-311.pyc,, +ray/_private/ray_logging/__pycache__/filters.cpython-311.pyc,, +ray/_private/ray_logging/__pycache__/formatters.cpython-311.pyc,, +ray/_private/ray_logging/__pycache__/logging_config.cpython-311.pyc,, +ray/_private/ray_logging/constants.py,sha256=0mKlxAgOAtNvhzfKDB7Ruk3LADk9blsrNiRKuUgnADg,1199 +ray/_private/ray_logging/default_impl.py,sha256=U7yTVUfIsQKP3MBwXuJjT3sM3Kl9YIQ441_RR_pJ4yA,156 +ray/_private/ray_logging/filters.py,sha256=u_3t29K-ISxSfyQTrtJO20oHw4z1m5eoZvQxK-3oefI,1490 +ray/_private/ray_logging/formatters.py,sha256=fg-BI0EaIJLmLUhf9SAaKW9DtXk6tXbhd-vG_CSawXg,3334 +ray/_private/ray_logging/logging_config.py,sha256=3OehS86H4VUEdCnSPpFWZabcl1sa-p6RnO4Q1wv2xH4,3710 +ray/_private/ray_microbenchmark_helpers.py,sha256=FbD-Jprx6Xj0qG_vig1F4PBgP-OvbA7sZCyEDmJLs1o,2549 +ray/_private/ray_option_utils.py,sha256=tJdcLrssv7XTVcBABOnncqHv600B33g-6SGaXmAQfrg,14964 +ray/_private/ray_perf.py,sha256=In-_Y39tCsptrnnK0k5qCOM0VBZ8RHWDRALNn9-bMoE,8978 +ray/_private/ray_process_reaper.py,sha256=TsjFrySyHEQdYtK0PEk0-CzRhbc4nA04o7x7l_l50NQ,2071 +ray/_private/resource_spec.py,sha256=NlpJ2QOkHlAAta31Z-0mvR8y70IeXhO8dBmXSyO0EKw,12528 +ray/_private/runtime_env/__init__.py,sha256=FufsPD2IbH6u2OCTWBnZuhtn9qG4wc7EX7MaYJs73Fg,221 +ray/_private/runtime_env/__pycache__/__init__.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/_clonevirtualenv.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/conda.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/conda_utils.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/constants.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/context.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/default_impl.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/dependency_utils.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/image_uri.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/java_jars.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/mpi.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/mpi_runner.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/nsight.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/packaging.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/pip.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/plugin.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/plugin_schema_manager.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/protocol.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/py_modules.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/setup_hook.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/uri_cache.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/utils.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/uv.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/validation.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/virtualenv_utils.cpython-311.pyc,, +ray/_private/runtime_env/__pycache__/working_dir.cpython-311.pyc,, +ray/_private/runtime_env/_clonevirtualenv.py,sha256=Jv10azUwb2sIOoSyBS26XoLXhZdF0HK_HaGHSZUkpnI,10970 +ray/_private/runtime_env/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/_private/runtime_env/agent/__pycache__/__init__.cpython-311.pyc,, +ray/_private/runtime_env/agent/__pycache__/main.cpython-311.pyc,, +ray/_private/runtime_env/agent/__pycache__/runtime_env_agent.cpython-311.pyc,, +ray/_private/runtime_env/agent/__pycache__/runtime_env_consts.cpython-311.pyc,, +ray/_private/runtime_env/agent/main.py,sha256=76rJk3RezAfuMiFcSJrc9KgCmqhMpwhTZKT0gLRSOUo,7676 +ray/_private/runtime_env/agent/runtime_env_agent.py,sha256=huXdg09mYRsjFOZhzyF_PfTji5lFxbEyeC71MFGFZzI,24745 +ray/_private/runtime_env/agent/runtime_env_consts.py,sha256=V5VegPHpS3RftGRZ-Y0EIFfiQT93kaRyM8fzQm0XUEo,750 +ray/_private/runtime_env/agent/thirdparty_files/aiohappyeyeballs-2.4.4.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +ray/_private/runtime_env/agent/thirdparty_files/aiohappyeyeballs-2.4.4.dist-info/LICENSE,sha256=Oy-B_iHRgcSZxZolbI4ZaEVdZonSaaqFNzv7avQdo78,13936 +ray/_private/runtime_env/agent/thirdparty_files/aiohappyeyeballs-2.4.4.dist-info/METADATA,sha256=CT9LuDMNOove0oCR6kFFKMoLkA-D_XuBVr_w4uCpcpY,6070 +ray/_private/runtime_env/agent/thirdparty_files/aiohappyeyeballs-2.4.4.dist-info/RECORD,sha256=Fcl-YQT6zBaBO5rPth8_X6Kod3PFCz1frbwYqjBCZow,1209 +ray/_private/runtime_env/agent/thirdparty_files/aiohappyeyeballs-2.4.4.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88 +ray/_private/runtime_env/agent/thirdparty_files/aiohappyeyeballs/__init__.py,sha256=64CUKZ1vpW6MnkJIyy-CHBU7o6c_TbKO7f6WAViSl9s,317 +ray/_private/runtime_env/agent/thirdparty_files/aiohappyeyeballs/__pycache__/__init__.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohappyeyeballs/__pycache__/_staggered.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohappyeyeballs/__pycache__/impl.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohappyeyeballs/__pycache__/types.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohappyeyeballs/__pycache__/utils.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohappyeyeballs/_staggered.py,sha256=LbTGSjib2cb11QDE4RlSVQNUauK3X9p1avCR9YuJF7s,6723 +ray/_private/runtime_env/agent/thirdparty_files/aiohappyeyeballs/impl.py,sha256=qrAnR-7xaxh6W7mg0i-9ozAJpzvCm7w-P3Yhy_LaTaM,8109 +ray/_private/runtime_env/agent/thirdparty_files/aiohappyeyeballs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/_private/runtime_env/agent/thirdparty_files/aiohappyeyeballs/types.py,sha256=iYPiBTl5J7YEjnIqEOVUTRPzz2DwqSHBRhvbAlM0zv0,234 +ray/_private/runtime_env/agent/thirdparty_files/aiohappyeyeballs/utils.py,sha256=on9GxIR0LhEfZu8P6Twi9hepX9zDanuZM20MWsb3xlQ,3028 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp-3.11.11.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp-3.11.11.dist-info/LICENSE.txt,sha256=n4DQ2311WpQdtFchcsJw7L2PCCuiFd3QlZhZQu2Uqes,588 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp-3.11.11.dist-info/METADATA,sha256=O_1EZEKVeXKI4c8DLjvHPGK3V7eiUup0765nWX0-TJ0,7712 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp-3.11.11.dist-info/RECORD,sha256=ZvwwHDxPrJTB_J-tKD9HK4vNqmdpWqtgsyEu-krhtek,9348 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp-3.11.11.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp-3.11.11.dist-info/WHEEL,sha256=9BFfIe-Zq441iQ0ehutX65O5faGDpmB1Uw3WaQGk4f0,151 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp-3.11.11.dist-info/top_level.txt,sha256=iv-JIaacmTl-hSho3QmphcKnbRRYx1st47yjz_178Ro,8 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/.hash/_cparser.pxd.hash,sha256=hYa9Vje-oMs2eh_7MfCPOh2QW_1x1yCjcZuc7AmwLd0,121 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/.hash/_find_header.pxd.hash,sha256=_mbpD6vM-CVCKq3ulUvsOAz5Wdo88wrDzfpOsMQaMNA,125 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/.hash/_http_parser.pyx.hash,sha256=GBgZjCNbtZApPhf9-gHpS5Z2WMIzM-vgp5VSZIEvZfk,125 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/.hash/_http_writer.pyx.hash,sha256=-UgSF82qclpxjP0og_gcFEsstXRKF9e3Ou4wziAyDvI,125 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/.hash/hdrs.py.hash,sha256=v6IaKbsxjsdQxBzhb5AjP0x_9G3rUe84D7avf7AI4cs,116 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__init__.py,sha256=Nqvv0TLm_6R9zrZPfJfRN9SRB04gUzWdYrPpUvTfD7Q,7840 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/__init__.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/abc.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/base_protocol.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/client.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/client_exceptions.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/client_proto.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/client_reqrep.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/client_ws.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/compression_utils.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/connector.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/cookiejar.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/formdata.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/hdrs.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/helpers.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/http.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/http_exceptions.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/http_parser.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/http_websocket.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/http_writer.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/log.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/multipart.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/payload.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/payload_streamer.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/pytest_plugin.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/resolver.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/streams.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/tcp_helpers.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/test_utils.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/tracing.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/typedefs.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/web.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/web_app.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/web_exceptions.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/web_fileresponse.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/web_log.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/web_middlewares.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/web_protocol.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/web_request.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/web_response.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/web_routedef.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/web_runner.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/web_server.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/web_urldispatcher.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/web_ws.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/__pycache__/worker.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_cparser.pxd,sha256=8jGIg-VJ9p3llwCakUYDsPGxA4HiZe9dmK9Jmtlz-5g,4318 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_find_header.pxd,sha256=0GfwFCPN2zxEKTO1_MA5sYq2UfzsG8kcV3aTqvwlz3g,68 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_headers.pxi,sha256=n701k28dVPjwRnx5j6LpJhLTfj7dqu2vJt7f0O60Oyg,2007 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_http_parser.cpython-311-x86_64-linux-gnu.so,sha256=rulksFv5PZ7AOPoQuR2P1THFflfukMumxkEfRfdFk0Y,2826344 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_http_parser.pyx,sha256=wQdADj5LizwC_7nFGr8nIlk6GpoaQeQ0359H0HMKGuM,28241 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_http_writer.cpython-311-x86_64-linux-gnu.so,sha256=zMYCtCYo-xjYJpSCcVx6UdBpGSHm_pMgnpM7JUmsWXA,463752 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_http_writer.pyx,sha256=fiCck_EVgRiTX7VtAoV2AldjuesJMFPev4TWd9Fx8jo,4597 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/.hash/mask.pxd.hash,sha256=Y0zBddk_ck3pi9-BFzMcpkcvCKvwvZ4GTtZFb9u1nxQ,128 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/.hash/mask.pyx.hash,sha256=90owpXYM8_kIma4KUcOxhWSk-Uv4NVMBoCYeFM1B3d0,128 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/.hash/reader_c.pxd.hash,sha256=EoZjkF_tAFEbGvV0oRY2GZOSuAfWFWFjMhXgq6mQExo,132 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/__init__.py,sha256=Mar3R9_vBN_Ea4lsW7iTAVXD7OKswKPGqF5xgSyt77k,44 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/__pycache__/__init__.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/__pycache__/helpers.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/__pycache__/models.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/__pycache__/reader.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/__pycache__/reader_c.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/__pycache__/reader_py.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/__pycache__/writer.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/helpers.py,sha256=P-XLv8IUaihKzDenVUqfKU5DJbWE5HvG8uhvUZK8Ic4,5038 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/mask.cpython-311-x86_64-linux-gnu.so,sha256=hq3aHe5ZVl5ENFRtaXjZcSrbS-ITBwqGgEneGVphY1w,245952 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/mask.pxd,sha256=sBmZ1Amym9kW4Ge8lj1fLZ7mPPya4LzLdpkQExQXv5M,112 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/mask.pyx,sha256=BHjOtV0O0w7xp9p0LNADRJvGmgfPn9sGeJvSs0fL__4,1397 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/models.py,sha256=XAzjs_8JYszWXIgZ6R3ZRrF-tX9Q_6LiD49WRYojopM,2121 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/reader.py,sha256=eC4qS0c5sOeQ2ebAHLaBpIaTVFaSKX79pY2xvh3Pqyw,1030 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/reader_c.cpython-311-x86_64-linux-gnu.so,sha256=bnETOmm4gSxKkarM68sAEhBjSd_bQt0GgDD2W7V8cUQ,1906008 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/reader_c.pxd,sha256=9rMWCpAC1jng7_gtqLjRlqQv9q7UkOn63tIQfq2k8Gc,2444 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/reader_c.py,sha256=anZsBKZWlL8SO8gArsZMDstH37qBuZOvJA7jtj0Z95M,17975 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/reader_py.py,sha256=anZsBKZWlL8SO8gArsZMDstH37qBuZOvJA7jtj0Z95M,17975 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/_websocket/writer.py,sha256=T3P36iMrzVPPC2XeScserHMD5vd9an6yizWzqDUkRZ0,7077 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/abc.py,sha256=JLMOxrKLGTDaPRLfraY1pl-xka53YiHhAH9yaF9QRXQ,6512 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/base_protocol.py,sha256=Tp8cxUPQvv9kUPk3w6lAzk6d2MAzV3scwI_3Go3C47c,3025 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/client.py,sha256=EPaO_Y4VpTdIAbcOfMwBGrzSfBUcYampYwZN3GO2Vm4,55006 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/client_exceptions.py,sha256=uyKbxI2peZhKl7lELBMx3UeusNkfpemPWpGFq0r6JeM,11367 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/client_proto.py,sha256=dV7u9floGWG-_xtD2fLUYqiANG6VsJtq0HMlTjf1g-g,10015 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/client_reqrep.py,sha256=VAgh0NxP2HvYWx6nX1Pr8FINc1m-W8-5q2zKeZV68n8,43925 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/client_ws.py,sha256=_n4hVk71H5rK8TFOIYT0bPTIHOmMCQ3FDFSrU7ctpfI,15031 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/compression_utils.py,sha256=0J3EAOR-0HehlYIudJXRu_Kr6hrYCY0IfuJ1px9MhQs,5681 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/connector.py,sha256=yW8vyZz4cmXbScbBkCneMF0giSl0WZPJ2NnNw-TegbQ,60225 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/cookiejar.py,sha256=PYR1K1mkLa24Hm6c9UEJnAitccNzz97CbsJyQ2ULAlU,17615 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/formdata.py,sha256=CUJnCWDNHFcXSYZ_TupaT6rHkY-Q7ghssvWzaYBPIo0,6552 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/hdrs.py,sha256=2rj5MyA-6yRdYPhW5UKkW4iNWhEAlGIOSBH5D4FmKNE,5111 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/helpers.py,sha256=KqPQECeiJ_EhA93k7-5ZoVdZH0sk_4n0tCoM_E-iMnE,29091 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/http.py,sha256=8o8j8xH70OWjnfTWA9V44NR785QPxEPrUtzMXiAVpwc,1842 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/http_exceptions.py,sha256=RYmBycJvvPerKkgXXm8v145I1N-fbsgSpcsbNIC-gdE,2961 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/http_parser.py,sha256=UqerYPJzA1MqLmeG1jURhTNO1YhwUASK3QVcNEz0me8,36851 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/http_websocket.py,sha256=8VXFKw6KQUEmPg48GtRMB37v0gTK7A0inoxXuDxMZEc,842 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/http_writer.py,sha256=RRQlUxD7K98aONPrrE9DGkWVWSuTDTzM1cr8xRaRIvw,7031 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/log.py,sha256=BbNKx9e3VMIm0xYjZI0IcBBoS7wjdeIeSaiJE7-qK2g,325 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/multipart.py,sha256=1jIh7GEFgSL-cnLQzbNBLWXHJlB4WKyy0NBm_i1Y3V4,36942 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/payload.py,sha256=rCA9JJI_RMCik_7qNIaC1Bh21aXhABGYK2tsYeaHRQ4,15793 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/payload_streamer.py,sha256=ZzEYyfzcjGWkVkK3XR2pBthSCSIykYvY3Wr5cGQ2eTc,2211 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/py.typed,sha256=sow9soTwP9T_gEAQSVh7Gb8855h04Nwmhs2We-JRgZM,7 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/pytest_plugin.py,sha256=AfJ6VIWzsp5KgpXRREsX3yqGUZrJyfb7zzcMqzWxz7I,12768 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/resolver.py,sha256=sJ8-LYCtl_g9f6gn_5X2NFQ9FQ72Q2Mr4_rLxo9NVeI,6375 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/streams.py,sha256=s4qMxBLQMMuXHUFxTeOScfX4apL8rWWvC2pxdrrTr98,22300 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/tcp_helpers.py,sha256=BSadqVWaBpMFDRWnhaaR941N9MiDZ7bdTrxgCb0CW-M,961 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/test_utils.py,sha256=r7kBasmZtC3tQY5OmyMaIl1B9P8Bnnq1oM3npVcAPKs,22811 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/tracing.py,sha256=66XQwtdR5DHv8p953eeNL0l8o6iHDaNwH9bBaybHXD4,15137 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/typedefs.py,sha256=wUlqwe9Mw9W8jT3HsYJcYk00qP3EMPz3nTkYXmeNN48,1657 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/web.py,sha256=As5nqGQy4QXWMXSaOsh0JudSVVJVIt_nr3n0b8CaMb0,18422 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/web_app.py,sha256=Zre0QHM9JAp4d7jrj5NRxlPnfTrKLNuA42Rdsh8Q2TI,19554 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/web_exceptions.py,sha256=7nIuiwhZ39vJJ9KrWqArA5QcWbUdqkz2CLwEpJapeN8,10360 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/web_fileresponse.py,sha256=FRsS0p9r1KU5y8ceG0QXBYnrL6xggjbxcXSmI6qIR4k,16504 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/web_log.py,sha256=rX5D7xLOX2B6BMdiZ-chme_KfJfW5IXEoFwLfkfkajs,7865 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/web_middlewares.py,sha256=sFI0AgeNjdyAjuz92QtMIpngmJSOxrqe2Jfbs4BNUu0,4165 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/web_protocol.py,sha256=WZFtp5Zoxr0AKft1h_1ExiAB6Yw0UwpHUM-edd8Thq0,25522 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/web_request.py,sha256=j_SSX9s-d3ZeNyqUTpFIaPUaNdSqHwb7yfc0ufL8xFA,29750 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/web_response.py,sha256=65aliDETi7rZ8P76ksuHQI0ZTu1cKpclCSailNu105M,28696 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/web_routedef.py,sha256=VT1GAx6BrawoDh5RwBwBu5wSABSqgWwAe74AUCyZAEo,6110 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/web_runner.py,sha256=v1G1nKiOOQgFnTSR4IMc6I9ReEFDMaHtMLvO_roDM-A,11786 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/web_server.py,sha256=-9WDKUAiR9ll-rSdwXSqG6YjaoW79d1R4y0BGSqgUMA,2888 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/web_urldispatcher.py,sha256=TIMxFmhLjERseG0xcZv2Ef9Xuo_GTBRqBqeMkCgL0K8,43825 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/web_ws.py,sha256=EOQX3LYqlrkNQHlFTaNpZkQpOYRCZfR-m1bHT4Iseq8,22488 +ray/_private/runtime_env/agent/thirdparty_files/aiohttp/worker.py,sha256=0lvxRNMjGM47ddlQWtci53ri9YN42Su1Vdd_Z7zMMH0,8040 +ray/_private/runtime_env/agent/thirdparty_files/aiosignal-1.3.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +ray/_private/runtime_env/agent/thirdparty_files/aiosignal-1.3.2.dist-info/LICENSE,sha256=b9UkPpLdf5jsacesN3co50kFcJ_1J6W_mNbQJjwE9bY,11332 +ray/_private/runtime_env/agent/thirdparty_files/aiosignal-1.3.2.dist-info/METADATA,sha256=TeI_xgZ191qgx37rviEnpMWC0QnYsg_j9EGVivNqqjc,3753 +ray/_private/runtime_env/agent/thirdparty_files/aiosignal-1.3.2.dist-info/RECORD,sha256=xI1qmjNSS-DmRvKa7DSxsisWdzntn_VREZWuV01mO-w,773 +ray/_private/runtime_env/agent/thirdparty_files/aiosignal-1.3.2.dist-info/WHEEL,sha256=pxeNX5JdtCe58PUSYP9upmc7jdRPgvT0Gm9kb1SHlVw,109 +ray/_private/runtime_env/agent/thirdparty_files/aiosignal-1.3.2.dist-info/top_level.txt,sha256=z45aNOKGDdrI1roqZY3BGXQ22kJFPHBmVdwtLYLtXC0,10 +ray/_private/runtime_env/agent/thirdparty_files/aiosignal/__init__.py,sha256=1oIrRl6kNpqFh32e7HfMFbMV_35v8sqJJFfnuKgmtEU,867 +ray/_private/runtime_env/agent/thirdparty_files/aiosignal/__init__.pyi,sha256=xeCddYSS8fZAkz8S4HuKSR2IDe3N7RW_LKcXDPPA1Xk,311 +ray/_private/runtime_env/agent/thirdparty_files/aiosignal/__pycache__/__init__.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/aiosignal/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/_private/runtime_env/agent/thirdparty_files/attr/__init__.py,sha256=fOYIvt1eGSqQre4uCS3sJWKZ0mwAuC8UD6qba5OS9_U,2057 +ray/_private/runtime_env/agent/thirdparty_files/attr/__init__.pyi,sha256=QIXnnHPoucmDWkbpNsWTP-cgJ1bn8le7DjyRa_wYdew,11281 +ray/_private/runtime_env/agent/thirdparty_files/attr/__pycache__/__init__.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/attr/__pycache__/_cmp.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/attr/__pycache__/_compat.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/attr/__pycache__/_config.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/attr/__pycache__/_funcs.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/attr/__pycache__/_make.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/attr/__pycache__/_next_gen.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/attr/__pycache__/_version_info.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/attr/__pycache__/converters.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/attr/__pycache__/exceptions.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/attr/__pycache__/filters.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/attr/__pycache__/setters.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/attr/__pycache__/validators.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/attr/_cmp.py,sha256=3umHiBtgsEYtvNP_8XrQwTCdFoZIX4DEur76N-2a3X8,4123 +ray/_private/runtime_env/agent/thirdparty_files/attr/_cmp.pyi,sha256=U-_RU_UZOyPUEQzXE6RMYQQcjkZRY25wTH99sN0s7MM,368 +ray/_private/runtime_env/agent/thirdparty_files/attr/_compat.py,sha256=4hlXbWhdDjQCDK6FKF1EgnZ3POiHgtpp54qE0nxaGHg,2704 +ray/_private/runtime_env/agent/thirdparty_files/attr/_config.py,sha256=dGq3xR6fgZEF6UBt_L0T-eUHIB4i43kRmH0P28sJVw8,843 +ray/_private/runtime_env/agent/thirdparty_files/attr/_funcs.py,sha256=5-tUKJtp3h5El55EcDl6GWXFp68fT8D8U7uCRN6497I,15854 +ray/_private/runtime_env/agent/thirdparty_files/attr/_make.py,sha256=XS_pYn_-KNo69Tb8-_y3YUcB3Xus00MwAShh2WulkjQ,94157 +ray/_private/runtime_env/agent/thirdparty_files/attr/_next_gen.py,sha256=7FRkbtl_N017SuBhf_Vw3mw2c2pGZhtCGOzadgz7tp4,24395 +ray/_private/runtime_env/agent/thirdparty_files/attr/_typing_compat.pyi,sha256=XDP54TUn-ZKhD62TOQebmzrwFyomhUCoGRpclb6alRA,469 +ray/_private/runtime_env/agent/thirdparty_files/attr/_version_info.py,sha256=exSqb3b5E-fMSsgZAlEw9XcLpEgobPORCZpcaEglAM4,2121 +ray/_private/runtime_env/agent/thirdparty_files/attr/_version_info.pyi,sha256=x_M3L3WuB7r_ULXAWjx959udKQ4HLB8l-hsc1FDGNvk,209 +ray/_private/runtime_env/agent/thirdparty_files/attr/converters.py,sha256=GlDeOzPeTFgeBBLbj9G57Ez5lAk68uhSALRYJ_exe84,3861 +ray/_private/runtime_env/agent/thirdparty_files/attr/converters.pyi,sha256=orU2bff-VjQa2kMDyvnMQV73oJT2WRyQuw4ZR1ym1bE,643 +ray/_private/runtime_env/agent/thirdparty_files/attr/exceptions.py,sha256=HRFq4iybmv7-DcZwyjl6M1euM2YeJVK_hFxuaBGAngI,1977 +ray/_private/runtime_env/agent/thirdparty_files/attr/exceptions.pyi,sha256=zZq8bCUnKAy9mDtBEw42ZhPhAUIHoTKedDQInJD883M,539 +ray/_private/runtime_env/agent/thirdparty_files/attr/filters.py,sha256=ZBiKWLp3R0LfCZsq7X11pn9WX8NslS2wXM4jsnLOGc8,1795 +ray/_private/runtime_env/agent/thirdparty_files/attr/filters.pyi,sha256=3J5BG-dTxltBk1_-RuNRUHrv2qu1v8v4aDNAQ7_mifA,208 +ray/_private/runtime_env/agent/thirdparty_files/attr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/_private/runtime_env/agent/thirdparty_files/attr/setters.py,sha256=5-dcT63GQK35ONEzSgfXCkbB7pPkaR-qv15mm4PVSzQ,1617 +ray/_private/runtime_env/agent/thirdparty_files/attr/setters.pyi,sha256=NnVkaFU1BB4JB8E4JuXyrzTUgvtMpj8p3wBdJY7uix4,584 +ray/_private/runtime_env/agent/thirdparty_files/attr/validators.py,sha256=WaB1HLAHHqRHWsrv_K9H-sJ7ESil3H3Cmv2d8TtVZx4,20046 +ray/_private/runtime_env/agent/thirdparty_files/attr/validators.pyi,sha256=s2WhKPqskxbsckJfKk8zOuuB088GfgpyxcCYSNFLqNU,2603 +ray/_private/runtime_env/agent/thirdparty_files/attrs-25.1.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +ray/_private/runtime_env/agent/thirdparty_files/attrs-25.1.0.dist-info/METADATA,sha256=bZidcSPgoF4BvFNQYyqph4NeHVg9r55WXiwAEtbvRnc,10999 +ray/_private/runtime_env/agent/thirdparty_files/attrs-25.1.0.dist-info/RECORD,sha256=prICSieF8PpkVHmfDSwN1pHQn2pcVXoiX-_jGbRF8aI,3556 +ray/_private/runtime_env/agent/thirdparty_files/attrs-25.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87 +ray/_private/runtime_env/agent/thirdparty_files/attrs-25.1.0.dist-info/licenses/LICENSE,sha256=iCEVyV38KvHutnFPjsbVy8q_Znyv-HKfQkINpj9xTp8,1109 +ray/_private/runtime_env/agent/thirdparty_files/attrs/__init__.py,sha256=qeQJZ4O08yczSn840v9bYOaZyRE81WsVi-QCrY3krCU,1107 +ray/_private/runtime_env/agent/thirdparty_files/attrs/__init__.pyi,sha256=nZmInocjM7tHV4AQw0vxO_fo6oJjL_PonlV9zKKW8DY,7931 +ray/_private/runtime_env/agent/thirdparty_files/attrs/__pycache__/__init__.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/attrs/__pycache__/converters.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/attrs/__pycache__/exceptions.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/attrs/__pycache__/filters.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/attrs/__pycache__/setters.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/attrs/__pycache__/validators.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/attrs/converters.py,sha256=8kQljrVwfSTRu8INwEk8SI0eGrzmWftsT7rM0EqyohM,76 +ray/_private/runtime_env/agent/thirdparty_files/attrs/exceptions.py,sha256=ACCCmg19-vDFaDPY9vFl199SPXCQMN_bENs4DALjzms,76 +ray/_private/runtime_env/agent/thirdparty_files/attrs/filters.py,sha256=VOUMZug9uEU6dUuA0dF1jInUK0PL3fLgP0VBS5d-CDE,73 +ray/_private/runtime_env/agent/thirdparty_files/attrs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/_private/runtime_env/agent/thirdparty_files/attrs/setters.py,sha256=eL1YidYQV3T2h9_SYIZSZR1FAcHGb1TuCTy0E0Lv2SU,73 +ray/_private/runtime_env/agent/thirdparty_files/attrs/validators.py,sha256=xcy6wD5TtTkdCG1f4XWbocPSO0faBjk5IfVJfP6SUj0,76 +ray/_private/runtime_env/agent/thirdparty_files/frozenlist-1.5.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +ray/_private/runtime_env/agent/thirdparty_files/frozenlist-1.5.0.dist-info/LICENSE,sha256=b9UkPpLdf5jsacesN3co50kFcJ_1J6W_mNbQJjwE9bY,11332 +ray/_private/runtime_env/agent/thirdparty_files/frozenlist-1.5.0.dist-info/METADATA,sha256=BpQvB7z2NbU3f4XTQDvhAZ9L08WR4XiYajilj9IY6Yk,13762 +ray/_private/runtime_env/agent/thirdparty_files/frozenlist-1.5.0.dist-info/RECORD,sha256=d0UCuRCt-vCe0RvFsg90dkj__OM_i3xEVipK97pm-7U,984 +ray/_private/runtime_env/agent/thirdparty_files/frozenlist-1.5.0.dist-info/WHEEL,sha256=g2F1VBkM0jT4VUJ6zw4l3h6A4vsUecrEFGycpjwnlV0,224 +ray/_private/runtime_env/agent/thirdparty_files/frozenlist-1.5.0.dist-info/top_level.txt,sha256=jivtxsPXA3nK3WBWW2LW5Mtu_GHt8UZA13NeCs2cKuA,11 +ray/_private/runtime_env/agent/thirdparty_files/frozenlist/__init__.py,sha256=ymVtnW3MinO-Ux3cBj_PLEpXnmLawk45el8vcX6IkWY,2371 +ray/_private/runtime_env/agent/thirdparty_files/frozenlist/__init__.pyi,sha256=vMEoES1xGegPtVXoCi9XydEeHsyuIq-KdeXwP5PdsaA,1470 +ray/_private/runtime_env/agent/thirdparty_files/frozenlist/__pycache__/__init__.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/frozenlist/_frozenlist.cpython-311-x86_64-linux-gnu.so,sha256=i8wUceqj_Nyr0hb7D8kyPPUbtAtLl4J7MtPQYTzhRug,923584 +ray/_private/runtime_env/agent/thirdparty_files/frozenlist/_frozenlist.pyx,sha256=4YturclNF7wioO7YX3Vzl7Ldb2-iswe6UrjJOMKSswU,2993 +ray/_private/runtime_env/agent/thirdparty_files/frozenlist/py.typed,sha256=sow9soTwP9T_gEAQSVh7Gb8855h04Nwmhs2We-JRgZM,7 +ray/_private/runtime_env/agent/thirdparty_files/idna-3.10.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +ray/_private/runtime_env/agent/thirdparty_files/idna-3.10.dist-info/LICENSE.md,sha256=pZ8LDvNjWHQQmkRhykT_enDVBpboFHZ7-vch1Mmw2w8,1541 +ray/_private/runtime_env/agent/thirdparty_files/idna-3.10.dist-info/METADATA,sha256=URR5ZyDfQ1PCEGhkYoojqfi2Ra0tau2--lhwG4XSfjI,10158 +ray/_private/runtime_env/agent/thirdparty_files/idna-3.10.dist-info/RECORD,sha256=IhWZ7lqRc-wPyRLgszxa4teKA3DVup_atJ2pjhzYv8U,1384 +ray/_private/runtime_env/agent/thirdparty_files/idna-3.10.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81 +ray/_private/runtime_env/agent/thirdparty_files/idna/__init__.py,sha256=MPqNDLZbXqGaNdXxAFhiqFPKEQXju2jNQhCey6-5eJM,868 +ray/_private/runtime_env/agent/thirdparty_files/idna/__pycache__/__init__.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/idna/__pycache__/codec.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/idna/__pycache__/compat.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/idna/__pycache__/core.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/idna/__pycache__/idnadata.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/idna/__pycache__/intranges.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/idna/__pycache__/package_data.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/idna/__pycache__/uts46data.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/idna/codec.py,sha256=PEew3ItwzjW4hymbasnty2N2OXvNcgHB-JjrBuxHPYY,3422 +ray/_private/runtime_env/agent/thirdparty_files/idna/compat.py,sha256=RzLy6QQCdl9784aFhb2EX9EKGCJjg0P3PilGdeXXcx8,316 +ray/_private/runtime_env/agent/thirdparty_files/idna/core.py,sha256=YJYyAMnwiQEPjVC4-Fqu_p4CJ6yKKuDGmppBNQNQpFs,13239 +ray/_private/runtime_env/agent/thirdparty_files/idna/idnadata.py,sha256=W30GcIGvtOWYwAjZj4ZjuouUutC6ffgNuyjJy7fZ-lo,78306 +ray/_private/runtime_env/agent/thirdparty_files/idna/intranges.py,sha256=amUtkdhYcQG8Zr-CoMM_kVRacxkivC1WgxN1b63KKdU,1898 +ray/_private/runtime_env/agent/thirdparty_files/idna/package_data.py,sha256=q59S3OXsc5VI8j6vSD0sGBMyk6zZ4vWFREE88yCJYKs,21 +ray/_private/runtime_env/agent/thirdparty_files/idna/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/_private/runtime_env/agent/thirdparty_files/idna/uts46data.py,sha256=rt90K9J40gUSwppDPCrhjgi5AA6pWM65dEGRSf6rIhM,239289 +ray/_private/runtime_env/agent/thirdparty_files/multidict-6.1.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +ray/_private/runtime_env/agent/thirdparty_files/multidict-6.1.0.dist-info/LICENSE,sha256=k9Ealo4vDzY3PECBH_bSDhc_WMPKtYhM1mF7v9eVSSo,611 +ray/_private/runtime_env/agent/thirdparty_files/multidict-6.1.0.dist-info/METADATA,sha256=OnCx5DR4XPf64GIDK4XmcA2e7HLQ_784vMfEQy287kM,4979 +ray/_private/runtime_env/agent/thirdparty_files/multidict-6.1.0.dist-info/RECORD,sha256=THSja2K6Gf_027hoEawT9H7Dk1naK5M4xcBZvvpHMvE,1415 +ray/_private/runtime_env/agent/thirdparty_files/multidict-6.1.0.dist-info/WHEEL,sha256=1pYTe4_OeXMoiAzbCCjVEUIQIlCH_vOwKRWEjMaDcV0,151 +ray/_private/runtime_env/agent/thirdparty_files/multidict-6.1.0.dist-info/top_level.txt,sha256=-euDElkk5_qkmfIJ7WiqCab02ZlSFZWynejKg59qZQQ,10 +ray/_private/runtime_env/agent/thirdparty_files/multidict/__init__.py,sha256=p60Ag5UVACSli1txazSi85foCmHN-cg3qZDCuWdOKng,928 +ray/_private/runtime_env/agent/thirdparty_files/multidict/__init__.pyi,sha256=SbgC2ew1NvNXWlRKs9o0KhW4moozgMqgQ0OA4Re5JQQ,4840 +ray/_private/runtime_env/agent/thirdparty_files/multidict/__pycache__/__init__.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/multidict/__pycache__/_abc.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/multidict/__pycache__/_compat.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/multidict/__pycache__/_multidict_base.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/multidict/__pycache__/_multidict_py.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/multidict/_abc.py,sha256=Zvnrn4SBkrv4QTD7-ZzqNcoxw0f8KStLMPzGvBuGT2w,1190 +ray/_private/runtime_env/agent/thirdparty_files/multidict/_compat.py,sha256=uCNUpVHJSFOiKUJmRcz3SDqMpkb37C_csc29ijr8Evo,352 +ray/_private/runtime_env/agent/thirdparty_files/multidict/_multidict.cpython-311-x86_64-linux-gnu.so,sha256=SUGf_kAmhQxhn861-jiCa0e51oNCqlgThx6k3IOgwqs,410592 +ray/_private/runtime_env/agent/thirdparty_files/multidict/_multidict_base.py,sha256=ZndtnZ5oc1sODKmXsv6F9kWvVNCda9xAEEFXkaPoFoA,3979 +ray/_private/runtime_env/agent/thirdparty_files/multidict/_multidict_py.py,sha256=57h4sYrRIu7EjMX4YpHVIZVrV9-q1KCW3F6rao10D3U,15050 +ray/_private/runtime_env/agent/thirdparty_files/multidict/py.typed,sha256=e9bmbH3UFxsabQrnNFPG9qxIXztwbcM6IKDYnvZwprY,15 +ray/_private/runtime_env/agent/thirdparty_files/propcache-0.2.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +ray/_private/runtime_env/agent/thirdparty_files/propcache-0.2.1.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358 +ray/_private/runtime_env/agent/thirdparty_files/propcache-0.2.1.dist-info/METADATA,sha256=6TbzbVLhMeuLzfke0g0g7gsp4f91XKQLOtFcmQPBY60,9176 +ray/_private/runtime_env/agent/thirdparty_files/propcache-0.2.1.dist-info/NOTICE,sha256=VtasbIEFwKUTBMIdsGDjYa-ajqCvmnXCOcKLXRNpODg,609 +ray/_private/runtime_env/agent/thirdparty_files/propcache-0.2.1.dist-info/RECORD,sha256=A0AH5SlmhdYApwiexI_AHxbUwvmdTQsjoDaimtdu6Hs,1360 +ray/_private/runtime_env/agent/thirdparty_files/propcache-0.2.1.dist-info/WHEEL,sha256=9BFfIe-Zq441iQ0ehutX65O5faGDpmB1Uw3WaQGk4f0,151 +ray/_private/runtime_env/agent/thirdparty_files/propcache-0.2.1.dist-info/top_level.txt,sha256=pVF_GbqSAITPMiX27kfU3QP9-ufhRvkADmudDxWdF3w,10 +ray/_private/runtime_env/agent/thirdparty_files/propcache/__init__.py,sha256=zm0_8WkuCrWe_q_FfVy_D3RiEx-POaZ9viD4zrjdIz4,965 +ray/_private/runtime_env/agent/thirdparty_files/propcache/__pycache__/__init__.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/propcache/__pycache__/_helpers.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/propcache/__pycache__/_helpers_py.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/propcache/__pycache__/api.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/propcache/_helpers.py,sha256=8CnlWmfTM6RDbMvNDXwL-VMHWiwIUjG8nbeqmvRsbh8,1579 +ray/_private/runtime_env/agent/thirdparty_files/propcache/_helpers_c.cpython-311-x86_64-linux-gnu.so,sha256=qHNxwgz3Pg_l338lXsRSM2jv9tCm5hpv1qcwiSoTSTU,800728 +ray/_private/runtime_env/agent/thirdparty_files/propcache/_helpers_c.pyx,sha256=8p6QRktqz3Gt7ok4E7nImkE13crRswIuIgNCmenUdD0,2487 +ray/_private/runtime_env/agent/thirdparty_files/propcache/_helpers_py.py,sha256=jnK6W43iETLcW-A1WMroGUKnElzX8Drw2UQfbEqLlI8,1637 +ray/_private/runtime_env/agent/thirdparty_files/propcache/api.py,sha256=wvgB-ypkkI5uf72VVYl2NFGc_TnzUQA2CxC7dTlL5ak,179 +ray/_private/runtime_env/agent/thirdparty_files/propcache/py.typed,sha256=ay5OMO475PlcZ_Fbun9maHW7Y6MBTk0UXL4ztHx3Iug,14 +ray/_private/runtime_env/agent/thirdparty_files/yarl-1.18.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +ray/_private/runtime_env/agent/thirdparty_files/yarl-1.18.3.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358 +ray/_private/runtime_env/agent/thirdparty_files/yarl-1.18.3.dist-info/METADATA,sha256=uCw3M98Beq35Z_oabzdjvJfOVVHsUKQLJkHFYlsLOAQ,69168 +ray/_private/runtime_env/agent/thirdparty_files/yarl-1.18.3.dist-info/NOTICE,sha256=VtasbIEFwKUTBMIdsGDjYa-ajqCvmnXCOcKLXRNpODg,609 +ray/_private/runtime_env/agent/thirdparty_files/yarl-1.18.3.dist-info/RECORD,sha256=FcuUw4Fz3XOKfT36wF_irF0Cohh__hMtpt8Fk2sptqc,1820 +ray/_private/runtime_env/agent/thirdparty_files/yarl-1.18.3.dist-info/WHEEL,sha256=9BFfIe-Zq441iQ0ehutX65O5faGDpmB1Uw3WaQGk4f0,151 +ray/_private/runtime_env/agent/thirdparty_files/yarl-1.18.3.dist-info/top_level.txt,sha256=vf3SJuQh-k7YtvsUrV_OPOrT9Kqn0COlk7IPYyhtGkQ,5 +ray/_private/runtime_env/agent/thirdparty_files/yarl/__init__.py,sha256=kOikSKDR4e054Sr-uNvv5edPUBIKHZ7Z-v4jYcffZFs,281 +ray/_private/runtime_env/agent/thirdparty_files/yarl/__pycache__/__init__.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/yarl/__pycache__/_parse.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/yarl/__pycache__/_path.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/yarl/__pycache__/_query.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/yarl/__pycache__/_quoters.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/yarl/__pycache__/_quoting.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/yarl/__pycache__/_quoting_py.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/yarl/__pycache__/_url.cpython-311.pyc,, +ray/_private/runtime_env/agent/thirdparty_files/yarl/_parse.py,sha256=b7EwD9mfrwh-1gOivqIo7674TFrnYjvlTMGy0jqyByc,6719 +ray/_private/runtime_env/agent/thirdparty_files/yarl/_path.py,sha256=A0FJUylZyzmlT0a3UDOBbK-EzZXCAYuQQBvG9eAC9hs,1291 +ray/_private/runtime_env/agent/thirdparty_files/yarl/_query.py,sha256=uOIglvIOHqxt_QPSFBVc_nTJZmnysEo3E0if0u064s8,4014 +ray/_private/runtime_env/agent/thirdparty_files/yarl/_quoters.py,sha256=IX1lZ0Dxz4yYjVCKAFZqq4QK8fBwYRoF9tURTX_eWDU,1079 +ray/_private/runtime_env/agent/thirdparty_files/yarl/_quoting.py,sha256=_Kyqs76exTwTY4HVChMOBvxYM2-ymb4dsApoiaJFCUs,509 +ray/_private/runtime_env/agent/thirdparty_files/yarl/_quoting_c.cpython-311-x86_64-linux-gnu.so,sha256=uSljlnIm0-pqINXra6mKuB1OwmSaVDLFNAtxS0RRpC0,1040232 +ray/_private/runtime_env/agent/thirdparty_files/yarl/_quoting_c.pyi,sha256=78wyjRGZNgeGX2VzQZlM6bLZEJSCoImGz-mll39VoW4,411 +ray/_private/runtime_env/agent/thirdparty_files/yarl/_quoting_c.pyx,sha256=qZ3AaFlE3yDqd2tdBwszXfd3FydhoSRusso0pHqilGU,13106 +ray/_private/runtime_env/agent/thirdparty_files/yarl/_quoting_py.py,sha256=DxBm600yabcmB3YanNbhH1OPJO-Dp2icEWzkGIDT0jw,6361 +ray/_private/runtime_env/agent/thirdparty_files/yarl/_url.py,sha256=n0Xt2EmyrMdQ8vK15Z_LsirgHxb5g9L6g7LFmy-gw3g,54413 +ray/_private/runtime_env/agent/thirdparty_files/yarl/py.typed,sha256=ay5OMO475PlcZ_Fbun9maHW7Y6MBTk0UXL4ztHx3Iug,14 +ray/_private/runtime_env/conda.py,sha256=OIA_hSSUiAtN6tHdf5F_ankRZF2Hhu3LKLScyjzSOoo,15147 +ray/_private/runtime_env/conda_utils.py,sha256=862wdJcFHF-A1F4Nfs_mAa8QH_3hRlgRJ8Ji9Vqwhv4,9464 +ray/_private/runtime_env/constants.py,sha256=n59A0vJ6oaWT5zrEXujILathVNaFbW4wX7zEHDK2aKQ,1076 +ray/_private/runtime_env/context.py,sha256=RVzfJS08nqvf13w-XXIKqbEorXCCoduB0IcUcHr_t0E,4264 +ray/_private/runtime_env/default_impl.py,sha256=qNyBaG0RV666GqLBpk5xq_Vr8pyEB4FF0OmJhLB1cRQ,252 +ray/_private/runtime_env/dependency_utils.py,sha256=ti-6PQAaCrLbczEIt2Ov1u7dbwH5GIKNap0eHmGzUr8,4322 +ray/_private/runtime_env/image_uri.py,sha256=dhHABNzt5GyunGuwsD7vXEBbp_bm_nqLdSerSfYSmV0,6346 +ray/_private/runtime_env/java_jars.py,sha256=BjmEbRb8h-w7IpoLQICebLRKD93jP3urdICV5V9OkpI,3647 +ray/_private/runtime_env/mpi.py,sha256=WU888qMhJWfP1dESSUjcPBZU8q3X8_Hgq2sV0hkJWo8,3466 +ray/_private/runtime_env/mpi_runner.py,sha256=mWgKIwf3NKwy6AVq_Igx-DGQ-33CCtAgJODd5i0NH6I,830 +ray/_private/runtime_env/nsight.py,sha256=Ed-YVVmuJrYh8NftTDHA3VRnHmdg5F6FrqGa3tGcoSY,5258 +ray/_private/runtime_env/packaging.py,sha256=DmssaNsgfi69cAaSWJmRUmXA5krQObKsa7pO3KYpGNI,32257 +ray/_private/runtime_env/pip.py,sha256=CNsKl1TC30W1vesaj7EwBppMXGSaHGEDsgD2gvH_Zjk,11752 +ray/_private/runtime_env/plugin.py,sha256=O34E5RWUwC9XgXVZSFPzSql4dB9v5OjBVFeJTCncUtQ,9334 +ray/_private/runtime_env/plugin_schema_manager.py,sha256=3LXRln3mp1L5YIdKR5LyjNj1QrqsAziA7PzlJzF1pW4,3502 +ray/_private/runtime_env/protocol.py,sha256=DJ-K_UDNkuGJKoQJzDF-8cAmKADzKrenRjxxZkANs-k,3720 +ray/_private/runtime_env/py_modules.py,sha256=XneFjSFu6dF4SWyGzqjeifjRDU4ZHDNKdS4aYjL85IA,8767 +ray/_private/runtime_env/setup_hook.py,sha256=Lfd-sHK-t0btI3A7z3xXrs7Mf59DMfF_jQwrad3A1ng,6778 +ray/_private/runtime_env/uri_cache.py,sha256=4-rqudZ6u5zeJr_1FVqjQSdu6TNeJL_hnY3SNLqZ4F4,4340 +ray/_private/runtime_env/utils.py,sha256=CnZXCEXF_2_AnGSuZ5Lu2gZYMCOsJ3kfeb9uz0HTq-w,3989 +ray/_private/runtime_env/uv.py,sha256=OGjNejk1RLo9mbFRNi54qyLRHWBkKD_Rbfpfp2eiz9k,12427 +ray/_private/runtime_env/validation.py,sha256=SwnaInI7liaiME3nJ9svlaQzWVSHG_G_vc0G_kP_Xkc,14696 +ray/_private/runtime_env/virtualenv_utils.py,sha256=eVXPsQ3UUeyWJyZpIVxFN7UsAMTJNmkzmGGJHsOldsY,3628 +ray/_private/runtime_env/working_dir.py,sha256=VShHgdGltHs-U38gqE7vi69bR7fvThTxF8_pccCXXFM,8473 +ray/_private/serialization.py,sha256=X3nr8bEGzQQ5lXbekNiJvLF1w45Zf6YE1YwdASWK3bc,24197 +ray/_private/services.py,sha256=2pAkLdTXPyddBjLYLwmODqHJBJsCWjHNZNojKQcr88w,89109 +ray/_private/signature.py,sha256=8vqNTVMVx0QS2Dao3n-viAmeEYH2Ahh8q9fzBzRqtxo,6281 +ray/_private/state.py,sha256=I4D0B7ZCK1nchIGmF-kD8exKRBNZwdiZY1V8W0wkv-M,41149 +ray/_private/state_api_test_utils.py,sha256=R4cdiXz7cHC7vRqW9Tr8ckE2vLhJcebiHK4aB6APzbg,16541 +ray/_private/storage.py,sha256=sEy8t4kGS_9FvmDaqEftdJ_V7MSaz_KJMPs4tCWCV14,16289 +ray/_private/test_utils.py,sha256=BOe_L0wzWVj8DSA9YFZZONMKr0t1_57V0J9B19J9XNI,75423 +ray/_private/thirdparty/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/_private/thirdparty/__pycache__/__init__.cpython-311.pyc,, +ray/_private/thirdparty/dacite/__init__.py,sha256=OZNF6CStZkbIfJnwudZ8uDHRZCzO8yAHb4vLtusuLy8,81 +ray/_private/thirdparty/dacite/__pycache__/__init__.cpython-311.pyc,, +ray/_private/thirdparty/dacite/__pycache__/config.cpython-311.pyc,, +ray/_private/thirdparty/dacite/__pycache__/core.cpython-311.pyc,, +ray/_private/thirdparty/dacite/__pycache__/data.cpython-311.pyc,, +ray/_private/thirdparty/dacite/__pycache__/dataclasses.cpython-311.pyc,, +ray/_private/thirdparty/dacite/__pycache__/exceptions.cpython-311.pyc,, +ray/_private/thirdparty/dacite/__pycache__/types.cpython-311.pyc,, +ray/_private/thirdparty/dacite/config.py,sha256=d0zlO-jqhSvpXW53Gie97sJkPMzbuvHbesIBwU1f1MU,407 +ray/_private/thirdparty/dacite/core.py,sha256=lX2HzgT4lSsbJDIhEacuorX6_JIuExeWjcYEZ73fdaY,5493 +ray/_private/thirdparty/dacite/data.py,sha256=YSkQNaokRQcsBU5scc-g9Uw3EGAm-xabGOEwTgmYUe4,52 +ray/_private/thirdparty/dacite/dataclasses.py,sha256=HYg-Bi-eL8H3QY3ll91QW0LLRjscGMs_JLQ5ITzouUA,1032 +ray/_private/thirdparty/dacite/exceptions.py,sha256=p87iJx6OH_siwS-bULadqWeb1W7VgLqCtpDavV4Sdl0,2587 +ray/_private/thirdparty/dacite/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/_private/thirdparty/dacite/types.py,sha256=sRPDh8FF-rWy_cPtuBWCavqtNJeofh9AQynYEmZ_Sk4,5823 +ray/_private/thirdparty/pathspec/__init__.py,sha256=Fx3qyGKKhKWkAVsb5x1zoMVzCr-4wIw4H9pyokvu7sw,2213 +ray/_private/thirdparty/pathspec/__pycache__/__init__.cpython-311.pyc,, +ray/_private/thirdparty/pathspec/__pycache__/compat.cpython-311.pyc,, +ray/_private/thirdparty/pathspec/__pycache__/pathspec.cpython-311.pyc,, +ray/_private/thirdparty/pathspec/__pycache__/pattern.cpython-311.pyc,, +ray/_private/thirdparty/pathspec/__pycache__/util.cpython-311.pyc,, +ray/_private/thirdparty/pathspec/compat.py,sha256=OZJedLvgxHbuKKn5Rnia_UDcyDZfnqCQerLoIvSR_Qc,777 +ray/_private/thirdparty/pathspec/pathspec.py,sha256=6DzqgsaxHFdSa1VChuk0yIhfL-hMekkdvhT6roBU8c0,7027 +ray/_private/thirdparty/pathspec/pattern.py,sha256=p-ibgRLK9kIkiXWoCtq4SangTZEBUaNIO0hgKQY4KEI,4405 +ray/_private/thirdparty/pathspec/patterns/__init__.py,sha256=Falv9rzI0S-Sjc-t-vCS9nUPcKwBptmdNderY9Kok50,184 +ray/_private/thirdparty/pathspec/patterns/__pycache__/__init__.cpython-311.pyc,, +ray/_private/thirdparty/pathspec/patterns/__pycache__/gitwildmatch.cpython-311.pyc,, +ray/_private/thirdparty/pathspec/patterns/gitwildmatch.py,sha256=cJfGcaj9rL9YhVhItJv-xuwYsveraCXFVQm_Xg_iMTE,9947 +ray/_private/thirdparty/pathspec/util.py,sha256=smB9T1UuQ7ZBvZZvdtRBr1C0W6BssfeFkNA-4c-cXRY,17929 +ray/_private/thirdparty/pyamdsmi/__init__.py,sha256=nM1QPuKAKqH1aMeiGk4HAd-6axHTpgQp-lpfcnKxQjk,56 +ray/_private/thirdparty/pyamdsmi/__pycache__/__init__.cpython-311.pyc,, +ray/_private/thirdparty/pyamdsmi/__pycache__/pyamdsmi.cpython-311.pyc,, +ray/_private/thirdparty/pyamdsmi/pyamdsmi.py,sha256=VMgczKTs9TitSw8GQ3uneFF5P7q_t2yYf3h_HGqAPUk,19304 +ray/_private/thirdparty/pynvml/__init__.py,sha256=WrEa5QLoEYjDk6Z6rNkFk2bLHNtYaK510qdSF5n65rQ,182 +ray/_private/thirdparty/pynvml/__pycache__/__init__.cpython-311.pyc,, +ray/_private/thirdparty/pynvml/__pycache__/pynvml.cpython-311.pyc,, +ray/_private/thirdparty/pynvml/pynvml.py,sha256=_1HdJjSXXOaQALcS5D4OyWWRrWPpMH9MtHNWoKPS_P4,135337 +ray/_private/thirdparty/tabulate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/_private/thirdparty/tabulate/__pycache__/__init__.cpython-311.pyc,, +ray/_private/thirdparty/tabulate/__pycache__/tabulate.cpython-311.pyc,, +ray/_private/thirdparty/tabulate/tabulate.py,sha256=9ljbv_oiLnG5MFG_70ItjhROStVSok-8Ti1F8ImD1-0,95389 +ray/_private/tls_utils.py,sha256=KAlRCm_hXubqJ_MKas_q1ubDss6w2Jcalwey3WWcEb0,3661 +ray/_private/usage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/_private/usage/__pycache__/__init__.cpython-311.pyc,, +ray/_private/usage/__pycache__/usage_constants.cpython-311.pyc,, +ray/_private/usage/__pycache__/usage_lib.cpython-311.pyc,, +ray/_private/usage/usage_constants.py,sha256=wYcxpwBfh6U-qNQ2BlAp1W938ie486rghfNwOXtOQPk,2421 +ray/_private/usage/usage_lib.py,sha256=R69OsvpGAmuXgZ-RQVNz3-Cri8KNi7jFD2p7yZnewMo,34011 +ray/_private/utils.py,sha256=goAq567hcnzqReW8BY45doP1OUtmEwVZ9Umb1VGIqhA,75077 +ray/_private/worker.py,sha256=4d-wiLb8cP_dwi15mOmOJcuq0gVABBomKx2SBG6cN0Y,133837 +ray/_private/workers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/_private/workers/__pycache__/__init__.cpython-311.pyc,, +ray/_private/workers/__pycache__/default_worker.cpython-311.pyc,, +ray/_private/workers/__pycache__/setup_worker.cpython-311.pyc,, +ray/_private/workers/default_worker.py,sha256=p8cexYWzRfLjmAs7wZA9bVpFd1vwDlDqG2NTM3bdIUw,9293 +ray/_private/workers/setup_worker.py,sha256=m5ncsOdAXj6IjshOZt0nhfiFghiLUQ_VOtX4HQI6CHQ,1154 +ray/_raylet.pxd,sha256=_D_y4vXAHQNwxWJln8nqcGsw6FOoyPq9gTYUMeHEsZM,5343 +ray/_raylet.pyi,sha256=6cPtYwFl5NDCW7K1Q6oUPbl6reeOZ0YL4gxJuQzQ7mk,169 +ray/_raylet.so,sha256=5VFuxe-jfvsDTKD6bIQDMxpDAQE1a9-YKc3tY1FRADc,35971224 +ray/_version.py,sha256=Z3XzkFGd_aO-DTrViBbEhnBHZXQt2u8e7JRDVa56csQ,199 +ray/actor.py,sha256=81nciN8FepImwNjTww2YQivnKFaJIRt8R4d4rU59DL4,75337 +ray/air/__init__.py,sha256=BwLQ37BzKBDAyaj4VzUlb1uTerrsXCNjf1pLpL7TNaY,494 +ray/air/__pycache__/__init__.cpython-311.pyc,, +ray/air/__pycache__/config.cpython-311.pyc,, +ray/air/__pycache__/constants.cpython-311.pyc,, +ray/air/__pycache__/data_batch_type.cpython-311.pyc,, +ray/air/__pycache__/result.cpython-311.pyc,, +ray/air/__pycache__/session.cpython-311.pyc,, +ray/air/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/air/_internal/__pycache__/__init__.cpython-311.pyc,, +ray/air/_internal/__pycache__/config.cpython-311.pyc,, +ray/air/_internal/__pycache__/filelock.cpython-311.pyc,, +ray/air/_internal/__pycache__/json.cpython-311.pyc,, +ray/air/_internal/__pycache__/mlflow.cpython-311.pyc,, +ray/air/_internal/__pycache__/tensorflow_utils.cpython-311.pyc,, +ray/air/_internal/__pycache__/torch_utils.cpython-311.pyc,, +ray/air/_internal/__pycache__/uri_utils.cpython-311.pyc,, +ray/air/_internal/__pycache__/usage.cpython-311.pyc,, +ray/air/_internal/__pycache__/util.cpython-311.pyc,, +ray/air/_internal/config.py,sha256=GDlQaSPROhvgA-u91uL5tctRbbE9SrdWQb3Iya3p-7o,1581 +ray/air/_internal/device_manager/__init__.py,sha256=db6XDVjQu9ZY4Qx-kyhAUj3YiLxl0vuAbEgJwo3w3J8,3310 +ray/air/_internal/device_manager/__pycache__/__init__.cpython-311.pyc,, +ray/air/_internal/device_manager/__pycache__/cpu.cpython-311.pyc,, +ray/air/_internal/device_manager/__pycache__/hpu.cpython-311.pyc,, +ray/air/_internal/device_manager/__pycache__/npu.cpython-311.pyc,, +ray/air/_internal/device_manager/__pycache__/nvidia_gpu.cpython-311.pyc,, +ray/air/_internal/device_manager/__pycache__/torch_device_manager.cpython-311.pyc,, +ray/air/_internal/device_manager/cpu.py,sha256=1Pumfvjt3aCOpRysunQDUhUHPS80aWCfPJdhQ_NUBus,813 +ray/air/_internal/device_manager/hpu.py,sha256=XmCa0NtfWm9D8YvYffECxTY3rsxcQYQPsusSBSxNY80,1481 +ray/air/_internal/device_manager/npu.py,sha256=T_JQihxAY6FG_jIBBpxLH5G5xJpOcb0Eg8QOeptoL-4,3451 +ray/air/_internal/device_manager/nvidia_gpu.py,sha256=llLYHvGPq0j1Fes8lDKHLn0v4JMAWDZjddCp06dWr-4,2993 +ray/air/_internal/device_manager/torch_device_manager.py,sha256=dNG8HQ74BQI_CVFGw2ssnSQFunfb6Mn5NbJT7Irvtng,1138 +ray/air/_internal/filelock.py,sha256=irjLwsoWyu4y2QFHjSlbbfq3htL2u9OH6u-8FYL7XMc,1431 +ray/air/_internal/json.py,sha256=vLHL8K4BMeogr_LTcw_q8ni82F-L_89RvrbED_mYYTU,908 +ray/air/_internal/mlflow.py,sha256=aue99PbzpfCqLemZPuCwnsegC2xIw_XVg47RQgWYNIA,12627 +ray/air/_internal/tensorflow_utils.py,sha256=_MwYRouv0v9o3thwNMcEPfB2gKobRBGN12wXOqskevg,4825 +ray/air/_internal/torch_utils.py,sha256=0aCs3sbcbDwJ-VfsTmonOfpZdi3u5GeTYeAIHlJMoGE,11443 +ray/air/_internal/uri_utils.py,sha256=S5DBhJ7UGebNsVI3UGGy58kMwwhWuvU7KFIzEKq9AjM,3096 +ray/air/_internal/usage.py,sha256=I4gPkT3k00UI2qx8JMyF8qMKor6Np9B94TML_G6O3g0,8736 +ray/air/_internal/util.py,sha256=eZeyHKoEXtEGFSyiceTJ5chZJXXGCdKxZVEuWXRsZso,4141 +ray/air/config.py,sha256=1KGaj3ltoGYVNXQ9arLo-jpzBFAC9zB-5qtgOZEVSck,32857 +ray/air/constants.py,sha256=UWSXvYmwVVzy_JW1RHvYNWjWJYHjV8C8VtZoVlmCfdk,3211 +ray/air/data_batch_type.py,sha256=vD4v2oi-T1xXdbmd5lG2U6NMkuKGpzYH8GrU4j8EM3s,287 +ray/air/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/air/examples/__pycache__/__init__.cpython-311.pyc,, +ray/air/examples/__pycache__/custom_trainer.cpython-311.pyc,, +ray/air/examples/custom_trainer.py,sha256=sEL3txmpMufw4JDcYYVVpaI5300WLL6CKHr0yk_2d7w,1698 +ray/air/execution/__init__.py,sha256=cixguYR5h_W2aIooIQfmpeQB3rstw5DVEFcAbgd5CEw,460 +ray/air/execution/__pycache__/__init__.cpython-311.pyc,, +ray/air/execution/_internal/__init__.py,sha256=NH6qtho9rC7Tkf4lWcosAzZ2ductAX8wt6oCbxJMGKg,251 +ray/air/execution/_internal/__pycache__/__init__.cpython-311.pyc,, +ray/air/execution/_internal/__pycache__/actor_manager.cpython-311.pyc,, +ray/air/execution/_internal/__pycache__/barrier.cpython-311.pyc,, +ray/air/execution/_internal/__pycache__/event_manager.cpython-311.pyc,, +ray/air/execution/_internal/__pycache__/tracked_actor.cpython-311.pyc,, +ray/air/execution/_internal/__pycache__/tracked_actor_task.cpython-311.pyc,, +ray/air/execution/_internal/actor_manager.py,sha256=GHJU_mRE9Wq_lHAtkpOSWjLO1-MiES2frBjwgG99mO8,35022 +ray/air/execution/_internal/barrier.py,sha256=lcA7Lkx4il0v7CbqhHe9mlQwK4ZcRGVJ7Etydc4NRbY,2951 +ray/air/execution/_internal/event_manager.py,sha256=OAlhQJK9RTU2Rgj6y2Kjjc7robf1QmZ_h7ZRu6VIocw,4933 +ray/air/execution/_internal/tracked_actor.py,sha256=wAixW_J8iKPMPvxEknk5bBDsCam3goMyc1o4mnrnhfY,1715 +ray/air/execution/_internal/tracked_actor_task.py,sha256=iYqDQNCD9W6MRWpzJVzDuA69S5nqgE6paPgZR-1RirM,1261 +ray/air/execution/resources/__init__.py,sha256=cixguYR5h_W2aIooIQfmpeQB3rstw5DVEFcAbgd5CEw,460 +ray/air/execution/resources/__pycache__/__init__.cpython-311.pyc,, +ray/air/execution/resources/__pycache__/fixed.cpython-311.pyc,, +ray/air/execution/resources/__pycache__/placement_group.cpython-311.pyc,, +ray/air/execution/resources/__pycache__/request.cpython-311.pyc,, +ray/air/execution/resources/__pycache__/resource_manager.cpython-311.pyc,, +ray/air/execution/resources/fixed.py,sha256=PK7Fja8oPsU2VNnDXEovTfJsETn9_1IOmSomzYCrC8g,5544 +ray/air/execution/resources/placement_group.py,sha256=mWXzYUKvJoU6n-J9EPxxvQvhJoqCmvzhMBCop-Hdng4,8541 +ray/air/execution/resources/request.py,sha256=4gWzO9shDnn5zZoTflZjwmlm1n8_Fo6CcMIIFV28sp4,8541 +ray/air/execution/resources/resource_manager.py,sha256=5wRkNnqIFuImjjsrQmOWGpby70dkryFVZevO0F-_JgE,6231 +ray/air/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/air/integrations/__pycache__/__init__.cpython-311.pyc,, +ray/air/integrations/__pycache__/comet.cpython-311.pyc,, +ray/air/integrations/__pycache__/keras.cpython-311.pyc,, +ray/air/integrations/__pycache__/mlflow.cpython-311.pyc,, +ray/air/integrations/__pycache__/wandb.cpython-311.pyc,, +ray/air/integrations/comet.py,sha256=jnLWDSNGqOegx1wcKZ1N2YljIo2cn7P11HNXHc54mvo,9144 +ray/air/integrations/keras.py,sha256=oKN9ssU3dbhk2a5w1uZAvaCd4E-WjL-XOqLGVHuCCvc,6522 +ray/air/integrations/mlflow.py,sha256=ndKgKyzi_LKieoTRTjmB0_X84ykhcn-qluK_tllSr54,12377 +ray/air/integrations/wandb.py,sha256=fl-IMTu87JyNwVVffIO65y3CnVYBuyHdDVwq97-HCKM,26922 +ray/air/result.py,sha256=QGif9wsViagnVGqigEO9Yj_tueG8PIUO8IIVwSpX-tQ,10998 +ray/air/session.py,sha256=WP3yXyfNlkwowGmN0Zey0QUTMTSNfyH9Ozc-I8Tz0Ok,61 +ray/air/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/air/util/__pycache__/__init__.cpython-311.pyc,, +ray/air/util/__pycache__/check_ingest.cpython-311.pyc,, +ray/air/util/__pycache__/data_batch_conversion.cpython-311.pyc,, +ray/air/util/__pycache__/node.cpython-311.pyc,, +ray/air/util/__pycache__/torch_dist.cpython-311.pyc,, +ray/air/util/__pycache__/transform_pyarrow.cpython-311.pyc,, +ray/air/util/check_ingest.py,sha256=CgxRweTCHLJHuWabDxXENxFhCfhwjNuXZ_96EclToxc,7345 +ray/air/util/data_batch_conversion.py,sha256=k2P_K2Jc6jGb5wqHXW10BFkfFcdJF8V7FQjdEPkxe3I,12539 +ray/air/util/node.py,sha256=ybbzkBSNSq5L_ZPPrQYb7yvogqT6P_F2MmT8UuXJWaE,2682 +ray/air/util/object_extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/air/util/object_extensions/__pycache__/__init__.cpython-311.pyc,, +ray/air/util/object_extensions/__pycache__/arrow.cpython-311.pyc,, +ray/air/util/object_extensions/__pycache__/pandas.cpython-311.pyc,, +ray/air/util/object_extensions/arrow.py,sha256=XrZLY77-s72Kgw_pbJZUVKNoWdIlR8VfSK8te8hEMAc,4070 +ray/air/util/object_extensions/pandas.py,sha256=isouYndAuTTRBr8jjOKnuQWh3_IFt4K_BW4CFv_myIc,4514 +ray/air/util/tensor_extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/air/util/tensor_extensions/__pycache__/__init__.cpython-311.pyc,, +ray/air/util/tensor_extensions/__pycache__/arrow.cpython-311.pyc,, +ray/air/util/tensor_extensions/__pycache__/pandas.cpython-311.pyc,, +ray/air/util/tensor_extensions/__pycache__/utils.cpython-311.pyc,, +ray/air/util/tensor_extensions/arrow.py,sha256=Xybr8a7wi9kVdQnBlSTKpSUgO3S-tEPRO0JifyLtPqw,49788 +ray/air/util/tensor_extensions/pandas.py,sha256=sDuXOQR769-9ffoCsMktvquUsC_zP0v3Q2zos53s3m4,50743 +ray/air/util/tensor_extensions/utils.py,sha256=nYPE2XxjlyjBuLi4MKlDYJiboZGjxnejmtPXo12QZiU,5207 +ray/air/util/torch_dist.py,sha256=eP1FJoxjKSCsq_UNmR8l5dBv_jdYUyc3Atn4CkCXQqQ,6242 +ray/air/util/transform_pyarrow.py,sha256=F6n4ozvS1IqOu1ibcEk6Eafd7yBZnpMwqMqWKRFZ45c,1338 +ray/autoscaler/__init__.py,sha256=aiHhRCAyGsh8oAsf3fMsFDsoB-s3ZJ3Ec8dChpX52kI,158 +ray/autoscaler/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/__pycache__/batching_node_provider.cpython-311.pyc,, +ray/autoscaler/__pycache__/command_runner.cpython-311.pyc,, +ray/autoscaler/__pycache__/launch_and_verify_cluster.cpython-311.pyc,, +ray/autoscaler/__pycache__/node_launch_exception.cpython-311.pyc,, +ray/autoscaler/__pycache__/node_provider.cpython-311.pyc,, +ray/autoscaler/__pycache__/tags.cpython-311.pyc,, +ray/autoscaler/_private/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/_private/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/autoscaler.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/cli_logger.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/cli_logger_demoall.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/cluster_dump.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/command_runner.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/commands.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/constants.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/docker.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/event_summarizer.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/event_system.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/legacy_info_string.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/load_metrics.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/loader.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/log_timer.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/monitor.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/node_launcher.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/node_provider_availability_tracker.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/node_tracker.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/prom_metrics.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/providers.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/resource_demand_scheduler.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/subprocess_output_util.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/updater.cpython-311.pyc,, +ray/autoscaler/_private/__pycache__/util.cpython-311.pyc,, +ray/autoscaler/_private/_azure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/_private/_azure/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/_private/_azure/__pycache__/config.cpython-311.pyc,, +ray/autoscaler/_private/_azure/__pycache__/node_provider.cpython-311.pyc,, +ray/autoscaler/_private/_azure/azure-config-template.json,sha256=GHBazvRT-eael7s4eXrjeVdfg7JkYBRd7iqFcjnqTJk,4914 +ray/autoscaler/_private/_azure/azure-vm-template.json,sha256=nWrtxTbISiAaN1wuoXn_o8-SSY3aWII3QATTmiAKSto,10916 +ray/autoscaler/_private/_azure/config.py,sha256=azhdKgmNv-hBEH6GrFivCyssJjZXOX6RBjJHyPjdkA8,7821 +ray/autoscaler/_private/_azure/node_provider.py,sha256=2F6ncVrKN77WIDz28dbFtcoPzWoA20mS69I4hbSZmrQ,18998 +ray/autoscaler/_private/aliyun/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/_private/aliyun/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/_private/aliyun/__pycache__/config.cpython-311.pyc,, +ray/autoscaler/_private/aliyun/__pycache__/node_provider.cpython-311.pyc,, +ray/autoscaler/_private/aliyun/__pycache__/utils.cpython-311.pyc,, +ray/autoscaler/_private/aliyun/config.py,sha256=Xs_brOQGEEhBAcNxDWrcq2yPDeOU81DnIOnX-4zMVmA,3822 +ray/autoscaler/_private/aliyun/node_provider.py,sha256=ArOL1hVY_AFgev9QTicH9q3joIsh11RJC0M7iZ57q8o,12726 +ray/autoscaler/_private/aliyun/utils.py,sha256=DqU2FXDBW3o3Js1HivUP-dD9hhhcc8Ql-hInn2pUc9Y,18551 +ray/autoscaler/_private/autoscaler.py,sha256=13w1pvCJD1O9jvLKGGjUill_uYmKABOrH9pntMiWyrU,64920 +ray/autoscaler/_private/aws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/_private/aws/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/_private/aws/__pycache__/config.cpython-311.pyc,, +ray/autoscaler/_private/aws/__pycache__/node_provider.cpython-311.pyc,, +ray/autoscaler/_private/aws/__pycache__/utils.cpython-311.pyc,, +ray/autoscaler/_private/aws/cloudwatch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/_private/aws/cloudwatch/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/_private/aws/cloudwatch/__pycache__/cloudwatch_helper.cpython-311.pyc,, +ray/autoscaler/_private/aws/cloudwatch/cloudwatch_helper.py,sha256=p1FKhKNbzQZmTrb0UORyjUIyVICzyaO7xHdwMCECgOw,32701 +ray/autoscaler/_private/aws/config.py,sha256=Wf5gWHFrvjCsc8EKrCyb5j6cW-gwj9IS6LEeDYAyBBI,44982 +ray/autoscaler/_private/aws/node_provider.py,sha256=LQqdqxwLXp-K3KE7b5Fkx1AC5nuSi6wDa6kWQhDDZkc,27067 +ray/autoscaler/_private/aws/utils.py,sha256=lYPrLd_oFTwsqnowa9pw9YQTsTnlSdedkBXra0Npq7Y,5917 +ray/autoscaler/_private/cli_logger.py,sha256=1HoJnyjfpwpo5y7JNM1ub7MfcxgEESBFcI3brEXYwnY,25916 +ray/autoscaler/_private/cli_logger_demoall.py,sha256=UB12VUVWDG-Ey6q13DVnWLQGaVyycp-7kQxdC27vap4,1261 +ray/autoscaler/_private/cluster_dump.py,sha256=KcDsS92ZO1Q31i29VgMsyRgEMue2ggeVdQUwdbNfmJs,19664 +ray/autoscaler/_private/command_runner.py,sha256=_tk_FhWQvz7dSLynyi84OyDgZ5ZUMDXDb2cJOcC035k,34708 +ray/autoscaler/_private/commands.py,sha256=-HYwealqt8JpP8KTQwwM5PI_cHcyiSFC1ppN2KFuJjk,56466 +ray/autoscaler/_private/constants.py,sha256=wNJid2IjGfodoH9mSVx3OQAZ61LAz0QUlbyZLF757qI,5631 +ray/autoscaler/_private/docker.py,sha256=zNxEQy28tYSlH0s_7X2AGi1MnLVbWk51u9hA7N1Tou4,3748 +ray/autoscaler/_private/event_summarizer.py,sha256=xdshB1iBm196bnGW02BsUDClYXEmUuU62wnAK0T0xw4,2881 +ray/autoscaler/_private/event_system.py,sha256=rd7wj33LgCSKcveGaqpSJ4RN3pwsqTlXCyTwAQGzVTQ,3870 +ray/autoscaler/_private/fake_multi_node/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/_private/fake_multi_node/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/_private/fake_multi_node/__pycache__/command_runner.cpython-311.pyc,, +ray/autoscaler/_private/fake_multi_node/__pycache__/docker_monitor.cpython-311.pyc,, +ray/autoscaler/_private/fake_multi_node/__pycache__/node_provider.cpython-311.pyc,, +ray/autoscaler/_private/fake_multi_node/__pycache__/test_utils.cpython-311.pyc,, +ray/autoscaler/_private/fake_multi_node/command_runner.py,sha256=pgeMrUV4GAYZakvDBuMliSbddZ_ASlG8LYFZV6HPx0Q,3222 +ray/autoscaler/_private/fake_multi_node/docker_monitor.py,sha256=Xl--oS_J6zpx8WhSoAKN4FXi0Sa70wCtDnOIKEpq2h4,7372 +ray/autoscaler/_private/fake_multi_node/node_provider.py,sha256=7FT1sHZ4VVjf5BIdCciX3yPmtWxz97QUm8xzvzfIPHM,25583 +ray/autoscaler/_private/fake_multi_node/test_utils.py,sha256=6nntSpvdjNRDW8OMYQlVO5xpoV09NcnWpZx8ydx5g3Y,12433 +ray/autoscaler/_private/gcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/_private/gcp/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/_private/gcp/__pycache__/config.cpython-311.pyc,, +ray/autoscaler/_private/gcp/__pycache__/node.cpython-311.pyc,, +ray/autoscaler/_private/gcp/__pycache__/node_provider.cpython-311.pyc,, +ray/autoscaler/_private/gcp/__pycache__/tpu_command_runner.cpython-311.pyc,, +ray/autoscaler/_private/gcp/config.py,sha256=rsjtdPQVyrV-eP5fYMl56lx0XkgQxyYoutWeSP_rGVw,28294 +ray/autoscaler/_private/gcp/node.py,sha256=V9J1TAlebhg-JIb7h_m3IlvyrvUoSZF5ZEKhgnR10uc,27082 +ray/autoscaler/_private/gcp/node_provider.py,sha256=SrbgHZ_u0FGo7ZrQslZnk8H26L4QjcbK6GDDFRp0AyY,12663 +ray/autoscaler/_private/gcp/tpu_command_runner.py,sha256=oJ7WO4aLUIrInS0j2wX0t2jg4s2i316I7s0G6H2nePY,12021 +ray/autoscaler/_private/kuberay/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/_private/kuberay/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/_private/kuberay/__pycache__/autoscaling_config.cpython-311.pyc,, +ray/autoscaler/_private/kuberay/__pycache__/node_provider.cpython-311.pyc,, +ray/autoscaler/_private/kuberay/__pycache__/run_autoscaler.cpython-311.pyc,, +ray/autoscaler/_private/kuberay/__pycache__/utils.cpython-311.pyc,, +ray/autoscaler/_private/kuberay/autoscaling_config.py,sha256=kJtLgOkeVpK4IMJXNo-qMsEsNum5WsSNcv7QXSiwA90,16104 +ray/autoscaler/_private/kuberay/node_provider.py,sha256=q8TCc-ViGvvfuYnhLwPiQxgF60yp16Vgxw8Dk5PdRZI,20864 +ray/autoscaler/_private/kuberay/run_autoscaler.py,sha256=T3cRa6c_176rLK_ryr82ybNk3tAIZMrxzkPB0tTylyk,4414 +ray/autoscaler/_private/kuberay/utils.py,sha256=qsLFUggL4JMMmO-TAIZ1M8MA7T8UmvJMsnkvk-aj-l0,3429 +ray/autoscaler/_private/legacy_info_string.py,sha256=Z2geRjdUbWaUFBiFsz137O5pu_oHXVb28foPBgis2ek,1225 +ray/autoscaler/_private/load_metrics.py,sha256=7jW-6rCNhGooE_hg7fVLynUSO2x6NOWBsUtQBtu2ySY,14751 +ray/autoscaler/_private/loader.py,sha256=qUmuP9226LpEwIoDc__q2n0kWuS0p9-p6Ghr0k-unuw,495 +ray/autoscaler/_private/local/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/_private/local/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/_private/local/__pycache__/config.cpython-311.pyc,, +ray/autoscaler/_private/local/__pycache__/coordinator_node_provider.cpython-311.pyc,, +ray/autoscaler/_private/local/__pycache__/node_provider.cpython-311.pyc,, +ray/autoscaler/_private/local/config.py,sha256=ClP8jQ0ZYDuH59IDMQJmnaOxQl6PqwG2-rXwQ-sdVTk,4526 +ray/autoscaler/_private/local/coordinator_node_provider.py,sha256=px1wHd7TCQ1N-f0ZSbfJJy3rhrQBVaBdNH0zK_Upo8k,4128 +ray/autoscaler/_private/local/node_provider.py,sha256=gBV4rBGRfNRoEXfov6WyEJL64sKCa2q8shcjRPFlEos,11658 +ray/autoscaler/_private/log_timer.py,sha256=lhEtdlAAGhFbxGngzSmo5e3u9dE6fIl8cLdU3p10AL8,876 +ray/autoscaler/_private/monitor.py,sha256=vUWc1o406AOp3xFFEUHZiUqB_D3CpVWxp5JrDCDlb5Y,27872 +ray/autoscaler/_private/node_launcher.py,sha256=LvaU6ZPROAGtOiIsMHCzK47AGACbZdqS-gKzmQumirA,8230 +ray/autoscaler/_private/node_provider_availability_tracker.py,sha256=QVn9Usn2uS0hnee9mKmb3YUBXXpFN_zrAOaMunV5BPQ,5862 +ray/autoscaler/_private/node_tracker.py,sha256=_rqXfHoZvLIXATduhIL-2x5V0zBZjiuiv6dHSYHoHhM,2744 +ray/autoscaler/_private/prom_metrics.py,sha256=SA_PWOIr7Ved6bbHx0DxpNMHDE_F2TSPF1qX8ws6CPY,11817 +ray/autoscaler/_private/providers.py,sha256=fZJt1zPMwzysHHRCgCO3MQc_3atusDde1kDwVxqbqNM,9220 +ray/autoscaler/_private/readonly/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/_private/readonly/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/_private/readonly/__pycache__/node_provider.cpython-311.pyc,, +ray/autoscaler/_private/readonly/node_provider.py,sha256=usZIRxb3rzTxtJrYeHo5tUUguhmBofCqHnArY5pV3IA,2545 +ray/autoscaler/_private/resource_demand_scheduler.py,sha256=OfhCjIpzBb_wNZc-VP-Qqby5Jnsu7kPn9-qXbNYyaR8,40624 +ray/autoscaler/_private/spark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/_private/spark/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/_private/spark/__pycache__/node_provider.cpython-311.pyc,, +ray/autoscaler/_private/spark/__pycache__/spark_job_server.cpython-311.pyc,, +ray/autoscaler/_private/spark/node_provider.py,sha256=SGEuj8vdMf5AkOu5N-QJbTeyfWhMKQ427tVZQtH5gcM,8970 +ray/autoscaler/_private/spark/spark_job_server.py,sha256=cnh0QlwSZL5ileKrc74awGsG_sEay8X4oSd-RI7d7gQ,11344 +ray/autoscaler/_private/subprocess_output_util.py,sha256=VwJTMnAo7u_HbJKeYTeCXIMWot8CBhkShN1YVpeB2KE,15003 +ray/autoscaler/_private/updater.py,sha256=QEZ2NDUc64bpfVovYTN4UHTPviK8Kqg9sBkd48VkIWY,24888 +ray/autoscaler/_private/util.py,sha256=OLt2wplC05SWB24K8tY2__SolcFc_d5xudUxuEs-Ztc,35557 +ray/autoscaler/_private/vsphere/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/_private/vsphere/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/_private/vsphere/__pycache__/config.cpython-311.pyc,, +ray/autoscaler/_private/vsphere/__pycache__/gpu_utils.cpython-311.pyc,, +ray/autoscaler/_private/vsphere/__pycache__/node_provider.cpython-311.pyc,, +ray/autoscaler/_private/vsphere/__pycache__/pyvmomi_sdk_provider.cpython-311.pyc,, +ray/autoscaler/_private/vsphere/__pycache__/scheduler.cpython-311.pyc,, +ray/autoscaler/_private/vsphere/__pycache__/utils.cpython-311.pyc,, +ray/autoscaler/_private/vsphere/__pycache__/vsphere_sdk_provider.cpython-311.pyc,, +ray/autoscaler/_private/vsphere/config.py,sha256=FWAg8YhUCjp683rGz9lxszF9IeV8OBDyjKMhQTnrNZ8,9565 +ray/autoscaler/_private/vsphere/gpu_utils.py,sha256=gZvKkwugS2hJkbCmbm7fNCJiDEXkDX9ZNII5h4hv9XI,13634 +ray/autoscaler/_private/vsphere/node_provider.py,sha256=lEbgRhcPmv4Urdp24sjqXCXHA_KtWYbxJCdffou6UQQ,19448 +ray/autoscaler/_private/vsphere/pyvmomi_sdk_provider.py,sha256=y-499akY0BzvU6_w1065z7i_WqAFWmrtZfBC6JX5BeM,13289 +ray/autoscaler/_private/vsphere/scheduler.py,sha256=GjGB8-wWiPr5xIRodlhprUpAs_xy-4cwdgPvDRxir_Y,1487 +ray/autoscaler/_private/vsphere/utils.py,sha256=edewQJLOVkCkSeNjQUmYE7Qs870W8QLiHwTM0PMg08Q,2130 +ray/autoscaler/_private/vsphere/vsphere_sdk_provider.py,sha256=5led99NexAHXNWdHK71nUEuonqXSu4FLvJ5DArjO9sc,18303 +ray/autoscaler/aliyun/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/aliyun/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/aws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/aws/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/aws/cloudwatch/prometheus.yml,sha256=AbNQEhaJsc1ohI7uxrhaj9QlGysVd9-q8yOSGfZJROc,334 +ray/autoscaler/aws/cloudwatch/ray_prometheus_waiter.sh,sha256=CHggfSNMYdXjlPGDFIY_we12VcWdXIgxwEet_RklXbs,1142 +ray/autoscaler/aws/defaults.yaml,sha256=IZeoyeuhv8BHmV3_VsEM_1Jp4DKdIFxjpxAeBEjT6v0,6907 +ray/autoscaler/azure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/azure/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/azure/defaults.yaml,sha256=Ca8_FgN3x68U7lBQzei6aUzrMQIMOg_YpD0bDb-oM2E,7162 +ray/autoscaler/batching_node_provider.py,sha256=xV4B_AWUyvbNMuh638jJ0f1uqCNyH52nGpttu8wGY_o,10437 +ray/autoscaler/command_runner.py,sha256=pto-4COYeRIWCVQciu0DwrKfNOEjhKElPlney6niI9o,3450 +ray/autoscaler/gcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/gcp/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/gcp/defaults.yaml,sha256=6AF5PhG5g-QSnLtczbdq77ohai7bROJGhzXyi5X139g,7296 +ray/autoscaler/launch_and_verify_cluster.py,sha256=oLEqe8DBQOQAVie96x9OyO998BBYY-bqHIGIPPiITfI,14559 +ray/autoscaler/local/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/local/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/local/__pycache__/coordinator_server.cpython-311.pyc,, +ray/autoscaler/local/coordinator_server.py,sha256=YxuPtyxZIlUUgt0yC4yDFWKYfOHviP5tUg-ts7PjWzo,4223 +ray/autoscaler/local/defaults.yaml,sha256=Pk5bSGGTK0UOHt8AT4TOEP8GVJMW8UFm8F9LOa6sHKU,893 +ray/autoscaler/node_launch_exception.py,sha256=EWnbG283fRiNah8-mUaYfFjnkk4p_0-yRnyvFYg0-RA,1238 +ray/autoscaler/node_provider.py,sha256=IOMTQwWbIgCHYPx0hNmhtFqN6BlC1Q7m-h2GH9rXx_E,10023 +ray/autoscaler/ray-schema.json,sha256=H9WXVKjmPuDH3AARXs00k81aEF7m3nc8M6nhaAa3cnA,18151 +ray/autoscaler/sdk/__init__.py,sha256=gHjOa9a1uT-Q6hbb3AbA6tTvqkUGGrzvb-9B16JP4C0,652 +ray/autoscaler/sdk/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/sdk/__pycache__/sdk.cpython-311.pyc,, +ray/autoscaler/sdk/sdk.py,sha256=HHvFLbOcZp2Q8RJ9T6O52Colpv6hfFK895jTEQeEdGk,12481 +ray/autoscaler/spark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/spark/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/spark/defaults.yaml,sha256=fujd8XkhAEV5aO_hETPKYPAe_KlS5r1t4YMV8mtiFxs,1513 +ray/autoscaler/tags.py,sha256=XhIcZN3-3oaePfdqWwWsDgrh0yLbTMADqmlp8Wh6GDE,1946 +ray/autoscaler/v2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/v2/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/v2/__pycache__/autoscaler.cpython-311.pyc,, +ray/autoscaler/v2/__pycache__/event_logger.cpython-311.pyc,, +ray/autoscaler/v2/__pycache__/metrics_reporter.cpython-311.pyc,, +ray/autoscaler/v2/__pycache__/monitor.cpython-311.pyc,, +ray/autoscaler/v2/__pycache__/scheduler.cpython-311.pyc,, +ray/autoscaler/v2/__pycache__/schema.cpython-311.pyc,, +ray/autoscaler/v2/__pycache__/sdk.cpython-311.pyc,, +ray/autoscaler/v2/__pycache__/utils.cpython-311.pyc,, +ray/autoscaler/v2/autoscaler.py,sha256=BX2hznr-8SpV7FYf52yPUeeEYWx7AQ3qAi0IuMewY-U,7790 +ray/autoscaler/v2/event_logger.py,sha256=ExEtloZumPtpZN1Zdo3wWQrNbXvMUCxI_6OkgU5wTnQ,6698 +ray/autoscaler/v2/instance_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/v2/instance_manager/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/v2/instance_manager/__pycache__/common.cpython-311.pyc,, +ray/autoscaler/v2/instance_manager/__pycache__/config.cpython-311.pyc,, +ray/autoscaler/v2/instance_manager/__pycache__/instance_manager.cpython-311.pyc,, +ray/autoscaler/v2/instance_manager/__pycache__/instance_storage.cpython-311.pyc,, +ray/autoscaler/v2/instance_manager/__pycache__/node_provider.cpython-311.pyc,, +ray/autoscaler/v2/instance_manager/__pycache__/ray_installer.cpython-311.pyc,, +ray/autoscaler/v2/instance_manager/__pycache__/reconciler.cpython-311.pyc,, +ray/autoscaler/v2/instance_manager/__pycache__/storage.cpython-311.pyc,, +ray/autoscaler/v2/instance_manager/cloud_providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/v2/instance_manager/cloud_providers/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/v2/instance_manager/cloud_providers/kuberay/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/v2/instance_manager/cloud_providers/kuberay/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/v2/instance_manager/cloud_providers/kuberay/__pycache__/cloud_provider.cpython-311.pyc,, +ray/autoscaler/v2/instance_manager/cloud_providers/kuberay/cloud_provider.py,sha256=qPujCC_w51DUWi6XxlxXfCVDCBKVjqkeRpnyi90PNZI,21682 +ray/autoscaler/v2/instance_manager/cloud_providers/read_only/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/v2/instance_manager/cloud_providers/read_only/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/v2/instance_manager/cloud_providers/read_only/__pycache__/cloud_provider.cpython-311.pyc,, +ray/autoscaler/v2/instance_manager/cloud_providers/read_only/cloud_provider.py,sha256=Lo2lZRewqO0fVM0Sa9tEgSMX4-upQJhxc6KBKbFEuqU,2681 +ray/autoscaler/v2/instance_manager/common.py,sha256=A0FsMRGLUugd8pH3id6RPRucdtEH0U1N_xZCZQJCTn4,19207 +ray/autoscaler/v2/instance_manager/config.py,sha256=7QcNpyCt8ZWVGvDUdYABLhEuWnwAhDgMZF96YuCoJaU,20705 +ray/autoscaler/v2/instance_manager/instance_manager.py,sha256=prDMhap7spSx8qEc8pigSUnmSD1AwRNbB6hRWGhnNgs,9681 +ray/autoscaler/v2/instance_manager/instance_storage.py,sha256=j3ecbqBvAB0zo1dRMlIOId_UL8KPW7wnYW2j3yFd5p4,5679 +ray/autoscaler/v2/instance_manager/node_provider.py,sha256=ggVKc-2WLuyAx8wZ_x7xlpZGU5cSWqMTMfrayveW8As,18391 +ray/autoscaler/v2/instance_manager/ray_installer.py,sha256=Z9b6UU5DgaXy3C35hIN-oKldwAaKrXK9TrVsAxz0dmg,3966 +ray/autoscaler/v2/instance_manager/reconciler.py,sha256=aeTqHWUZXAQjs848BvpPOzENCrM6TpG5Z3FywRhy14A,64065 +ray/autoscaler/v2/instance_manager/storage.py,sha256=sonkaNbQLA_KT7sTO09RI-fjpIKgKT6C5ao0Z14MRLw,6755 +ray/autoscaler/v2/instance_manager/subscribers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/v2/instance_manager/subscribers/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/v2/instance_manager/subscribers/__pycache__/cloud_instance_updater.cpython-311.pyc,, +ray/autoscaler/v2/instance_manager/subscribers/__pycache__/ray_stopper.cpython-311.pyc,, +ray/autoscaler/v2/instance_manager/subscribers/__pycache__/threaded_ray_installer.cpython-311.pyc,, +ray/autoscaler/v2/instance_manager/subscribers/cloud_instance_updater.py,sha256=MHDvHSPuw0IB196psHjcrIqv8zb4G9qJGVZMFk8lbGI,3207 +ray/autoscaler/v2/instance_manager/subscribers/ray_stopper.py,sha256=1n1TjHjG8mVi0esEJmlOCpmhAjgq3wjurXXCWBc4HzI,5264 +ray/autoscaler/v2/instance_manager/subscribers/threaded_ray_installer.py,sha256=KUlcHX0tguwpApTwac6q0u5ALw7xa72h4JnsffK0taM,3712 +ray/autoscaler/v2/metrics_reporter.py,sha256=JQ1pojYgdoQQyIpC7P5PTLzfhmNV1K3K06nXfX2c7u0,4423 +ray/autoscaler/v2/monitor.py,sha256=oLqGTAqEBch_OvXUN7CKZOMRJCkWQr1GB194pQH1y0Q,10198 +ray/autoscaler/v2/scheduler.py,sha256=wIA7Lqhh1hJC6tzyU6qF3S-xrS4Mm2NUr9kT8aCA__U,64962 +ray/autoscaler/v2/schema.py,sha256=hlT-n3tX0KtNigS8jV2GvzbMirCKqXckMNRlXAHB1aA,12614 +ray/autoscaler/v2/sdk.py,sha256=F0eVpytX1CY3B7LqKAzHP5u9BLf-0i86Q_3M7rSpprI,3595 +ray/autoscaler/v2/utils.py,sha256=jLLjtOrk-TpvkPUbjbWag6cKmL8dxGQvQyrECvw5opA,30255 +ray/autoscaler/vsphere/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/autoscaler/vsphere/__pycache__/__init__.cpython-311.pyc,, +ray/autoscaler/vsphere/defaults.yaml,sha256=OWUpWB72C6W2z6HLfCLo-J2fepKuIPjWasKzhaVY-uY,8344 +ray/client_builder.py,sha256=AU238dmq_a9VYkgxuDLTd0PJxgA7Dzd9NVd9hgrRNew,14719 +ray/cloudpickle/__init__.py,sha256=ViLvGLB1m1nDNe5FdlYsaLs3Ty8XXr2Tal9HqcmrAJo,1510 +ray/cloudpickle/__pycache__/__init__.cpython-311.pyc,, +ray/cloudpickle/__pycache__/cloudpickle.cpython-311.pyc,, +ray/cloudpickle/__pycache__/cloudpickle_fast.cpython-311.pyc,, +ray/cloudpickle/__pycache__/compat.cpython-311.pyc,, +ray/cloudpickle/__pycache__/py_pickle.cpython-311.pyc,, +ray/cloudpickle/cloudpickle.py,sha256=ejxhXSXd0dq7yZQ0nawKqH0PhGT1Qj6H5Kb16zHICMs,55282 +ray/cloudpickle/cloudpickle_fast.py,sha256=1GqUD4nLKsv0vv9ty2La3eVLyeWNrPFlhUCN-aNI-30,322 +ray/cloudpickle/compat.py,sha256=UMzLRwgoQjqrL7x9ar71hQXQ4oOm-kHO9rzhg0E9Cj4,664 +ray/cloudpickle/py_pickle.py,sha256=ATzQ96P3YbYhf3Z1aZfzzKMmbiQBdp2J94CjUQ3-fx8,676 +ray/cluster_utils.py,sha256=c3NqFA4F3vMaUbc64jpzpmtmSSkPThwB6ZoLs6ZoFiU,15505 +ray/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/core/__pycache__/__init__.cpython-311.pyc,, +ray/core/generated/__pycache__/agent_manager_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/agent_manager_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/autoscaler_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/autoscaler_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/common_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/common_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/core_worker_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/core_worker_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/dependency_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/dependency_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/event_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/event_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/export_actor_data_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/export_actor_data_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/export_driver_job_event_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/export_driver_job_event_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/export_event_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/export_event_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/export_node_data_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/export_node_data_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/export_runtime_env_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/export_runtime_env_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/export_submission_job_event_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/export_submission_job_event_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/export_task_event_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/export_task_event_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/gcs_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/gcs_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/gcs_service_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/gcs_service_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/instance_manager_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/instance_manager_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/logging_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/logging_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/metrics_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/metrics_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/node_manager_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/node_manager_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/pubsub_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/pubsub_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/ray_client_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/ray_client_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/reporter_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/reporter_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/resource_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/resource_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/runtime_env_agent_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/runtime_env_agent_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/runtime_env_common_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/runtime_env_common_pb2_grpc.cpython-311.pyc,, +ray/core/generated/__pycache__/usage_pb2.cpython-311.pyc,, +ray/core/generated/__pycache__/usage_pb2_grpc.cpython-311.pyc,, +ray/core/generated/agent_manager_pb2.py,sha256=8Mohq8hOeF5TcBi77TEFSoEoi9oLbw4QLxSNPW3mva8,1214 +ray/core/generated/agent_manager_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159 +ray/core/generated/autoscaler_pb2.py,sha256=pGYtc4UkbrAPcwjV8orK7w6sCW-2pirD6S07Hk7ao90,30362 +ray/core/generated/autoscaler_pb2_grpc.py,sha256=ni6xPqbxf8FrgQIBLRe1UUbX3rdxArr9GOeotlJ-NEg,12304 +ray/core/generated/common_pb2.py,sha256=vxpgtV3eN4BX-xWye-2A1Qy-edeSTvV7eQM463orYbI,61250 +ray/core/generated/common_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159 +ray/core/generated/core_worker_pb2.py,sha256=eceRe4O7gmMaAYw9oV5aJKlAskWeA_Q7G8XTwymd1Vo,40228 +ray/core/generated/core_worker_pb2_grpc.py,sha256=X0SGClv_aOI_vBqCYPJCOxcyiH8U9wz01yiSsyNU3Bs,44659 +ray/core/generated/dependency_pb2.py,sha256=aBlRlo3lu7F6HVRsVe32l2Gi-nk6t9A7E2afujBlMa8,1277 +ray/core/generated/dependency_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159 +ray/core/generated/event_pb2.py,sha256=H2PckEetL9KuEXf95UK2kk8UKGxxl4tinGdR9qBNihs,4556 +ray/core/generated/event_pb2_grpc.py,sha256=K8jPKEf0qXSU8oKj-BzdJtv8goeb8OUpNPHghAzrrrQ,2706 +ray/core/generated/export_actor_data_pb2.py,sha256=efmKoaEuOr9P60B1t-g8iRSRx_siM2ztRNRJGQ3-fu4,3700 +ray/core/generated/export_actor_data_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159 +ray/core/generated/export_driver_job_event_pb2.py,sha256=KuzfW8J2e43Oi4IwgUBvmEmsEIDS4u_d7qUlGXHieG0,3908 +ray/core/generated/export_driver_job_event_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159 +ray/core/generated/export_event_pb2.py,sha256=fx-Q-3icD_qXaC-Zm-nXYQHJxtX5W1iHdLtuZMFqqzw,3312 +ray/core/generated/export_event_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159 +ray/core/generated/export_node_data_pb2.py,sha256=1mXe7o0gNJYD6PXsEkI0-89TaBMnGuwvyWBjamnXA2o,5132 +ray/core/generated/export_node_data_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159 +ray/core/generated/export_runtime_env_pb2.py,sha256=BNhyK9eydG8cVcId8IN-HCcG8Pt_Y3YbSVHis4XPnuw,3258 +ray/core/generated/export_runtime_env_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159 +ray/core/generated/export_submission_job_event_pb2.py,sha256=QbthE3twOrCb405gizDd2FwnLgfCIGu5coq_QL4Sks4,3926 +ray/core/generated/export_submission_job_event_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159 +ray/core/generated/export_task_event_pb2.py,sha256=fWmKTUjo_oXrCM7yPPOQPG4fLGupvSdUs1bwYbcOjxk,10885 +ray/core/generated/export_task_event_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159 +ray/core/generated/gcs_pb2.py,sha256=0Eiet6HbR3Ur4wqcUJ3sAebKP0vSt9cs3v50u6lbDqE,44134 +ray/core/generated/gcs_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159 +ray/core/generated/gcs_service_pb2.py,sha256=qj_DdqUhC70s7o-IFGvEWCi0VqXCA7MGtrT54iZZnd8,88222 +ray/core/generated/gcs_service_pb2_grpc.py,sha256=E6P2LVhZ_JVUe4mqEoLpXC0lQXr5ixNVK9BZX_nNqWg,98730 +ray/core/generated/instance_manager_pb2.py,sha256=zsKj5OQEFK0of0-WPFaE3c1T2GVHf1GHF16pSMTk380,14252 +ray/core/generated/instance_manager_pb2_grpc.py,sha256=PHHQ29_Uf7fTGpxr1-7RUPdKD-F1F_uGrKXzWKo2CfQ,5237 +ray/core/generated/logging_pb2.py,sha256=LtBFvE-49KMXyBnLuncN2SuVHMsmiWXOK4jIs-Cp_YI,1498 +ray/core/generated/logging_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159 +ray/core/generated/metrics_pb2.py,sha256=C0yB-61QWP8wd6BPEt_YrvdKjoRoZZ_6o-aWtd8VcaY,13773 +ray/core/generated/metrics_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159 +ray/core/generated/node_manager_pb2.py,sha256=lo3Sa710FEIX2eJU5mO2mGJSXbhThq4n9LNIKe8S_8A,38990 +ray/core/generated/node_manager_pb2_grpc.py,sha256=_W7uV0cqt0ni34hn_uYcvPqTCmNwvPr1GjGODY0qo9U,44744 +ray/core/generated/pubsub_pb2.py,sha256=x3SpljdShtPXc9Zo8pbz2sGJZoMChjeqOH6McFIpct0,14750 +ray/core/generated/pubsub_pb2_grpc.py,sha256=MFYtBqHwAumqX2OKBFocu2tnyIsWkhWhNV1vFJ8OObQ,4566 +ray/core/generated/ray_client_pb2.py,sha256=SArxwpDrTg1nb6hwVieBeuzTVtWNQb2Crw0Zw8n3fVw,38546 +ray/core/generated/ray_client_pb2_grpc.py,sha256=kNp7RJIYJWyo61W_1aBCDMxsnFThVr8uXvehD9FEJrc,31474 +ray/core/generated/reporter_pb2.py,sha256=kZxhlFBdWSG0zPj5dKNmqN6JXayZappvLEH29jkyZwk,9939 +ray/core/generated/reporter_pb2_grpc.py,sha256=tKIOU5zuunaangYIoE3YL0BO9EGwbugik-pUFhEhP7U,12027 +ray/core/generated/resource_pb2.py,sha256=ZnF3b1DBIuH_46s4J4KUAs1VEuNv9FBMOCcrqmh6UwA,2522 +ray/core/generated/resource_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159 +ray/core/generated/runtime_env_agent_pb2.py,sha256=SzHYujET6IryoMRRzRqzqFBiKi-vgZUPlVfcSwvvXVs,5739 +ray/core/generated/runtime_env_agent_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159 +ray/core/generated/runtime_env_common_pb2.py,sha256=YAAZyynDWbaLmmZPXFSGlSX9KTUMav2EfC7R30qrPSI,3781 +ray/core/generated/runtime_env_common_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159 +ray/core/generated/usage_pb2.py,sha256=HriE7Ug7E66ubmgfaoiwPaBkDu9MIkp5n2fsMCVLHvA,7457 +ray/core/generated/usage_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159 +ray/core/libjemalloc.so,sha256=AoSRnbI_leaSAmA5g4rvibWWS1z-xKiKy5s6n0oib9U,885296 +ray/core/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/core/src/__pycache__/__init__.cpython-311.pyc,, +ray/core/src/plasma/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/core/src/plasma/__pycache__/__init__.cpython-311.pyc,, +ray/core/src/ray/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/core/src/ray/__pycache__/__init__.cpython-311.pyc,, +ray/core/src/ray/gcs/gcs_server,sha256=6W4O2KgY6Ci8sxfCvMfS2XtdnLVxYha-eK7OkdVRNiw,26474536 +ray/core/src/ray/raylet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/core/src/ray/raylet/__pycache__/__init__.cpython-311.pyc,, +ray/core/src/ray/raylet/raylet,sha256=huaexscsl3irc-C7CcVfzwxOtxERO6gIR24BPBhXVL4,29047616 +ray/cross_language.py,sha256=zLBhiTmHpQN1_46-8HzC-3payWYMZ3t1yRw5YuoIsNg,3777 +ray/dag/__init__.py,sha256=h637YhI7QhEgHgLYzdnkiEJ73PtkrcZujYVOXdwYoQo,1146 +ray/dag/__pycache__/__init__.cpython-311.pyc,, +ray/dag/__pycache__/base.cpython-311.pyc,, +ray/dag/__pycache__/class_node.cpython-311.pyc,, +ray/dag/__pycache__/collective_node.cpython-311.pyc,, +ray/dag/__pycache__/compiled_dag_node.cpython-311.pyc,, +ray/dag/__pycache__/conftest.cpython-311.pyc,, +ray/dag/__pycache__/constants.cpython-311.pyc,, +ray/dag/__pycache__/context.cpython-311.pyc,, +ray/dag/__pycache__/dag_node.cpython-311.pyc,, +ray/dag/__pycache__/dag_node_operation.cpython-311.pyc,, +ray/dag/__pycache__/dag_operation_future.cpython-311.pyc,, +ray/dag/__pycache__/format_utils.cpython-311.pyc,, +ray/dag/__pycache__/function_node.cpython-311.pyc,, +ray/dag/__pycache__/input_node.cpython-311.pyc,, +ray/dag/__pycache__/output_node.cpython-311.pyc,, +ray/dag/__pycache__/py_obj_scanner.cpython-311.pyc,, +ray/dag/__pycache__/utils.cpython-311.pyc,, +ray/dag/__pycache__/vis_utils.cpython-311.pyc,, +ray/dag/base.py,sha256=YtWL9E3ufvwgrIEAlrktYiDTSYslL3236q34V8yKHfk,236 +ray/dag/class_node.py,sha256=otrQWaDJAma7jNDRuYVgUwEXyfe-ikF4Q4GIMkCHxdA,11270 +ray/dag/collective_node.py,sha256=JUKkk1gfrVUP0bQHL_Rhc4KrBNCFXiNhRHJobJl471E,6727 +ray/dag/compiled_dag_node.py,sha256=KgF1UYnHwHqYJbqk_mGP1G6UG71v-o5i1b2Wke2NOhk,129435 +ray/dag/conftest.py,sha256=8UukTAlsFSI-AmTHEqQ6DjZS9rJmXMrprRfrtjLqubo,450 +ray/dag/constants.py,sha256=GKkJNdrQNHXwoWLQk3YpxIxY1VLMn61oK-zCO38DSiU,1274 +ray/dag/context.py,sha256=w-o9jsKNF94cmN4egBSVcGn9jaxSc5gNumfsWgwqiq8,4271 +ray/dag/dag_node.py,sha256=YWswhvhG392uYb4QIrtYPFXExvUkxIUvOmUXph8nC1c,24310 +ray/dag/dag_node_operation.py,sha256=F1VAGThOO69EtEWyBqNqx9t_7z5o0O2-7awYbIL14ZE,34707 +ray/dag/dag_operation_future.py,sha256=M2n1LaecSvXfF_TN6s0zthwncbEQ6NiUOjIBZ9t1Wpc,2697 +ray/dag/experimental/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/dag/experimental/__pycache__/__init__.cpython-311.pyc,, +ray/dag/format_utils.py,sha256=z5PhuyA9F_zQe8dhiRJF_ICtP5q3IKjKzshMHCF91Ik,5432 +ray/dag/function_node.py,sha256=VgJQb4w0On-bsPErrZK_VC4BK2ss-WoQdTvuxOKiNT8,1658 +ray/dag/input_node.py,sha256=4lDw0niGM9XcEFja7ljZumxC5Ksi6qPNT85qzJWpZsg,11243 +ray/dag/output_node.py,sha256=9ed4zc_FwhPRfkAovPa0WKzi7B3KnSaAcQBtZedEAaY,1363 +ray/dag/py_obj_scanner.py,sha256=yTdyPjpfC1Md3aFFwmzfsTKmUBjF9AO5e6L_uJA1bec,3678 +ray/dag/utils.py,sha256=YKrHPQsSgUTZ32Q_iI7u3B0CNe6M5r2wkZ6Bpa_Y7hY,2244 +ray/dag/vis_utils.py,sha256=V_d-q0NQGzNVsIk0SChKo6htJoTJZnzzi-PPUoy2mYQ,3021 +ray/dashboard/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/dashboard/__pycache__/__init__.cpython-311.pyc,, +ray/dashboard/__pycache__/agent.cpython-311.pyc,, +ray/dashboard/__pycache__/consts.cpython-311.pyc,, +ray/dashboard/__pycache__/dashboard.cpython-311.pyc,, +ray/dashboard/__pycache__/dashboard_metrics.cpython-311.pyc,, +ray/dashboard/__pycache__/datacenter.cpython-311.pyc,, +ray/dashboard/__pycache__/head.cpython-311.pyc,, +ray/dashboard/__pycache__/http_server_agent.cpython-311.pyc,, +ray/dashboard/__pycache__/http_server_head.cpython-311.pyc,, +ray/dashboard/__pycache__/k8s_utils.cpython-311.pyc,, +ray/dashboard/__pycache__/memory_utils.cpython-311.pyc,, +ray/dashboard/__pycache__/optional_deps.cpython-311.pyc,, +ray/dashboard/__pycache__/optional_utils.cpython-311.pyc,, +ray/dashboard/__pycache__/routes.cpython-311.pyc,, +ray/dashboard/__pycache__/state_aggregator.cpython-311.pyc,, +ray/dashboard/__pycache__/state_api_utils.cpython-311.pyc,, +ray/dashboard/__pycache__/timezone_utils.cpython-311.pyc,, +ray/dashboard/__pycache__/utils.cpython-311.pyc,, +ray/dashboard/agent.py,sha256=hDleYfxwlMrpGyKrZUo4JMPSh2YC7-LtxDxspAtJUas,15995 +ray/dashboard/client/build/asset-manifest.json,sha256=v6o5Ow-6TNMNMK6VIp6MUHCuTroqgZ-EVa4wj1Fvx_Q,3403 +ray/dashboard/client/build/favicon.ico,sha256=rQx7hQCsoElXbbBeXhh0MRzi9zBoOEBFUWSOGhyUdlE,4286 +ray/dashboard/client/build/index.html,sha256=erd7RfcCmNqln7KajZ63SjDdm4led2DZmbxXQvu0TcY,446 +ray/dashboard/client/build/speedscope-1.5.3/LICENSE,sha256=YkSxPpvyXP1C2ByTnWxTXZMllujDIAUCNPLCrFpvNqA,1067 +ray/dashboard/client/build/speedscope-1.5.3/README,sha256=-PRL6Fdn8PLdpgP1AVgD1Xl0JSblPENMwecjXerTccQ,124 +ray/dashboard/client/build/speedscope-1.5.3/demangle-cpp.8a387750.js,sha256=mv-Npn65w_JY38YBee4t9RzfyKOF-bXZ9NjnS_3CW74,168983 +ray/dashboard/client/build/speedscope-1.5.3/favicon-16x16.361d2b26.png,sha256=piptp3QrQ-55ixBrcJqoLq_RtQDvBQQnz-wF5NQdrKw,679 +ray/dashboard/client/build/speedscope-1.5.3/favicon-32x32.1165a94e.png,sha256=nqbm0Tt7gGQYeGbeuh6GdNi6JQcSebp7FfNLVN8lCNA,1585 +ray/dashboard/client/build/speedscope-1.5.3/file-format-schema.json,sha256=w9yvzZSfe6sSZt1MtB8yleqeqhPOuwoGVtQ1Pz3qkfs,9517 +ray/dashboard/client/build/speedscope-1.5.3/import.a03c2bef.js,sha256=Qe4Z_L5Rr7ULfRICH3SdWiqtBggNhFq2bu-x_vwjlDo,184993 +ray/dashboard/client/build/speedscope-1.5.3/index.html,sha256=nAQjhLPU6jkZXzxm5475aPI7-FXX-wjBz_P7Jo6JyjQ,611 +ray/dashboard/client/build/speedscope-1.5.3/perf-vertx-stacks-01-collapsed-all.3e0a632c.txt,sha256=3tqhyAVSZ2OAMO-iUIERYQX9DjV5RM78CXTnkt_Kvt0,263949 +ray/dashboard/client/build/speedscope-1.5.3/release.txt,sha256=osQRt7-ph11D7a46UXabHDHPoXrIkMjpH5f5cT9hLGM,87 +ray/dashboard/client/build/speedscope-1.5.3/reset.7ae984ff.css,sha256=jaknxOGdqznF5pYqR9NyjmKVx3nwhW_D3wAm8deN2nQ,835 +ray/dashboard/client/build/speedscope-1.5.3/speedscope.75eb7d8e.js,sha256=YFtVhhIYS0LG3C5nA0L637BvXxKjj0-5QoE4EZdz_eA,209212 +ray/dashboard/client/build/static/css/main.388a904b.css,sha256=BXM07M3GnaxZqhtnB1Jskw2rjD9chAgDM1vjal-h3Rs,5995 +ray/dashboard/client/build/static/css/main.388a904b.css.map,sha256=GyKVBvNhPKjtPFd9oOV2Q4H3FjCv-zi7ndYK4U7NCjU,9323 +ray/dashboard/client/build/static/js/495.01ff0983.chunk.js,sha256=sYE2hzD-JL8zgXIC03Vyvd3q_HQRPzpzMNaFl97i-5w,354 +ray/dashboard/client/build/static/js/495.01ff0983.chunk.js.map,sha256=xw0DE1CLbOUuFmzAlzhMMC5gpdyg1mIx6NPJnMX2oU4,685 +ray/dashboard/client/build/static/js/591.222f4f03.chunk.js,sha256=MoykCAVrOo0-icWPYtB8T-LRaHsskViOn8hdZlEO2lc,1808 +ray/dashboard/client/build/static/js/591.222f4f03.chunk.js.map,sha256=NAYTZbhtnxQBE4Jg5O8Tne0lmuyYzlMVXeboWB2Gc2w,6543 +ray/dashboard/client/build/static/js/main.378317da.js,sha256=sLl55NPYNlbOcKuMvu-r26FpMzndackixwHJhfY4QSU,1067464 +ray/dashboard/client/build/static/js/main.378317da.js.LICENSE.txt,sha256=Snsan2qc7LP5d4xF0YKf3KYSJYPmFM5KONhSCevnlsc,2804 +ray/dashboard/client/build/static/js/main.378317da.js.map,sha256=fE-im_DC3bq9ckexC_dFwObGVsafA3pQRbP2V4PNAs0,6400089 +ray/dashboard/client/build/static/media/logo.3704c1bbca650bb72a64b5d4c3fa5ced.svg,sha256=253qk71FS2ttzmMB_BbxrMj7DGBee1P7TRKe5vPYtNo,2625 +ray/dashboard/client/build/static/media/roboto-latin-100.a45108d3b34af91f9113.woff,sha256=xOrU3p96_yN9BrUw6thBPRNXQn9qkllENCu04rHc5tA,20368 +ray/dashboard/client/build/static/media/roboto-latin-100.c2aa4ab115bf9c6057cb.woff2,sha256=EoI9WFYFI4EhVUr_i7BgojXcNvN-_Z-x5-bqGpYivDU,15808 +ray/dashboard/client/build/static/media/roboto-latin-100italic.451d4e559d6f57cdf6a1.woff,sha256=WjqYQEFHaPouyYizPJ6Wb9_-LbflYKJws6nGugHxdxg,21704 +ray/dashboard/client/build/static/media/roboto-latin-100italic.7f839a8652da29745ce4.woff2,sha256=JskepDt5sdRWaV3kaPUD4BQenrdn_hZNr4vz86EBJW8,17008 +ray/dashboard/client/build/static/media/roboto-latin-300.37a7069dc30fc663c878.woff2,sha256=KfbaCowhxWgVEbubCGY9P9LF0Jyb2AVOw1TFY7jIt8E,15784 +ray/dashboard/client/build/static/media/roboto-latin-300.865f928cbabcc9f8f2b5.woff,sha256=drBUAP_52ltDhi43EwmeORORamKVYCZe0ksZ0DEifL8,20348 +ray/dashboard/client/build/static/media/roboto-latin-300italic.bd5b7a13f2c52b531a2a.woff,sha256=C-Cubv2FKzaVy3p2KGCW9g6Tt9McFuC3HKNeztf96PY,22204 +ray/dashboard/client/build/static/media/roboto-latin-300italic.c64e7e354c88e613c77c.woff2,sha256=ngJSTr7NgT_EvLQDNrsrAzhxsf3L0jQine5BidxEhQ0,17448 +ray/dashboard/client/build/static/media/roboto-latin-400.176f8f5bd5f02b3abfcf.woff2,sha256=SMP6b4bFTx2btRkiBxPUsKH4zRpYmjwDufqC6Y7LE-M,15736 +ray/dashboard/client/build/static/media/roboto-latin-400.49ae34d4cc6b98c00c69.woff,sha256=wdyH-Zx_8iiAYRfVjwhcbFcwV_ojcigIGAK32NPPdoQ,20268 +ray/dashboard/client/build/static/media/roboto-latin-400italic.b1d9d9904bfca8802a63.woff,sha256=gIFe_jvZMXxmbfDy5tcBM14XiVT2TrHpkQP-qBwqoTc,21952 +ray/dashboard/client/build/static/media/roboto-latin-400italic.d022bc70dc1bf7b3425d.woff2,sha256=QB5sJYAbotWXldBabdlz-VVmtBBw05ObqTB9ZYYK5Q4,17324 +ray/dashboard/client/build/static/media/roboto-latin-500.cea99d3e3e13a3a599a0.woff,sha256=upj5kdACxr-q97h0ZS_9zekmGoaSXbh98-0oYeoICt8,20464 +ray/dashboard/client/build/static/media/roboto-latin-500.f5b74d7ffcdf85b9dd60.woff2,sha256=JDaeGyRhr53O_sr5zJPWTPIqTFusMlBhALniEBRQe88,15872 +ray/dashboard/client/build/static/media/roboto-latin-500italic.0d8bb5b3ee5f5dac9e44.woff2,sha256=hoi2IEJzjro56Lwu34augykF6O4yQbVYNVJkZdnrjhs,17316 +ray/dashboard/client/build/static/media/roboto-latin-500italic.18d00f739ff1e1c52db1.woff,sha256=byl0o5bcBpXQcehCVR56-ccvDvjS0Hb-c6UjsaPC0Oc,22020 +ray/dashboard/client/build/static/media/roboto-latin-700.2267169ee7270a22a963.woff,sha256=gG6kbEJq-Pwk5c9CohAihzlpaTPTYpnrKK7mT2n8cfE,20356 +ray/dashboard/client/build/static/media/roboto-latin-700.c18ee39fb002ad58b6dc.woff2,sha256=tNB4ks3nFdULtpwZgt9JY4XR39j50YZ8MfGaPIY0z64,15816 +ray/dashboard/client/build/static/media/roboto-latin-700italic.7d8125ff7f707231fd89.woff2,sha256=XMLkdwHufcnguhYwPhcNsPyy3ymJt3Y6xwWJPTe04jc,17020 +ray/dashboard/client/build/static/media/roboto-latin-700italic.9360531f9bb817f917f0.woff,sha256=7sFCYI6LQX4qy25TAadQBHoE4sWmVjIjyq5JnhnqCO4,21588 +ray/dashboard/client/build/static/media/roboto-latin-900.870c8c1486f76054301a.woff2,sha256=7c3z9gJSpZh77cnIa1Qi2XK6UJu75g1YklMQx0SjPig,15712 +ray/dashboard/client/build/static/media/roboto-latin-900.bac8362e7a6ea60b6983.woff,sha256=6FhvnbfAUDqYTJRK0vH3g79gUa6ioGa8If3tyP5_poo,20392 +ray/dashboard/client/build/static/media/roboto-latin-900italic.c20d916c1a1b094c1cec.woff,sha256=aoDZy09JtZUbQH-JBc-oh_Hj8uLsQ2m_WOrGM7LgWUg,22304 +ray/dashboard/client/build/static/media/roboto-latin-900italic.cb5ad999740e9d8a8bd1.woff2,sha256=leYLk5GTHcTVzJs7DCiw6ydRuQZgN_dZS6dsR3OcGHs,17520 +ray/dashboard/consts.py,sha256=vie6xN_MaCBPzUIhbqLlWZDvitSsXEf2wej8ZP_QuPI,3834 +ray/dashboard/dashboard.py,sha256=fXrGOZNF6l6_ItBE5eybl2v8WD9keeDt9Ej82BUp8eI,9437 +ray/dashboard/dashboard_metrics.py,sha256=ZW162Ylx1W98i6NtykfnVE1D2TlB_rZQCQS9H92E0XI,4047 +ray/dashboard/datacenter.py,sha256=hxiy_bwvyaRpiSooWhCGLvbbnB76qjZ-r7SaKXIhL9o,10967 +ray/dashboard/head.py,sha256=WUn0u_uCSIHWjetFItPw0snkfECWO05Br5nOCyIje2c,13362 +ray/dashboard/http_server_agent.py,sha256=20EMfXlCzljRlCCVlZvGfMstM-PnZK4RjtRAVhQfOAY,2909 +ray/dashboard/http_server_head.py,sha256=ALgS4jNzvFp000yYDghyIc3vRClV4KZQYK5sXr9T8uc,11217 +ray/dashboard/k8s_utils.py,sha256=iWQ_Y_KDM1iP-e6dmRaCR8Vf8qm_ct0C_ashuEhIR68,3928 +ray/dashboard/memory_utils.py,sha256=-Vkaac6teGFl1zrzuPxiF49BFrKV75zIYXHy42hDO90,18636 +ray/dashboard/modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/dashboard/modules/__pycache__/__init__.cpython-311.pyc,, +ray/dashboard/modules/__pycache__/dashboard_sdk.cpython-311.pyc,, +ray/dashboard/modules/__pycache__/version.cpython-311.pyc,, +ray/dashboard/modules/actor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/dashboard/modules/actor/__pycache__/__init__.cpython-311.pyc,, +ray/dashboard/modules/actor/__pycache__/actor_consts.cpython-311.pyc,, +ray/dashboard/modules/actor/__pycache__/actor_head.cpython-311.pyc,, +ray/dashboard/modules/actor/actor_consts.py,sha256=FjwluhIqNxqTy2fOfBUmyOS5z_yAg4VvM_W0iGnvgTM,119 +ray/dashboard/modules/actor/actor_head.py,sha256=maHvy_bheq5_W2Kf0fauWfBvkjzGtw2MoTNIzdTchEw,11223 +ray/dashboard/modules/dashboard_sdk.py,sha256=MeuEUK8Gd-ibg0JGGSFL6O6XAKIW0b7Yt5xo-fAIJ5o,14390 +ray/dashboard/modules/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/dashboard/modules/data/__pycache__/__init__.cpython-311.pyc,, +ray/dashboard/modules/data/__pycache__/data_head.cpython-311.pyc,, +ray/dashboard/modules/data/data_head.py,sha256=6RsLzOyQncChoDiU95yH1sXjhYCr4K_lrKEM3UcZr5A,6732 +ray/dashboard/modules/event/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/dashboard/modules/event/__pycache__/__init__.cpython-311.pyc,, +ray/dashboard/modules/event/__pycache__/event_agent.cpython-311.pyc,, +ray/dashboard/modules/event/__pycache__/event_consts.cpython-311.pyc,, +ray/dashboard/modules/event/__pycache__/event_head.cpython-311.pyc,, +ray/dashboard/modules/event/__pycache__/event_utils.cpython-311.pyc,, +ray/dashboard/modules/event/event_agent.py,sha256=3ngxIz5OJ-G4z_tnGZnFNC18hFIR4ZILN0N8tSBNS1Q,5280 +ray/dashboard/modules/event/event_consts.py,sha256=D1_BO_iCxFq-mrXGF8a-iMxZIXw8uMJSHxtPVPWzHns,748 +ray/dashboard/modules/event/event_head.py,sha256=JrPGs5fM4fQ5GGonA-YB_qkPV-R9JVV6NMrdKRi4HWc,8027 +ray/dashboard/modules/event/event_utils.py,sha256=kLDOg0Q5VCPiRGs9MTBtTZIg2WNJnjQRQd8vKol4Ugg,7503 +ray/dashboard/modules/healthz/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/dashboard/modules/healthz/__pycache__/__init__.cpython-311.pyc,, +ray/dashboard/modules/healthz/__pycache__/healthz_agent.cpython-311.pyc,, +ray/dashboard/modules/healthz/__pycache__/healthz_head.cpython-311.pyc,, +ray/dashboard/modules/healthz/__pycache__/utils.cpython-311.pyc,, +ray/dashboard/modules/healthz/healthz_agent.py,sha256=aAr5GztOtG8vW9_rJKwAFfGvNMxOghT3NSjUUUNlKCI,1949 +ray/dashboard/modules/healthz/healthz_head.py,sha256=f0MJKbTKimp61BNWRDc94DLfkGoTvHQ1ZtFU6Y_bRV0,1305 +ray/dashboard/modules/healthz/utils.py,sha256=KoXbOVokQxYEfv0ntxIrnf0_QRfCV_QKuj6FHOel7po,713 +ray/dashboard/modules/job/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/dashboard/modules/job/__pycache__/__init__.cpython-311.pyc,, +ray/dashboard/modules/job/__pycache__/cli.cpython-311.pyc,, +ray/dashboard/modules/job/__pycache__/cli_utils.cpython-311.pyc,, +ray/dashboard/modules/job/__pycache__/common.cpython-311.pyc,, +ray/dashboard/modules/job/__pycache__/job_agent.cpython-311.pyc,, +ray/dashboard/modules/job/__pycache__/job_head.cpython-311.pyc,, +ray/dashboard/modules/job/__pycache__/job_log_storage_client.cpython-311.pyc,, +ray/dashboard/modules/job/__pycache__/job_manager.cpython-311.pyc,, +ray/dashboard/modules/job/__pycache__/job_supervisor.cpython-311.pyc,, +ray/dashboard/modules/job/__pycache__/pydantic_models.cpython-311.pyc,, +ray/dashboard/modules/job/__pycache__/sdk.cpython-311.pyc,, +ray/dashboard/modules/job/__pycache__/utils.cpython-311.pyc,, +ray/dashboard/modules/job/cli.py,sha256=MmrwA4jr9dvvf8HfTemQhdTK8cacL802w9LffZviGuQ,15570 +ray/dashboard/modules/job/cli_utils.py,sha256=nqq_R36FiOCX_2guPGlDEo29C2SR6ZRjrU8hVF81Wn0,1462 +ray/dashboard/modules/job/common.py,sha256=8bupl_-kdlKx2eZ6glbUpM8sM3VfnQp2KsNVu3eTt_Q,20935 +ray/dashboard/modules/job/job_agent.py,sha256=4YiHIrEfRqj4Oun82HY0e_0MWRxPDLR7VhDG_qoxT_k,7853 +ray/dashboard/modules/job/job_head.py,sha256=KArQEy--GeBl3k_P80dcWXv2MclZ2GCrQJMd84urOpo,22093 +ray/dashboard/modules/job/job_log_storage_client.py,sha256=gyyLtWNgYcXpYXBuf6KphEQU2s1Xp2YPSITn-ts5B_E,2079 +ray/dashboard/modules/job/job_manager.py,sha256=GagaZI42RTfAwn7gPaAsEeCglSHzQxIGw2SST0JV6ZE,27066 +ray/dashboard/modules/job/job_supervisor.py,sha256=mErqyvQ2XJ7vk8KH12FmhOwBaZ5BXOt4DDHRG8n-F8Q,20533 +ray/dashboard/modules/job/pydantic_models.py,sha256=9rYAwXvMswjYlR0CvXx2aJ4SzuwwxhNLEwKL5leGahQ,4329 +ray/dashboard/modules/job/sdk.py,sha256=aQl0MldYsRmVKVqmvhkwAZbxqPQK3JxBCPFF-P4b1Ic,20095 +ray/dashboard/modules/job/utils.py,sha256=2xuECbYjr1qaIQih28X87ltrSjNFs48spyEFOJkkG3M,10058 +ray/dashboard/modules/log/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/dashboard/modules/log/__pycache__/__init__.cpython-311.pyc,, +ray/dashboard/modules/log/__pycache__/log_agent.cpython-311.pyc,, +ray/dashboard/modules/log/__pycache__/log_consts.cpython-311.pyc,, +ray/dashboard/modules/log/__pycache__/log_manager.cpython-311.pyc,, +ray/dashboard/modules/log/__pycache__/log_utils.cpython-311.pyc,, +ray/dashboard/modules/log/log_agent.py,sha256=2glBjff-jrGZx-0hMlw10oLmuLYLFgJUqKS73w9iLeM,14040 +ray/dashboard/modules/log/log_consts.py,sha256=ppK99FPwkRHMMj0Ss2dhI_527lH4yoVo81M60R2rZSY,129 +ray/dashboard/modules/log/log_manager.py,sha256=oPw7JmkWVlUeQuqtzqgCDb_c8QrbS9QdT3EwuLk6g7E,17892 +ray/dashboard/modules/log/log_utils.py,sha256=IRpef6B8H86jBPaGieD8hTN8_YWW6xKFe-NjJOGss6o,238 +ray/dashboard/modules/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/dashboard/modules/metrics/__pycache__/__init__.cpython-311.pyc,, +ray/dashboard/modules/metrics/__pycache__/grafana_dashboard_factory.cpython-311.pyc,, +ray/dashboard/modules/metrics/__pycache__/install_and_start_prometheus.cpython-311.pyc,, +ray/dashboard/modules/metrics/__pycache__/metrics_head.cpython-311.pyc,, +ray/dashboard/modules/metrics/__pycache__/templates.cpython-311.pyc,, +ray/dashboard/modules/metrics/dashboards/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/dashboard/modules/metrics/dashboards/__pycache__/__init__.cpython-311.pyc,, +ray/dashboard/modules/metrics/dashboards/__pycache__/common.cpython-311.pyc,, +ray/dashboard/modules/metrics/dashboards/__pycache__/data_dashboard_panels.cpython-311.pyc,, +ray/dashboard/modules/metrics/dashboards/__pycache__/default_dashboard_panels.cpython-311.pyc,, +ray/dashboard/modules/metrics/dashboards/__pycache__/serve_dashboard_panels.cpython-311.pyc,, +ray/dashboard/modules/metrics/dashboards/__pycache__/serve_deployment_dashboard_panels.cpython-311.pyc,, +ray/dashboard/modules/metrics/dashboards/common.py,sha256=PXpffdLhAJST92gu2rNXoZbAVu5t5DNjEX48CZZk-bs,2021 +ray/dashboard/modules/metrics/dashboards/data_dashboard_panels.py,sha256=yNa5eUBMZRv3DWZdlxZni-tMysyMYOCgFD2dmt-obnQ,17275 +ray/dashboard/modules/metrics/dashboards/data_grafana_dashboard_base.json,sha256=ROnEqHWuFQhLe6JFqTFyFmzY_zN-ix5v1_hmm54h88E,4381 +ray/dashboard/modules/metrics/dashboards/default_dashboard_panels.py,sha256=kuxjxtGA5SCBJ21Fhpr0khwSa86AXnoE_MXGxKX8si8,22222 +ray/dashboard/modules/metrics/dashboards/default_grafana_dashboard_base.json,sha256=5PF1cvsyk57iW62HsGtew--1ewkPQlKLOatZN2iBgLY,3970 +ray/dashboard/modules/metrics/dashboards/serve_dashboard_panels.py,sha256=TpbbE06eVK2NsfHfamdWkvBf0YSsnSO46K38AZUh0as,16640 +ray/dashboard/modules/metrics/dashboards/serve_deployment_dashboard_panels.py,sha256=PT08vTnQENxLsZ4172WxoNul6nSVYqNO3vDOnC3vK04,8973 +ray/dashboard/modules/metrics/dashboards/serve_deployment_grafana_dashboard_base.json,sha256=VJcD1vNdgklw2KM0FM2RdZKI-vsKDyNfPfW_AmxI7Qw,6251 +ray/dashboard/modules/metrics/dashboards/serve_grafana_dashboard_base.json,sha256=MmVV7eNLMoECjymkN4RhSHviG0XGfGL_V8TB6n75u64,5047 +ray/dashboard/modules/metrics/export/prometheus/prometheus.yml,sha256=OHUFwiB6QQGgsEukeC0WYEVeCvtqNDNrM-whkgmnzJM,476 +ray/dashboard/modules/metrics/grafana_dashboard_factory.py,sha256=jh7zzIUmrp8UETqLOAJXH2uXaJqyaEWTJ6oxX_V351U,8643 +ray/dashboard/modules/metrics/install_and_start_prometheus.py,sha256=dA-PRXV4H3--wEZEgWBELVK1-0zWQI7V0_kGfUZspWU,6400 +ray/dashboard/modules/metrics/metrics_head.py,sha256=lJ27tRujFMET4rQztNcuadDURH3JiSAHKRtRctdryTA,16868 +ray/dashboard/modules/metrics/templates.py,sha256=2cLRGIynKXTsXflXzV3N9rEBlYZ6Q4WYZRRUOIneEoY,1494 +ray/dashboard/modules/node/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/dashboard/modules/node/__pycache__/__init__.cpython-311.pyc,, +ray/dashboard/modules/node/__pycache__/node_consts.cpython-311.pyc,, +ray/dashboard/modules/node/__pycache__/node_head.cpython-311.pyc,, +ray/dashboard/modules/node/node_consts.py,sha256=wVB6RpZXdLONV0cNeAkvk90vdo8JHYTqfTda5Qfh9DU,636 +ray/dashboard/modules/node/node_head.py,sha256=E4m4ZM9Z_z0j0ezudRWSEzDviIurBUZCok2IFMCtPVw,19758 +ray/dashboard/modules/reporter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/dashboard/modules/reporter/__pycache__/__init__.cpython-311.pyc,, +ray/dashboard/modules/reporter/__pycache__/profile_manager.cpython-311.pyc,, +ray/dashboard/modules/reporter/__pycache__/reporter_agent.cpython-311.pyc,, +ray/dashboard/modules/reporter/__pycache__/reporter_consts.cpython-311.pyc,, +ray/dashboard/modules/reporter/__pycache__/reporter_head.cpython-311.pyc,, +ray/dashboard/modules/reporter/profile_manager.py,sha256=57wz4rNoZ6X7ebCVZI0MFa9XijfZwLa6zljHYPj8iA4,12577 +ray/dashboard/modules/reporter/reporter_agent.py,sha256=SHMwX2s5W7dpPK2L6t9f2sZ6nWVhZdppdu7behI3Dbo,45388 +ray/dashboard/modules/reporter/reporter_consts.py,sha256=8E9gYcn59Pga7D2TO_wZKEfk4W8-o5uSDKQVJ8cywTM,254 +ray/dashboard/modules/reporter/reporter_head.py,sha256=IhALatzQXle1sarCr63M9cW1Sj6BPbY0u5qKRb1JlKc,28166 +ray/dashboard/modules/serve/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/dashboard/modules/serve/__pycache__/__init__.cpython-311.pyc,, +ray/dashboard/modules/serve/__pycache__/sdk.cpython-311.pyc,, +ray/dashboard/modules/serve/__pycache__/serve_agent.cpython-311.pyc,, +ray/dashboard/modules/serve/__pycache__/serve_head.cpython-311.pyc,, +ray/dashboard/modules/serve/__pycache__/serve_rest_api_impl.cpython-311.pyc,, +ray/dashboard/modules/serve/sdk.py,sha256=PObjPjxiA98VRymiErkcDeZgQNuidzGtOH7LosSXaUU,2916 +ray/dashboard/modules/serve/serve_agent.py,sha256=NhPJqHFAm17vjFUGc2nPAUmTStg79S5YZFPgcYJnx9o,451 +ray/dashboard/modules/serve/serve_head.py,sha256=cIYFXZ2eNsVBoT2B65horLG9aXcKidgEKh_ijsUlMPI,412 +ray/dashboard/modules/serve/serve_rest_api_impl.py,sha256=9hm1XhMIEk2fq3O8drxqx190byjpWPJW8esoqBx9ga8,10986 +ray/dashboard/modules/snapshot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/dashboard/modules/snapshot/__pycache__/__init__.cpython-311.pyc,, +ray/dashboard/modules/snapshot/__pycache__/snapshot_head.cpython-311.pyc,, +ray/dashboard/modules/snapshot/snapshot_head.py,sha256=Hvo45J_okyHHvNxIqBlb6fhcEq18vwRWxtnkR_ou_Sk,9289 +ray/dashboard/modules/state/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/dashboard/modules/state/__pycache__/__init__.cpython-311.pyc,, +ray/dashboard/modules/state/__pycache__/state_head.cpython-311.pyc,, +ray/dashboard/modules/state/state_head.py,sha256=1RYbL8Xo8Dlana6JvieKL68QF9tGiImTEplbJGUByRw,17014 +ray/dashboard/modules/train/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/dashboard/modules/train/__pycache__/__init__.cpython-311.pyc,, +ray/dashboard/modules/train/__pycache__/train_head.cpython-311.pyc,, +ray/dashboard/modules/train/train_head.py,sha256=D4zPDDhW2xcuQ68c3GnKz6zIbAGIkuQVZ9Fl3nL4R7Y,8364 +ray/dashboard/modules/usage_stats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/dashboard/modules/usage_stats/__pycache__/__init__.cpython-311.pyc,, +ray/dashboard/modules/usage_stats/__pycache__/usage_stats_head.cpython-311.pyc,, +ray/dashboard/modules/usage_stats/usage_stats_head.py,sha256=HZgdukp03QF_KpRg0HV0tvW83tjisXRuM7PB8AiIbUg,7852 +ray/dashboard/modules/version.py,sha256=McYMc3HBcNn5HSuq-uuVZHWuxxGZtq2eX7B_UFHONhI,630 +ray/dashboard/optional_deps.py,sha256=GHcdH6r0_IAc27jqAgruaSfh1_2rQWbssDdzyVd4S0w,893 +ray/dashboard/optional_utils.py,sha256=Jv58jGHLHkNo-CQw4I9uVJgEJwmmCHA_ul7tG3ieeKo,6911 +ray/dashboard/routes.py,sha256=gwAX2i-klmk005nBXbE8guMNMMVcLXOnwkqgay3bCJ4,6202 +ray/dashboard/state_aggregator.py,sha256=HUpxmpetyj2VizMcOxe1tXUKNIWxXnFi69ZsklMn1Mo,25851 +ray/dashboard/state_api_utils.py,sha256=RkgyubUi_oxZQRHdRrXhlBolacX5IHsJ87OWlFHg77k,9243 +ray/dashboard/subprocesses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/dashboard/subprocesses/__pycache__/__init__.cpython-311.pyc,, +ray/dashboard/subprocesses/__pycache__/handle.cpython-311.pyc,, +ray/dashboard/subprocesses/__pycache__/message.cpython-311.pyc,, +ray/dashboard/subprocesses/__pycache__/module.cpython-311.pyc,, +ray/dashboard/subprocesses/__pycache__/routes.cpython-311.pyc,, +ray/dashboard/subprocesses/__pycache__/utils.cpython-311.pyc,, +ray/dashboard/subprocesses/handle.py,sha256=X3cuLTtZ6eQExFQCdBMleGwJl1oIXvHXmlAeFj8Y2ow,16155 +ray/dashboard/subprocesses/message.py,sha256=WUNxUwqIaU3OybVcZW0rv-XFwWw6ihjuL37X7tqlx6Y,1453 +ray/dashboard/subprocesses/module.py,sha256=s_U5iGCa2jCNF3ZnJGIHDItt-EGQjpMVR7GBt0Ct-0I,6682 +ray/dashboard/subprocesses/routes.py,sha256=0eT_-upmtpeJh7VSrvxQw-aedWDmJPiBx1FzN_3yAaM,9962 +ray/dashboard/subprocesses/utils.py,sha256=vEse3-7d-G7FvN7lkIOIWIEX4p913eVe3VS2h4QHmJc,1827 +ray/dashboard/timezone_utils.py,sha256=Y-JaOJUvwmQxPsRBeQunSDDClUN5_koGJlwwwP4WVk0,2352 +ray/dashboard/utils.py,sha256=BtNUzpuNaO3gMblD0H-MvTKK4OOphuoCrCXjJ9RBRn0,27344 +ray/data/__init__.py,sha256=IarTBhvCx3_YGLtW8JuvB-au7kHWHYbe2YxbWD8BNVo,4279 +ray/data/__pycache__/__init__.cpython-311.pyc,, +ray/data/__pycache__/aggregate.cpython-311.pyc,, +ray/data/__pycache__/block.cpython-311.pyc,, +ray/data/__pycache__/context.cpython-311.pyc,, +ray/data/__pycache__/dataset.cpython-311.pyc,, +ray/data/__pycache__/exceptions.cpython-311.pyc,, +ray/data/__pycache__/grouped_data.cpython-311.pyc,, +ray/data/__pycache__/iterator.cpython-311.pyc,, +ray/data/__pycache__/preprocessor.cpython-311.pyc,, +ray/data/__pycache__/random_access_dataset.cpython-311.pyc,, +ray/data/__pycache__/read_api.cpython-311.pyc,, +ray/data/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/data/_internal/__pycache__/__init__.cpython-311.pyc,, +ray/data/_internal/__pycache__/aggregate.cpython-311.pyc,, +ray/data/_internal/__pycache__/arrow_block.cpython-311.pyc,, +ray/data/_internal/__pycache__/batcher.cpython-311.pyc,, +ray/data/_internal/__pycache__/block_builder.cpython-311.pyc,, +ray/data/_internal/__pycache__/block_list.cpython-311.pyc,, +ray/data/_internal/__pycache__/compute.cpython-311.pyc,, +ray/data/_internal/__pycache__/delegating_block_builder.cpython-311.pyc,, +ray/data/_internal/__pycache__/equalize.cpython-311.pyc,, +ray/data/_internal/__pycache__/logging.cpython-311.pyc,, +ray/data/_internal/__pycache__/memory_tracing.cpython-311.pyc,, +ray/data/_internal/__pycache__/null_aggregate.cpython-311.pyc,, +ray/data/_internal/__pycache__/numpy_support.cpython-311.pyc,, +ray/data/_internal/__pycache__/output_buffer.cpython-311.pyc,, +ray/data/_internal/__pycache__/pandas_block.cpython-311.pyc,, +ray/data/_internal/__pycache__/plan.cpython-311.pyc,, +ray/data/_internal/__pycache__/progress_bar.cpython-311.pyc,, +ray/data/_internal/__pycache__/remote_fn.cpython-311.pyc,, +ray/data/_internal/__pycache__/row.cpython-311.pyc,, +ray/data/_internal/__pycache__/size_estimator.cpython-311.pyc,, +ray/data/_internal/__pycache__/split.cpython-311.pyc,, +ray/data/_internal/__pycache__/stats.cpython-311.pyc,, +ray/data/_internal/__pycache__/table_block.cpython-311.pyc,, +ray/data/_internal/__pycache__/torch_iterable_dataset.cpython-311.pyc,, +ray/data/_internal/__pycache__/util.cpython-311.pyc,, +ray/data/_internal/aggregate.py,sha256=psNoncAE2neo7TYcrt1Y8ZrJmvi15y_H_rJryTdFsIQ,12665 +ray/data/_internal/arrow_block.py,sha256=XWFrjTobPn6k8EzUNsFZ7NnnVDHInrwbwAPG8Q9Z2AU,22621 +ray/data/_internal/arrow_ops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/data/_internal/arrow_ops/__pycache__/__init__.cpython-311.pyc,, +ray/data/_internal/arrow_ops/__pycache__/transform_polars.cpython-311.pyc,, +ray/data/_internal/arrow_ops/__pycache__/transform_pyarrow.cpython-311.pyc,, +ray/data/_internal/arrow_ops/transform_polars.py,sha256=ULp-le_ppKi_e9hdC91J5tPFhfcUjgAGdh7yM_Bu3ZA,1045 +ray/data/_internal/arrow_ops/transform_pyarrow.py,sha256=XHaijriVbZF4JKTOLa_LuDQ8X4aNuF0FH5KvY9bVGqo,20250 +ray/data/_internal/batcher.py,sha256=pErbyIH6Da3ebRUtR-VzNCyTgjc9DVMtFwZdhknBFWY,13412 +ray/data/_internal/block_batching/__init__.py,sha256=yh48Q33rYuRur6LwWmnEwHdr_86mbP3li_LLSE6zNGM,102 +ray/data/_internal/block_batching/__pycache__/__init__.cpython-311.pyc,, +ray/data/_internal/block_batching/__pycache__/block_batching.cpython-311.pyc,, +ray/data/_internal/block_batching/__pycache__/interfaces.cpython-311.pyc,, +ray/data/_internal/block_batching/__pycache__/iter_batches.cpython-311.pyc,, +ray/data/_internal/block_batching/__pycache__/util.cpython-311.pyc,, +ray/data/_internal/block_batching/block_batching.py,sha256=tH6EEOzhvlBJ6rywC6w6QRfSKFHgph6IuhLSwDycIa8,1914 +ray/data/_internal/block_batching/interfaces.py,sha256=kanL0i9r-EaAhKVeZeNO1VThP4xUDtcg4m_v-G-QLjQ,1182 +ray/data/_internal/block_batching/iter_batches.py,sha256=Ua6UwKsdFaE7DgKuCat6Xo96EgICntCeCubi-xx0CKc,13079 +ray/data/_internal/block_batching/util.py,sha256=e7TaSumWyhoV9SpKcgNEOnVZR4Dal0lvTkuktXdiVjg,10162 +ray/data/_internal/block_builder.py,sha256=5R8yM1VjfBxY4f7MJhowPOSO-QEKiIAOfD9SZsyFyzI,1197 +ray/data/_internal/block_list.py,sha256=VOGaMya8MAkIv8YEAZkkWK3_iu4EVuef9siR_mWv-Cc,3654 +ray/data/_internal/compute.py,sha256=rMuqyF6a5MkITs8FWydjbWxuBcjFoJcb38mPoWVbEJ4,5408 +ray/data/_internal/datasource/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/data/_internal/datasource/__pycache__/__init__.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/audio_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/avro_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/bigquery_datasink.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/bigquery_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/binary_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/clickhouse_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/csv_datasink.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/csv_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/databricks_uc_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/delta_sharing_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/hudi_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/huggingface_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/iceberg_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/image_datasink.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/image_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/json_datasink.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/json_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/lance_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/mongo_datasink.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/mongo_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/numpy_datasink.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/numpy_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/parquet_bulk_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/parquet_datasink.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/parquet_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/range_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/sql_datasink.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/sql_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/text_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/tfrecords_datasink.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/tfrecords_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/torch_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/video_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/webdataset_datasink.cpython-311.pyc,, +ray/data/_internal/datasource/__pycache__/webdataset_datasource.cpython-311.pyc,, +ray/data/_internal/datasource/audio_datasource.py,sha256=6a5sdqJZi1XZcyRxTAuB5reJejp0pRYIFQPqZMKPq-E,1574 +ray/data/_internal/datasource/avro_datasource.py,sha256=5CmQlHuWPhUNL45cSUzuBqYHU7j-QIKNnJ41t2qIbsY,1331 +ray/data/_internal/datasource/bigquery_datasink.py,sha256=nIlUxuYFPE6ZZZpSN9gXQvxi4dWoY80nFAeMs9DQEXc,5080 +ray/data/_internal/datasource/bigquery_datasource.py,sha256=EOKPA14cWApqGKIzRcI5ZU0iQyKaoQZ2aF-KXpl3dlo,4942 +ray/data/_internal/datasource/binary_datasource.py,sha256=vFwIi_j9QQRseiYDcCHSfKOc_37qlMbKnnWcNwDUHK0,625 +ray/data/_internal/datasource/clickhouse_datasource.py,sha256=QM2E8N5zBQDX7hRtXjbVEkImh9GgwjxhMCEDIZNos2Q,14740 +ray/data/_internal/datasource/csv_datasink.py,sha256=x2iHSSfIOm49wsZ1MtzRP35QMPEdu7x4qOscSZWD_3E,1234 +ray/data/_internal/datasource/csv_datasource.py,sha256=Ltrsr32YPYzAQWJq-p5dCA_s8b29u1lqW5ssyZsWpU4,2520 +ray/data/_internal/datasource/databricks_uc_datasource.py,sha256=Z7C-DNWdyaGl92pIL_qAupupoD7-GjGwXEJmUJ4Povo,6274 +ray/data/_internal/datasource/delta_sharing_datasource.py,sha256=sTmb7qJfaiZubvKL6Mw_LpZmg1LNn_we7zjYkhrjTzI,4438 +ray/data/_internal/datasource/hudi_datasource.py,sha256=xa-5JYxWNTXo5yC_ho_HEPcpvg_sT4ZUugCnFO7ODkM,3084 +ray/data/_internal/datasource/huggingface_datasource.py,sha256=XAeAmOleT1NxJ7hU905QswkZTMunOFxDvnZ3Cgeruo4,7783 +ray/data/_internal/datasource/iceberg_datasource.py,sha256=R1NIkavocGZWwoQXOzgfE97fNK478jF5eBIk8hZQkgw,9584 +ray/data/_internal/datasource/image_datasink.py,sha256=9RR3qBnEQEd_uwKmLWYTjGh5-H25LP4gTRxEspL-5KY,705 +ray/data/_internal/datasource/image_datasource.py,sha256=_9n_KmswdLglJCPD6bHNOXn5RmGz2ZBykVWjE5SHhkQ,6583 +ray/data/_internal/datasource/json_datasink.py,sha256=FhVN9is4Um-hjqnARGKOuy5rqOBYVxhqveHsZazLerM,1280 +ray/data/_internal/datasource/json_datasource.py,sha256=hnSi4iRb6Om4ajxYRVJyrI9_3BYmNxMwLGQ_W1oDzMs,6230 +ray/data/_internal/datasource/lance_datasource.py,sha256=yP4F76eGm1AvSTB_y3d6g8lPru2yBM9FBYGBpX1qaYE,4206 +ray/data/_internal/datasource/mongo_datasink.py,sha256=yoejPDlM97KY__8cp0AQpA0Sfq0qHScxjhtC4gI74QM,1586 +ray/data/_internal/datasource/mongo_datasource.py,sha256=4aBR-HGscNEYWBkBQbH4bm9d6dvNmsyle3Sz1VNNL_E,4698 +ray/data/_internal/datasource/numpy_datasink.py,sha256=RICLpCrT0secP-szSPSYuBry7hkTDVG055ybsHD2K8I,617 +ray/data/_internal/datasource/numpy_datasource.py,sha256=Jznq_rFfN56e4xjBeZNmZmP_X2aw87cygjkiOFpCfwA,1251 +ray/data/_internal/datasource/parquet_bulk_datasource.py,sha256=JCfE_u1gVZuSIp1zwaVrSs9zX6qRfSA5fYwUShkUL-g,1549 +ray/data/_internal/datasource/parquet_datasink.py,sha256=alS-FW8RkWdQv1AA38WzFVG-jjOY1WZgPElhy8FRKUk,6418 +ray/data/_internal/datasource/parquet_datasource.py,sha256=tZgIkNT62Er8MZLJIzM3TmDNxnvv9bkslvRfiZkGkn4,27908 +ray/data/_internal/datasource/range_datasource.py,sha256=Lpu8E_VyGJkKAVjG7zJz1La4rcX2AA9_zlaT43q4a2k,4826 +ray/data/_internal/datasource/sql_datasink.py,sha256=ZH9A4_cqgUKPANh-GQ6R5t-dU3Xp9O7pncJTwrXjSNA,1251 +ray/data/_internal/datasource/sql_datasource.py,sha256=F6KJxLmzLzGEWH02VA7Zg9yOsRlqN_wml-BIOddLt9I,3573 +ray/data/_internal/datasource/text_datasource.py,sha256=AmMEMiMsTEVcRrqKjnPByI2CFGUhkOhaNXVgKDhrJkA,1197 +ray/data/_internal/datasource/tfrecords_datasink.py,sha256=ITi8Oh21E2hlaE4hMWWhwqF9kCm0ejaktsjH7hBi26s,7860 +ray/data/_internal/datasource/tfrecords_datasource.py,sha256=pjXxAo40NFOZyNw2DkuiiqIALu6KWKTP4CoP_s58ziA,16477 +ray/data/_internal/datasource/torch_datasource.py,sha256=97pDLcn3mjeQ4_UA4-Fl-W_8L6PGF45VyqZe01JUboY,1642 +ray/data/_internal/datasource/video_datasource.py,sha256=8TDUXAI1fJXHzrr4dUc4B-lR6E3y-xnalAAQvpGUT7I,1389 +ray/data/_internal/datasource/webdataset_datasink.py,sha256=8cqVTLedeKBCPi6bNFXBDwTeWkuBvyGJTPSXmXBtl9c,1793 +ray/data/_internal/datasource/webdataset_datasource.py,sha256=OnP7v6Mk2YzQ2Pk5aaG4tVHkMWwOJYEg2Zk-Ok9kQrw,12582 +ray/data/_internal/delegating_block_builder.py,sha256=-S-YEiwzGYdLDQmIBaN4BDN9PkE1PsZZfdgUNdDhE70,2696 +ray/data/_internal/equalize.py,sha256=l4_Rdg5FucF9Qxwy_Rct4yrLljeeA2GmPKqqbesiXXo,5300 +ray/data/_internal/execution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/data/_internal/execution/__pycache__/__init__.cpython-311.pyc,, +ray/data/_internal/execution/__pycache__/autoscaling_requester.cpython-311.pyc,, +ray/data/_internal/execution/__pycache__/execution_callback.cpython-311.pyc,, +ray/data/_internal/execution/__pycache__/legacy_compat.cpython-311.pyc,, +ray/data/_internal/execution/__pycache__/resource_manager.cpython-311.pyc,, +ray/data/_internal/execution/__pycache__/streaming_executor.cpython-311.pyc,, +ray/data/_internal/execution/__pycache__/streaming_executor_state.cpython-311.pyc,, +ray/data/_internal/execution/__pycache__/util.cpython-311.pyc,, +ray/data/_internal/execution/autoscaler/__init__.py,sha256=rmT7Yep_p9fT_S-v4taCDIgQTLQDd2g_UJL0skOTWaE,392 +ray/data/_internal/execution/autoscaler/__pycache__/__init__.cpython-311.pyc,, +ray/data/_internal/execution/autoscaler/__pycache__/autoscaler.cpython-311.pyc,, +ray/data/_internal/execution/autoscaler/__pycache__/autoscaling_actor_pool.cpython-311.pyc,, +ray/data/_internal/execution/autoscaler/__pycache__/default_autoscaler.cpython-311.pyc,, +ray/data/_internal/execution/autoscaler/autoscaler.py,sha256=AXd5oGkFdUjSiBkoFOiSIl1_TrWfdj5yoNOfDbWKZEE,1394 +ray/data/_internal/execution/autoscaler/autoscaling_actor_pool.py,sha256=raFzupubFgS_yPwEU1qC20t5kHydJJHxLwxv47dmAPQ,2600 +ray/data/_internal/execution/autoscaler/default_autoscaler.py,sha256=P0pOsD4fsswKGLnmEKcQM7inuur8CDQM3WJFisONP9g,8310 +ray/data/_internal/execution/autoscaling_requester.py,sha256=F-QMxBbXHOOvabx8sy6idkho2atGeHGO95-rAcGTvBw,5136 +ray/data/_internal/execution/backpressure_policy/__init__.py,sha256=pK_ihJhSaI0CdxNMe_ycz3-LYMOd2Xco4RUzZKVNJNA,984 +ray/data/_internal/execution/backpressure_policy/__pycache__/__init__.cpython-311.pyc,, +ray/data/_internal/execution/backpressure_policy/__pycache__/backpressure_policy.cpython-311.pyc,, +ray/data/_internal/execution/backpressure_policy/__pycache__/concurrency_cap_backpressure_policy.cpython-311.pyc,, +ray/data/_internal/execution/backpressure_policy/backpressure_policy.py,sha256=sV30EpO7HhY-OFpZ6qNlbJ8U5a7wpDwd4GPlDjmMm28,992 +ray/data/_internal/execution/backpressure_policy/concurrency_cap_backpressure_policy.py,sha256=3bu-6tqQF8-6cd7-Y44UswO8pVNSuLouwZNJHZXVHyA,1530 +ray/data/_internal/execution/bundle_queue/__init__.py,sha256=-5iP8h7pXGVIj56-Vpm7fGkKd5zFl1AhFX8YfuaNIdM,209 +ray/data/_internal/execution/bundle_queue/__pycache__/__init__.cpython-311.pyc,, +ray/data/_internal/execution/bundle_queue/__pycache__/bundle_queue.cpython-311.pyc,, +ray/data/_internal/execution/bundle_queue/__pycache__/fifo_bundle_queue.cpython-311.pyc,, +ray/data/_internal/execution/bundle_queue/bundle_queue.py,sha256=Qas-BsHkzQfMSdYarzDtwLVMNVje54WfISI7OZUMehA,1561 +ray/data/_internal/execution/bundle_queue/fifo_bundle_queue.py,sha256=YMk0EJLEohYSXaidReRFTmCbt7P8zW_USipZ1h213As,4315 +ray/data/_internal/execution/execution_callback.py,sha256=nV96ac7RTkK8foND1wcw5ggFC8z7T-Lojs-DHGw6O44,1427 +ray/data/_internal/execution/interfaces/__init__.py,sha256=4TaMztWAkQo4EZwdbLBg9jSVLB8OOcGEDF9HBnSkcmE,518 +ray/data/_internal/execution/interfaces/__pycache__/__init__.cpython-311.pyc,, +ray/data/_internal/execution/interfaces/__pycache__/common.cpython-311.pyc,, +ray/data/_internal/execution/interfaces/__pycache__/execution_options.cpython-311.pyc,, +ray/data/_internal/execution/interfaces/__pycache__/executor.cpython-311.pyc,, +ray/data/_internal/execution/interfaces/__pycache__/op_runtime_metrics.cpython-311.pyc,, +ray/data/_internal/execution/interfaces/__pycache__/physical_operator.cpython-311.pyc,, +ray/data/_internal/execution/interfaces/__pycache__/ref_bundle.cpython-311.pyc,, +ray/data/_internal/execution/interfaces/__pycache__/task_context.cpython-311.pyc,, +ray/data/_internal/execution/interfaces/__pycache__/transform_fn.cpython-311.pyc,, +ray/data/_internal/execution/interfaces/common.py,sha256=xA6b7P6z3rfj_bIyP3oXHb9Hj5nROEbjfaFmLVDJ7XQ,88 +ray/data/_internal/execution/interfaces/execution_options.py,sha256=PPHRRdUceGtZIrPL5-wvk83YoYAVC902UGOmPSQco5g,11364 +ray/data/_internal/execution/interfaces/executor.py,sha256=GJfYcnlyvc6WAGr3IVzacX7D-JIsCFme_w4_ayQ_ejY,2546 +ray/data/_internal/execution/interfaces/op_runtime_metrics.py,sha256=u6fSR-zGYhz3Ij1GKc6CciMqYRGySd1996pI55ZDXTY,21140 +ray/data/_internal/execution/interfaces/physical_operator.py,sha256=LzfpDoxHMhMMo4vO2h1RSIFIqnG7EHoZ7c6TvQpMiM8,20718 +ray/data/_internal/execution/interfaces/ref_bundle.py,sha256=-Ry8GJKPDgv3PFURYhlX1CFXXfZuHMghdlQpF2WofvM,5060 +ray/data/_internal/execution/interfaces/task_context.py,sha256=wBnZLsA6SCtjicCEzVygWAupz4bt5srNCwfTX190dgA,1966 +ray/data/_internal/execution/interfaces/transform_fn.py,sha256=z0V0D3dJM9Iug1D-QLbueIK3YXrNzWYz-XrDS6bRl2Y,322 +ray/data/_internal/execution/legacy_compat.py,sha256=U8RaBO8zjrmXkxJGfmiMoUdnuztOqQ97Sg6bKYrT1Rk,6770 +ray/data/_internal/execution/operators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/data/_internal/execution/operators/__pycache__/__init__.cpython-311.pyc,, +ray/data/_internal/execution/operators/__pycache__/actor_pool_map_operator.cpython-311.pyc,, +ray/data/_internal/execution/operators/__pycache__/aggregate_num_rows.cpython-311.pyc,, +ray/data/_internal/execution/operators/__pycache__/base_physical_operator.cpython-311.pyc,, +ray/data/_internal/execution/operators/__pycache__/input_data_buffer.cpython-311.pyc,, +ray/data/_internal/execution/operators/__pycache__/limit_operator.cpython-311.pyc,, +ray/data/_internal/execution/operators/__pycache__/map_operator.cpython-311.pyc,, +ray/data/_internal/execution/operators/__pycache__/map_transformer.cpython-311.pyc,, +ray/data/_internal/execution/operators/__pycache__/output_splitter.cpython-311.pyc,, +ray/data/_internal/execution/operators/__pycache__/task_pool_map_operator.cpython-311.pyc,, +ray/data/_internal/execution/operators/__pycache__/union_operator.cpython-311.pyc,, +ray/data/_internal/execution/operators/__pycache__/zip_operator.cpython-311.pyc,, +ray/data/_internal/execution/operators/actor_pool_map_operator.py,sha256=xh60AZmqG5AUqKAcNTSP-reiqRE2QopeOmR70LN456k,31195 +ray/data/_internal/execution/operators/aggregate_num_rows.py,sha256=sPDQs1zoUx_bsIx0xpQeRlRI4owo7M_TbCeJz31Y8PY,1848 +ray/data/_internal/execution/operators/base_physical_operator.py,sha256=bMZe9zgqi65EmupC2tHZO-vle1R3AwDeAseVtsBvQEk,6149 +ray/data/_internal/execution/operators/input_data_buffer.py,sha256=3tYeV15X-N_JatXZBpyMYA7Gsox18fs4aLQk92Rk5Mo,3346 +ray/data/_internal/execution/operators/limit_operator.py,sha256=sVh_iu-DJ7BAZKb6XT7vTzNyQvwsImrcxlE3MZMT4xg,5237 +ray/data/_internal/execution/operators/map_operator.py,sha256=XlZyS5jcPSiYKLMGPYSIJ3JaVW-lPE6GtWsGRAShn_4,28381 +ray/data/_internal/execution/operators/map_transformer.py,sha256=3cXIir93MZEB8xZzmgJ9EoA3ggsh04auuMQPwl6QpTI,15393 +ray/data/_internal/execution/operators/output_splitter.py,sha256=rK237jcpJNmZ5mY8bSVzso0UR1LxHaVoMVI133QowH0,12853 +ray/data/_internal/execution/operators/task_pool_map_operator.py,sha256=urHAGRUjA79Hcv884EbaLSNuAijKaHtS1tWpwTye2eU,6100 +ray/data/_internal/execution/operators/union_operator.py,sha256=xBqMKf4NvlEGK8j3fES_0nF4OdniDmTKWXWTaWKM6fA,4558 +ray/data/_internal/execution/operators/zip_operator.py,sha256=nHfVNdPIb2HFK3tX61UTuZd4YuN_VyTphGQ6Zl4CsT8,10367 +ray/data/_internal/execution/resource_manager.py,sha256=Qx-uIgzrtuN878pLqKx0U01PDQ9xP14i22FLDthhzHQ,30168 +ray/data/_internal/execution/streaming_executor.py,sha256=wGSJeItm3wI-C0kKdRogKWYKYv7VrKaNeLJzyhtaxE0,20102 +ray/data/_internal/execution/streaming_executor_state.py,sha256=g6a6BSFM7PBA4kendoF7ok_W5q0choC0ZVSXBG-eQkI,26785 +ray/data/_internal/execution/util.py,sha256=l5ovmKstgryQO7OUcvgYAVk5AOmf8HsCAK_cnAI8tmk,2501 +ray/data/_internal/iterator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/data/_internal/iterator/__pycache__/__init__.cpython-311.pyc,, +ray/data/_internal/iterator/__pycache__/iterator_impl.cpython-311.pyc,, +ray/data/_internal/iterator/__pycache__/stream_split_iterator.cpython-311.pyc,, +ray/data/_internal/iterator/iterator_impl.py,sha256=6QCW9AxozKPza38BraBV0T6tAdG235am38tSZU8R2zY,1245 +ray/data/_internal/iterator/stream_split_iterator.py,sha256=-BrV59G-ukXZ4x6MeILhegzqzr7TM0RmzDBkmOhw4pk,10562 +ray/data/_internal/logging.py,sha256=dVSaYS1LIfSPdYqjW3VfNI2hg-gAI-XsxsqkZtVILYg,6926 +ray/data/_internal/logical/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/data/_internal/logical/__pycache__/__init__.cpython-311.pyc,, +ray/data/_internal/logical/__pycache__/optimizers.cpython-311.pyc,, +ray/data/_internal/logical/__pycache__/util.cpython-311.pyc,, +ray/data/_internal/logical/interfaces/__init__.py,sha256=ozTSGNAJjoRamfveVil3WJOhxAYsNtEUYQMjp4CzYmE,351 +ray/data/_internal/logical/interfaces/__pycache__/__init__.cpython-311.pyc,, +ray/data/_internal/logical/interfaces/__pycache__/logical_operator.cpython-311.pyc,, +ray/data/_internal/logical/interfaces/__pycache__/logical_plan.cpython-311.pyc,, +ray/data/_internal/logical/interfaces/__pycache__/operator.cpython-311.pyc,, +ray/data/_internal/logical/interfaces/__pycache__/optimizer.cpython-311.pyc,, +ray/data/_internal/logical/interfaces/__pycache__/physical_plan.cpython-311.pyc,, +ray/data/_internal/logical/interfaces/__pycache__/plan.cpython-311.pyc,, +ray/data/_internal/logical/interfaces/logical_operator.py,sha256=X7G8zaciBo84J7X0hwk_f0l67c6tLm8qzhvyiUI8-ac,2913 +ray/data/_internal/logical/interfaces/logical_plan.py,sha256=cQDiwJlLgsVxRVEnesKSab59miYKxA4YwrbWJFNTUI4,928 +ray/data/_internal/logical/interfaces/operator.py,sha256=WH6jXxZ7oReAmOBJfQJNsFIh_YG3nfOgssCy18EtST4,1768 +ray/data/_internal/logical/interfaces/optimizer.py,sha256=-LklmCqDEX8RBJW05jgL-rn1J6uPWLBxGTQ7IHnLdxE,729 +ray/data/_internal/logical/interfaces/physical_plan.py,sha256=RTISbVwvCp4fR0nvfkBPPfhPHPP_MrYaVaeHV3q0S3c,922 +ray/data/_internal/logical/interfaces/plan.py,sha256=Voi8TGBED58w7k3qWqeVgCJDjUrs-HW7EPuu5XEon34,590 +ray/data/_internal/logical/operators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/data/_internal/logical/operators/__pycache__/__init__.cpython-311.pyc,, +ray/data/_internal/logical/operators/__pycache__/all_to_all_operator.cpython-311.pyc,, +ray/data/_internal/logical/operators/__pycache__/count_operator.cpython-311.pyc,, +ray/data/_internal/logical/operators/__pycache__/from_operators.cpython-311.pyc,, +ray/data/_internal/logical/operators/__pycache__/input_data_operator.cpython-311.pyc,, +ray/data/_internal/logical/operators/__pycache__/map_operator.cpython-311.pyc,, +ray/data/_internal/logical/operators/__pycache__/n_ary_operator.cpython-311.pyc,, +ray/data/_internal/logical/operators/__pycache__/one_to_one_operator.cpython-311.pyc,, +ray/data/_internal/logical/operators/__pycache__/read_operator.cpython-311.pyc,, +ray/data/_internal/logical/operators/__pycache__/write_operator.cpython-311.pyc,, +ray/data/_internal/logical/operators/all_to_all_operator.py,sha256=Q4kYwkoda4dbi19xl2sXwiatwAtiQI2m-Gj0MCsYr3Q,5396 +ray/data/_internal/logical/operators/count_operator.py,sha256=013XGX7Rqpt7LRROgwpXyTsjjx6FwAdfmR-fzZDS7EM,634 +ray/data/_internal/logical/operators/from_operators.py,sha256=5jtWbvN0-ScDVaPu_Gr_9hLJZAYzJrYQS6w7vt0hYTI,2951 +ray/data/_internal/logical/operators/input_data_operator.py,sha256=oHPzBep2QjaI0bmHloR6Br2SRpqPtaqWDcg2r6hhOC8,2573 +ray/data/_internal/logical/operators/map_operator.py,sha256=IqFXtpzi3FhCmJwpbmyrldQWP6FXce139oHnPOC597A,11988 +ray/data/_internal/logical/operators/n_ary_operator.py,sha256=iqm4AVcY3vADoIWto88xyqx5qUzu-pkubnJhg0zjilk,1719 +ray/data/_internal/logical/operators/one_to_one_operator.py,sha256=L5GJFyfiV_7VDrl0fQr690kYDVAYk-0jrCNYZtn-dAU,2505 +ray/data/_internal/logical/operators/read_operator.py,sha256=f61Cug3gTZKOXR_ve6uKsCf5ghOydNhA7IyRH5eAH1s,3376 +ray/data/_internal/logical/operators/write_operator.py,sha256=l0aMhQqKSsKxqSLiAM3A_QMXDwYJpx7D5J9CuzTSHHU,1215 +ray/data/_internal/logical/optimizers.py,sha256=OPyYAdhly-1bMpM33VYpm38iMIEDHpI0aQ_5TmY08SU,2743 +ray/data/_internal/logical/rules/__init__.py,sha256=gnMwrWakFZw_G20PAPBSxaen3F2kgcpAC_zBfImnC94,233 +ray/data/_internal/logical/rules/__pycache__/__init__.cpython-311.pyc,, +ray/data/_internal/logical/rules/__pycache__/inherit_batch_format.cpython-311.pyc,, +ray/data/_internal/logical/rules/__pycache__/inherit_target_max_block_size.cpython-311.pyc,, +ray/data/_internal/logical/rules/__pycache__/limit_pushdown.cpython-311.pyc,, +ray/data/_internal/logical/rules/__pycache__/operator_fusion.cpython-311.pyc,, +ray/data/_internal/logical/rules/__pycache__/randomize_blocks.cpython-311.pyc,, +ray/data/_internal/logical/rules/__pycache__/set_read_parallelism.cpython-311.pyc,, +ray/data/_internal/logical/rules/__pycache__/zero_copy_map_fusion.cpython-311.pyc,, +ray/data/_internal/logical/rules/inherit_batch_format.py,sha256=3liaenM0jJCx_3jhzZE6ET6rrTbRShMjSJhYSv00E2g,1684 +ray/data/_internal/logical/rules/inherit_target_max_block_size.py,sha256=tE10UxT7378AaV0PK4Lr4OyQu2RB4QBoYIXnCN4k9o8,1227 +ray/data/_internal/logical/rules/limit_pushdown.py,sha256=6E3InEBz7vCc-RXBt8EoRjkB01gCaiLq__1KVEMncVg,6613 +ray/data/_internal/logical/rules/operator_fusion.py,sha256=TnUIoy4elHlwdw0hncFkLgafKtxDRKLNqYYdxT9AGU8,19765 +ray/data/_internal/logical/rules/randomize_blocks.py,sha256=PN2BNdIb6oiVkzIoiKd9Rs9-THrpKBqcQx9oNZGZ4xM,3258 +ray/data/_internal/logical/rules/set_read_parallelism.py,sha256=k7Y-ho3CXZ7hWmeHq9TjSEk_XhfdZBKdAgRW0WgQj3E,5360 +ray/data/_internal/logical/rules/zero_copy_map_fusion.py,sha256=sN44lLU1UOPlG0k5HsigfU7H82VDOjFGax65nHP1KGE,3244 +ray/data/_internal/logical/util.py,sha256=ZKbDPSNK-fsgcUVzlqg_50hADiiaKvz_9aFpfARg0Cw,3079 +ray/data/_internal/memory_tracing.py,sha256=HC_9pDdGuOrDtxO5aKG98tMKySbesMLaD7ImjZJzmcc,5861 +ray/data/_internal/null_aggregate.py,sha256=uCIxG6cFiWadILRza4gPWQAAew5tE1BYoX-Qz0JabSE,9572 +ray/data/_internal/numpy_support.py,sha256=mIVnI3yxyex1CVgXXF7V0qhnr4gL3vzE3xnNOuQXMoA,9117 +ray/data/_internal/output_buffer.py,sha256=qI3aCPav6432WuIhzG9daAbOrVwubpjtqUGh0rXIMJA,4749 +ray/data/_internal/pandas_block.py,sha256=DZyJ57jxr7ezB7qFYj_E6KZl_92JTakcqS3BNgxqSII,26250 +ray/data/_internal/plan.py,sha256=ENCsZEShnFqAclQHyiA9eiHAFWZ560v5c6HTmDlh9hU,24665 +ray/data/_internal/planner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/data/_internal/planner/__pycache__/__init__.cpython-311.pyc,, +ray/data/_internal/planner/__pycache__/aggregate.cpython-311.pyc,, +ray/data/_internal/planner/__pycache__/plan_all_to_all_op.cpython-311.pyc,, +ray/data/_internal/planner/__pycache__/plan_from_arrow_op.cpython-311.pyc,, +ray/data/_internal/planner/__pycache__/plan_from_items_op.cpython-311.pyc,, +ray/data/_internal/planner/__pycache__/plan_from_numpy_op.cpython-311.pyc,, +ray/data/_internal/planner/__pycache__/plan_from_pandas_op.cpython-311.pyc,, +ray/data/_internal/planner/__pycache__/plan_read_op.cpython-311.pyc,, +ray/data/_internal/planner/__pycache__/plan_udf_map_op.cpython-311.pyc,, +ray/data/_internal/planner/__pycache__/plan_write_op.cpython-311.pyc,, +ray/data/_internal/planner/__pycache__/planner.cpython-311.pyc,, +ray/data/_internal/planner/__pycache__/random_shuffle.cpython-311.pyc,, +ray/data/_internal/planner/__pycache__/randomize_blocks.cpython-311.pyc,, +ray/data/_internal/planner/__pycache__/repartition.cpython-311.pyc,, +ray/data/_internal/planner/__pycache__/sort.cpython-311.pyc,, +ray/data/_internal/planner/aggregate.py,sha256=k7bS1no6EEmEqEMb6cIS0ic-nJY4bs97c-cm9GVv9mI,2872 +ray/data/_internal/planner/exchange/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/data/_internal/planner/exchange/__pycache__/__init__.cpython-311.pyc,, +ray/data/_internal/planner/exchange/__pycache__/aggregate_task_spec.cpython-311.pyc,, +ray/data/_internal/planner/exchange/__pycache__/interfaces.cpython-311.pyc,, +ray/data/_internal/planner/exchange/__pycache__/pull_based_shuffle_task_scheduler.cpython-311.pyc,, +ray/data/_internal/planner/exchange/__pycache__/push_based_shuffle_task_scheduler.cpython-311.pyc,, +ray/data/_internal/planner/exchange/__pycache__/shuffle_task_spec.cpython-311.pyc,, +ray/data/_internal/planner/exchange/__pycache__/sort_task_spec.cpython-311.pyc,, +ray/data/_internal/planner/exchange/__pycache__/split_repartition_task_scheduler.cpython-311.pyc,, +ray/data/_internal/planner/exchange/aggregate_task_spec.py,sha256=VfrsyVK2FHwa9jNjb7kGaPvA0bfBHen-IUJYqK7EjcE,3848 +ray/data/_internal/planner/exchange/interfaces.py,sha256=jQrwUjayDc-ahGX98UJN7FixMOzYia3zmmlD5Xu2QKQ,4739 +ray/data/_internal/planner/exchange/pull_based_shuffle_task_scheduler.py,sha256=r2M8G-6KkdYOwEslIQlgSGyIsSfV5jGF8nT6Er8oTcY,5933 +ray/data/_internal/planner/exchange/push_based_shuffle_task_scheduler.py,sha256=WfjvWY02mtqCqBK4oXaOPB7ikekkl69QW48l7lvBtv4,32510 +ray/data/_internal/planner/exchange/shuffle_task_spec.py,sha256=fEyXbhPCF7ifS0HDX-vfeh8fYnhXy3il1KZeZmdxklQ,5151 +ray/data/_internal/planner/exchange/sort_task_spec.py,sha256=1cGKkmZSqRdmcYKVKqtSx9CeTmjIkGD3lb5C0vZsbD0,8726 +ray/data/_internal/planner/exchange/split_repartition_task_scheduler.py,sha256=aGJ3LF266zJuscrgg3yXvDrQhJ0J6lxgpTj1wvNTook,5759 +ray/data/_internal/planner/plan_all_to_all_op.py,sha256=HsPffUerF8eoxvxwUJZVoOUlNbZLJgXRONOYDcDs9qY,3674 +ray/data/_internal/planner/plan_expression/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/data/_internal/planner/plan_expression/__pycache__/__init__.cpython-311.pyc,, +ray/data/_internal/planner/plan_expression/__pycache__/expression_evaluator.cpython-311.pyc,, +ray/data/_internal/planner/plan_expression/expression_evaluator.py,sha256=mObm0SsN7yCHh2ypL5wFD4rJnYYEC1hJ31tZQ7qeVOg,8765 +ray/data/_internal/planner/plan_from_arrow_op.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/data/_internal/planner/plan_from_items_op.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/data/_internal/planner/plan_from_numpy_op.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/data/_internal/planner/plan_from_pandas_op.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/data/_internal/planner/plan_read_op.py,sha256=6A4z1vxOjQFOW1KeKZXmf4kTEqzkzxnWeWvQH1j8kuc,4826 +ray/data/_internal/planner/plan_udf_map_op.py,sha256=tPUStt_RPd6de9ZpCrSr3B_e1Yy_k_hDfhG8kqy4qe8,22382 +ray/data/_internal/planner/plan_write_op.py,sha256=KDpUCAa8-JE2n88B5yseaDY9AzO-tYd5SYOUmjd82Ag,4191 +ray/data/_internal/planner/planner.py,sha256=umd06KYs0h_W1pG367B6bBZ4klA3-OoCIvEX_DvaRvM,7191 +ray/data/_internal/planner/random_shuffle.py,sha256=y2CkI9Jdtq_MQYBRtvVoa-cAUKZB8CJxytL3AZ0Zdus,3344 +ray/data/_internal/planner/randomize_blocks.py,sha256=xL_StmJc75V5ak6UjKKAM8VsuH6h75vmUrw6-Hy2KhY,1528 +ray/data/_internal/planner/repartition.py,sha256=SWe_eWbXz4__SivHdbbM2GPQRgQ_cJzjrawbP1lBd38,3172 +ray/data/_internal/planner/sort.py,sha256=F2Ru47GnLgBaW9HOGm688dOUM3Rbe700U-1e9J50pLg,3059 +ray/data/_internal/progress_bar.py,sha256=k0Y7fkOiI5KeL_J_q1tofKeNN-ic80cLnzJAjQbq4Jo,7346 +ray/data/_internal/remote_fn.py,sha256=NWhWFnzKhkPyERyQOgpjMiDpT5cqEDiPJDbUUQlhRPk,3127 +ray/data/_internal/row.py,sha256=O2HBLzbl8Dpgogr1S1U_cPij_202tBVP3FT_BH16hiM,1262 +ray/data/_internal/size_estimator.py,sha256=ysmwWsXLZHvikQWAd8cUC1awnW-nz727yv6ICXkeODI,2869 +ray/data/_internal/split.py,sha256=4xUwS8r2APJl6b4lFPpl8LYp5vDrBKHDbsylERAxgRU,11171 +ray/data/_internal/stats.py,sha256=fdL5AY6pTb8NE8sJKtjMu3YKwTc0oL-esEFSAbOvwVo,60142 +ray/data/_internal/table_block.py,sha256=9oBYSZVuD0NmvhIMxUZS5J2Six9ZC8Troro-D9s_NNY,11046 +ray/data/_internal/torch_iterable_dataset.py,sha256=WYYir0pFH5-xd-1M0-Hpr6wQ5-SRjJditEA-QaCDWTE,259 +ray/data/_internal/util.py,sha256=UlUMy7idFrRWluOm0sJAowscRpCRy0gcTAorwcM1Yso,46896 +ray/data/aggregate.py,sha256=1na4ubfY2XUFG9yKVjHZRYO0JuY_nbv49Ynae6ztYaE,3121 +ray/data/block.py,sha256=iVXNXkhs1yfypUpbpV8fjcPnhv2kelolL8cV9AhNir4,19072 +ray/data/context.py,sha256=jSldkBQHaH_HRpGe1EsPgJ2yMuBDfNXwMgsnUxXP1p8,20311 +ray/data/dataset.py,sha256=_Qt9502WKGtAV1pKZkWrJUZd6j-7u5e9JN7IR0C9db8,232681 +ray/data/datasource/__init__.py,sha256=OYVrTRQj7Be8c94SN69aCvkQxgGrUJZ2mMcK7w5CkC0,1846 +ray/data/datasource/__pycache__/__init__.cpython-311.pyc,, +ray/data/datasource/__pycache__/datasink.cpython-311.pyc,, +ray/data/datasource/__pycache__/datasource.cpython-311.pyc,, +ray/data/datasource/__pycache__/file_based_datasource.cpython-311.pyc,, +ray/data/datasource/__pycache__/file_datasink.cpython-311.pyc,, +ray/data/datasource/__pycache__/file_meta_provider.cpython-311.pyc,, +ray/data/datasource/__pycache__/filename_provider.cpython-311.pyc,, +ray/data/datasource/__pycache__/parquet_meta_provider.cpython-311.pyc,, +ray/data/datasource/__pycache__/partitioning.cpython-311.pyc,, +ray/data/datasource/__pycache__/path_util.cpython-311.pyc,, +ray/data/datasource/datasink.py,sha256=0AoICzlTB2-vVbDboN-vlc5r8e99cu-36KlQOZubdp0,5030 +ray/data/datasource/datasource.py,sha256=wCgLpZQ9TzaoKALDHxWpjkc21oPps-ExxlHeU3v9acg,8499 +ray/data/datasource/file_based_datasource.py,sha256=1mCW3DSZ_b6z6Mp-URQriaO8qtei2sKz2HIjRoc2bfg,19820 +ray/data/datasource/file_datasink.py,sha256=r8AHysuZ_cO-Gk2qlYwTDNQ7KAjmS-Fn5VrEXyGRXe8,10169 +ray/data/datasource/file_meta_provider.py,sha256=WSfv7Xw90cr9GR5loL5OyIrkZbFLJAYAYL1SKbneLfo,17750 +ray/data/datasource/filename_provider.py,sha256=GDDEANkghOObFa_Xwu7XV953HNwhRdHBXTxPN3qLNQQ,4635 +ray/data/datasource/parquet_meta_provider.py,sha256=2cRCO8LGB2Y10h_nEE9foh4QWGJYw4cx99bQVAUEkGg,10803 +ray/data/datasource/partitioning.py,sha256=z-3Ypg8Si8RvivTx385YaZeerVN49uYvPHVnQODZKNY,19248 +ray/data/datasource/path_util.py,sha256=Z-epTj3e-mxjc9AnS1Ka_IyCQKi3Tc2gg8FbtJRczu8,7652 +ray/data/exceptions.py,sha256=OVu94NLXZaBT5Pr3yfACxd8klhZ73hHl0154R9mQM0g,3924 +ray/data/extensions/__init__.py,sha256=wfJu5w7Offu__LsrBGAR41UlKlZ1exB9TRLWjbuTgWg,1187 +ray/data/extensions/__pycache__/__init__.cpython-311.pyc,, +ray/data/extensions/__pycache__/object_extension.cpython-311.pyc,, +ray/data/extensions/__pycache__/tensor_extension.cpython-311.pyc,, +ray/data/extensions/object_extension.py,sha256=ZUSj0p2sfBBShI3mi3on2S7Z66H_Fj-4AM9i42t9-Gs,301 +ray/data/extensions/tensor_extension.py,sha256=xeEYpd5EgkEbCe1ufWiuKvinnZ5L7Q_1S_7re6s7V00,476 +ray/data/grouped_data.py,sha256=YxiNiR14kBfz9LeatJz5Jatrq72A-WV3DspVQWTVjG8,21342 +ray/data/iterator.py,sha256=IWk3jtl-s1ZvyjZngDcgV5Lb23fVO4yS42mEAmnYoSk,42482 +ray/data/preprocessor.py,sha256=ib0tO8jKIOYfznPGhvApB76UvxBIre1yF0pIBV6BbZo,11769 +ray/data/preprocessors/__init__.py,sha256=cmLZN7WN66y806Cgjid9gdoG8bd_aWyhJQFJQliBiSo,1389 +ray/data/preprocessors/__pycache__/__init__.cpython-311.pyc,, +ray/data/preprocessors/__pycache__/chain.cpython-311.pyc,, +ray/data/preprocessors/__pycache__/concatenator.cpython-311.pyc,, +ray/data/preprocessors/__pycache__/discretizer.cpython-311.pyc,, +ray/data/preprocessors/__pycache__/encoder.cpython-311.pyc,, +ray/data/preprocessors/__pycache__/hasher.cpython-311.pyc,, +ray/data/preprocessors/__pycache__/imputer.cpython-311.pyc,, +ray/data/preprocessors/__pycache__/normalizer.cpython-311.pyc,, +ray/data/preprocessors/__pycache__/scaler.cpython-311.pyc,, +ray/data/preprocessors/__pycache__/tokenizer.cpython-311.pyc,, +ray/data/preprocessors/__pycache__/torch.cpython-311.pyc,, +ray/data/preprocessors/__pycache__/transformer.cpython-311.pyc,, +ray/data/preprocessors/__pycache__/utils.cpython-311.pyc,, +ray/data/preprocessors/__pycache__/vectorizer.cpython-311.pyc,, +ray/data/preprocessors/chain.py,sha256=E_jkX1f26ASHB_oxvGH8lmNvPRSM3FJQ9WNtPZp9sGg,3740 +ray/data/preprocessors/concatenator.py,sha256=lTAMzXX_zGeRFQPpHZGCw33M_GMMJAV6FO4A4BWp2kc,4690 +ray/data/preprocessors/discretizer.py,sha256=dMxWSBEA1jt8EjO3Ui6soiB9Y7HaTE7XeaFAev8JJGA,13275 +ray/data/preprocessors/encoder.py,sha256=p9-PblKDoX7mQquKHFEbfmYBK2SNylDWk-nC-CL4y1I,24639 +ray/data/preprocessors/hasher.py,sha256=kQ_3b5ydaojR94rGS7u0Th1lScK-E_Y-wpNlVi0HWtE,4203 +ray/data/preprocessors/imputer.py,sha256=kTO8ZM2UF5wU40r-rXfNQdIQ-4kgEezgxcfzVPzRTTw,6078 +ray/data/preprocessors/normalizer.py,sha256=nKTTxFV5_EfV5B47MP4w-SAqGNRQzXkB7EX-jzGnKNo,3443 +ray/data/preprocessors/scaler.py,sha256=2AXLNmKZCya7OlhKhneTm8KrBPL5oknI8fGBWaqThrM,12036 +ray/data/preprocessors/tokenizer.py,sha256=-OwuxULfILRxaC4y5mw4fUNuxYMcA6rbxHcptRhHius,2579 +ray/data/preprocessors/torch.py,sha256=XH-nrMHwf3xOjZ3pfWyiJZTIpsqkAc1Y6Ze65-MIyy4,5745 +ray/data/preprocessors/transformer.py,sha256=UE8NIB_xs4AvhrTOPxdEwM0GXmjH3zrlG5_sBHzDgC8,3261 +ray/data/preprocessors/utils.py,sha256=pdlZqaQmND8G0TumQDEZHpTepQiClgj-vT9OhsbPRtc,562 +ray/data/preprocessors/vectorizer.py,sha256=_qiqGXy5uN739CVy4aCrgiqr4MuJvlBnvPDL6WpAmBo,11320 +ray/data/random_access_dataset.py,sha256=ISx8oD82jRn9QICLr3tTN5VX7_tMtXjmu2gDspRzxGM,10173 +ray/data/read_api.py,sha256=aBNwR4wjxE3iR6zkf-JV7GkN1VQFKBaJlaA0WNqxY_o,154489 +ray/exceptions.py,sha256=qP9SSeD5U8fFNRLXz_y-pkjE0QhdLqoLWUt7B4P2Vk0,29530 +ray/experimental/__init__.py,sha256=c0_dQVGITRQkFNr1KRQwV0IYGTyoaO0KwXE3DIkvDYw,330 +ray/experimental/__pycache__/__init__.cpython-311.pyc,, +ray/experimental/__pycache__/compiled_dag_ref.cpython-311.pyc,, +ray/experimental/__pycache__/dynamic_resources.cpython-311.pyc,, +ray/experimental/__pycache__/gradio_utils.cpython-311.pyc,, +ray/experimental/__pycache__/internal_kv.cpython-311.pyc,, +ray/experimental/__pycache__/locations.cpython-311.pyc,, +ray/experimental/__pycache__/queue.cpython-311.pyc,, +ray/experimental/__pycache__/shuffle.cpython-311.pyc,, +ray/experimental/__pycache__/tf_utils.cpython-311.pyc,, +ray/experimental/__pycache__/tqdm_ray.cpython-311.pyc,, +ray/experimental/array/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/experimental/array/__pycache__/__init__.cpython-311.pyc,, +ray/experimental/array/distributed/__init__.py,sha256=YC2lKOBtXo2U5PBtSeivc7mGZUh6-0DUUjy8torCo7c,536 +ray/experimental/array/distributed/__pycache__/__init__.cpython-311.pyc,, +ray/experimental/array/distributed/__pycache__/core.cpython-311.pyc,, +ray/experimental/array/distributed/__pycache__/linalg.cpython-311.pyc,, +ray/experimental/array/distributed/__pycache__/random.cpython-311.pyc,, +ray/experimental/array/distributed/core.py,sha256=gke19Or3BWp0L3MmULQiOfI58CTkWA-niLBY5WICAGA,10742 +ray/experimental/array/distributed/linalg.py,sha256=0Q1mHwl7xnqBCoi2yz7aVUZ7U00EHmTo3BRGro0cBZk,7821 +ray/experimental/array/distributed/random.py,sha256=bMuekIXQZEJMhfWfjNVqSvzb4yCGfvWHjiOKx0q0WVs,464 +ray/experimental/array/remote/__init__.py,sha256=YnT6se3fxdEM6Ez3jreTtC8-dUkE5ndxAZgXYAvmLTc,540 +ray/experimental/array/remote/__pycache__/__init__.cpython-311.pyc,, +ray/experimental/array/remote/__pycache__/core.cpython-311.pyc,, +ray/experimental/array/remote/__pycache__/linalg.cpython-311.pyc,, +ray/experimental/array/remote/__pycache__/random.cpython-311.pyc,, +ray/experimental/array/remote/core.py,sha256=K1_Cirbf9tF_hlDwvny1aLK93etW3CMPuiNZeWAl2_Q,1817 +ray/experimental/array/remote/linalg.py,sha256=WvStlQJXeMrMWVHTpQFk3PU15zuPhPZ3MZOMLEsE3fg,1634 +ray/experimental/array/remote/random.py,sha256=7zyimU_JKcz2dIK41uEfq3XtYWgdCtDySvR6rggtCww,104 +ray/experimental/channel/__init__.py,sha256=mFpFMMPWKqRCn-nKJfu62oWFjmPZajamBjUych3O-v0,1117 +ray/experimental/channel/__pycache__/__init__.cpython-311.pyc,, +ray/experimental/channel/__pycache__/auto_transport_type.cpython-311.pyc,, +ray/experimental/channel/__pycache__/cached_channel.cpython-311.pyc,, +ray/experimental/channel/__pycache__/common.cpython-311.pyc,, +ray/experimental/channel/__pycache__/communicator.cpython-311.pyc,, +ray/experimental/channel/__pycache__/conftest.cpython-311.pyc,, +ray/experimental/channel/__pycache__/cpu_communicator.cpython-311.pyc,, +ray/experimental/channel/__pycache__/intra_process_channel.cpython-311.pyc,, +ray/experimental/channel/__pycache__/nccl_group.cpython-311.pyc,, +ray/experimental/channel/__pycache__/serialization_context.cpython-311.pyc,, +ray/experimental/channel/__pycache__/shared_memory_channel.cpython-311.pyc,, +ray/experimental/channel/__pycache__/torch_tensor_nccl_channel.cpython-311.pyc,, +ray/experimental/channel/__pycache__/torch_tensor_type.cpython-311.pyc,, +ray/experimental/channel/__pycache__/utils.cpython-311.pyc,, +ray/experimental/channel/auto_transport_type.py,sha256=hlFOVC6Sc0toWBErzte8QUsKNOkiZoRxFa7oYZWESKg,6297 +ray/experimental/channel/cached_channel.py,sha256=MH9h0FVYmDxk4yY2NQiKzDQ5NQNKLaLlIriD4QyEWDw,4672 +ray/experimental/channel/common.py,sha256=ghv5SWrEXfjkhmE57T5m_MraQ3-zWTdwAGuNvIUAnMs,24355 +ray/experimental/channel/communicator.py,sha256=mVbJSsKs2cEqtS-VPjDD3iqvTvxhx8lyQG7xgFgKzsc,4675 +ray/experimental/channel/conftest.py,sha256=UAd0t9qSAmkZ3gjUWMS7ZIsVKMZUa2dIgZGe3nUgeGY,5323 +ray/experimental/channel/cpu_communicator.py,sha256=PsVpxA3JtUW4tLvMzbIPOAPGvlqj1Yo13TQo9UOJWm4,6328 +ray/experimental/channel/intra_process_channel.py,sha256=rwTORm7iXTCtBTq3k9gKBFGyFskOAUADX_JPBa90XqQ,2749 +ray/experimental/channel/nccl_group.py,sha256=iPqCCdNt2ztg3cRt4Dt0FPU-9WN7GWFjMeSu78HIF4o,12065 +ray/experimental/channel/serialization_context.py,sha256=DJZJJ4GIc7GrK3fHwlOIfrUS7DZqR6UMCWR_SDyWMcw,7996 +ray/experimental/channel/shared_memory_channel.py,sha256=AQ1xf9B0r0rZJEzJKgtmwrJHiq2OWxz5dT9Td9Vo3iw,31013 +ray/experimental/channel/torch_tensor_nccl_channel.py,sha256=S1hd8tcGN0uCV8VPQIjGCS5_rXWpQ1Molab9OrOkxE4,32268 +ray/experimental/channel/torch_tensor_type.py,sha256=J00_k-buQWnzUBjv2MT8QbuRBiaeaY9GS5RnLNcyZlQ,6711 +ray/experimental/channel/utils.py,sha256=TT58vkWzOKelynMJ4OjZYNaX4740Xxq24EQhDD8Zozo,1232 +ray/experimental/collective/__init__.py,sha256=gvMDq3Q2Gg0o27JP6FPpd4yVdE3lE-rh3Q3PtE64qEs,85 +ray/experimental/collective/__pycache__/__init__.cpython-311.pyc,, +ray/experimental/collective/__pycache__/allreduce.cpython-311.pyc,, +ray/experimental/collective/__pycache__/conftest.cpython-311.pyc,, +ray/experimental/collective/allreduce.py,sha256=G3CToaZ6Ni0cBNUGlb_3C8LhFIMTVtPrLN4DUSEmz0E,3284 +ray/experimental/collective/conftest.py,sha256=N0vIZ1QLKknjidIxxN2f7n_UtOTL30PAQFp8oDPOfzk,7463 +ray/experimental/compiled_dag_ref.py,sha256=vqbcCOt7IAHYktOn-TRwIHTbG4lcXwiOHEWIWiJMY08,8881 +ray/experimental/dynamic_resources.py,sha256=xLcUITwjRz3VborMa-3irftI_kcfZIXy1akR2T6MIyA,366 +ray/experimental/gradio_utils.py,sha256=yeAKHd5mSocJ_Kuvii43sndbwJFbZkibGn6NBO5Fhbo,426 +ray/experimental/internal_kv.py,sha256=70sXf6AyN4F2lDeW68Hbm2QWbZ2kxovc-XG9q7NyaD8,3369 +ray/experimental/job/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/experimental/job/__pycache__/__init__.cpython-311.pyc,, +ray/experimental/job/example_job/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/experimental/job/example_job/__pycache__/__init__.cpython-311.pyc,, +ray/experimental/job/example_job/__pycache__/demo_script.cpython-311.pyc,, +ray/experimental/job/example_job/demo_script.py,sha256=L9s61byeJoxKrEIxLY2bDqCMxNSWGh_ubuK8-bTHHyE,2258 +ray/experimental/locations.py,sha256=0kurQ-lHu1RHT7usojiVPoDHqPjq_hcCo-YcTbr90l0,2829 +ray/experimental/multiprocessing/__init__.py,sha256=hLGdYmPBcC5PUMJkdzHQtmkpoxB4zyFV78jtyM5G35A,101 +ray/experimental/multiprocessing/__pycache__/__init__.cpython-311.pyc,, +ray/experimental/multiprocessing/__pycache__/pool.cpython-311.pyc,, +ray/experimental/multiprocessing/pool.py,sha256=yg38ubcXojfwJfhHh3LyXDWTZgQ0cECr-U4fm3NjVbM,107 +ray/experimental/packaging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/experimental/packaging/__pycache__/__init__.cpython-311.pyc,, +ray/experimental/packaging/__pycache__/load_package.cpython-311.pyc,, +ray/experimental/packaging/load_package.py,sha256=0HFDBlIJjXTYxj63COYyi0_brkOLzT5ROO2MKoyylU4,8521 +ray/experimental/queue.py,sha256=PtN0yekRZRd6mPfLV9UZg7AUNOVDjpD1Vmy3k42cA0c,278 +ray/experimental/shuffle.py,sha256=bGL9biDRlMJBUwIik9BRHIZ9sEv0JTJRIS_89Iw1fwE,11888 +ray/experimental/state/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/experimental/state/__pycache__/__init__.cpython-311.pyc,, +ray/experimental/state/__pycache__/api.cpython-311.pyc,, +ray/experimental/state/__pycache__/common.cpython-311.pyc,, +ray/experimental/state/__pycache__/custom_types.cpython-311.pyc,, +ray/experimental/state/__pycache__/exception.cpython-311.pyc,, +ray/experimental/state/__pycache__/state_cli.cpython-311.pyc,, +ray/experimental/state/__pycache__/state_manager.cpython-311.pyc,, +ray/experimental/state/__pycache__/util.cpython-311.pyc,, +ray/experimental/state/api.py,sha256=lTSJNmYiuJH7H6cl3KWBJJEJipQLahY5h4MUAd1qEjM,153 +ray/experimental/state/common.py,sha256=z0wOGro4JJknd9w8v4jT47rDL_vAAgAPBDhjzeXONH8,160 +ray/experimental/state/custom_types.py,sha256=PiB8tDTW5h9g8cgJGUyaX0R_4g5V9Wjn-x4_kPdepoY,166 +ray/experimental/state/exception.py,sha256=I3QCtFf7vzLryGd0EywtcQtWeWxDgiNWsvK0gjD7z7Y,163 +ray/experimental/state/state_cli.py,sha256=XbcE3Pf2LUYgYsZzIyMSNXeeKdJKKi99MNM0BBzoYP8,163 +ray/experimental/state/state_manager.py,sha256=J8L5kVU-z9JFDpO3dGU2kWft_YVCAzHzdY_xbK1Y6yI,167 +ray/experimental/state/util.py,sha256=elplAt5gVGD8C1pYaJveHZq-rPiSAVfJ5NT6upvjcGI,158 +ray/experimental/tf_utils.py,sha256=NRslrnwvB2tGfqDBVltO02B8UoBkls5MYLTLveuZZjo,8641 +ray/experimental/tqdm_ray.py,sha256=jyrqzbs1nrpyAit5Ko-HNPr433w4Xh-7yzDvsjp6VR4,13608 +ray/experimental/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/experimental/util/__pycache__/__init__.cpython-311.pyc,, +ray/experimental/util/__pycache__/types.cpython-311.pyc,, +ray/experimental/util/types.py,sha256=Va2BHVxqXESQD8gpvCU9jIuWgvLR-EMkrdbW_rrTaR0,274 +ray/includes/__init__.pxd,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/includes/common.pxd,sha256=Px36SUlDdXl1J1lgSpQ0jwck1VmjFv-MWrRGbMbNVv4,28465 +ray/includes/function_descriptor.pxd,sha256=Vy4rxapEoeNsSgtlHICzwBD48HEdWt1_e9fA65mEK2Y,2954 +ray/includes/global_state_accessor.pxd,sha256=yWGhtPLIbqGlqW6D_x9Te_Y9qhJqFgTS45ASVO7S_zQ,5724 +ray/includes/libcoreworker.pxd,sha256=n7KJUoQatbf4DJmyEoXAWfzUIkDCG2DgIKTxBZIZkoc,19240 +ray/includes/metric.pxd,sha256=hdhCViCRhYkY6jUMofbDBFZTlrqdRcbfl0MDQMnrd_k,1707 +ray/includes/optional.pxd,sha256=oU2g1EOi9-fnxfZ6Y2Oj9LookffOAJd6Yk4n8Sd_E9g,1083 +ray/includes/ray_config.pxd,sha256=3YdfvsG4Ug31XhnYDkhmq5J-1LzJ5awIYZupsiefS18,2628 +ray/includes/unique_ids.pxd,sha256=FlhJNWjF6y8Bx0GoS5N4k-idRTSjCuhYLjpEJ6jFaEY,5202 +ray/internal/__init__.py,sha256=LYqgMsS5qemO2omV9My10UZ8pMcm_Ik_PwCBX5VwkNQ,63 +ray/internal/__pycache__/__init__.cpython-311.pyc,, +ray/jars/ray_dist.jar,sha256=Hzg1_inzY6Z8BRYKXGBjSUKrvUZyDlh_qtSIyt69Loo,32364530 +ray/job_config.py,sha256=oFtXAh2nmoz7hJuvrBpCNsLXRC_zL2JM9yvUJhWsPpo,9582 +ray/job_submission/__init__.py,sha256=PWfA3J047UH5Rppxv6wAP1SqxXz1bHC_626XUT6zW2c,337 +ray/job_submission/__pycache__/__init__.cpython-311.pyc,, +ray/nightly-wheels.yaml,sha256=39nLCMEmHDM-lPcov1Ea3Hokor2LA76wttE6AlfSUQA,674 +ray/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/remote_function.py,sha256=9Sk_ZcTCQWOxf7bGfLR72cOLAldfYwzaul71uz_K2Uo,23181 +ray/rllib/__init__.py,sha256=NjTdNRaJN1BXV1inA8Wxue1XsDd9nqLmzoFb7k9wh1c,1639 +ray/rllib/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/__init__.py,sha256=nh7H-bkZf7bL7_BW_40XUYa7IgOcnR33aZv4V5lYwbA,960 +ray/rllib/algorithms/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/__pycache__/algorithm.cpython-311.pyc,, +ray/rllib/algorithms/__pycache__/algorithm_config.cpython-311.pyc,, +ray/rllib/algorithms/__pycache__/callbacks.cpython-311.pyc,, +ray/rllib/algorithms/__pycache__/mock.cpython-311.pyc,, +ray/rllib/algorithms/__pycache__/registry.cpython-311.pyc,, +ray/rllib/algorithms/__pycache__/utils.cpython-311.pyc,, +ray/rllib/algorithms/algorithm.py,sha256=k9E_HX9mHI6io5qiqKKrk8NNagUM_zlO9-SGjmIfQoI,186769 +ray/rllib/algorithms/algorithm_config.py,sha256=4Hz4iCSMjIsibzmNNdTZMl3-cE4vMpuMN46Jg2ZTX8A,288871 +ray/rllib/algorithms/appo/__init__.py,sha256=cRAMgsk4tf2GdjrmkiZIFNMBzyvFrpaaYRG_fTlLpd0,343 +ray/rllib/algorithms/appo/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/appo/__pycache__/appo.cpython-311.pyc,, +ray/rllib/algorithms/appo/__pycache__/appo_learner.cpython-311.pyc,, +ray/rllib/algorithms/appo/__pycache__/appo_rl_module.cpython-311.pyc,, +ray/rllib/algorithms/appo/__pycache__/appo_tf_policy.cpython-311.pyc,, +ray/rllib/algorithms/appo/__pycache__/appo_torch_policy.cpython-311.pyc,, +ray/rllib/algorithms/appo/__pycache__/default_appo_rl_module.cpython-311.pyc,, +ray/rllib/algorithms/appo/__pycache__/utils.cpython-311.pyc,, +ray/rllib/algorithms/appo/appo.py,sha256=iSIEbO_hkN9Aphwur9DtYU9kxLN_MesMJ0s6TF5OZWg,18195 +ray/rllib/algorithms/appo/appo_learner.py,sha256=HERC2jMwGMIwsNB3T-xpwBmGrgUf6LNJwZaMt3BoPM8,5920 +ray/rllib/algorithms/appo/appo_rl_module.py,sha256=Y5jfdtkj5HSUKHJ_N13pDdQ6eIb7Nhkxg6VPxviHa1M,386 +ray/rllib/algorithms/appo/appo_tf_policy.py,sha256=L36FPiU2UvjxVnL_Ukm8DCApK0mNdbGkZQwNJAJNmII,15368 +ray/rllib/algorithms/appo/appo_torch_policy.py,sha256=3ty6yiDkLIzJESQWLJPkepb3Ej0gKfTFjyxh030tqOw,15696 +ray/rllib/algorithms/appo/default_appo_rl_module.py,sha256=vXqlb0NJidOjDVJWtqGK5xjtAvhAdgzAj-r1-gaIc-I,2327 +ray/rllib/algorithms/appo/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/algorithms/appo/torch/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/appo/torch/__pycache__/appo_torch_learner.cpython-311.pyc,, +ray/rllib/algorithms/appo/torch/__pycache__/appo_torch_rl_module.cpython-311.pyc,, +ray/rllib/algorithms/appo/torch/__pycache__/default_appo_torch_rl_module.cpython-311.pyc,, +ray/rllib/algorithms/appo/torch/appo_torch_learner.py,sha256=LJ0RS6BWGC43uG6Wi5RqEZZG-3duczbOR5gH0hap6eU,9029 +ray/rllib/algorithms/appo/torch/appo_torch_rl_module.py,sha256=tDXwRhHF6VeKTl6TYfMc-k_4MlaChu8f_ZFgm9rxYa8,450 +ray/rllib/algorithms/appo/torch/default_appo_torch_rl_module.py,sha256=6WFlKnJ0dHVza2j09F7CHIAkpww7gZTIHVQokRkOXDs,334 +ray/rllib/algorithms/appo/utils.py,sha256=BnJQi1TPg2kFahzGXnAvew_eUvS3rKGTyIlbsorL30U,4266 +ray/rllib/algorithms/bc/__init__.py,sha256=AKNC0PiOF65pLXVQMNqQquHdtoBx7ZWijI2F4nRSLx0,93 +ray/rllib/algorithms/bc/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/bc/__pycache__/bc.cpython-311.pyc,, +ray/rllib/algorithms/bc/__pycache__/bc_catalog.cpython-311.pyc,, +ray/rllib/algorithms/bc/bc.py,sha256=_t7MNNlHvq2CwooWC3x7YZRQYlc87lY8UrSVaGNBsrY,3936 +ray/rllib/algorithms/bc/bc_catalog.py,sha256=iTxvZdBC9o0RGFdqhmVg9HiKgyTZkqnj2sxju93f-tc,4478 +ray/rllib/algorithms/bc/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/algorithms/bc/torch/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/bc/torch/__pycache__/default_bc_torch_rl_module.cpython-311.pyc,, +ray/rllib/algorithms/bc/torch/default_bc_torch_rl_module.py,sha256=CwERN0owB4q7zZrBOC9kT4p_YX8dz7D6xaXXJh50Hrs,1712 +ray/rllib/algorithms/callbacks.py,sha256=V1q4ctJSoOzEhs_A4GQZ0d6AsiWpjst0MOhHnnP3Gv0,236 +ray/rllib/algorithms/cql/__init__.py,sha256=3PzQXLnbdxMQsmVrqdl-RXAVqkLTiOyqkt85ooIk2Zg,209 +ray/rllib/algorithms/cql/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/cql/__pycache__/cql.cpython-311.pyc,, +ray/rllib/algorithms/cql/__pycache__/cql_tf_policy.cpython-311.pyc,, +ray/rllib/algorithms/cql/__pycache__/cql_torch_policy.cpython-311.pyc,, +ray/rllib/algorithms/cql/cql.py,sha256=o2dd3k5wgfff_lUt-PLV-2S_pdjr0O6BfBVxMfIrdZw,15074 +ray/rllib/algorithms/cql/cql_tf_policy.py,sha256=ZaqvUyvFzWB8iVSmQSRxdEqPW3PVNIowEoxodPuQyqg,15772 +ray/rllib/algorithms/cql/cql_torch_policy.py,sha256=Z1pMQGEwdhT9YWFMVD1Hxtw37TaQNEUG-qqfkFDzUjE,14720 +ray/rllib/algorithms/cql/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/algorithms/cql/torch/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/cql/torch/__pycache__/cql_torch_learner.cpython-311.pyc,, +ray/rllib/algorithms/cql/torch/__pycache__/default_cql_torch_rl_module.cpython-311.pyc,, +ray/rllib/algorithms/cql/torch/cql_torch_learner.py,sha256=C7fiSK18NgqQRgvuOkdis39sGtAgmat9cfbgj-rUPO0,11437 +ray/rllib/algorithms/cql/torch/default_cql_torch_rl_module.py,sha256=xD6DXJCIjtSfMyQZqLkm9idg6MKt405nDc9IqUCIRf4,8420 +ray/rllib/algorithms/dqn/__init__.py,sha256=u7YA5eq0n3QsV_3-SUXbXHNkDCX2seBWA3vnvLlfiU8,272 +ray/rllib/algorithms/dqn/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/dqn/__pycache__/default_dqn_rl_module.cpython-311.pyc,, +ray/rllib/algorithms/dqn/__pycache__/distributional_q_tf_model.cpython-311.pyc,, +ray/rllib/algorithms/dqn/__pycache__/dqn.cpython-311.pyc,, +ray/rllib/algorithms/dqn/__pycache__/dqn_catalog.cpython-311.pyc,, +ray/rllib/algorithms/dqn/__pycache__/dqn_learner.cpython-311.pyc,, +ray/rllib/algorithms/dqn/__pycache__/dqn_tf_policy.cpython-311.pyc,, +ray/rllib/algorithms/dqn/__pycache__/dqn_torch_model.cpython-311.pyc,, +ray/rllib/algorithms/dqn/__pycache__/dqn_torch_policy.cpython-311.pyc,, +ray/rllib/algorithms/dqn/default_dqn_rl_module.py,sha256=R34A4N-Pv3xEjWgdsfna3B_f_ARecgQDUtpYBjUcUq8,7909 +ray/rllib/algorithms/dqn/distributional_q_tf_model.py,sha256=Ee6ZwtzBsCkcHnnD2inFn4rkGJ2NvnKxTbO0bEjnDWU,8019 +ray/rllib/algorithms/dqn/dqn.py,sha256=M94S-YQWKEU203YzVuMPPZb7OkyvsTii3zpZb-lbQbE,36624 +ray/rllib/algorithms/dqn/dqn_catalog.py,sha256=0cHF8UnxdzcDT_sAGQPBoN_GhC7YqdH7IhxDUqLP7Rg,7417 +ray/rllib/algorithms/dqn/dqn_learner.py,sha256=GmTAh7MIiIJuPY_ykRGpUGAuOPGSpRkGUnG-jI4bZeA,4655 +ray/rllib/algorithms/dqn/dqn_tf_policy.py,sha256=k6vRboksOU_7RR1pGS29b3aN2cF6UHClvHn3aPAH2Gg,17643 +ray/rllib/algorithms/dqn/dqn_torch_model.py,sha256=_923fc-RE-yufdAAvJWyjYCvrNKCLaX6CEd5bTneFEA,6863 +ray/rllib/algorithms/dqn/dqn_torch_policy.py,sha256=891e4IPWtqSsbWFwwztoYr9LXkcO_AnD5qYcgoV5WjA,17270 +ray/rllib/algorithms/dqn/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/algorithms/dqn/torch/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/dqn/torch/__pycache__/default_dqn_torch_rl_module.cpython-311.pyc,, +ray/rllib/algorithms/dqn/torch/__pycache__/dqn_torch_learner.cpython-311.pyc,, +ray/rllib/algorithms/dqn/torch/default_dqn_torch_rl_module.py,sha256=pb5nbOo5j6zO9F2fpsmAgzvmmdBcYR-j2WMe31n5k6Y,13845 +ray/rllib/algorithms/dqn/torch/dqn_torch_learner.py,sha256=rmE9sAQkemE854ORvzX0M2poNFfL9K9OtYeWV-CWlHU,12426 +ray/rllib/algorithms/dreamerv3/__init__.py,sha256=k6k1cCGIdnzCUkAJ85FKlvfZXh1S90XrQy2pdgEfE1A,420 +ray/rllib/algorithms/dreamerv3/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/__pycache__/dreamerv3.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/__pycache__/dreamerv3_catalog.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/__pycache__/dreamerv3_learner.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/__pycache__/dreamerv3_rl_module.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/dreamerv3.py,sha256=pv3F9uIOBttgH9l50HzWjKIYwlPedAHICv2EpW39VTQ,34513 +ray/rllib/algorithms/dreamerv3/dreamerv3_catalog.py,sha256=D4tMve_SYfXt1Y_ab1PFq6djzIeIXEAS_z7mD4SCWEs,2876 +ray/rllib/algorithms/dreamerv3/dreamerv3_learner.py,sha256=iDJWts4gxSF6wsgRmWVUp6poSZ-bK-7rYfsjLb1_lOM,1039 +ray/rllib/algorithms/dreamerv3/dreamerv3_rl_module.py,sha256=IfVx4aDPQUvrhYhXHJJv29KDvLO1rJp5qL4o7aIkOic,5848 +ray/rllib/algorithms/dreamerv3/tf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/algorithms/dreamerv3/tf/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/__pycache__/dreamerv3_tf_learner.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/__pycache__/dreamerv3_tf_rl_module.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/dreamerv3_tf_learner.py,sha256=TPeOPgNd6fSNvkxn2PJjVWs7NhW3FCG7W_e5v72Zvm8,39026 +ray/rllib/algorithms/dreamerv3/tf/dreamerv3_tf_rl_module.py,sha256=BVfcHffX5YuzZ88b529NnAzJYo1k_v_94lQhrsBkVEU,745 +ray/rllib/algorithms/dreamerv3/tf/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/algorithms/dreamerv3/tf/models/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/models/__pycache__/actor_network.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/models/__pycache__/critic_network.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/models/__pycache__/disagree_networks.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/models/__pycache__/dreamer_model.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/models/__pycache__/world_model.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/models/actor_network.py,sha256=nJNu2cQG4yItQpX7liZeVqisci5cz2WJ4stOND4_ZAU,8093 +ray/rllib/algorithms/dreamerv3/tf/models/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/algorithms/dreamerv3/tf/models/components/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/models/components/__pycache__/cnn_atari.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/models/components/__pycache__/continue_predictor.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/models/components/__pycache__/conv_transpose_atari.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/models/components/__pycache__/dynamics_predictor.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/models/components/__pycache__/mlp.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/models/components/__pycache__/representation_layer.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/models/components/__pycache__/reward_predictor.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/models/components/__pycache__/reward_predictor_layer.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/models/components/__pycache__/sequence_model.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/models/components/__pycache__/vector_decoder.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/tf/models/components/cnn_atari.py,sha256=cjMbXaGkCgwBHaWMlw6rtvMzYyISLi4faO75d7U9OIE,4200 +ray/rllib/algorithms/dreamerv3/tf/models/components/continue_predictor.py,sha256=UUGsR1kPp6qjWJi8qXWAjm3i8SEutX_BOSJdolhZjMw,3581 +ray/rllib/algorithms/dreamerv3/tf/models/components/conv_transpose_atari.py,sha256=C4k3EkH-LfabYUwYwFSrz9C2dxiG4_C0FiyvDxlXsyc,7241 +ray/rllib/algorithms/dreamerv3/tf/models/components/dynamics_predictor.py,sha256=wNsgUh20w1W338H2T2zla3nRFe1DJe-aj-Lll_Z4vU4,3221 +ray/rllib/algorithms/dreamerv3/tf/models/components/mlp.py,sha256=mdZw22h0OOpO6X7P1AdTgaVDXZvlG8UCbnALUcP8OvM,3647 +ray/rllib/algorithms/dreamerv3/tf/models/components/representation_layer.py,sha256=xdmFQAZMiMT0cdPgCSaUalGQqkRaFyMFrKHyuXUO1JQ,5719 +ray/rllib/algorithms/dreamerv3/tf/models/components/reward_predictor.py,sha256=4CgHoq_YK8MAm7-RfIKaIsg-ANrfeeH2YH4oWlQQVkg,4163 +ray/rllib/algorithms/dreamerv3/tf/models/components/reward_predictor_layer.py,sha256=FVWymN-A6uMc2hOsgWiiiCT4fgR8aJRnkl_MeveIulg,4758 +ray/rllib/algorithms/dreamerv3/tf/models/components/sequence_model.py,sha256=B7_aj4LrZHa5ocAr0rqu-P3EmqwcRTcfl8d_FQ89lMs,5563 +ray/rllib/algorithms/dreamerv3/tf/models/components/vector_decoder.py,sha256=pIz4swAMpt9f4GOLLhpTkKDW5-8qkwgzM1sA98Rj_vc,3188 +ray/rllib/algorithms/dreamerv3/tf/models/critic_network.py,sha256=_Hvk1QChqS3-0EeZcje3WwYgkAinlEFKGwtG_O59CoE,7375 +ray/rllib/algorithms/dreamerv3/tf/models/disagree_networks.py,sha256=IrSUweL0oWCP8Iu5NWFse3osnOMxqso4Uf0kQ2wirTo,3600 +ray/rllib/algorithms/dreamerv3/tf/models/dreamer_model.py,sha256=0Z6W4Wi6sbIlH0rQm9EdfSLz9ulUnubHrEJb0xsjZcc,25634 +ray/rllib/algorithms/dreamerv3/tf/models/world_model.py,sha256=OorBwPd4aInBSya42hBX916TT6oIBopKGf4VZ1BZ9jo,18674 +ray/rllib/algorithms/dreamerv3/utils/__init__.py,sha256=Xk4WbtFriNYnQDYpcl3M84NBuq0jribHjdo0lcV4cVU,3574 +ray/rllib/algorithms/dreamerv3/utils/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/utils/__pycache__/debugging.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/utils/__pycache__/env_runner.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/utils/__pycache__/summaries.cpython-311.pyc,, +ray/rllib/algorithms/dreamerv3/utils/debugging.py,sha256=HXC73X19luToR24CpAU4S16PGeBE1oYuALMUzHHb3VM,5967 +ray/rllib/algorithms/dreamerv3/utils/env_runner.py,sha256=XOwhf3d2Q0eHs0SeNmX_EokJydNk14ipMgk0WjkI894,28179 +ray/rllib/algorithms/dreamerv3/utils/summaries.py,sha256=I6DE7hRfCFxnY49kjpMzH1h76jrQM--uLduzVMiDwGA,14773 +ray/rllib/algorithms/impala/__init__.py,sha256=rs17erk_qm_EWlF61uL1hAgWQcEUvzzPhffevJW0q8U,500 +ray/rllib/algorithms/impala/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/impala/__pycache__/impala.cpython-311.pyc,, +ray/rllib/algorithms/impala/__pycache__/impala_learner.cpython-311.pyc,, +ray/rllib/algorithms/impala/__pycache__/impala_tf_policy.cpython-311.pyc,, +ray/rllib/algorithms/impala/__pycache__/impala_torch_policy.cpython-311.pyc,, +ray/rllib/algorithms/impala/__pycache__/utils.cpython-311.pyc,, +ray/rllib/algorithms/impala/__pycache__/vtrace_tf.cpython-311.pyc,, +ray/rllib/algorithms/impala/__pycache__/vtrace_torch.cpython-311.pyc,, +ray/rllib/algorithms/impala/impala.py,sha256=mCdxXZX-IoocvId_We5aEirHMtDgIu0pk4KBxiy0QzM,59049 +ray/rllib/algorithms/impala/impala_learner.py,sha256=kuCMhvZY74Wxq3nd9Hxoq9IFWKheDoD_xA_8hEw6jnQ,8205 +ray/rllib/algorithms/impala/impala_tf_policy.py,sha256=afuuzdmybfZlxZGWBPoRAtXT27KxPjuCJ5ZkRbtxe_Y,17557 +ray/rllib/algorithms/impala/impala_torch_policy.py,sha256=AllTdeSnM6iewq_0G9FjUR8ch8Q4_EySReOZKqOVeuc,16339 +ray/rllib/algorithms/impala/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/algorithms/impala/torch/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/impala/torch/__pycache__/impala_torch_learner.cpython-311.pyc,, +ray/rllib/algorithms/impala/torch/__pycache__/vtrace_torch_v2.cpython-311.pyc,, +ray/rllib/algorithms/impala/torch/impala_torch_learner.py,sha256=jDceuLIvGmcVe3FLLagEtNwBaQRnwAPiKaWOyMgmJu8,6534 +ray/rllib/algorithms/impala/torch/vtrace_torch_v2.py,sha256=TAkAQZ1z0__KgxVhCX8_KpaPLNPl4oSAkd5D49qfSCY,6808 +ray/rllib/algorithms/impala/utils.py,sha256=D5-KOiw5o2e4yNO0u07jmgL1Df-9jnIONtNb9HEDqGs,3216 +ray/rllib/algorithms/impala/vtrace_tf.py,sha256=5Pf02sazw11lsQOx1Bw44qOlOnh7mKkT9qySO3u3NTw,16182 +ray/rllib/algorithms/impala/vtrace_torch.py,sha256=UhGszIEBNTFt1oFVoTfY7NtmqQQTIS5TecgDM9O5itQ,14496 +ray/rllib/algorithms/marwil/__init__.py,sha256=KosRDwnLVcvYDUpxC0x6gzZyz-renwL6XNHFlIlK2hI,401 +ray/rllib/algorithms/marwil/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/marwil/__pycache__/marwil.cpython-311.pyc,, +ray/rllib/algorithms/marwil/__pycache__/marwil_learner.cpython-311.pyc,, +ray/rllib/algorithms/marwil/__pycache__/marwil_tf_policy.cpython-311.pyc,, +ray/rllib/algorithms/marwil/__pycache__/marwil_torch_policy.cpython-311.pyc,, +ray/rllib/algorithms/marwil/marwil.py,sha256=qCPz8tF20MVFTOeyAevGcKop-KvvsuCUNlrANFUGI2I,21054 +ray/rllib/algorithms/marwil/marwil_learner.py,sha256=l3kF1AhZ30SobBjt4LByYC7Q2zOk2qbwg5ZmsDjrUSg,1806 +ray/rllib/algorithms/marwil/marwil_tf_policy.py,sha256=UjcHq4jp2DgOCyYuQQlHmPwj2Bjng9Uk77QnoZ3ot7k,9211 +ray/rllib/algorithms/marwil/marwil_torch_policy.py,sha256=W7xJmMUyuSyBTgPDtLT_f1VgZjD-c88G2CVY8HtMlnU,5350 +ray/rllib/algorithms/marwil/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/algorithms/marwil/torch/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/marwil/torch/__pycache__/marwil_torch_learner.cpython-311.pyc,, +ray/rllib/algorithms/marwil/torch/marwil_torch_learner.py,sha256=hA065trq-ou3XGvigEIv-toQPxAc5RLxNG_NGCvUtHo,5588 +ray/rllib/algorithms/mock.py,sha256=_rs7xnFrg2z55XPWVheWBBw-zw5P27zheC9oa3J3Lic,4429 +ray/rllib/algorithms/ppo/__init__.py,sha256=aP-yMF-eq0mpT-USl525ysm84c81DpSpu-UtSwrCz-A,327 +ray/rllib/algorithms/ppo/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/ppo/__pycache__/default_ppo_rl_module.cpython-311.pyc,, +ray/rllib/algorithms/ppo/__pycache__/ppo.cpython-311.pyc,, +ray/rllib/algorithms/ppo/__pycache__/ppo_catalog.cpython-311.pyc,, +ray/rllib/algorithms/ppo/__pycache__/ppo_learner.cpython-311.pyc,, +ray/rllib/algorithms/ppo/__pycache__/ppo_rl_module.cpython-311.pyc,, +ray/rllib/algorithms/ppo/__pycache__/ppo_tf_policy.cpython-311.pyc,, +ray/rllib/algorithms/ppo/__pycache__/ppo_torch_policy.cpython-311.pyc,, +ray/rllib/algorithms/ppo/default_ppo_rl_module.py,sha256=Dp1_zpMB7ndl4G13Z6aRGJXIMVOPXvl5v5vnZETYgIU,2543 +ray/rllib/algorithms/ppo/ppo.py,sha256=ypbhYl-XZo0JD7QGpEGfcashiXHsWMnpCzg0oFR6E3M,23671 +ray/rllib/algorithms/ppo/ppo_catalog.py,sha256=fgrczvbN6RT8XNZVRc42VwV36aDc1PGLBBhQHq_KXPo,8192 +ray/rllib/algorithms/ppo/ppo_learner.py,sha256=Ua3qEZ0OznnJ12OOBQNOgwPztdAQ3yY0MNv7oKm5eUA,5779 +ray/rllib/algorithms/ppo/ppo_rl_module.py,sha256=YmTaPVwWt5Ak7st4UhhvLJeF53wID5f_qZCY0oB4XL0,376 +ray/rllib/algorithms/ppo/ppo_tf_policy.py,sha256=KvvGAB2r1eMoMCWcgqAS6pb8lJoKPT18ZAlXhiDgt_g,8775 +ray/rllib/algorithms/ppo/ppo_torch_policy.py,sha256=nRKzIgsUXAQiP4V64JuyXyDcEF5yESSs5EHocCv_JzA,7784 +ray/rllib/algorithms/ppo/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/algorithms/ppo/torch/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/ppo/torch/__pycache__/default_ppo_torch_rl_module.cpython-311.pyc,, +ray/rllib/algorithms/ppo/torch/__pycache__/ppo_torch_learner.cpython-311.pyc,, +ray/rllib/algorithms/ppo/torch/__pycache__/ppo_torch_rl_module.cpython-311.pyc,, +ray/rllib/algorithms/ppo/torch/default_ppo_torch_rl_module.py,sha256=fb0t_Ve96y15Tgqpe4DcKWEk_qZjxRb9TY5BxrW27XY,3126 +ray/rllib/algorithms/ppo/torch/ppo_torch_learner.py,sha256=k0ewPSE9qhVy6RNyy63MqHpogUE6rYeRkGW-BEGPR4o,6745 +ray/rllib/algorithms/ppo/torch/ppo_torch_rl_module.py,sha256=Qkmq3Ya9JJ4LWw23TJopzGJyEl74wEP3ihCWSdJJ2bU,440 +ray/rllib/algorithms/registry.py,sha256=_p88Ubft-50V2FFnTGlSjpF3zp3dzSFiEpHi19aVYm0,4839 +ray/rllib/algorithms/sac/__init__.py,sha256=sMmd9l6UmU6OCWgIFS6RHUdHfs_x4zHPDAL-4H5glBo,272 +ray/rllib/algorithms/sac/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/sac/__pycache__/default_sac_rl_module.cpython-311.pyc,, +ray/rllib/algorithms/sac/__pycache__/sac.cpython-311.pyc,, +ray/rllib/algorithms/sac/__pycache__/sac_catalog.cpython-311.pyc,, +ray/rllib/algorithms/sac/__pycache__/sac_learner.cpython-311.pyc,, +ray/rllib/algorithms/sac/__pycache__/sac_tf_model.cpython-311.pyc,, +ray/rllib/algorithms/sac/__pycache__/sac_tf_policy.cpython-311.pyc,, +ray/rllib/algorithms/sac/__pycache__/sac_torch_model.cpython-311.pyc,, +ray/rllib/algorithms/sac/__pycache__/sac_torch_policy.cpython-311.pyc,, +ray/rllib/algorithms/sac/default_sac_rl_module.py,sha256=TRHIHTmQEMpqyDVIv3yPDKZog41xyMLUGiCPrdu8D1w,6354 +ray/rllib/algorithms/sac/sac.py,sha256=o9kTtO78ZjF6Vo2sjbSs7nz-4f76FbI5WycNZ0dpQ-M,27677 +ray/rllib/algorithms/sac/sac_catalog.py,sha256=juiYK_1zYmzqT6fQxUDElQEr0JB_I6aTSWIwlTROOzY,8764 +ray/rllib/algorithms/sac/sac_learner.py,sha256=b8vRCCkbbysr_4grnGOfMJzBo52FDFUYcCnMseNcmO4,2784 +ray/rllib/algorithms/sac/sac_tf_model.py,sha256=M2mukfN-_UKMFkAXxmrUZlTGPfckez-MatKN66xHGdE,12618 +ray/rllib/algorithms/sac/sac_tf_policy.py,sha256=EBzpvFP02APYNHfE6YIaoUQvD38WpA2nC2BuBWhcPnY,30631 +ray/rllib/algorithms/sac/sac_torch_model.py,sha256=-dKPKxbYP8SO1jbij7zm_mZN69N4YBybzzS9pXW-ZRw,13076 +ray/rllib/algorithms/sac/sac_torch_policy.py,sha256=LjJrT4J5CrkvDNHL86rvprNpkC-vDBuNOPed3ZQzKfs,20130 +ray/rllib/algorithms/sac/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/algorithms/sac/torch/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/algorithms/sac/torch/__pycache__/default_sac_torch_rl_module.cpython-311.pyc,, +ray/rllib/algorithms/sac/torch/__pycache__/sac_torch_learner.cpython-311.pyc,, +ray/rllib/algorithms/sac/torch/default_sac_torch_rl_module.py,sha256=7N9aCEUXRru8a_MEpqjka4Gk6MVM4ElEGGN4jgMxKJI,8145 +ray/rllib/algorithms/sac/torch/sac_torch_learner.py,sha256=Ah2J0gwJuitkijzrstx9oFyfe5j8ltKUp3yFM0tWEx0,10538 +ray/rllib/algorithms/utils.py,sha256=dTYRSs3JolZlK4lY7sBVshRZ7zt32oZhNIy57Ycy1nk,4714 +ray/rllib/callbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/callbacks/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/callbacks/__pycache__/callbacks.cpython-311.pyc,, +ray/rllib/callbacks/__pycache__/utils.cpython-311.pyc,, +ray/rllib/callbacks/callbacks.py,sha256=UDq9oXjN13H7JdpXiNTs3hkpbL_5ODItbXPWW6u44dg,26425 +ray/rllib/callbacks/utils.py,sha256=OMiw2e-MpYLcNPqAwqM3HCTlAzSBPpo3iUjnolTJ9Zk,5331 +ray/rllib/connectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/connectors/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/connectors/__pycache__/connector.cpython-311.pyc,, +ray/rllib/connectors/__pycache__/connector_pipeline_v2.cpython-311.pyc,, +ray/rllib/connectors/__pycache__/connector_v2.cpython-311.pyc,, +ray/rllib/connectors/__pycache__/registry.cpython-311.pyc,, +ray/rllib/connectors/__pycache__/util.cpython-311.pyc,, +ray/rllib/connectors/action/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/connectors/action/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/connectors/action/__pycache__/clip.cpython-311.pyc,, +ray/rllib/connectors/action/__pycache__/immutable.cpython-311.pyc,, +ray/rllib/connectors/action/__pycache__/lambdas.cpython-311.pyc,, +ray/rllib/connectors/action/__pycache__/normalize.cpython-311.pyc,, +ray/rllib/connectors/action/__pycache__/pipeline.cpython-311.pyc,, +ray/rllib/connectors/action/clip.py,sha256=vMT1ESU3RVoralGkjjGDokZG4h3ZjWP5f6MGA3avP34,1339 +ray/rllib/connectors/action/immutable.py,sha256=E_daSYJAsn9AbnO3aBOoJHnt7A1udZwrqZprEJcPV1c,1240 +ray/rllib/connectors/action/lambdas.py,sha256=YAzYvniDV_k1fas-owHXfEHAZITDMX5y3GomAkZG9wk,2317 +ray/rllib/connectors/action/normalize.py,sha256=JjUBuF5L5NFLvw5DKH5RHERKnZysDkLOPd3aPZeC_4o,1385 +ray/rllib/connectors/action/pipeline.py,sha256=xP1ZE2f_ROhHDaiyWc7CQkuXPI92Qo1FHTHYSJ1BfD8,2087 +ray/rllib/connectors/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/connectors/agent/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/connectors/agent/__pycache__/clip_reward.cpython-311.pyc,, +ray/rllib/connectors/agent/__pycache__/env_sampling.cpython-311.pyc,, +ray/rllib/connectors/agent/__pycache__/lambdas.cpython-311.pyc,, +ray/rllib/connectors/agent/__pycache__/mean_std_filter.cpython-311.pyc,, +ray/rllib/connectors/agent/__pycache__/obs_preproc.cpython-311.pyc,, +ray/rllib/connectors/agent/__pycache__/pipeline.cpython-311.pyc,, +ray/rllib/connectors/agent/__pycache__/state_buffer.cpython-311.pyc,, +ray/rllib/connectors/agent/__pycache__/synced_filter.cpython-311.pyc,, +ray/rllib/connectors/agent/__pycache__/view_requirement.cpython-311.pyc,, +ray/rllib/connectors/agent/clip_reward.py,sha256=MZLk27kVOpYWMQPpwttswX93-HAYFTqxSywGQl1nJCY,1723 +ray/rllib/connectors/agent/env_sampling.py,sha256=HCBFf-2lMQkeLWlGIxUN8eFKiBGxu9q3rs_8QPBuvDs,964 +ray/rllib/connectors/agent/lambdas.py,sha256=YvdIroPGqDReJnR67LFnqagqFIOiHdGPcLD0JL3jpgg,2607 +ray/rllib/connectors/agent/mean_std_filter.py,sha256=G6AtB9hofMrweNsnqlxwjYIan1l3YiwEi8dJBogEgUo,6994 +ray/rllib/connectors/agent/obs_preproc.py,sha256=fL7fD5p2FYQ_mrt74Wc13Di9yairsUig3CpGOX6upwU,2520 +ray/rllib/connectors/agent/pipeline.py,sha256=6Lngx6Y44__L2ZixNfM9WKOTv8RuiwHaqexnwxN2MIg,2381 +ray/rllib/connectors/agent/state_buffer.py,sha256=Md9Pavr-Z7YBy0mhAftZF9KV3_TdstAExgT2oiUyuG0,4401 +ray/rllib/connectors/agent/synced_filter.py,sha256=QKnxWF5dGQ8e0YyLXc-oYuzhcbCVfO6iHAvOz1VdMJg,1938 +ray/rllib/connectors/agent/view_requirement.py,sha256=PZ-Lmetzi4HZJFGtfYtJFkKbImb1BqNtRY6CY8NYbWk,5288 +ray/rllib/connectors/common/__init__.py,sha256=C9qPcw3n1uyUwAgTO6f6OLWQVQ0iPJhNx3OC41GuSvk,793 +ray/rllib/connectors/common/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/connectors/common/__pycache__/add_observations_from_episodes_to_batch.cpython-311.pyc,, +ray/rllib/connectors/common/__pycache__/add_states_from_episodes_to_batch.cpython-311.pyc,, +ray/rllib/connectors/common/__pycache__/add_time_dim_to_batch_and_zero_pad.cpython-311.pyc,, +ray/rllib/connectors/common/__pycache__/agent_to_module_mapping.cpython-311.pyc,, +ray/rllib/connectors/common/__pycache__/batch_individual_items.cpython-311.pyc,, +ray/rllib/connectors/common/__pycache__/frame_stacking.cpython-311.pyc,, +ray/rllib/connectors/common/__pycache__/module_to_agent_unmapping.cpython-311.pyc,, +ray/rllib/connectors/common/__pycache__/numpy_to_tensor.cpython-311.pyc,, +ray/rllib/connectors/common/__pycache__/tensor_to_numpy.cpython-311.pyc,, +ray/rllib/connectors/common/add_observations_from_episodes_to_batch.py,sha256=lylqu1ssGsEsmQ6E2BYfH0MxEIqpxxpfbilTX2OmY78,7027 +ray/rllib/connectors/common/add_states_from_episodes_to_batch.py,sha256=roszxKXEbFhURhS7nhe4_mJVdioDhzLxVWIapI0mI_8,14509 +ray/rllib/connectors/common/add_time_dim_to_batch_and_zero_pad.py,sha256=GExDg9usP3OfhQwbiTO3LKfmkTTlLV6_7rbPMd6tEeY,12294 +ray/rllib/connectors/common/agent_to_module_mapping.py,sha256=yw6G2UBglf7JxDmwVjtTO9MrK_CXaFr7PnsTqwbhBCg,12048 +ray/rllib/connectors/common/batch_individual_items.py,sha256=fm2pRVb0wO75dDjEYTSuTnsoMFKTj9y6dX3PcUKnYdc,8197 +ray/rllib/connectors/common/frame_stacking.py,sha256=PxcLpEzHEBd34j4jnudBFw4bq080GwHUs7ENuYW9l3A,5811 +ray/rllib/connectors/common/module_to_agent_unmapping.py,sha256=A7cWhhH9gyN4YENugL_6t1fgQ_ZBq_fWFjtromJPx18,1636 +ray/rllib/connectors/common/numpy_to_tensor.py,sha256=GsXoxraZyV9yx1oVKWXtQUNOSPabVbn1_x6z4t1UTTU,4718 +ray/rllib/connectors/common/tensor_to_numpy.py,sha256=3q0OGwkDp0bujobTa-4heEYmJTWZOWYf9VyfTJ4kuVc,826 +ray/rllib/connectors/connector.py,sha256=cubaqR_Tnu5oQZxKEMrEYey5OeqvIxNISEMepB3-2SY,16045 +ray/rllib/connectors/connector_pipeline_v2.py,sha256=MIOkuYFhNQR_TgcQDtSQy9LYjTjhH7kz4o3F8c4OoxM,14858 +ray/rllib/connectors/connector_v2.py,sha256=fwIR7jhnSOVf6UTeWD4hCSyg_ntsx9DOaCmfN8ovLhE,45903 +ray/rllib/connectors/env_to_module/__init__.py,sha256=UNjL8ZsjkIAkblJTt0mcYoZAbErwp_qPQRl5Nr7lVjc,1426 +ray/rllib/connectors/env_to_module/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/connectors/env_to_module/__pycache__/env_to_module_pipeline.cpython-311.pyc,, +ray/rllib/connectors/env_to_module/__pycache__/flatten_observations.cpython-311.pyc,, +ray/rllib/connectors/env_to_module/__pycache__/frame_stacking.cpython-311.pyc,, +ray/rllib/connectors/env_to_module/__pycache__/mean_std_filter.cpython-311.pyc,, +ray/rllib/connectors/env_to_module/__pycache__/observation_preprocessor.cpython-311.pyc,, +ray/rllib/connectors/env_to_module/__pycache__/prev_actions_prev_rewards.cpython-311.pyc,, +ray/rllib/connectors/env_to_module/__pycache__/write_observations_to_episodes.cpython-311.pyc,, +ray/rllib/connectors/env_to_module/env_to_module_pipeline.py,sha256=5c-JWYyRej1N-NThkPgrxU-eq0cVUzsyO3eWi0McY54,1844 +ray/rllib/connectors/env_to_module/flatten_observations.py,sha256=9ucqHTmER3guFUj4_R34KnR-KPf7FlKRM3LksDCCo4E,8353 +ray/rllib/connectors/env_to_module/frame_stacking.py,sha256=I3Wxn2huQqfdm7uXxMyqCF-S70-6dgA-ioh26QzLBco,182 +ray/rllib/connectors/env_to_module/mean_std_filter.py,sha256=rVWCPs_f4uLJyp597bL6sMtYr1BPoPotBGVwnRoUEOs,10297 +ray/rllib/connectors/env_to_module/observation_preprocessor.py,sha256=a8Keoni--30v042c0Bg6zV6kHQUqZVlWBO3qhSVeQqA,3205 +ray/rllib/connectors/env_to_module/prev_actions_prev_rewards.py,sha256=OO4GG3ow1_jdPL1A72sMN4K0DaEynPp8-OUCnKQY7aw,6813 +ray/rllib/connectors/env_to_module/write_observations_to_episodes.py,sha256=5ul-8hjJXWJndOqTscoRAzCcsE_ideYFhh3m3uy1PAw,5510 +ray/rllib/connectors/learner/__init__.py,sha256=83Hfb9L4e7RcxUIVpgiAWxITWZh4U8Hum9MgFdBaHLk,1699 +ray/rllib/connectors/learner/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/connectors/learner/__pycache__/add_columns_from_episodes_to_train_batch.cpython-311.pyc,, +ray/rllib/connectors/learner/__pycache__/add_next_observations_from_episodes_to_train_batch.cpython-311.pyc,, +ray/rllib/connectors/learner/__pycache__/add_one_ts_to_episodes_and_truncate.cpython-311.pyc,, +ray/rllib/connectors/learner/__pycache__/compute_returns_to_go.cpython-311.pyc,, +ray/rllib/connectors/learner/__pycache__/frame_stacking.cpython-311.pyc,, +ray/rllib/connectors/learner/__pycache__/general_advantage_estimation.cpython-311.pyc,, +ray/rllib/connectors/learner/__pycache__/learner_connector_pipeline.cpython-311.pyc,, +ray/rllib/connectors/learner/add_columns_from_episodes_to_train_batch.py,sha256=TZC7V7AGlzj36sS8L4BA1dzCS7PqLqL7Z4UKlUYMEuQ,6757 +ray/rllib/connectors/learner/add_next_observations_from_episodes_to_train_batch.py,sha256=myjzVVxg0XQjokdYm-a51ZJRl9ABULVoEAG_CZO1D1I,3880 +ray/rllib/connectors/learner/add_one_ts_to_episodes_and_truncate.py,sha256=nJ4u4dmILqgSgN29QuiaPWJgEYdPR01vPmP--5K779Y,6858 +ray/rllib/connectors/learner/compute_returns_to_go.py,sha256=3FtYAKge8ziEZdcMFFKKb7RMlPpyEoLiflDaZcm86xM,2337 +ray/rllib/connectors/learner/frame_stacking.py,sha256=-mjCOGzXP0nixrQ_3n6OjzhoEB-SQhpUbwj1xcN0SPY,177 +ray/rllib/connectors/learner/general_advantage_estimation.py,sha256=ue8dSPQVidBzIRyslJhkRnAO0C8ZyEAwG_e33MAF8D4,8785 +ray/rllib/connectors/learner/learner_connector_pipeline.py,sha256=wksgG4HsnkfiViP0Rt11z8Djcxbee--3Kw5bwM-M8Bw,1966 +ray/rllib/connectors/module_to_env/__init__.py,sha256=j9kJP17KnZsqxSrFY0AzYpCesY92_YkSxu0Qh_6Sj6U,1023 +ray/rllib/connectors/module_to_env/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/connectors/module_to_env/__pycache__/get_actions.cpython-311.pyc,, +ray/rllib/connectors/module_to_env/__pycache__/listify_data_for_vector_env.cpython-311.pyc,, +ray/rllib/connectors/module_to_env/__pycache__/module_to_env_pipeline.cpython-311.pyc,, +ray/rllib/connectors/module_to_env/__pycache__/normalize_and_clip_actions.cpython-311.pyc,, +ray/rllib/connectors/module_to_env/__pycache__/remove_single_ts_time_rank_from_batch.cpython-311.pyc,, +ray/rllib/connectors/module_to_env/__pycache__/unbatch_to_individual_items.cpython-311.pyc,, +ray/rllib/connectors/module_to_env/get_actions.py,sha256=OWntRZ2w-cHAsrrA9KdXJ5xqllTCZUvLKssJ4cn9jZ8,3493 +ray/rllib/connectors/module_to_env/listify_data_for_vector_env.py,sha256=lnNhtt8C4bpDoJtTuLjyb-clya5E6CV4I4oBrGRvZGM,2935 +ray/rllib/connectors/module_to_env/module_to_env_pipeline.py,sha256=nWuf4DqMm9aqG5yokvcieC5m4zMMyTL6pKi-d--pooM,207 +ray/rllib/connectors/module_to_env/normalize_and_clip_actions.py,sha256=zYlvwtaJBdwVLyP7fst1FqLd8IjESCtmAgi7g2eYSng,5983 +ray/rllib/connectors/module_to_env/remove_single_ts_time_rank_from_batch.py,sha256=ybWcFdw7oZXE1Xe8-S9P0MYB593lQupqheySmarSc6w,2294 +ray/rllib/connectors/module_to_env/unbatch_to_individual_items.py,sha256=bQNB-j9RsKw7OyFsibYTNssuZzDw1AxLhunF_aJkF9g,3883 +ray/rllib/connectors/registry.py,sha256=oMjPCSSkW_lluhD0ibbgmbX1enQkN_d-o2tRmhwC1Pg,1331 +ray/rllib/connectors/util.py,sha256=Cpje0lKZT9j_mqQnBIj1Y6xLwTxYk7y2l-0m-59xd4c,6196 +ray/rllib/core/__init__.py,sha256=GMqqaw6sOlUCfQr1b-Nj2pImHADWrjYMVNHTLuJh400,1015 +ray/rllib/core/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/core/__pycache__/columns.cpython-311.pyc,, +ray/rllib/core/columns.py,sha256=8NatwbdDuECeq4WtTkUJnHrxFRE8ZjerRQSRrTPG8FU,2560 +ray/rllib/core/learner/__init__.py,sha256=aOEprGW3n-U3bk6794bska7jwH7MnfecHuhjKCR2DFw,164 +ray/rllib/core/learner/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/core/learner/__pycache__/learner.cpython-311.pyc,, +ray/rllib/core/learner/__pycache__/learner_group.cpython-311.pyc,, +ray/rllib/core/learner/__pycache__/utils.cpython-311.pyc,, +ray/rllib/core/learner/learner.py,sha256=0stJluX2Zyikw5Bgf3vUHnAYdZW3A7Ni9iaq45JNq48,75928 +ray/rllib/core/learner/learner_group.py,sha256=ZUXatPEsJZuXZHsVrZowWG9NTodVl1KQmgiB9rtPsOU,44542 +ray/rllib/core/learner/tf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/core/learner/tf/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/core/learner/tf/__pycache__/tf_learner.cpython-311.pyc,, +ray/rllib/core/learner/tf/tf_learner.py,sha256=IZuUqvpN2ED6qNDF5nAIlZcM9XSk-HpvpMHdV9P0Uqw,13518 +ray/rllib/core/learner/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/core/learner/torch/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/core/learner/torch/__pycache__/torch_learner.cpython-311.pyc,, +ray/rllib/core/learner/torch/torch_learner.py,sha256=wpOT2HlgTbDLduZp8hLTNA_xGHSgPFGHVTDGnwmonik,27509 +ray/rllib/core/learner/utils.py,sha256=882vaxwzLtA1ku68vJM3hoDDCYkGN20ELS8lpgfOFsU,1926 +ray/rllib/core/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/core/models/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/core/models/__pycache__/base.cpython-311.pyc,, +ray/rllib/core/models/__pycache__/catalog.cpython-311.pyc,, +ray/rllib/core/models/__pycache__/configs.cpython-311.pyc,, +ray/rllib/core/models/base.py,sha256=Lp6Sg-gpKiN9GnxMWX5AGilrJJhqL1WPjau5QDJvYxY,15709 +ray/rllib/core/models/catalog.py,sha256=qgujdJNOMBHIGCWOkBgaYGNw3DTjZtCtIeltAEaZkMQ,28024 +ray/rllib/core/models/configs.py,sha256=Mxf85teE7xWhVdhIgmA2WvDLi5qJ5Z5HwfzTewfZB3g,45378 +ray/rllib/core/models/specs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/core/models/specs/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/core/models/specs/__pycache__/specs_base.cpython-311.pyc,, +ray/rllib/core/models/specs/__pycache__/specs_dict.cpython-311.pyc,, +ray/rllib/core/models/specs/__pycache__/typing.cpython-311.pyc,, +ray/rllib/core/models/specs/specs_base.py,sha256=NLzYN1MRF5SCtUcflAY9FqrmjhhdWEYK542CxsbLlzA,7725 +ray/rllib/core/models/specs/specs_dict.py,sha256=AjuXd9hoE692rFe3bjrMjAxFsY_n6ZQRB3_tzt7O2EU,2703 +ray/rllib/core/models/specs/typing.py,sha256=I7BEFgZ5ug7ROr290g_USsdsvu_P8HtkiWtYwXYqUOY,328 +ray/rllib/core/models/tf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/core/models/tf/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/core/models/tf/__pycache__/base.cpython-311.pyc,, +ray/rllib/core/models/tf/__pycache__/encoder.cpython-311.pyc,, +ray/rllib/core/models/tf/__pycache__/heads.cpython-311.pyc,, +ray/rllib/core/models/tf/__pycache__/primitives.cpython-311.pyc,, +ray/rllib/core/models/tf/base.py,sha256=7SIpUBYX4tLG_Hc4RCD6K5EZz1dCbPsw85furYxB29k,1753 +ray/rllib/core/models/tf/encoder.py,sha256=WXOqmIB7igse1Tg95hL61V7VXBqR26CXwT-edwmHs7Y,11904 +ray/rllib/core/models/tf/heads.py,sha256=H7NXGOODxd5rnktMT_ALxvplxD6lzoJBe-kWVGMzx4Y,8861 +ray/rllib/core/models/tf/primitives.py,sha256=GIQ_VVE7uORJQb_lofeB5ejCUN-TsE6EwkjkT3ziBLc,21506 +ray/rllib/core/models/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/core/models/torch/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/core/models/torch/__pycache__/base.cpython-311.pyc,, +ray/rllib/core/models/torch/__pycache__/encoder.cpython-311.pyc,, +ray/rllib/core/models/torch/__pycache__/heads.cpython-311.pyc,, +ray/rllib/core/models/torch/__pycache__/primitives.cpython-311.pyc,, +ray/rllib/core/models/torch/__pycache__/utils.cpython-311.pyc,, +ray/rllib/core/models/torch/base.py,sha256=t92hAmjOdIwsz9O1AVJNAeCDgRq7siN9YDlYtbFsWbk,3174 +ray/rllib/core/models/torch/encoder.py,sha256=1rSYGiCPRl0FyGDTMw53poMH5MgzAqeUdZ0CeLw7YFU,10125 +ray/rllib/core/models/torch/heads.py,sha256=NnlQ4eY5zgWpIbKYmz3MKXGNzAeC2Wzyx2c8h_DvyNQ,8905 +ray/rllib/core/models/torch/primitives.py,sha256=SnvGdzNwl-u9wzs3FsmeXT5E47T-JlBM-LS-XLFe5xM,23293 +ray/rllib/core/models/torch/utils.py,sha256=DgVUlmSoFImdyFcIHTeYNLIoRXbWrDEJyxjCCIF2Bio,2945 +ray/rllib/core/rl_module/__init__.py,sha256=WfMwVR7XUpxMEzX1qawD0OveNhzCHD5KvcPquD-uTPg,1622 +ray/rllib/core/rl_module/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/core/rl_module/__pycache__/default_model_config.cpython-311.pyc,, +ray/rllib/core/rl_module/__pycache__/multi_rl_module.cpython-311.pyc,, +ray/rllib/core/rl_module/__pycache__/rl_module.cpython-311.pyc,, +ray/rllib/core/rl_module/apis/__init__.py,sha256=mMxKIicmVhC3wpllmOZQfNhcUSRR1Eh1-I--44w7y20,604 +ray/rllib/core/rl_module/apis/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/core/rl_module/apis/__pycache__/inference_only_api.cpython-311.pyc,, +ray/rllib/core/rl_module/apis/__pycache__/q_net_api.cpython-311.pyc,, +ray/rllib/core/rl_module/apis/__pycache__/self_supervised_loss_api.cpython-311.pyc,, +ray/rllib/core/rl_module/apis/__pycache__/target_network_api.cpython-311.pyc,, +ray/rllib/core/rl_module/apis/__pycache__/value_function_api.cpython-311.pyc,, +ray/rllib/core/rl_module/apis/inference_only_api.py,sha256=W-6EGdeinNHF2gCCzvDtN5AUTsIROEF77yMG3msDAyI,2654 +ray/rllib/core/rl_module/apis/q_net_api.py,sha256=-oSCciHQFLl5XTU0b4tQnZ7QuGw7jaf7KoFBcTVL7Nc,2045 +ray/rllib/core/rl_module/apis/self_supervised_loss_api.py,sha256=o9RtXUqHG9PwWWDiH3ESxjCn1ezlyO3N_IFfgibDevY,2303 +ray/rllib/core/rl_module/apis/target_network_api.py,sha256=Ah3elsMOq9iHIW7rfPzUWjFqPxSRAJwtQ5eq0A-NkeE,2076 +ray/rllib/core/rl_module/apis/value_function_api.py,sha256=uEPU8bY3LpCs_YTM9KypthGi14Ab354cxrHJiBLEUSE,1286 +ray/rllib/core/rl_module/default_model_config.py,sha256=NbB8DKxNaq0l8oO1dLOWY22N0te1rS0dVvSA57p1c9A,11231 +ray/rllib/core/rl_module/multi_rl_module.py,sha256=1vVGwH7pl4riC4tOtkPpSv8LwgZJqiXRnwJzCmpnFPA,33880 +ray/rllib/core/rl_module/rl_module.py,sha256=glUPaNSUhIVamnAV4sbUoINSmdN7RVSTtdg2NVR0z08,32406 +ray/rllib/core/rl_module/tf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/core/rl_module/tf/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/core/rl_module/tf/__pycache__/tf_rl_module.cpython-311.pyc,, +ray/rllib/core/rl_module/tf/tf_rl_module.py,sha256=tnY91C-4W8508EZph9-UcIbN4aUhNYCDJ13-L0YfjSM,3217 +ray/rllib/core/rl_module/torch/__init__.py,sha256=F_S_bYNHu1gUzXdAZ-C8Yjy0uf57CawBuSWT30VOrbs,72 +ray/rllib/core/rl_module/torch/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/core/rl_module/torch/__pycache__/torch_compile_config.cpython-311.pyc,, +ray/rllib/core/rl_module/torch/__pycache__/torch_rl_module.cpython-311.pyc,, +ray/rllib/core/rl_module/torch/torch_compile_config.py,sha256=_QEt38oVKr9H3mNeY2HuPcMioGQIuwDCNKYu2A1iNPA,1601 +ray/rllib/core/rl_module/torch/torch_rl_module.py,sha256=1UJD3m6wHaVzDftVFpX3yVRGKcUYICKDx--DTWna4dA,12087 +ray/rllib/core/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/core/testing/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/core/testing/__pycache__/bc_algorithm.cpython-311.pyc,, +ray/rllib/core/testing/__pycache__/testing_learner.cpython-311.pyc,, +ray/rllib/core/testing/bc_algorithm.py,sha256=NflDHyJVY9JDrHGLeMzPFgw4kzm92-q3z4l_qN9xu70,1888 +ray/rllib/core/testing/testing_learner.py,sha256=iVigmDRTqM2VW6aF2NeZgYNHLf5tIZhM2vKRupxDFD0,2770 +ray/rllib/core/testing/tf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/core/testing/tf/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/core/testing/tf/__pycache__/bc_learner.cpython-311.pyc,, +ray/rllib/core/testing/tf/__pycache__/bc_module.cpython-311.pyc,, +ray/rllib/core/testing/tf/bc_learner.py,sha256=wBi6TkjEYk4C0D27AAOgcWOqHShUVuVos3Gr2B9DkOU,1147 +ray/rllib/core/testing/tf/bc_module.py,sha256=B6Bs1YorT4wUVvHct2i3Kl05ZT4TFaxngsyIC-hruaM,3640 +ray/rllib/core/testing/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/core/testing/torch/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/core/testing/torch/__pycache__/bc_learner.cpython-311.pyc,, +ray/rllib/core/testing/torch/__pycache__/bc_module.cpython-311.pyc,, +ray/rllib/core/testing/torch/bc_learner.py,sha256=oR7sMPYLXnvxdZuseDKdM90jb_tXe7nQmpTKVpV6zYk,1157 +ray/rllib/core/testing/torch/bc_module.py,sha256=WEVo4c1PZXcxLR0500T9FGH2UloIjuu32cuC93Z5wOE,5493 +ray/rllib/env/__init__.py,sha256=XyRFPgmcQoxz-ZPAQqA5-ZDJsbYc9bIRDiWLTKX1OYE,1254 +ray/rllib/env/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/env/__pycache__/base_env.cpython-311.pyc,, +ray/rllib/env/__pycache__/env_context.cpython-311.pyc,, +ray/rllib/env/__pycache__/env_runner.cpython-311.pyc,, +ray/rllib/env/__pycache__/env_runner_group.cpython-311.pyc,, +ray/rllib/env/__pycache__/external_env.cpython-311.pyc,, +ray/rllib/env/__pycache__/external_multi_agent_env.cpython-311.pyc,, +ray/rllib/env/__pycache__/multi_agent_env.cpython-311.pyc,, +ray/rllib/env/__pycache__/multi_agent_env_runner.cpython-311.pyc,, +ray/rllib/env/__pycache__/multi_agent_episode.cpython-311.pyc,, +ray/rllib/env/__pycache__/policy_client.cpython-311.pyc,, +ray/rllib/env/__pycache__/policy_server_input.cpython-311.pyc,, +ray/rllib/env/__pycache__/remote_base_env.cpython-311.pyc,, +ray/rllib/env/__pycache__/single_agent_env_runner.cpython-311.pyc,, +ray/rllib/env/__pycache__/single_agent_episode.cpython-311.pyc,, +ray/rllib/env/__pycache__/tcp_client_inference_env_runner.cpython-311.pyc,, +ray/rllib/env/__pycache__/vector_env.cpython-311.pyc,, +ray/rllib/env/base_env.py,sha256=HVugnKGyoGMV4IxIo_qgvePvhRyylkL4fqUtvOLEN3U,15998 +ray/rllib/env/env_context.py,sha256=7tdAWcY8b7QDSRtPaTR05z1THu23OLx5ST62b9BjRCs,5200 +ray/rllib/env/env_runner.py,sha256=vyMWHMPOXP-jDiwNofzbiKtag8Ibyu0mY5Ygv1axz4E,7271 +ray/rllib/env/env_runner_group.py,sha256=5n2PhhVX2b255qVGAypX7XsrCjPjI8f1mx10Vi8o6Ys,53406 +ray/rllib/env/external_env.py,sha256=4XPd8eK3YqNdYTVol1Ti4xoY5iRS9v_ASur5__7TNQc,17121 +ray/rllib/env/external_multi_agent_env.py,sha256=h9XDq5DLYpHd2iIr3oJp4s3CJTj7zrBMVVvmR9I4GhA,5486 +ray/rllib/env/multi_agent_env.py,sha256=sMRgNqW4GMDWkDdjiDv5w3_iKNk0vnj53x6bpXnunJc,30445 +ray/rllib/env/multi_agent_env_runner.py,sha256=9POJzww9voquCUp9YkHZHPMTIMKvfMdHU_9lFQpFmAc,44730 +ray/rllib/env/multi_agent_episode.py,sha256=2hF69B_L3AaWxuJPTqXQ3RXzFzIS4lg1uqnK0eslwkY,124544 +ray/rllib/env/policy_client.py,sha256=K8I36jAsFn4Y_3wDtZqFxesSxxSfag0-BmMwYVr8Gvg,13753 +ray/rllib/env/policy_server_input.py,sha256=hu968RVBJa6KPyoK3jreB8akk_NJMWeqj8IzmhEibBA,13454 +ray/rllib/env/remote_base_env.py,sha256=ES62YDcacur5f7CRwlknSwTp3Bx21OXaFEUiT6VQy7w,19279 +ray/rllib/env/single_agent_env_runner.py,sha256=W2VBD7zAVO7bt-S3eclUVv5lhf2XS2Cyq63XwBrFLfg,34565 +ray/rllib/env/single_agent_episode.py,sha256=p0RrnaPu_ruI9fh6NwTHlI7meg02Yg4Tu0B79S7PySs,88488 +ray/rllib/env/tcp_client_inference_env_runner.py,sha256=dWoqp0pr2H55J0vIHscO5Hpy9htfm5Z3voB-oqA1FyE,22039 +ray/rllib/env/utils/__init__.py,sha256=Yb08UmJLv1xNgTzBWfkb47ngkd7QQTYgGuhU2WPpGZo,3777 +ray/rllib/env/utils/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/env/utils/__pycache__/external_env_protocol.cpython-311.pyc,, +ray/rllib/env/utils/__pycache__/infinite_lookback_buffer.cpython-311.pyc,, +ray/rllib/env/utils/external_env_protocol.py,sha256=CJajFLNgWuDLkYqR89DvZpmdDvn4OgegtMJSVzEA3z8,1473 +ray/rllib/env/utils/infinite_lookback_buffer.py,sha256=gGeDrC5XfErmNtgG07YxY9nH1sINoHzIqJCOl_cMSMI,28888 +ray/rllib/env/vector_env.py,sha256=DMnlsdQjkf9y2dDH4n9sLIFwpa6uVLEUeTOqtgvtD5Q,20297 +ray/rllib/env/wrappers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/env/wrappers/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/env/wrappers/__pycache__/atari_wrappers.cpython-311.pyc,, +ray/rllib/env/wrappers/__pycache__/dm_control_wrapper.cpython-311.pyc,, +ray/rllib/env/wrappers/__pycache__/dm_env_wrapper.cpython-311.pyc,, +ray/rllib/env/wrappers/__pycache__/group_agents_wrapper.cpython-311.pyc,, +ray/rllib/env/wrappers/__pycache__/multi_agent_env_compatibility.cpython-311.pyc,, +ray/rllib/env/wrappers/__pycache__/open_spiel.cpython-311.pyc,, +ray/rllib/env/wrappers/__pycache__/pettingzoo_env.cpython-311.pyc,, +ray/rllib/env/wrappers/__pycache__/unity3d_env.cpython-311.pyc,, +ray/rllib/env/wrappers/atari_wrappers.py,sha256=XEJojy4Axiiqz8JBRNVk01XYQPeCdowHm0s4sbRdPzA,13883 +ray/rllib/env/wrappers/dm_control_wrapper.py,sha256=lebSDRS5Hxjfmv6DqfEyINO5zk4g4Rfld3B0Vf7cWCk,7561 +ray/rllib/env/wrappers/dm_env_wrapper.py,sha256=p4O2SFMK6iQfKdaP0uUp-NctHzz9jicYHIgF7O54v4A,2793 +ray/rllib/env/wrappers/group_agents_wrapper.py,sha256=M6_4zv1RvQhX-nNFH02lzYH5VjzIjcjvCArSp-Wy2PA,5904 +ray/rllib/env/wrappers/multi_agent_env_compatibility.py,sha256=QbE2eYjEMW3ilX-TGA853Lxplu5sIRrYCcaZxCsJPXw,2574 +ray/rllib/env/wrappers/open_spiel.py,sha256=-0-xUFiHI91reGnADRAHdh5JDowwKq94WRTblnLkLsI,4675 +ray/rllib/env/wrappers/pettingzoo_env.py,sha256=eZuVu7PqvHL2XY_3ThK2DX1Viut2imHPJ5IBPoNFif8,5987 +ray/rllib/env/wrappers/unity3d_env.py,sha256=LC0sEvfBt5GZxeM_iNruRX_3iKJp-dfCsFWc_pco50A,15482 +ray/rllib/evaluation/__init__.py,sha256=ezyub9wS4Bjx5j0gfppOBAX_ywy-4LiO0oFu0h4187Q,634 +ray/rllib/evaluation/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/evaluation/__pycache__/env_runner_v2.cpython-311.pyc,, +ray/rllib/evaluation/__pycache__/episode_v2.cpython-311.pyc,, +ray/rllib/evaluation/__pycache__/metrics.cpython-311.pyc,, +ray/rllib/evaluation/__pycache__/observation_function.cpython-311.pyc,, +ray/rllib/evaluation/__pycache__/postprocessing.cpython-311.pyc,, +ray/rllib/evaluation/__pycache__/rollout_worker.cpython-311.pyc,, +ray/rllib/evaluation/__pycache__/sample_batch_builder.cpython-311.pyc,, +ray/rllib/evaluation/__pycache__/sampler.cpython-311.pyc,, +ray/rllib/evaluation/__pycache__/worker_set.cpython-311.pyc,, +ray/rllib/evaluation/collectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/evaluation/collectors/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/evaluation/collectors/__pycache__/agent_collector.cpython-311.pyc,, +ray/rllib/evaluation/collectors/__pycache__/sample_collector.cpython-311.pyc,, +ray/rllib/evaluation/collectors/__pycache__/simple_list_collector.cpython-311.pyc,, +ray/rllib/evaluation/collectors/agent_collector.py,sha256=aNwkzmMj_fDS3d7H0MWRn9MoA7rVMo5BfJUuzXSLINU,30953 +ray/rllib/evaluation/collectors/sample_collector.py,sha256=AUO0APgrL1Tgik2xSv-HHoDCizJ-iTY3eXgov5sSE3c,12275 +ray/rllib/evaluation/collectors/simple_list_collector.py,sha256=Kh2r-g4ybmZlZmFfUi9_OS88m3hi2VZagLeS4d4Ni9A,28703 +ray/rllib/evaluation/env_runner_v2.py,sha256=x-iutF2pjMfo1gFz4wJbIE9uUGI22IAOcZE8FBssIQ0,51736 +ray/rllib/evaluation/episode_v2.py,sha256=nmIp9U2hCBDOWsMIzINK2F6W9Nnjt-yztZPVG3Poa5I,14948 +ray/rllib/evaluation/metrics.py,sha256=7FfuMxYQO9wjlfW_zD2Fz0nKeN4p0Wq8XTdm4o4gfn8,9159 +ray/rllib/evaluation/observation_function.py,sha256=7ZrzyroZ0xzWoW8HP_oC0WudCiXDErMpYqtPs4-eRbw,3182 +ray/rllib/evaluation/postprocessing.py,sha256=o24lR_7E6HUT95AK3ZSoKdQ5Y7o8m8mW0zcagcOY7nQ,12164 +ray/rllib/evaluation/rollout_worker.py,sha256=XE4LxB0kTZ1IA9rsBDIlLqMKE_uNJgPi9yx_UBYT1_A,80412 +ray/rllib/evaluation/sample_batch_builder.py,sha256=PjGdW2ye1eORrtmdOL1iW0-AP_rZhyTm68LQAcPpKLs,10042 +ray/rllib/evaluation/sampler.py,sha256=F6ZxLHcIwoJvyXQnA0u2-3kkBVbM05jlTGoQReXuG9o,9722 +ray/rllib/evaluation/worker_set.py,sha256=48nGd8bVV2I3tj-RHp83c9kZxuahAT9kKwNqWIlyark,243 +ray/rllib/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/__pycache__/centralized_critic.cpython-311.pyc,, +ray/rllib/examples/__pycache__/compute_adapted_gae_on_postprocess_trajectory.cpython-311.pyc,, +ray/rllib/examples/__pycache__/quadx_waypoints.cpython-311.pyc,, +ray/rllib/examples/__pycache__/replay_buffer_api.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/_old_api_stack/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/__pycache__/attention_net_supervised.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/__pycache__/parametric_actions_cartpole.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/__pycache__/parametric_actions_cartpole_embeddings_learnt_by_model.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/attention_net_supervised.py,sha256=diI8T2WL90DKdxd2sLQokX4p5eJm2loOSMEclk3mAfg,2379 +ray/rllib/examples/_old_api_stack/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/_old_api_stack/models/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/models/__pycache__/action_mask_model.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/models/__pycache__/autoregressive_action_dist.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/models/__pycache__/autoregressive_action_model.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/models/__pycache__/centralized_critic_models.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/models/__pycache__/custom_loss_model.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/models/__pycache__/fast_model.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/models/__pycache__/mobilenet_v2_encoder.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/models/__pycache__/mobilenet_v2_with_lstm_models.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/models/__pycache__/neural_computer.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/models/__pycache__/parametric_actions_model.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/models/__pycache__/shared_weights_model.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/models/__pycache__/simple_rpg_model.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/models/action_mask_model.py,sha256=5FSX1-Y7I9PoD1tXYHN81j_yH6z1ij1JPL1BYlqvIz4,4292 +ray/rllib/examples/_old_api_stack/models/autoregressive_action_dist.py,sha256=hpTtpa-XJBsgv24yK_wChCDaE-7cO-9PaHwXRFJJ9tY,4994 +ray/rllib/examples/_old_api_stack/models/autoregressive_action_model.py,sha256=vS8rnCj4BXPm3c0iNufA8Z9ZiEJ_40knxPJrgNyYhWs,5736 +ray/rllib/examples/_old_api_stack/models/centralized_critic_models.py,sha256=5vdWWbuykQMsEm27u0sgqPmylNTJ_O-LYrX4NZAZGaI,6916 +ray/rllib/examples/_old_api_stack/models/custom_loss_model.py,sha256=YhE9DNdhZj0hyJGvvctnmGdPhRLD7AfBrzSUosizwqE,5362 +ray/rllib/examples/_old_api_stack/models/fast_model.py,sha256=MPHPdJCawlICl-sL4Ux59BNjMNyzLuMib3KAvCzFzSI,2840 +ray/rllib/examples/_old_api_stack/models/mobilenet_v2_encoder.py,sha256=PjBY0AGLUUxuSM4qblcYu3IgaKhczTl5xcDZaXKFa-o,1659 +ray/rllib/examples/_old_api_stack/models/mobilenet_v2_with_lstm_models.py,sha256=XD8NYd1UktRwDGWBgPqOgoAmzGqP8LJ-OGQoTU_zyqs,5790 +ray/rllib/examples/_old_api_stack/models/neural_computer.py,sha256=bFfNL9Il7_C314_RmR2-r6JRWlYF5ycNp997gTLU7g0,8595 +ray/rllib/examples/_old_api_stack/models/parametric_actions_model.py,sha256=DvU4aYxHJexBF9DHXxKLEFGw_oM6sXqvMhUV0CTgH3A,7332 +ray/rllib/examples/_old_api_stack/models/shared_weights_model.py,sha256=xH4R44E1T-rL2sJ6bpAfMwXuEcnDSQu2yD0UatDWO5k,6969 +ray/rllib/examples/_old_api_stack/models/simple_rpg_model.py,sha256=NZQq0Dgg32cnf5-f6VowLCSq6U6LaX_3dls2L4PhUzk,2632 +ray/rllib/examples/_old_api_stack/parametric_actions_cartpole.py,sha256=Wo02y7aGqvU9Reuiji0fueovBotUaRnoVdHKUnUiwqc,3823 +ray/rllib/examples/_old_api_stack/parametric_actions_cartpole_embeddings_learnt_by_model.py,sha256=PEUpayCWSVBEK6WHMkDaF0z1b7jvsr0xSNUkBXbbq6I,3536 +ray/rllib/examples/_old_api_stack/policy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/_old_api_stack/policy/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/policy/__pycache__/cliff_walking_wall_policy.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/policy/__pycache__/random_policy.cpython-311.pyc,, +ray/rllib/examples/_old_api_stack/policy/cliff_walking_wall_policy.py,sha256=0KsvOJKAnZPLN3zFOJR_JHDv4CIoXEIdmpWJx7WaCUQ,4180 +ray/rllib/examples/_old_api_stack/policy/random_policy.py,sha256=mVvSTYW9Mu4EQHzlwdwj2Ej6UcCdTwbpc9-YisNHyn4,3213 +ray/rllib/examples/actions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/actions/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/actions/__pycache__/autoregressive_actions.cpython-311.pyc,, +ray/rllib/examples/actions/__pycache__/nested_action_spaces.cpython-311.pyc,, +ray/rllib/examples/actions/autoregressive_actions.py,sha256=UA1Mt8pgwMUpP_a6JnkuKBSL9TWxDpp2JYxoMzFdMUI,4267 +ray/rllib/examples/actions/nested_action_spaces.py,sha256=lTlm_PcdTtJ06eUF45xSP_AopxySpNRYcDM-waWDtDQ,2757 +ray/rllib/examples/algorithms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/algorithms/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/algorithms/__pycache__/vpg_custom_algorithm.cpython-311.pyc,, +ray/rllib/examples/algorithms/classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/algorithms/classes/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/algorithms/classes/__pycache__/vpg.cpython-311.pyc,, +ray/rllib/examples/algorithms/classes/vpg.py,sha256=2yM1mF1JJLSKjnlKiOagPtigTdHO2UqPVw3Nw-pwgIc,6872 +ray/rllib/examples/algorithms/vpg_custom_algorithm.py,sha256=imF4-To-L-tHp9lhnbiKm09x2XGR-tWou0_bwKxnPcQ,5146 +ray/rllib/examples/centralized_critic.py,sha256=4moWNAfQo_MNeREoSpcWuH0mpAL9J6fcnCwgkR_9-Ys,11241 +ray/rllib/examples/checkpoints/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/checkpoints/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/checkpoints/__pycache__/cartpole_dqn_export.cpython-311.pyc,, +ray/rllib/examples/checkpoints/__pycache__/change_config_during_training.cpython-311.pyc,, +ray/rllib/examples/checkpoints/__pycache__/checkpoint_by_custom_criteria.cpython-311.pyc,, +ray/rllib/examples/checkpoints/__pycache__/continue_training_from_checkpoint.cpython-311.pyc,, +ray/rllib/examples/checkpoints/__pycache__/onnx_tf.cpython-311.pyc,, +ray/rllib/examples/checkpoints/__pycache__/onnx_torch.cpython-311.pyc,, +ray/rllib/examples/checkpoints/__pycache__/onnx_torch_lstm.cpython-311.pyc,, +ray/rllib/examples/checkpoints/__pycache__/restore_1_of_n_agents_from_checkpoint.cpython-311.pyc,, +ray/rllib/examples/checkpoints/cartpole_dqn_export.py,sha256=2S2ABOoklrtyZTl6cMeN-xPfqwlRQPFzI4AEyAUxBBE,2594 +ray/rllib/examples/checkpoints/change_config_during_training.py,sha256=aym-lUrW0LWfV50xGxSGTkP4GztFN5a_7vWQNZyE-LE,11868 +ray/rllib/examples/checkpoints/checkpoint_by_custom_criteria.py,sha256=7b_rhkKOTsxxlYVJnI-pIq44WuQMADQ4x_oN4xoCQVA,6401 +ray/rllib/examples/checkpoints/continue_training_from_checkpoint.py,sha256=hOEHvGunFK3Yw9edh-4SvVEBHqaRmS2NXtQGAMV7MH4,12706 +ray/rllib/examples/checkpoints/onnx_tf.py,sha256=miThOBIYPkqN-FqRvHKlmVOMaf_DUt31uiN56wwMres,2484 +ray/rllib/examples/checkpoints/onnx_torch.py,sha256=CpWUhGG0x6UeJzQQr6E_YB1vBJ8SYUezZmLYmeo7WoM,2175 +ray/rllib/examples/checkpoints/onnx_torch_lstm.py,sha256=9qfX1oNaIaoJh_rQnAufIBYjaDLTTDTJgZo7qeoZDnc,4262 +ray/rllib/examples/checkpoints/restore_1_of_n_agents_from_checkpoint.py,sha256=zH5P1szHhSXF-5QWmC2QIEE-Y3u2qHsExbhMmg_jG3U,6203 +ray/rllib/examples/compute_adapted_gae_on_postprocess_trajectory.py,sha256=RAjSQrlgGqQ9gGHKwKTR9W6LNWAKN5-pWV0qPveXd1g,5694 +ray/rllib/examples/connectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/connectors/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/connectors/__pycache__/count_based_curiosity.cpython-311.pyc,, +ray/rllib/examples/connectors/__pycache__/euclidian_distance_based_curiosity.cpython-311.pyc,, +ray/rllib/examples/connectors/__pycache__/flatten_observations_dict_space.cpython-311.pyc,, +ray/rllib/examples/connectors/__pycache__/frame_stacking.cpython-311.pyc,, +ray/rllib/examples/connectors/__pycache__/mean_std_filtering.cpython-311.pyc,, +ray/rllib/examples/connectors/__pycache__/prev_actions_prev_rewards.cpython-311.pyc,, +ray/rllib/examples/connectors/classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/connectors/classes/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/connectors/classes/__pycache__/count_based_curiosity.cpython-311.pyc,, +ray/rllib/examples/connectors/classes/__pycache__/euclidian_distance_based_curiosity.cpython-311.pyc,, +ray/rllib/examples/connectors/classes/__pycache__/protobuf_cartpole_observation_decoder.cpython-311.pyc,, +ray/rllib/examples/connectors/classes/count_based_curiosity.py,sha256=H8LylHqdviWGBypiK_B6WJo0cs7FnS92AGG_MVv2iNc,3622 +ray/rllib/examples/connectors/classes/euclidian_distance_based_curiosity.py,sha256=6DCmXP4Uq2eAh3jYQCXR-Gxf2Zl_Ak6KytwWh8ytGEo,4959 +ray/rllib/examples/connectors/classes/protobuf_cartpole_observation_decoder.py,sha256=yjD5uvhyyhStkCwtSq2oATDhbV3JJuopPPHhDL2Cnj0,2890 +ray/rllib/examples/connectors/count_based_curiosity.py,sha256=8OgGt6d7QegkHNueG9XtyP290KQcrmXxplj_ju-TMok,424 +ray/rllib/examples/connectors/euclidian_distance_based_curiosity.py,sha256=Eur41PMN8HgpWnSOx7wiQKoWPwNKbaCFz7QJ6o1kVH8,437 +ray/rllib/examples/connectors/flatten_observations_dict_space.py,sha256=xJwLneCQ6ctQ7SSwDP_t0a-CA9z8erKy6P9fxWuXyYE,6286 +ray/rllib/examples/connectors/frame_stacking.py,sha256=uC7Zu2nnaJo5lSEiadoDa4FK6EJFvJWXOqOX2oqnRgQ,9562 +ray/rllib/examples/connectors/mean_std_filtering.py,sha256=5-LjHzW9vRS2AGGazD3QvQrTHbBX1WhZrJUDVDJZOyI,8447 +ray/rllib/examples/connectors/prev_actions_prev_rewards.py,sha256=iB39i3UzjIMkRz4bvO-fm_57lEn5qfYdU3vQjawH-DU,7236 +ray/rllib/examples/curiosity/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/curiosity/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/curiosity/__pycache__/count_based_curiosity.cpython-311.pyc,, +ray/rllib/examples/curiosity/__pycache__/euclidian_distance_based_curiosity.cpython-311.pyc,, +ray/rllib/examples/curiosity/__pycache__/intrinsic_curiosity_model_based_curiosity.cpython-311.pyc,, +ray/rllib/examples/curiosity/count_based_curiosity.py,sha256=Oik1gax-vdZ3ootQ_M_NRtw46_E4sgRT5qqkK6HV_Mg,5559 +ray/rllib/examples/curiosity/euclidian_distance_based_curiosity.py,sha256=oy9-OlgoQWbKsT0yhXt3qa_7edw_N1nW8P0CCZpjxn0,5316 +ray/rllib/examples/curiosity/intrinsic_curiosity_model_based_curiosity.py,sha256=tYjBfPF31y2LRmpniC7nKL1hK3lx8nYeHgN_-qXZ9AE,11295 +ray/rllib/examples/curriculum/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/curriculum/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/curriculum/__pycache__/curriculum_learning.cpython-311.pyc,, +ray/rllib/examples/curriculum/curriculum_learning.py,sha256=9oiH6kfEBp9GzpxB4DKhpYo1QE8O3h1S1D3N8W0pR0k,9095 +ray/rllib/examples/debugging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/debugging/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/debugging/__pycache__/deterministic_training.cpython-311.pyc,, +ray/rllib/examples/debugging/deterministic_training.py,sha256=hdcj0G6q37aB2y6NDOIuIAJgrSca1ekuMEszqwGGT2o,3694 +ray/rllib/examples/envs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/envs/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/envs/__pycache__/agents_act_in_sequence.cpython-311.pyc,, +ray/rllib/examples/envs/__pycache__/agents_act_simultaneously.cpython-311.pyc,, +ray/rllib/examples/envs/__pycache__/async_gym_env_vectorization.cpython-311.pyc,, +ray/rllib/examples/envs/__pycache__/custom_env_render_method.cpython-311.pyc,, +ray/rllib/examples/envs/__pycache__/custom_gym_env.cpython-311.pyc,, +ray/rllib/examples/envs/__pycache__/env_connecting_to_rllib_w_tcp_client.cpython-311.pyc,, +ray/rllib/examples/envs/__pycache__/env_rendering_and_recording.cpython-311.pyc,, +ray/rllib/examples/envs/__pycache__/env_w_protobuf_observations.cpython-311.pyc,, +ray/rllib/examples/envs/__pycache__/greyscale_env.cpython-311.pyc,, +ray/rllib/examples/envs/__pycache__/unity3d_env_local.cpython-311.pyc,, +ray/rllib/examples/envs/agents_act_in_sequence.py,sha256=cByyJ_oB0lXfZXoHXQ4Ntv3wefO8TDi5jcSrYokD1PQ,3440 +ray/rllib/examples/envs/agents_act_simultaneously.py,sha256=-zLSCQb0uJzKUA2ZNm9Y7vdF3tRxdz53P9BWIJlK4Qg,4269 +ray/rllib/examples/envs/async_gym_env_vectorization.py,sha256=CVxxJRFOPzElsIJLCy_SxXx-iD_JAaM5PEVIWHyG4ak,5392 +ray/rllib/examples/envs/classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/envs/classes/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/action_mask_env.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/cartpole_crashing.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/cartpole_sparse_rewards.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/cartpole_with_dict_observation_space.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/cartpole_with_large_observation_space.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/cartpole_with_protobuf_observation_space.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/cliff_walking_wall_env.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/correlated_actions_env.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/d4rl_env.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/debug_counter_env.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/deterministic_envs.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/dm_control_suite.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/env_using_remote_actor.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/env_with_subprocess.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/fast_image_env.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/gpu_requiring_env.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/look_and_push.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/memory_leaking_env.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/mock_env.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/nested_space_repeat_after_me_env.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/parametric_actions_cartpole.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/random_env.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/recommender_system_envs_with_recsim.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/repeat_after_me_env.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/repeat_initial_obs_env.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/simple_corridor.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/simple_rpg.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/six_room_env.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/stateless_cartpole.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/stateless_pendulum.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/transformed_action_space_env.cpython-311.pyc,, +ray/rllib/examples/envs/classes/__pycache__/windy_maze_env.cpython-311.pyc,, +ray/rllib/examples/envs/classes/action_mask_env.py,sha256=HLbeoPMkzlySuWDGIgtgc_1vS8bsLLukzcXLCYK7o4w,1490 +ray/rllib/examples/envs/classes/cartpole_crashing.py,sha256=OiGQPbavjOv--ZKOJwIKumH7woRxNwKxgSYohayZrNs,6976 +ray/rllib/examples/envs/classes/cartpole_sparse_rewards.py,sha256=xmtI3owJVNFNtb1aHS_7FpQ_fqO-BnK-WQ2BPucLQYE,1597 +ray/rllib/examples/envs/classes/cartpole_with_dict_observation_space.py,sha256=66ER9y6o0oq9mmZKUyHeUFmGQ2aVBR-EspSxm6WOoGI,2913 +ray/rllib/examples/envs/classes/cartpole_with_large_observation_space.py,sha256=Vi4aJFN9vTDk5-MDWeOPKhe9EkYYnG6Enz_795bMGWw,2483 +ray/rllib/examples/envs/classes/cartpole_with_protobuf_observation_space.py,sha256=gVv5563iQBkjp2M-iv58665WJfUq_FdLFJEyvKCjPEE,2973 +ray/rllib/examples/envs/classes/cliff_walking_wall_env.py,sha256=BwNZqzH5DoMON2sDw22NbMSYeAc-fz6htPN5y7QatPI,2251 +ray/rllib/examples/envs/classes/correlated_actions_env.py,sha256=wgBYAcrGNJePJpbPhnp6hWmz5yn9M7IvAanjSfYk2rc,3236 +ray/rllib/examples/envs/classes/d4rl_env.py,sha256=vRf83pcdSVl9jbIwBWSJD1-ekD19UlmjVgz06RtLCbQ,859 +ray/rllib/examples/envs/classes/debug_counter_env.py,sha256=0OVRScn2PsO1Ah6Bsj2_goQOq67faSP7abZTgLMDGHM,3091 +ray/rllib/examples/envs/classes/deterministic_envs.py,sha256=K9O5MbtVvZhw_3V2iNACPpBVRhDpvvpjiax3Z7EDrVo,296 +ray/rllib/examples/envs/classes/dm_control_suite.py,sha256=aBzx4GRrm84h5_UXmjb1r0OqdjTE8vDK3jAs43YzBWo,2888 +ray/rllib/examples/envs/classes/env_using_remote_actor.py,sha256=IZb3e57yQM-D2SmKDlyY0w28tjD0DXLD1l6qOBKmysc,2159 +ray/rllib/examples/envs/classes/env_with_subprocess.py,sha256=rmOJXV4avCKUkqIdet7lu1Lm2KmQzhlTvSeQEFxQTgU,1325 +ray/rllib/examples/envs/classes/fast_image_env.py,sha256=_3UaAxWM0Ch8-7fIJ2FEHY1hbHg1mFJd8gs5bqhDXPc,574 +ray/rllib/examples/envs/classes/gpu_requiring_env.py,sha256=Uqn6_zO5_GjrDL9bupHr-Mv0Mmw8X8qmdydTJ0l1QWM,1441 +ray/rllib/examples/envs/classes/look_and_push.py,sha256=QE3gFWKJ5nQs69nYTyaSOrB8o9TUL4VH4ItVz7IGnak,2121 +ray/rllib/examples/envs/classes/memory_leaking_env.py,sha256=vcPpsMDp7DJqBzaCaaokw9M3wFVCxuMRfRmgjKk6W50,915 +ray/rllib/examples/envs/classes/mock_env.py,sha256=7XXRgOtwA7zWcus4ztMfr8ZWyfdm7gmQpeXjuzPvIoo,7674 +ray/rllib/examples/envs/classes/multi_agent/__init__.py,sha256=rpGSagiv5LmKPtXU0DEsk2IwPniVFGFyMJH7V3ySJM0,1237 +ray/rllib/examples/envs/classes/multi_agent/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/envs/classes/multi_agent/__pycache__/bandit_envs_discrete.cpython-311.pyc,, +ray/rllib/examples/envs/classes/multi_agent/__pycache__/bandit_envs_recommender_system.cpython-311.pyc,, +ray/rllib/examples/envs/classes/multi_agent/__pycache__/guess_the_number_game.cpython-311.pyc,, +ray/rllib/examples/envs/classes/multi_agent/__pycache__/pettingzoo_chess.cpython-311.pyc,, +ray/rllib/examples/envs/classes/multi_agent/__pycache__/pettingzoo_connect4.cpython-311.pyc,, +ray/rllib/examples/envs/classes/multi_agent/__pycache__/rock_paper_scissors.cpython-311.pyc,, +ray/rllib/examples/envs/classes/multi_agent/__pycache__/tic_tac_toe.cpython-311.pyc,, +ray/rllib/examples/envs/classes/multi_agent/__pycache__/two_step_game.cpython-311.pyc,, +ray/rllib/examples/envs/classes/multi_agent/bandit_envs_discrete.py,sha256=vc3zBjL_dVWePljCW5ZbqTqeApbaopSCODWZQgi2PNk,6412 +ray/rllib/examples/envs/classes/multi_agent/bandit_envs_recommender_system.py,sha256=1BlswevHW7yYzTkO9V_RKIMVrQTwhJBUfNp0jkgeuXE,8856 +ray/rllib/examples/envs/classes/multi_agent/guess_the_number_game.py,sha256=b_rmhpkHvkhiadtBT12vkKtwAlBd1KNsEpINwoZH6Bs,3536 +ray/rllib/examples/envs/classes/multi_agent/pettingzoo_chess.py,sha256=zSiV4m7ACnhRAMKh8HxLUzd8pTrRuhcvh94HSRdJulI,6674 +ray/rllib/examples/envs/classes/multi_agent/pettingzoo_connect4.py,sha256=xCvVUcJtivIGyNj8X3YZXGWmJIyhdd3HTsRmxMLUUMQ,6092 +ray/rllib/examples/envs/classes/multi_agent/rock_paper_scissors.py,sha256=maKcKnebqam01cvHqJ1nbWDICZw3EmnTWg8UUS1cuzk,4473 +ray/rllib/examples/envs/classes/multi_agent/tic_tac_toe.py,sha256=FbcvCE99N-1jQZMV2nQHCfOpXNwjxjYLFeLP6QKFtEQ,4977 +ray/rllib/examples/envs/classes/multi_agent/two_step_game.py,sha256=thA9QTmHFTeAAk2mtjs8bKCnAfF4msF7fWG6wXq_oIU,4556 +ray/rllib/examples/envs/classes/nested_space_repeat_after_me_env.py,sha256=oXUc-LXArI4gj93zYtSIbJDKO8Rui9ltDAwBCLggMuE,1866 +ray/rllib/examples/envs/classes/parametric_actions_cartpole.py,sha256=SPt7neS5SjZzFHLNePINmYqkIIcnwM7bPgFXAU4QHMA,5484 +ray/rllib/examples/envs/classes/random_env.py,sha256=0GtZobUDrP6Nm3G4t99WOj94HMu3oaTvehEQf6NQnXM,4629 +ray/rllib/examples/envs/classes/recommender_system_envs_with_recsim.py,sha256=gBLitl5JB_ejBVelJ131X1NJwxkQvX_6kPqtDBAh-6o,3386 +ray/rllib/examples/envs/classes/repeat_after_me_env.py,sha256=Vau9X-y0wOYYjEPiJAAFuQwOzVTv3M5aid2k4t_b7jk,1591 +ray/rllib/examples/envs/classes/repeat_initial_obs_env.py,sha256=XnOXupCPaMD41M8R7YMq1BetS3tTacNHAa5rb3woRYo,904 +ray/rllib/examples/envs/classes/simple_corridor.py,sha256=WCqtmXS4Kv3ch7OstVRp3zur77YRFZZJLSapzWLBk68,1351 +ray/rllib/examples/envs/classes/simple_rpg.py,sha256=Vu6OPlc3PCSP3SVZcUJxQ8O9W7_q1sSBhxEraeZyzkU,1564 +ray/rllib/examples/envs/classes/six_room_env.py,sha256=NaAE_FZEOWJEaPicF5lRTuHyGsNTVB3mSV3w-mMfws4,11254 +ray/rllib/examples/envs/classes/stateless_cartpole.py,sha256=D0pwEQrdZn4J11hxRcGktOj-yzXrvRcwXqA9v_QC1HY,1333 +ray/rllib/examples/envs/classes/stateless_pendulum.py,sha256=KrlUNSUUwXGoWhmAiGGeqpXTkyli5uUyayZVOjGId5Q,1280 +ray/rllib/examples/envs/classes/transformed_action_space_env.py,sha256=knrKYUqNiEWNyz1n68B_7ShtGr1823ShdY07_RLZwJ8,2043 +ray/rllib/examples/envs/classes/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/envs/classes/utils/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/envs/classes/utils/__pycache__/cartpole_observations_proto.cpython-311.pyc,, +ray/rllib/examples/envs/classes/utils/cartpole_observations_proto.py,sha256=fL_O6a69GU1CKV0mhVg_tz00NdpsJv_J8gy6NmJR_qQ,1250 +ray/rllib/examples/envs/classes/windy_maze_env.py,sha256=xFDU9OzmWluIHAVmRvFK1wlovb4o8aUNw1665g306kk,5761 +ray/rllib/examples/envs/custom_env_render_method.py,sha256=N1d9eYF9z4HdG0BMhr3MUI5mxImFqEN8plDOSF1tVbE,7946 +ray/rllib/examples/envs/custom_gym_env.py,sha256=3Ew-xYsic4-0L2mw2vQVT4x_WRBV4bcHsa96fWFVTtg,5910 +ray/rllib/examples/envs/env_connecting_to_rllib_w_tcp_client.py,sha256=4xAU6yFSgg95JqMm5_ifPA_e9jAc_ZqtqNTwDr2nQIs,4923 +ray/rllib/examples/envs/env_rendering_and_recording.py,sha256=SsbsqNceeGy8rdMYYV90IebV-pPz93T7zWLOt3YOWrs,12850 +ray/rllib/examples/envs/env_w_protobuf_observations.py,sha256=LqtkM4EZJjGz4zVSw_eLj0LMsPJHUZ3zX7xejCnQUUk,3564 +ray/rllib/examples/envs/greyscale_env.py,sha256=BCwgXOWE0xE7lBvPxJR-3xwIjr34QObgZtI-O4oTo-g,3852 +ray/rllib/examples/envs/unity3d_env_local.py,sha256=tL_ACaRWjA3XoUeWI0NLc_7oMbvl2XhCaQA-S4u5UYI,6641 +ray/rllib/examples/evaluation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/evaluation/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/evaluation/__pycache__/custom_evaluation.cpython-311.pyc,, +ray/rllib/examples/evaluation/__pycache__/evaluation_parallel_to_training.cpython-311.pyc,, +ray/rllib/examples/evaluation/custom_evaluation.py,sha256=xb7NGuJBGuyKlVP0gq1h7f3CLNfcxHiqFuxRUYDI5aY,9838 +ray/rllib/examples/evaluation/evaluation_parallel_to_training.py,sha256=PG31xW-2OX5ZVZBbqj9DtwCvPQMbCU9dWv_TwYQlhwI,11243 +ray/rllib/examples/fault_tolerance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/fault_tolerance/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/fault_tolerance/__pycache__/crashing_and_stalling_env.cpython-311.pyc,, +ray/rllib/examples/fault_tolerance/crashing_and_stalling_env.py,sha256=OMChoWphgVpalitk6zWa3JzKiCvLnIdHAH1xmHL2JK0,7732 +ray/rllib/examples/gpus/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/gpus/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/gpus/__pycache__/float16_training_and_inference.cpython-311.pyc,, +ray/rllib/examples/gpus/__pycache__/fractional_gpus_per_learner.cpython-311.pyc,, +ray/rllib/examples/gpus/__pycache__/gpus_on_env_runners.cpython-311.pyc,, +ray/rllib/examples/gpus/__pycache__/mixed_precision_training_float16_inference.cpython-311.pyc,, +ray/rllib/examples/gpus/float16_training_and_inference.py,sha256=Sj4Etbs0mNLY2SeFbaDbywONHrFFSeZPCffnDvSdHGY,10245 +ray/rllib/examples/gpus/fractional_gpus_per_learner.py,sha256=bVCU9f_9EoWq5MofpObszKiaHh3lHg4dXvqihBWDnqU,5307 +ray/rllib/examples/gpus/gpus_on_env_runners.py,sha256=tw3jsaDfQfZtLaRhuq7QHXaaf4ISszJjOs7NPNx03oc,3336 +ray/rllib/examples/gpus/mixed_precision_training_float16_inference.py,sha256=qwDUiujgqLto-pKpfZyyPU7rrs0Itsb0R5AqinpLN_U,6864 +ray/rllib/examples/hierarchical/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/hierarchical/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/hierarchical/__pycache__/hierarchical_training.cpython-311.pyc,, +ray/rllib/examples/hierarchical/hierarchical_training.py,sha256=XfPVDndP9-k4PHTqtIlzVxfABXsQf93PyME828ESXwA,7310 +ray/rllib/examples/inference/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/inference/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/inference/__pycache__/policy_inference_after_training.cpython-311.pyc,, +ray/rllib/examples/inference/__pycache__/policy_inference_after_training_w_connector.cpython-311.pyc,, +ray/rllib/examples/inference/__pycache__/policy_inference_after_training_with_attention.cpython-311.pyc,, +ray/rllib/examples/inference/__pycache__/policy_inference_after_training_with_lstm.cpython-311.pyc,, +ray/rllib/examples/inference/policy_inference_after_training.py,sha256=yQn69XX7FBVQ-MfutQrqqJv6RfQBtOrgE8LiE_b4dhE,7460 +ray/rllib/examples/inference/policy_inference_after_training_w_connector.py,sha256=vCxeLGixS0F6mSNMclQF6y7XsPHTiV1S2yb-0S2eE70,10174 +ray/rllib/examples/inference/policy_inference_after_training_with_attention.py,sha256=gmOllzssUNON-grbwLRBIkCV7oLWobUqpNfVW81QNeM,6280 +ray/rllib/examples/inference/policy_inference_after_training_with_lstm.py,sha256=cxn0gKyj4AuKW1BprEGai7F1MFU0H6recPTYh1KTwT8,5664 +ray/rllib/examples/learners/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/learners/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/learners/__pycache__/ppo_load_rl_modules.cpython-311.pyc,, +ray/rllib/examples/learners/__pycache__/ppo_with_custom_loss_fn.cpython-311.pyc,, +ray/rllib/examples/learners/__pycache__/ppo_with_torch_lr_schedulers.cpython-311.pyc,, +ray/rllib/examples/learners/__pycache__/separate_vf_lr_and_optimizer.cpython-311.pyc,, +ray/rllib/examples/learners/classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/learners/classes/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/learners/classes/__pycache__/custom_ppo_loss_fn_learner.cpython-311.pyc,, +ray/rllib/examples/learners/classes/__pycache__/intrinsic_curiosity_learners.cpython-311.pyc,, +ray/rllib/examples/learners/classes/__pycache__/separate_vf_lr_and_optimizer_learner.cpython-311.pyc,, +ray/rllib/examples/learners/classes/__pycache__/vpg_torch_learner.cpython-311.pyc,, +ray/rllib/examples/learners/classes/custom_ppo_loss_fn_learner.py,sha256=Ag_y2yPhGuuMflRvX0Bj42bgqHXhaWb433OEyv_V9_0,1774 +ray/rllib/examples/learners/classes/intrinsic_curiosity_learners.py,sha256=I5_R8OVHRzscrLgh-p01JVXg5bEr-8HVycU-oaTfr0o,6613 +ray/rllib/examples/learners/classes/separate_vf_lr_and_optimizer_learner.py,sha256=-4F9EZY4g_gf0LnBk9pFv29zAgehbqKFJc0jmxWCtB0,3772 +ray/rllib/examples/learners/classes/vpg_torch_learner.py,sha256=dsUYs5gAaB27cxP4ZcpFwAn8LMfQDxtSdnAZmFsIVgY,2899 +ray/rllib/examples/learners/ppo_load_rl_modules.py,sha256=VWxopUCFKD364geyBSZmZmhYp9GNmbT8NO0d7PCYdd8,2471 +ray/rllib/examples/learners/ppo_with_custom_loss_fn.py,sha256=G7VLjrZGriZLDKGZzdzE4yx8zDKZ_BeS090Md5X0r68,5877 +ray/rllib/examples/learners/ppo_with_torch_lr_schedulers.py,sha256=PzRxYwPUQzs_joQ52qmo4ZSR9sWy_Ro_1NVHrtVA9II,7915 +ray/rllib/examples/learners/separate_vf_lr_and_optimizer.py,sha256=VHWzLCiEj7Ypn6JSt0HNnP1xM8qQy_lRqIcbib-yTPQ,5972 +ray/rllib/examples/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/metrics/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/metrics/__pycache__/custom_metrics_in_algorithm_training_step.cpython-311.pyc,, +ray/rllib/examples/metrics/__pycache__/custom_metrics_in_env_runners.cpython-311.pyc,, +ray/rllib/examples/metrics/custom_metrics_in_algorithm_training_step.py,sha256=uzFiiAxeMShUWWGH6K_kmyZHmMBNGdbvJplPUDJRGDs,4182 +ray/rllib/examples/metrics/custom_metrics_in_env_runners.py,sha256=WX4AAwm6S_FLor3Tjln1bPLMkGHtYpWvjB2B1BVnSxo,13953 +ray/rllib/examples/multi_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/multi_agent/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/multi_agent/__pycache__/custom_heuristic_policy.cpython-311.pyc,, +ray/rllib/examples/multi_agent/__pycache__/different_spaces_for_agents.cpython-311.pyc,, +ray/rllib/examples/multi_agent/__pycache__/multi_agent_cartpole.cpython-311.pyc,, +ray/rllib/examples/multi_agent/__pycache__/multi_agent_pendulum.cpython-311.pyc,, +ray/rllib/examples/multi_agent/__pycache__/pettingzoo_independent_learning.cpython-311.pyc,, +ray/rllib/examples/multi_agent/__pycache__/pettingzoo_parameter_sharing.cpython-311.pyc,, +ray/rllib/examples/multi_agent/__pycache__/pettingzoo_shared_value_function.cpython-311.pyc,, +ray/rllib/examples/multi_agent/__pycache__/rock_paper_scissors_heuristic_vs_learned.cpython-311.pyc,, +ray/rllib/examples/multi_agent/__pycache__/rock_paper_scissors_learned_vs_learned.cpython-311.pyc,, +ray/rllib/examples/multi_agent/__pycache__/self_play_league_based_with_open_spiel.cpython-311.pyc,, +ray/rllib/examples/multi_agent/__pycache__/self_play_with_open_spiel.cpython-311.pyc,, +ray/rllib/examples/multi_agent/__pycache__/two_step_game_with_grouped_agents.cpython-311.pyc,, +ray/rllib/examples/multi_agent/custom_heuristic_policy.py,sha256=Dv6ISguOmgY3wSrNSaYizC71Scovt08hXUkIGamg7qU,3868 +ray/rllib/examples/multi_agent/different_spaces_for_agents.py,sha256=vimiZlZ2ya8WRiEOTXopCylmH_aPxwtX2b2aD0orjfE,4147 +ray/rllib/examples/multi_agent/multi_agent_cartpole.py,sha256=Xh-EGg1TNVA9lhPP30_EyaIw-8CoOw-PGaQud33eZCY,2234 +ray/rllib/examples/multi_agent/multi_agent_pendulum.py,sha256=D2h9X-tUIW4h3e-RMsrtIM4IVA32WMEYnmflFykbON0,2372 +ray/rllib/examples/multi_agent/pettingzoo_independent_learning.py,sha256=3UNA32h0gbiAJrjl9f1G4uQba0HH_vPSicXPzJJRhtI,4260 +ray/rllib/examples/multi_agent/pettingzoo_parameter_sharing.py,sha256=eMvz9cDRpCTfK4sSbzuUj0Lk-79qD6HykPTo3-Wj4jM,3913 +ray/rllib/examples/multi_agent/pettingzoo_shared_value_function.py,sha256=ty_VEsbyNoDSYlb0gAJVou1Qt8KLgHvOpAsZuHnMhQ4,241 +ray/rllib/examples/multi_agent/rock_paper_scissors_heuristic_vs_learned.py,sha256=lpteTQ7zRPZrhz8USIPZ1Gmyw150WxITBPAvZhcQ2Xs,5472 +ray/rllib/examples/multi_agent/rock_paper_scissors_learned_vs_learned.py,sha256=wcs4rdmujEqxEwwU6ChOlXp79JlFs_ONpJ2fCI4BdAo,3063 +ray/rllib/examples/multi_agent/self_play_league_based_with_open_spiel.py,sha256=i9iypYqOwkbvLGSf4ntHOkClGma20Hs6X8AjhxyzxBs,10934 +ray/rllib/examples/multi_agent/self_play_with_open_spiel.py,sha256=0ybvKREG02oUujDQib1s-5hDm_DRsqsIRJ7p5SZEYbg,9642 +ray/rllib/examples/multi_agent/two_step_game_with_grouped_agents.py,sha256=FWDzzihHQe9QttLNcRVgwospkt6qv14WzGeQ6Fwf2Q0,3435 +ray/rllib/examples/multi_agent/utils/__init__.py,sha256=JdMIuKodNX4ITuYTJbqyE_qjhXc3DTadTFwR1IYIi6s,1321 +ray/rllib/examples/multi_agent/utils/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/multi_agent/utils/__pycache__/self_play_callback.cpython-311.pyc,, +ray/rllib/examples/multi_agent/utils/__pycache__/self_play_callback_old_api_stack.cpython-311.pyc,, +ray/rllib/examples/multi_agent/utils/__pycache__/self_play_league_based_callback.cpython-311.pyc,, +ray/rllib/examples/multi_agent/utils/__pycache__/self_play_league_based_callback_old_api_stack.cpython-311.pyc,, +ray/rllib/examples/multi_agent/utils/self_play_callback.py,sha256=cLz7LtH8TABpfln07Y_g937rTzMsvnJc8gdcunN2JXw,3691 +ray/rllib/examples/multi_agent/utils/self_play_callback_old_api_stack.py,sha256=4YBZ_Lw8W-F9ycqV-KUVDpLkrSFgSZoWT4ZCz3CWCsg,3557 +ray/rllib/examples/multi_agent/utils/self_play_league_based_callback.py,sha256=uusASY3RDuiv_nJJo31q5A9fvsAKQsu41gHdB5o5U3g,12334 +ray/rllib/examples/multi_agent/utils/self_play_league_based_callback_old_api_stack.py,sha256=SKMoREm_LY19VzyuUbW7yZkHAPKCNUGWJOezeoAxzZM,9236 +ray/rllib/examples/offline_rl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/offline_rl/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/offline_rl/__pycache__/cartpole_recording.cpython-311.pyc,, +ray/rllib/examples/offline_rl/__pycache__/custom_input_api.cpython-311.pyc,, +ray/rllib/examples/offline_rl/__pycache__/offline_rl.cpython-311.pyc,, +ray/rllib/examples/offline_rl/__pycache__/offline_rl_with_image_data.cpython-311.pyc,, +ray/rllib/examples/offline_rl/__pycache__/pretrain_bc_single_agent_evaluate_as_multi_agent.cpython-311.pyc,, +ray/rllib/examples/offline_rl/__pycache__/saving_experiences.cpython-311.pyc,, +ray/rllib/examples/offline_rl/__pycache__/train_w_bc_finetune_w_ppo.cpython-311.pyc,, +ray/rllib/examples/offline_rl/cartpole_recording.py,sha256=meKS6eySusSxzFFBIeTtNypPDkcCXNEN3JnDNlOLouk,5915 +ray/rllib/examples/offline_rl/classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/offline_rl/classes/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/offline_rl/classes/__pycache__/image_offline_data.cpython-311.pyc,, +ray/rllib/examples/offline_rl/classes/__pycache__/image_offline_prelearner.cpython-311.pyc,, +ray/rllib/examples/offline_rl/classes/image_offline_data.py,sha256=UMl56dir7BhC0D1tUXZflZ2MkJqhGsgjPQGUO_KUsHY,2756 +ray/rllib/examples/offline_rl/classes/image_offline_prelearner.py,sha256=TM5mja40v5frkPdJr0XFNJJE5v7QjqXMz-fSj5rauLU,3734 +ray/rllib/examples/offline_rl/custom_input_api.py,sha256=hWaNn-ii20g5r1ZUgwiOS424MFCnvfcIgbcoG34V0Is,4264 +ray/rllib/examples/offline_rl/offline_rl.py,sha256=DdBj6rYeIJIbFAGlV--l5YX7Qdz49rQVadCtcjKBKZc,6218 +ray/rllib/examples/offline_rl/offline_rl_with_image_data.py,sha256=0-FbXvPzMgsHeza72A33ApbznaM9SnpKZkH6fHN7q1g,4784 +ray/rllib/examples/offline_rl/pretrain_bc_single_agent_evaluate_as_multi_agent.py,sha256=EVTbSMSg-K1EDhrBiTZzilVJbM-yigLLvhBw5aLkS3s,7244 +ray/rllib/examples/offline_rl/saving_experiences.py,sha256=y-ttOX2x97AZNSQDSdLaYkfDcb_Ozx_NaRDNKPsh83Y,2250 +ray/rllib/examples/offline_rl/train_w_bc_finetune_w_ppo.py,sha256=F40y1kFQORjsDzYwRoaKAgFmZBnormkDrHHrmzaflbc,12561 +ray/rllib/examples/quadx_waypoints.py,sha256=aEbvNYXJAQIgAmA5UP_hHLQ9SbC0k4zym-pXgA_0HGg,4035 +ray/rllib/examples/ray_serve/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/ray_serve/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/ray_serve/__pycache__/ray_serve_with_rllib.cpython-311.pyc,, +ray/rllib/examples/ray_serve/classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/ray_serve/classes/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/ray_serve/classes/__pycache__/cartpole_deployment.cpython-311.pyc,, +ray/rllib/examples/ray_serve/classes/cartpole_deployment.py,sha256=sPfLlDZB5sq-TFG-90iGnCuP-LX0Lofwpm0ba-v0D9U,1832 +ray/rllib/examples/ray_serve/ray_serve_with_rllib.py,sha256=VsrqjwHyfrxtE6Ww5pKuv_5q2hoTSt_X_8EqeTf9oJk,6697 +ray/rllib/examples/ray_tune/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/ray_tune/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/ray_tune/__pycache__/custom_experiment.cpython-311.pyc,, +ray/rllib/examples/ray_tune/__pycache__/custom_logger.cpython-311.pyc,, +ray/rllib/examples/ray_tune/__pycache__/custom_progress_reporter.cpython-311.pyc,, +ray/rllib/examples/ray_tune/custom_experiment.py,sha256=i8kCJgy81YuuiXeMzKD8oqaavcDCHsdD5SmXnPbpyPw,8348 +ray/rllib/examples/ray_tune/custom_logger.py,sha256=Tn5ytO-JWbz8VHJGkjldfawzTGFtJ__5AWL8gCozVMg,4766 +ray/rllib/examples/ray_tune/custom_progress_reporter.py,sha256=V9kRxycWZWB0LNR0hM8FtONzHs_ZojAKk5htuZZWZNY,4788 +ray/rllib/examples/replay_buffer_api.py,sha256=7RbnKwJnR8sV08s4_JRagjIYpwtJxJ1IMS5DCIX8yhg,2551 +ray/rllib/examples/rl_modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/examples/rl_modules/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/rl_modules/__pycache__/action_masking_rl_module.cpython-311.pyc,, +ray/rllib/examples/rl_modules/__pycache__/custom_cnn_rl_module.cpython-311.pyc,, +ray/rllib/examples/rl_modules/__pycache__/custom_lstm_rl_module.cpython-311.pyc,, +ray/rllib/examples/rl_modules/__pycache__/migrate_modelv2_to_new_api_stack_by_config.cpython-311.pyc,, +ray/rllib/examples/rl_modules/__pycache__/migrate_modelv2_to_new_api_stack_by_policy_checkpoint.cpython-311.pyc,, +ray/rllib/examples/rl_modules/__pycache__/pretraining_single_agent_training_multi_agent.cpython-311.pyc,, +ray/rllib/examples/rl_modules/action_masking_rl_module.py,sha256=dZCgB2CeR-tsIc7FOPaczdymx1v5mInY3SePVi13nps,5338 +ray/rllib/examples/rl_modules/classes/__init__.py,sha256=_X-VyEj6kuAH_4tJ_B0_SCMj6Fz3yGqcc-19R6r4RCM,216 +ray/rllib/examples/rl_modules/classes/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/examples/rl_modules/classes/__pycache__/action_masking_rlm.cpython-311.pyc,, +ray/rllib/examples/rl_modules/classes/__pycache__/autoregressive_actions_rlm.cpython-311.pyc,, +ray/rllib/examples/rl_modules/classes/__pycache__/intrinsic_curiosity_model_rlm.cpython-311.pyc,, +ray/rllib/examples/rl_modules/classes/__pycache__/lstm_containing_rlm.cpython-311.pyc,, +ray/rllib/examples/rl_modules/classes/__pycache__/mobilenet_rlm.cpython-311.pyc,, +ray/rllib/examples/rl_modules/classes/__pycache__/modelv2_to_rlm.cpython-311.pyc,, +ray/rllib/examples/rl_modules/classes/__pycache__/random_rlm.cpython-311.pyc,, +ray/rllib/examples/rl_modules/classes/__pycache__/rock_paper_scissors_heuristic_rlm.cpython-311.pyc,, +ray/rllib/examples/rl_modules/classes/__pycache__/tiny_atari_cnn_rlm.cpython-311.pyc,, +ray/rllib/examples/rl_modules/classes/__pycache__/vpg_torch_rlm.cpython-311.pyc,, +ray/rllib/examples/rl_modules/classes/__pycache__/vpg_using_shared_encoder_rlm.cpython-311.pyc,, +ray/rllib/examples/rl_modules/classes/action_masking_rlm.py,sha256=49BCzZ2dalaRA07JAS-n-KYf3pYqeEOHi1kxIGaDP1Q,9350 +ray/rllib/examples/rl_modules/classes/autoregressive_actions_rlm.py,sha256=04kGtX7eXqIHBsKGhMvbFlTq4BgHnALFSBvRIQ09BTI,4817 +ray/rllib/examples/rl_modules/classes/intrinsic_curiosity_model_rlm.py,sha256=jc8rlo8fRIbflLSk8B-egThLXKlPs5z67HcgErn2x1U,9483 +ray/rllib/examples/rl_modules/classes/lstm_containing_rlm.py,sha256=iGMjGS_WuNhIuug8YQab_nio8aFjSHq6EEcnzPQjOJI,6039 +ray/rllib/examples/rl_modules/classes/mobilenet_rlm.py,sha256=rQAcvkGW7RVe6fpnQnp7_LQhVaKviRA76wWOlN3ytBQ,2905 +ray/rllib/examples/rl_modules/classes/modelv2_to_rlm.py,sha256=jNjhW_pE78dy77l7Z_mXpcZUnsJvSZ5dKuBsho-u8LM,9246 +ray/rllib/examples/rl_modules/classes/random_rlm.py,sha256=SgXlZTVtBRmprvB0qqcNPkxUa9ltuRR8KAFvY8fxUyM,2450 +ray/rllib/examples/rl_modules/classes/rock_paper_scissors_heuristic_rlm.py,sha256=R1HxK1crB7CKxniwoGD9qPLArUXGj2Svh-0qxtt_VnU,3652 +ray/rllib/examples/rl_modules/classes/tiny_atari_cnn_rlm.py,sha256=tyt78jKwLSMtIcIJ0b926waouxjah1AxP7Tzd_kLsio,7812 +ray/rllib/examples/rl_modules/classes/vpg_torch_rlm.py,sha256=PDFnPksFmCGMUWpV5OEVwoMAX4gQ7Fc4_ppGmn2HDRk,2014 +ray/rllib/examples/rl_modules/classes/vpg_using_shared_encoder_rlm.py,sha256=fRAr3xIZZrz5o8P-tg0dB7MW5xqzesdBXSOThp6zq0c,6468 +ray/rllib/examples/rl_modules/custom_cnn_rl_module.py,sha256=hbfFbM0dD3zH7DPESuHH68wEgjbgBzk3q34DgcEScxc,4929 +ray/rllib/examples/rl_modules/custom_lstm_rl_module.py,sha256=tKNMNERD37rcirZrM-QU2HQcblx1vl53onoG5AgFrB8,3976 +ray/rllib/examples/rl_modules/migrate_modelv2_to_new_api_stack_by_config.py,sha256=dsIkBuY_WwlPJoTy2AiNKESoYbTQMBSYJ7Xsxe994p8,2430 +ray/rllib/examples/rl_modules/migrate_modelv2_to_new_api_stack_by_policy_checkpoint.py,sha256=N2ii4hXBEm4FZx1NbrKniSgeqWEfootu8DrBVfWjTS8,3963 +ray/rllib/examples/rl_modules/pretraining_single_agent_training_multi_agent.py,sha256=RX7uQ-Wn770Dv3hYwJmarD31gmKR9_1FoDuz0btU5AA,7621 +ray/rllib/execution/__init__.py,sha256=PPaT8U0E3sl-rv8RG5NfRUd9WLjJviLdirpeyqJtxC8,697 +ray/rllib/execution/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/execution/__pycache__/learner_thread.cpython-311.pyc,, +ray/rllib/execution/__pycache__/minibatch_buffer.cpython-311.pyc,, +ray/rllib/execution/__pycache__/multi_gpu_learner_thread.cpython-311.pyc,, +ray/rllib/execution/__pycache__/replay_ops.cpython-311.pyc,, +ray/rllib/execution/__pycache__/rollout_ops.cpython-311.pyc,, +ray/rllib/execution/__pycache__/segment_tree.cpython-311.pyc,, +ray/rllib/execution/__pycache__/train_ops.cpython-311.pyc,, +ray/rllib/execution/buffers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/execution/buffers/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/execution/buffers/__pycache__/mixin_replay_buffer.cpython-311.pyc,, +ray/rllib/execution/buffers/mixin_replay_buffer.py,sha256=OG-oluxm_HXNWpXvORuM6AaeCmc2TtdBrQiLeTBctwM,6842 +ray/rllib/execution/learner_thread.py,sha256=cTICVornfI7RnbFcH1BdU1vpx3fMdegujZkZZlzaIiI,5733 +ray/rllib/execution/minibatch_buffer.py,sha256=vm6VLbRsnsXF7_Sm89B9ZNVApQNltGxOjgipfYmCxSE,1943 +ray/rllib/execution/multi_gpu_learner_thread.py,sha256=aQILYPxTi1ebcIOJg5fHyQQL3qVEXeu5DUOWwMfERBg,9666 +ray/rllib/execution/replay_ops.py,sha256=imKeNsqbDaw9nuDEcdEE861hJEM5fViMLClLxB-dj4c,1255 +ray/rllib/execution/rollout_ops.py,sha256=DjW-11NZ_5ooOzuXgFLtaOpanFvvrU3f9aTEbQm6Axw,8645 +ray/rllib/execution/segment_tree.py,sha256=ZjIZTfQjXmiNYbB-t2vnMMxrMMh9xN0mNN4inH07ax8,7863 +ray/rllib/execution/train_ops.py,sha256=1rvqFN2f0g2xYZ2k8cJ97RplAYJDlsmAoK76864hbHM,8133 +ray/rllib/models/__init__.py,sha256=97lHYQRcopNy5fgVZs3Cn00cekZA__Qynp6Ua9LFDk0,345 +ray/rllib/models/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/models/__pycache__/action_dist.cpython-311.pyc,, +ray/rllib/models/__pycache__/catalog.cpython-311.pyc,, +ray/rllib/models/__pycache__/distributions.cpython-311.pyc,, +ray/rllib/models/__pycache__/modelv2.cpython-311.pyc,, +ray/rllib/models/__pycache__/preprocessors.cpython-311.pyc,, +ray/rllib/models/__pycache__/repeated_values.cpython-311.pyc,, +ray/rllib/models/__pycache__/utils.cpython-311.pyc,, +ray/rllib/models/action_dist.py,sha256=fSNCThCOU9ncGevILfA0jofx4K6c45LiPkuotXL6Z1c,3425 +ray/rllib/models/catalog.py,sha256=dSdCb0oKsJWV1QRgE2OOPs8LYkltwjwIyoHcHLzKV9M,36151 +ray/rllib/models/distributions.py,sha256=Udk9rlDCwisO5JoVzH8RKi75KwHPR7jyYkiGDGBq9H0,8466 +ray/rllib/models/modelv2.py,sha256=feic6XpnqwYWOjFOhIbc5CQZo6xKtB69qT-HmHyz-oQ,17927 +ray/rllib/models/preprocessors.py,sha256=47xpS6UwC9xqS8uwKyVxF4C265eDeeQ49q6d8o8zc5w,16615 +ray/rllib/models/repeated_values.py,sha256=Alo7NfDCdI4v6h9-PCYMl-usueuHlUkVSXTxYKPckzw,6791 +ray/rllib/models/tf/__init__.py,sha256=JMAi3egccoqZz18C9UowdHf1EuJV8qxtkmxAaDwZ_oM,338 +ray/rllib/models/tf/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/models/tf/__pycache__/attention_net.cpython-311.pyc,, +ray/rllib/models/tf/__pycache__/complex_input_net.cpython-311.pyc,, +ray/rllib/models/tf/__pycache__/fcnet.cpython-311.pyc,, +ray/rllib/models/tf/__pycache__/misc.cpython-311.pyc,, +ray/rllib/models/tf/__pycache__/recurrent_net.cpython-311.pyc,, +ray/rllib/models/tf/__pycache__/tf_action_dist.cpython-311.pyc,, +ray/rllib/models/tf/__pycache__/tf_distributions.cpython-311.pyc,, +ray/rllib/models/tf/__pycache__/tf_modelv2.cpython-311.pyc,, +ray/rllib/models/tf/__pycache__/visionnet.cpython-311.pyc,, +ray/rllib/models/tf/attention_net.py,sha256=YNyUH83g64Xev15xQKAa3W7PjJUiovayJ20oqZsG2Ek,23014 +ray/rllib/models/tf/complex_input_net.py,sha256=ACeHGMTpwSC_crgILvfrW9oGP8WGhi5QzLdrPMbMTy0,8352 +ray/rllib/models/tf/fcnet.py,sha256=H_4lwDQi5Y1FZOAiB9hV257Jnkvqi6Ogl2qExiFg55g,5563 +ray/rllib/models/tf/layers/__init__.py,sha256=NZhUUnKuRbu2Ib8mpzZYjlU_vPhqa7gnvZ051e_D5hs,554 +ray/rllib/models/tf/layers/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/models/tf/layers/__pycache__/gru_gate.cpython-311.pyc,, +ray/rllib/models/tf/layers/__pycache__/multi_head_attention.cpython-311.pyc,, +ray/rllib/models/tf/layers/__pycache__/noisy_layer.cpython-311.pyc,, +ray/rllib/models/tf/layers/__pycache__/relative_multi_head_attention.cpython-311.pyc,, +ray/rllib/models/tf/layers/__pycache__/skip_connection.cpython-311.pyc,, +ray/rllib/models/tf/layers/gru_gate.py,sha256=3aSECwqBPsmDHLR1v6gqbMyC0TtV3wgZ_s9cbSePLSg,1972 +ray/rllib/models/tf/layers/multi_head_attention.py,sha256=4L41owitoqBV2NLSHZnV1f57v3Ek5bAZ-G7-d9TyYaA,2261 +ray/rllib/models/tf/layers/noisy_layer.py,sha256=X6rwy8se9Eyo8Vs1Tlg1CvP_XXkekQfi0NMPYtUzuYo,3965 +ray/rllib/models/tf/layers/relative_multi_head_attention.py,sha256=8oqt7JVqwXNRTh8oNqfX30dDFlEv3_yz9TN9COBWteA,5761 +ray/rllib/models/tf/layers/skip_connection.py,sha256=0f7NobGAVvPLmrJSPpL47o7gLKGsczhPSpTwRmGTMmQ,1657 +ray/rllib/models/tf/misc.py,sha256=EFxtwbvnyzQpq_TNfom5dV-6SyAR5RMukMqOXO2TrcE,2657 +ray/rllib/models/tf/recurrent_net.py,sha256=EnOampB1aMd8agCU5AmyJ9U2btZdSQgI33cOBRqiU5E,11572 +ray/rllib/models/tf/tf_action_dist.py,sha256=e4j24NszFYnlr86UFP758TP7RDMEFtlNV_YvmKfcsmM,27264 +ray/rllib/models/tf/tf_distributions.py,sha256=8MRwLzMi2b-_qOXXfk6jbz3Hdu4cqZPSxuhJXFCDM2E,18735 +ray/rllib/models/tf/tf_modelv2.py,sha256=y728MmHAsW49CpRbs6YCzHtV2LyLBgnS9WmabQo9N0o,5128 +ray/rllib/models/tf/visionnet.py,sha256=6hSrVub_CGp1ttbDjk-6LK3Y-I1eBQbyplzAKE0TSVk,10645 +ray/rllib/models/torch/__init__.py,sha256=zM2oOUgiqMKv7qQW2pBM6XyIqqjddHvTfnVoSEbjoos,387 +ray/rllib/models/torch/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/models/torch/__pycache__/attention_net.cpython-311.pyc,, +ray/rllib/models/torch/__pycache__/complex_input_net.cpython-311.pyc,, +ray/rllib/models/torch/__pycache__/fcnet.cpython-311.pyc,, +ray/rllib/models/torch/__pycache__/mingpt.cpython-311.pyc,, +ray/rllib/models/torch/__pycache__/misc.cpython-311.pyc,, +ray/rllib/models/torch/__pycache__/recurrent_net.cpython-311.pyc,, +ray/rllib/models/torch/__pycache__/torch_action_dist.cpython-311.pyc,, +ray/rllib/models/torch/__pycache__/torch_distributions.cpython-311.pyc,, +ray/rllib/models/torch/__pycache__/torch_modelv2.cpython-311.pyc,, +ray/rllib/models/torch/__pycache__/visionnet.cpython-311.pyc,, +ray/rllib/models/torch/attention_net.py,sha256=M8gA4HMsxOxbaukkkv2dPyctO33sGw007XkQZ6_rko4,18228 +ray/rllib/models/torch/complex_input_net.py,sha256=vNfK7xeyneVQpB5Lswt2RAGCqgNWPCe6Nuflsleyw9o,9287 +ray/rllib/models/torch/fcnet.py,sha256=H2AoV9A66lWs0otShELn-oGZfAhmDUYIRKhbrbMIL0I,5902 +ray/rllib/models/torch/mingpt.py,sha256=8opj4Sb9-SnE3wOpSSiG9BagldCQlgIWtZBfLJCJ4z8,11163 +ray/rllib/models/torch/misc.py,sha256=IO3Q4OoBxcrT1ug3eyWQEKs0MTWSvyOZAzW7d2SjpEc,11631 +ray/rllib/models/torch/modules/__init__.py,sha256=HcEs6_p32uWqTvqexeyYWLAt707FcyNQZkTHKGZ7zLw,438 +ray/rllib/models/torch/modules/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/models/torch/modules/__pycache__/gru_gate.cpython-311.pyc,, +ray/rllib/models/torch/modules/__pycache__/multi_head_attention.cpython-311.pyc,, +ray/rllib/models/torch/modules/__pycache__/noisy_layer.cpython-311.pyc,, +ray/rllib/models/torch/modules/__pycache__/relative_multi_head_attention.cpython-311.pyc,, +ray/rllib/models/torch/modules/__pycache__/skip_connection.cpython-311.pyc,, +ray/rllib/models/torch/modules/gru_gate.py,sha256=JdVCD8KywnSzghNMwsjOrRUeFVP8C2fC8NDBVafo6yo,2334 +ray/rllib/models/torch/modules/multi_head_attention.py,sha256=Jpo-8iIL1dB13M6-D9FTZA2obxDHawV11Y_Q4TLZVio,2504 +ray/rllib/models/torch/modules/noisy_layer.py,sha256=8xWGXFyhQPOZQ4fhT4-6JZZe7FEAuieReblh6xnPA2s,3406 +ray/rllib/models/torch/modules/relative_multi_head_attention.py,sha256=f7L38tc2SwrbqUBJ6a6BFSPGGTEV08zaIEQE72K71C0,6336 +ray/rllib/models/torch/modules/skip_connection.py,sha256=q5n3nzS67RKuSBrdwGbG13Fr6cyMdr3tWjHrzDA54Bc,1454 +ray/rllib/models/torch/recurrent_net.py,sha256=qmMT4MXgGFWSy0f5a1bauDy6bujbZWTa5P09S6bE_h8,12227 +ray/rllib/models/torch/torch_action_dist.py,sha256=y7dTpDGCOcc9TUtKkDSYyV5mm0rsHqGAypBkUBAZCIE,24344 +ray/rllib/models/torch/torch_distributions.py,sha256=gJ8efpLOlngEythfuGT0-nBfnaUBmz2CeHluX-dxEjc,23772 +ray/rllib/models/torch/torch_modelv2.py,sha256=RSrIs-IMv66lX6i6eOYQ5IR3ee2R6n1LkTrdacCPyKg,2709 +ray/rllib/models/torch/visionnet.py,sha256=HF7d0r7Ts7XWqz59DYkwV39Jn-11XQl2uU_hhgxYY5Q,10803 +ray/rllib/models/utils.py,sha256=8plV3aXuxlibL1suORYB51vIepz7nxYE_t63YTd1HVA,10026 +ray/rllib/offline/__init__.py,sha256=WLO9oRv0vc6ujxHK1Dwt_uViwImYkv5E-zLSbXJJ3_o,1045 +ray/rllib/offline/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/offline/__pycache__/d4rl_reader.cpython-311.pyc,, +ray/rllib/offline/__pycache__/dataset_reader.cpython-311.pyc,, +ray/rllib/offline/__pycache__/dataset_writer.cpython-311.pyc,, +ray/rllib/offline/__pycache__/feature_importance.cpython-311.pyc,, +ray/rllib/offline/__pycache__/input_reader.cpython-311.pyc,, +ray/rllib/offline/__pycache__/io_context.cpython-311.pyc,, +ray/rllib/offline/__pycache__/is_estimator.cpython-311.pyc,, +ray/rllib/offline/__pycache__/json_reader.cpython-311.pyc,, +ray/rllib/offline/__pycache__/json_writer.cpython-311.pyc,, +ray/rllib/offline/__pycache__/mixed_input.cpython-311.pyc,, +ray/rllib/offline/__pycache__/off_policy_estimator.cpython-311.pyc,, +ray/rllib/offline/__pycache__/offline_data.cpython-311.pyc,, +ray/rllib/offline/__pycache__/offline_env_runner.cpython-311.pyc,, +ray/rllib/offline/__pycache__/offline_evaluation_utils.cpython-311.pyc,, +ray/rllib/offline/__pycache__/offline_evaluator.cpython-311.pyc,, +ray/rllib/offline/__pycache__/offline_prelearner.cpython-311.pyc,, +ray/rllib/offline/__pycache__/output_writer.cpython-311.pyc,, +ray/rllib/offline/__pycache__/resource.cpython-311.pyc,, +ray/rllib/offline/__pycache__/shuffled_input.cpython-311.pyc,, +ray/rllib/offline/__pycache__/wis_estimator.cpython-311.pyc,, +ray/rllib/offline/d4rl_reader.py,sha256=80fJA96y2BaOIVushDqszTCCTYnNa-cFP8-s9gen9Dg,1595 +ray/rllib/offline/dataset_reader.py,sha256=6vKwDxmerosMedsjv8cI5-pntJchteDOg_LF5UEPemU,11709 +ray/rllib/offline/dataset_writer.py,sha256=gBielIc-jckjZUMlbutD3mSEyIDffczrZDzyGk78i8k,2801 +ray/rllib/offline/estimators/__init__.py,sha256=57f-aPF0vHWLaK88gxnt6o_YOorNEenyRCOZI7gIIns,544 +ray/rllib/offline/estimators/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/offline/estimators/__pycache__/direct_method.cpython-311.pyc,, +ray/rllib/offline/estimators/__pycache__/doubly_robust.cpython-311.pyc,, +ray/rllib/offline/estimators/__pycache__/feature_importance.cpython-311.pyc,, +ray/rllib/offline/estimators/__pycache__/fqe_torch_model.cpython-311.pyc,, +ray/rllib/offline/estimators/__pycache__/importance_sampling.cpython-311.pyc,, +ray/rllib/offline/estimators/__pycache__/off_policy_estimator.cpython-311.pyc,, +ray/rllib/offline/estimators/__pycache__/weighted_importance_sampling.cpython-311.pyc,, +ray/rllib/offline/estimators/direct_method.py,sha256=Jjedk6oH9h1xcbdlF_s_SiG2JfEMWqUJX0drgaMqnT8,6746 +ray/rllib/offline/estimators/doubly_robust.py,sha256=XchVO0ohK91avoKLtr9MY8-UblKAjN5gzqTaCUl6Mxk,9620 +ray/rllib/offline/estimators/feature_importance.py,sha256=MyCB2ZmHrn0Ohol2yNTDbY-ZKMfZxjL_ac5MRMUGsrk,336 +ray/rllib/offline/estimators/fqe_torch_model.py,sha256=CgRdfL9DmaycNAkbUPEXmZCa65LF7kkduh10IDqAM2k,11850 +ray/rllib/offline/estimators/importance_sampling.py,sha256=5eP5uEwLZ_2wsB3TwKfdDTj5jryikkj-i7X8yFsPWsM,4602 +ray/rllib/offline/estimators/off_policy_estimator.py,sha256=MMuzkROQuVQjS_1ZCpKPoBoqSIwOl-pvdqwbM-SGZ00,10120 +ray/rllib/offline/estimators/weighted_importance_sampling.py,sha256=-wOirgqeroj9KwqfERLED9_Ls2-NeCSxyxUZT9_sOco,7047 +ray/rllib/offline/feature_importance.py,sha256=fdkxMYbL0tUsKxMfV0b0OfjI-UwM0fcACt0nMdrXbI0,10680 +ray/rllib/offline/input_reader.py,sha256=Um89vZZdOl0ghIj9aDSRxX79mMHnVUgEOVNo0q8bUqs,4854 +ray/rllib/offline/io_context.py,sha256=VCMCZuPeOepo07uM5cWOfNLHqkfwWrWdmyRWkHt9hSA,2543 +ray/rllib/offline/is_estimator.py,sha256=mg_Pdhd3Ux-fb2de4om_mJUsLo325iOyoAM0JjcRpjk,308 +ray/rllib/offline/json_reader.py,sha256=4AMsNOuxkaeR7EtxGThyKxlFzRA2Zyb-Cc49OmZEs1c,16889 +ray/rllib/offline/json_writer.py,sha256=BvxbDJ4mViG7QT0aJY7cq-ceNYySy-R7y5onxKoDLFc,4960 +ray/rllib/offline/mixed_input.py,sha256=udGI8goUdupXAKdUbo4FzXX8j40rG8c2obGrHU8XySE,2029 +ray/rllib/offline/off_policy_estimator.py,sha256=aygoIfKqXX5XO2eo3sIg86L-QWUaarMY8BnY2UEUD4w,315 +ray/rllib/offline/offline_data.py,sha256=_KV4XekAI_J7qK8Q4I-HLgMBEkUW_4IzBpMCP8VDWMQ,10238 +ray/rllib/offline/offline_env_runner.py,sha256=xlDKD-FGqsWBeGpkg43agPvGIEFnf7Yl3EIN1MigSdk,13429 +ray/rllib/offline/offline_evaluation_utils.py,sha256=L5_TKKFkQ7V2jbkPgIkngdrSUlXJgmtTp1VbQG-Tf0I,4743 +ray/rllib/offline/offline_evaluator.py,sha256=0fkHuiwlVSEgtiKTp6Y0PPuF4Zn3uAez6wN_N8FcLmk,2286 +ray/rllib/offline/offline_prelearner.py,sha256=fgS9sspcs7EC23_SJ0PkOtWWt4OvNbjLongUPEukkLE,29060 +ray/rllib/offline/output_writer.py,sha256=t-iKGb1_v7bXVoIpxS8TOdPOv80pOUeobm_6sYbJ6SA,660 +ray/rllib/offline/resource.py,sha256=ZdivH-jRTDIZh0gczaixKPccL45Wdtp-A4Cjm6r5xPU,1264 +ray/rllib/offline/shuffled_input.py,sha256=PEZtbyTdpGVY0FGAjXd_bflEj5GETCnjtrrbutAzj1M,1355 +ray/rllib/offline/wis_estimator.py,sha256=qWBgDZ_pmSTeNrdwMwalVt89ciNKDRkbkyzw8KB_Drg,374 +ray/rllib/policy/__init__.py,sha256=XtSjY7iVde_gd_08Zi1i2oaEUL-R8mbFUcQ45wAzotE,386 +ray/rllib/policy/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/policy/__pycache__/dynamic_tf_policy.cpython-311.pyc,, +ray/rllib/policy/__pycache__/dynamic_tf_policy_v2.cpython-311.pyc,, +ray/rllib/policy/__pycache__/eager_tf_policy.cpython-311.pyc,, +ray/rllib/policy/__pycache__/eager_tf_policy_v2.cpython-311.pyc,, +ray/rllib/policy/__pycache__/policy.cpython-311.pyc,, +ray/rllib/policy/__pycache__/policy_map.cpython-311.pyc,, +ray/rllib/policy/__pycache__/policy_template.cpython-311.pyc,, +ray/rllib/policy/__pycache__/rnn_sequencing.cpython-311.pyc,, +ray/rllib/policy/__pycache__/sample_batch.cpython-311.pyc,, +ray/rllib/policy/__pycache__/tf_mixins.cpython-311.pyc,, +ray/rllib/policy/__pycache__/tf_policy.cpython-311.pyc,, +ray/rllib/policy/__pycache__/tf_policy_template.cpython-311.pyc,, +ray/rllib/policy/__pycache__/torch_mixins.cpython-311.pyc,, +ray/rllib/policy/__pycache__/torch_policy.cpython-311.pyc,, +ray/rllib/policy/__pycache__/torch_policy_v2.cpython-311.pyc,, +ray/rllib/policy/__pycache__/view_requirement.cpython-311.pyc,, +ray/rllib/policy/dynamic_tf_policy.py,sha256=gC4b0QhOoDcG9hTxAYaMUe8RY2CUf0xNIgpXjE08bqA,57830 +ray/rllib/policy/dynamic_tf_policy_v2.py,sha256=fv4mV92m-XSkcnHGGfZellHrBCjpR90xzQIcdlZpvgw,40748 +ray/rllib/policy/eager_tf_policy.py,sha256=YQi7gAjaoIg6_j1kfsCtb864SDdch61X41TMIpOha2A,43461 +ray/rllib/policy/eager_tf_policy_v2.py,sha256=EMWMsm0tsElEKXfl0X25mjtuefaH_Tfov7EpmN4S2WU,35968 +ray/rllib/policy/policy.py,sha256=A6EZ3Kmd_txNzXjpCUH_slgcEPAT7BeX1-tQXRxYuJ4,69973 +ray/rllib/policy/policy_map.py,sha256=bsMjDwpyEZzucVXyiHVeTr9scuhJyMY34LvW_StGX-8,10251 +ray/rllib/policy/policy_template.py,sha256=4uLX4-rCOo9bCroiUV4J05ZCzFNFIHmDsRaQfOVkBgU,19797 +ray/rllib/policy/rnn_sequencing.py,sha256=wUG2_f_sCmuZx2Nyfb2mOBLlUUrlGJoT0hP81FeKUkQ,26865 +ray/rllib/policy/sample_batch.py,sha256=kaZKFso3_0jTEioBG-lgu-nPHEo76zMOYUnyiYkyGfk,68050 +ray/rllib/policy/tf_mixins.py,sha256=KGejDCOO3bECkaChPVsHfVLJvuTdzsrtRssaqtjVbxg,15279 +ray/rllib/policy/tf_policy.py,sha256=VK8SeEUFow3oUY4QuR3AZIBm-EZT9zuvFmWkho2cFD8,48819 +ray/rllib/policy/tf_policy_template.py,sha256=VH7-h1zQ60ljLA6XH8j8sYIvSxWVcj9hrR2z5ASm2eI,16606 +ray/rllib/policy/torch_mixins.py,sha256=fF1me7JfH_gQg_p0lnOipe0zOYm_8nPQD0xz21kfkGk,8682 +ray/rllib/policy/torch_policy.py,sha256=cfo1ZT0vpHLM97AxOu_ydDDDmHGjW9IIja13AsuOP7E,49541 +ray/rllib/policy/torch_policy_v2.py,sha256=Fg6sZIZ707xtDM5_aiIx_TqgSHX8BOTLVQtHEXy9mgQ,49486 +ray/rllib/policy/view_requirement.py,sha256=6uFLadh3LImwbpg6-FNWV1rQc5ITeUN_mVAPW9bmEJg,6293 +ray/rllib/tuned_examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/tuned_examples/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/tuned_examples/__pycache__/cleanup_experiment.cpython-311.pyc,, +ray/rllib/tuned_examples/cleanup_experiment.py,sha256=M-3Aq_7BpWCtbBlfGRLwjFxhdSsxa4gzc4fp5txj3xE,7538 +ray/rllib/tuned_examples/dreamerv3/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/tuned_examples/dreamerv3/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/tuned_examples/dreamerv3/__pycache__/atari_100k.cpython-311.pyc,, +ray/rllib/tuned_examples/dreamerv3/__pycache__/atari_200M.cpython-311.pyc,, +ray/rllib/tuned_examples/dreamerv3/__pycache__/cartpole.cpython-311.pyc,, +ray/rllib/tuned_examples/dreamerv3/__pycache__/dm_control_suite_vision.cpython-311.pyc,, +ray/rllib/tuned_examples/dreamerv3/__pycache__/flappy_bird.cpython-311.pyc,, +ray/rllib/tuned_examples/dreamerv3/__pycache__/frozenlake_2x2.cpython-311.pyc,, +ray/rllib/tuned_examples/dreamerv3/__pycache__/frozenlake_4x4_deterministic.cpython-311.pyc,, +ray/rllib/tuned_examples/dreamerv3/__pycache__/gymnasium_robotics.cpython-311.pyc,, +ray/rllib/tuned_examples/dreamerv3/__pycache__/highway_env.cpython-311.pyc,, +ray/rllib/tuned_examples/dreamerv3/__pycache__/pendulum.cpython-311.pyc,, +ray/rllib/tuned_examples/dreamerv3/atari_100k.py,sha256=Fj89gYscUyw4TTHenl30Pv29-ngwqIeZ1gfVo7pEZ78,2771 +ray/rllib/tuned_examples/dreamerv3/atari_200M.py,sha256=Qk4b5BzQGeo6yzFo5YiECsDtblpBzsbddIPZJc0uTVA,2973 +ray/rllib/tuned_examples/dreamerv3/cartpole.py,sha256=rUX_AG0ozm2M0hUoeAZR2Tm2xOhzXb5M1dRW1EGwffE,561 +ray/rllib/tuned_examples/dreamerv3/dm_control_suite_vision.py,sha256=ViZgBXih3a45gLymrm8P5HCJ1KYbl75CSaNVqNZRPZY,1702 +ray/rllib/tuned_examples/dreamerv3/flappy_bird.py,sha256=R_M3XjJz_Wt9eSuW43EwcX61wrI8mbdmiE21HuKesN8,2463 +ray/rllib/tuned_examples/dreamerv3/frozenlake_2x2.py,sha256=i2oDe4u9JhgFqtxOQwxQmMushJp20MBZ7gHds3wL2AI,725 +ray/rllib/tuned_examples/dreamerv3/frozenlake_4x4_deterministic.py,sha256=nbH9oz2w9RCC6nK4rJwb_ULFCLCnx_3xbnQ17oZwjjA,677 +ray/rllib/tuned_examples/dreamerv3/gymnasium_robotics.py,sha256=AaFzzS1BVG34oZx3tFliwfWFyiFKSCqwDyochdjspro,2213 +ray/rllib/tuned_examples/dreamerv3/highway_env.py,sha256=a5riNBiIkPoVLbCeMq1Xge7GTrpYMaxMhzyxYLLJpNg,2230 +ray/rllib/tuned_examples/dreamerv3/pendulum.py,sha256=ps8wzAErJLAxgBHboR6OPCWOJtpyobVOj5zPU9Kn0HA,538 +ray/rllib/utils/__init__.py,sha256=euAcEKF3yAaYjoOijMS__y4IQ1Q4DudMtmMBYm-3VjY,3114 +ray/rllib/utils/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/utils/__pycache__/actor_manager.cpython-311.pyc,, +ray/rllib/utils/__pycache__/actors.cpython-311.pyc,, +ray/rllib/utils/__pycache__/annotations.cpython-311.pyc,, +ray/rllib/utils/__pycache__/checkpoints.cpython-311.pyc,, +ray/rllib/utils/__pycache__/compression.cpython-311.pyc,, +ray/rllib/utils/__pycache__/deprecation.cpython-311.pyc,, +ray/rllib/utils/__pycache__/error.cpython-311.pyc,, +ray/rllib/utils/__pycache__/filter.cpython-311.pyc,, +ray/rllib/utils/__pycache__/filter_manager.cpython-311.pyc,, +ray/rllib/utils/__pycache__/framework.cpython-311.pyc,, +ray/rllib/utils/__pycache__/from_config.cpython-311.pyc,, +ray/rllib/utils/__pycache__/images.cpython-311.pyc,, +ray/rllib/utils/__pycache__/lambda_defaultdict.cpython-311.pyc,, +ray/rllib/utils/__pycache__/memory.cpython-311.pyc,, +ray/rllib/utils/__pycache__/minibatch_utils.cpython-311.pyc,, +ray/rllib/utils/__pycache__/numpy.cpython-311.pyc,, +ray/rllib/utils/__pycache__/policy.cpython-311.pyc,, +ray/rllib/utils/__pycache__/serialization.cpython-311.pyc,, +ray/rllib/utils/__pycache__/sgd.cpython-311.pyc,, +ray/rllib/utils/__pycache__/tensor_dtype.cpython-311.pyc,, +ray/rllib/utils/__pycache__/test_utils.cpython-311.pyc,, +ray/rllib/utils/__pycache__/tf_run_builder.cpython-311.pyc,, +ray/rllib/utils/__pycache__/tf_utils.cpython-311.pyc,, +ray/rllib/utils/__pycache__/threading.cpython-311.pyc,, +ray/rllib/utils/__pycache__/torch_utils.cpython-311.pyc,, +ray/rllib/utils/__pycache__/typing.cpython-311.pyc,, +ray/rllib/utils/actor_manager.py,sha256=QEDfli_M33g5tZM2a9VXI8Vw9DhkY8MAHIII0PORzM4,36396 +ray/rllib/utils/actors.py,sha256=S7yXvKYUJEoq2Jo2bLh3Un6p3r3GKWHPH1XgBCSoRYI,9964 +ray/rllib/utils/annotations.py,sha256=E2nf5FhK4YuYHn_RDDA7vDSEzWuB_W1CyIsxBRp2014,6832 +ray/rllib/utils/checkpoints.py,sha256=aM5qemKg3d_vlB6uW4NgwFUC2DTt6MPEjSSl8-QsbY0,42603 +ray/rllib/utils/compression.py,sha256=ACo3jgBm0M1C7RLdgSFQaB9Teic6nRC-kJMcVf8cV58,2162 +ray/rllib/utils/debug/__init__.py,sha256=IqDAlg6WAQj3mxVUoLtA235CwtEm5cHfv8SZuR6RFzQ,290 +ray/rllib/utils/debug/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/utils/debug/__pycache__/deterministic.cpython-311.pyc,, +ray/rllib/utils/debug/__pycache__/memory.cpython-311.pyc,, +ray/rllib/utils/debug/__pycache__/summary.cpython-311.pyc,, +ray/rllib/utils/debug/deterministic.py,sha256=fQuXHTgKjkfgrqMb-kdty0hVUZWFcwFDY1SpGfwZLQY,1682 +ray/rllib/utils/debug/memory.py,sha256=iqLoPulbdgmx1Vlk5eNwkGGyhs4zyYLtWLJNO9oAfNI,7788 +ray/rllib/utils/debug/summary.py,sha256=u7KrerexOQprlUMIh-X6jK3mjUiw8uty7uOxmPvfRL0,2336 +ray/rllib/utils/deprecation.py,sha256=Ru3nCI_LSxcwMIzb8wIaPGkN4_oVqxwwB1E1x3wHWz8,4580 +ray/rllib/utils/error.py,sha256=qEUAys-RCPd4AGIpOM-EeodNJ-0eAoT2mNypWHTCbeo,5220 +ray/rllib/utils/exploration/__init__.py,sha256=3cxogxAbxHskETM9HRLZ5gghVh2ljccrf5_XMaZB28s,1668 +ray/rllib/utils/exploration/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/utils/exploration/__pycache__/curiosity.cpython-311.pyc,, +ray/rllib/utils/exploration/__pycache__/epsilon_greedy.cpython-311.pyc,, +ray/rllib/utils/exploration/__pycache__/exploration.cpython-311.pyc,, +ray/rllib/utils/exploration/__pycache__/gaussian_noise.cpython-311.pyc,, +ray/rllib/utils/exploration/__pycache__/ornstein_uhlenbeck_noise.cpython-311.pyc,, +ray/rllib/utils/exploration/__pycache__/parameter_noise.cpython-311.pyc,, +ray/rllib/utils/exploration/__pycache__/per_worker_epsilon_greedy.cpython-311.pyc,, +ray/rllib/utils/exploration/__pycache__/per_worker_gaussian_noise.cpython-311.pyc,, +ray/rllib/utils/exploration/__pycache__/per_worker_ornstein_uhlenbeck_noise.cpython-311.pyc,, +ray/rllib/utils/exploration/__pycache__/random.cpython-311.pyc,, +ray/rllib/utils/exploration/__pycache__/random_encoder.cpython-311.pyc,, +ray/rllib/utils/exploration/__pycache__/slate_epsilon_greedy.cpython-311.pyc,, +ray/rllib/utils/exploration/__pycache__/slate_soft_q.cpython-311.pyc,, +ray/rllib/utils/exploration/__pycache__/soft_q.cpython-311.pyc,, +ray/rllib/utils/exploration/__pycache__/stochastic_sampling.cpython-311.pyc,, +ray/rllib/utils/exploration/__pycache__/thompson_sampling.cpython-311.pyc,, +ray/rllib/utils/exploration/__pycache__/upper_confidence_bound.cpython-311.pyc,, +ray/rllib/utils/exploration/curiosity.py,sha256=LbPUwwlWPL6PNGFKNAAyi4YucQ0dWH9ch0Ieml-Zr9I,18661 +ray/rllib/utils/exploration/epsilon_greedy.py,sha256=yukf_Gj96CQnmrgpbKdYkJuuw2-vZROT1l7wPMF-9r8,9428 +ray/rllib/utils/exploration/exploration.py,sha256=3d_DztwrzcCS2E-j3-oUMyA0JAFLyOpedTA0hgqZ1E0,7176 +ray/rllib/utils/exploration/gaussian_noise.py,sha256=9hHW2O7WXFN1_Qo6J_2FVWLN5eU8P7muXWM4YmOso3s,9196 +ray/rllib/utils/exploration/ornstein_uhlenbeck_noise.py,sha256=rb-POiw1AiYdR4vgmt0P0uFSXi9zQ-dB5nYcjBhwTzc,10452 +ray/rllib/utils/exploration/parameter_noise.py,sha256=LQxNsmm4iYaucvCApB05QMajI4uXmeB3W-VeabFthL4,17225 +ray/rllib/utils/exploration/per_worker_epsilon_greedy.py,sha256=oo03AEQCuooqANuixh9dkqnoy1bHCXmQ2Dr1tuHNylo,2145 +ray/rllib/utils/exploration/per_worker_gaussian_noise.py,sha256=17N36vKaulFnTFgNn4ArVRWYTkZ2Xi0TIPYVZInxlaA,1778 +ray/rllib/utils/exploration/per_worker_ornstein_uhlenbeck_noise.py,sha256=sRkfwcIXLH75zsiGuoxMWBnIQWq37TzTQmy-_VH-d2k,1946 +ray/rllib/utils/exploration/random.py,sha256=SflzExLT2-axDvO_jFoqA9hNnW3GwBNiHXoBvv-zf9Y,6660 +ray/rllib/utils/exploration/random_encoder.py,sha256=W5UONFEB_qr-mqUUmAjiZHATNQr2gyOTRQVhxQHhPLs,10694 +ray/rllib/utils/exploration/slate_epsilon_greedy.py,sha256=mS-xxsFlIl_2qq-E74Q-KU0KMNM0chj4GncY3PrKdVE,3871 +ray/rllib/utils/exploration/slate_soft_q.py,sha256=RBOHsroxQQIPXS9gwFFR9XtpJOLj1L_j5qkGZIhazJA,1509 +ray/rllib/utils/exploration/soft_q.py,sha256=M2WARqVCq0EjgpMjFaVRmwisrQWxw4LUHmx_QlF_vS4,2114 +ray/rllib/utils/exploration/stochastic_sampling.py,sha256=Qn5E2htrdgY5q0MLuYDYDtPMiYzRX_nWUEb3jb8e0qg,5426 +ray/rllib/utils/exploration/thompson_sampling.py,sha256=P9WGW-CyCRIgIWoTevqbVDyf2dYYzIq0rkgBW0ER49E,1490 +ray/rllib/utils/exploration/upper_confidence_bound.py,sha256=fmvRbfNkX45JJB_XbGq5N8mWWXMDBTmd7y8h53z-iXE,1405 +ray/rllib/utils/filter.py,sha256=tu4PmzvSes5sTnMckxL5lC4hg1xHAubhuc_t5zX0mq4,12667 +ray/rllib/utils/filter_manager.py,sha256=8xIe_spWnh9A6BaMkp8RsntXWYmzcrZl5XLG9arxDqM,3238 +ray/rllib/utils/framework.py,sha256=apbYCRyDFawaRKN9A3R29_Xw54HSoXdq4ZMzX0nswB8,12900 +ray/rllib/utils/from_config.py,sha256=7fMZKDTeklSfkl_ZDZqluJWCqFEFuxsOSJWcMWoPr3U,11701 +ray/rllib/utils/images.py,sha256=-2tvSRCZ5xTLMNm9RUMkzxlyfxu16C_0G7A8CH1UYys,1557 +ray/rllib/utils/lambda_defaultdict.py,sha256=Z7qlHYxnUsqLELE_AF585VGdG6GtbT-_bnpNjjuViyw,1998 +ray/rllib/utils/memory.py,sha256=sfOeYcGIk6Ltam5bG9oyXjMCWyfyGpn5BAUlGP5LnfA,251 +ray/rllib/utils/metrics/__init__.py,sha256=Tr5mFKYma1tIz5oCxNq3X_G_5GalXLqI0qu2zqpHUZ0,7723 +ray/rllib/utils/metrics/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/utils/metrics/__pycache__/learner_info.cpython-311.pyc,, +ray/rllib/utils/metrics/__pycache__/metrics_logger.cpython-311.pyc,, +ray/rllib/utils/metrics/__pycache__/stats.cpython-311.pyc,, +ray/rllib/utils/metrics/__pycache__/window_stat.cpython-311.pyc,, +ray/rllib/utils/metrics/learner_info.py,sha256=lVD_nEO_bh8ANIVMTfg82duruRE8BWNP306ShoBoXH4,4440 +ray/rllib/utils/metrics/metrics_logger.py,sha256=vvtUD0YCp6zhm8KP7PAMmnFbvjBsp3OrZW-2speKnLs,54257 +ray/rllib/utils/metrics/stats.py,sha256=rlV-e_RtC32iRSU8M_Sqdz8rslQFJZFqbIKw9ZXJ4LA,33147 +ray/rllib/utils/metrics/window_stat.py,sha256=6m5JtxatluH1qJrdZFYR9DT6b3P1IyPEMGHqsvkPDRI,2553 +ray/rllib/utils/minibatch_utils.py,sha256=cI6S8At5EvCGIPAE-xBzvWppIjScy6Ghgk78Vmrarg0,14026 +ray/rllib/utils/numpy.py,sha256=j9haMwMKdujKJvBNCh-b0-EDq5VUQN50vOvnQ67mPzg,20051 +ray/rllib/utils/policy.py,sha256=0fKSSr5fdRCm7tLSlyky33NucgxFno9BpusFzRzFqYM,11243 +ray/rllib/utils/postprocessing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/utils/postprocessing/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/utils/postprocessing/__pycache__/episodes.cpython-311.pyc,, +ray/rllib/utils/postprocessing/__pycache__/value_predictions.cpython-311.pyc,, +ray/rllib/utils/postprocessing/__pycache__/zero_padding.cpython-311.pyc,, +ray/rllib/utils/postprocessing/episodes.py,sha256=lXW2IZJCwH-k8V8jGgqngcl_jIjrPLPBmdm3ogQUnVQ,5263 +ray/rllib/utils/postprocessing/value_predictions.py,sha256=ts899IEI25w-vnNnJaMoXNDhvhxZKRFNS5GUDhEgm9o,4313 +ray/rllib/utils/postprocessing/zero_padding.py,sha256=xRsAxQ8-0QVILR6pVz-UbRaN8BY_UVvodSISAp6pWtE,8034 +ray/rllib/utils/pre_checks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/utils/pre_checks/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/utils/pre_checks/__pycache__/env.cpython-311.pyc,, +ray/rllib/utils/pre_checks/env.py,sha256=iotuhWJAtGDbN211XbdaWpv3ThjJ6zqIEXSDnjIzt7Y,10850 +ray/rllib/utils/replay_buffers/__init__.py,sha256=NonMPynNBe-FUXOFrikci5z096fVWKEtJwQlbpuqgVA,1616 +ray/rllib/utils/replay_buffers/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/utils/replay_buffers/__pycache__/base.cpython-311.pyc,, +ray/rllib/utils/replay_buffers/__pycache__/episode_replay_buffer.cpython-311.pyc,, +ray/rllib/utils/replay_buffers/__pycache__/fifo_replay_buffer.cpython-311.pyc,, +ray/rllib/utils/replay_buffers/__pycache__/multi_agent_episode_buffer.cpython-311.pyc,, +ray/rllib/utils/replay_buffers/__pycache__/multi_agent_mixin_replay_buffer.cpython-311.pyc,, +ray/rllib/utils/replay_buffers/__pycache__/multi_agent_prioritized_episode_buffer.cpython-311.pyc,, +ray/rllib/utils/replay_buffers/__pycache__/multi_agent_prioritized_replay_buffer.cpython-311.pyc,, +ray/rllib/utils/replay_buffers/__pycache__/multi_agent_replay_buffer.cpython-311.pyc,, +ray/rllib/utils/replay_buffers/__pycache__/prioritized_episode_buffer.cpython-311.pyc,, +ray/rllib/utils/replay_buffers/__pycache__/prioritized_replay_buffer.cpython-311.pyc,, +ray/rllib/utils/replay_buffers/__pycache__/replay_buffer.cpython-311.pyc,, +ray/rllib/utils/replay_buffers/__pycache__/reservoir_replay_buffer.cpython-311.pyc,, +ray/rllib/utils/replay_buffers/__pycache__/simple_replay_buffer.cpython-311.pyc,, +ray/rllib/utils/replay_buffers/__pycache__/utils.cpython-311.pyc,, +ray/rllib/utils/replay_buffers/base.py,sha256=abZy1tEYskdv-vvWwxyI3qJWIRC2Ev9LMC72BzNus4E,2271 +ray/rllib/utils/replay_buffers/episode_replay_buffer.py,sha256=pUTiOid8tn5oX5tbsz-6G-x1erjB8H4UuEES-LOKbXw,46687 +ray/rllib/utils/replay_buffers/fifo_replay_buffer.py,sha256=GjiVr6KtompDEKfpbwmUiOMn_80dhXVahbo5qcNm7b4,3489 +ray/rllib/utils/replay_buffers/multi_agent_episode_buffer.py,sha256=tYOerxhrNHkc0SDjrLDQsjideFocT9p4mVHqJ872Z5o,46298 +ray/rllib/utils/replay_buffers/multi_agent_mixin_replay_buffer.py,sha256=x-hY8CKMscmWEwBBpPRjAkLG3rcllsa1nZ6WElW_10c,16706 +ray/rllib/utils/replay_buffers/multi_agent_prioritized_episode_buffer.py,sha256=ZsfXtS3MqBnHdgB3JxLb-vl5Z67ZsQOUAcCs1fixVVQ,42877 +ray/rllib/utils/replay_buffers/multi_agent_prioritized_replay_buffer.py,sha256=u3GFqbLV7C4PJTiu62qfIiVEfi4NVUXQ3FrFUZI2xQs,12269 +ray/rllib/utils/replay_buffers/multi_agent_replay_buffer.py,sha256=3DDSUkk6NdqvaV5CoxDOczTdRdHohOgUK02qdIyoqTw,16369 +ray/rllib/utils/replay_buffers/prioritized_episode_buffer.py,sha256=a1Q-S7hZc27gwZNHuaeEGImoABNLKLR2Aa2q9WDJiwI,31498 +ray/rllib/utils/replay_buffers/prioritized_replay_buffer.py,sha256=HqNAwcZKYMiB9zi76ONt_M3dd9ho7_iSyiMpTNXdetg,8789 +ray/rllib/utils/replay_buffers/replay_buffer.py,sha256=euJGokPeLDh1w3S4lQ0NGpwPVI6iKiTUsFMbpieK01I,14389 +ray/rllib/utils/replay_buffers/reservoir_replay_buffer.py,sha256=Tld4o_--YU3p2OuXHjE_gwfmHEwM0nKLA9Rr4J_upfY,4533 +ray/rllib/utils/replay_buffers/simple_replay_buffer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/utils/replay_buffers/utils.py,sha256=TADrbuzfUTGL-Whqo60RtRjcYU5juygQltlnllxSQgE,18068 +ray/rllib/utils/schedules/__init__.py,sha256=0mB40d8b4x6XoeU5MYFk51omFrJhnNR7fcQH64Zo7kA,584 +ray/rllib/utils/schedules/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/utils/schedules/__pycache__/constant_schedule.cpython-311.pyc,, +ray/rllib/utils/schedules/__pycache__/exponential_schedule.cpython-311.pyc,, +ray/rllib/utils/schedules/__pycache__/linear_schedule.cpython-311.pyc,, +ray/rllib/utils/schedules/__pycache__/piecewise_schedule.cpython-311.pyc,, +ray/rllib/utils/schedules/__pycache__/polynomial_schedule.cpython-311.pyc,, +ray/rllib/utils/schedules/__pycache__/schedule.cpython-311.pyc,, +ray/rllib/utils/schedules/__pycache__/scheduler.cpython-311.pyc,, +ray/rllib/utils/schedules/constant_schedule.py,sha256=SJhiuhFc6MbIikZbs6BNfZCiETedK9JF7vZ8vJa3VU0,1002 +ray/rllib/utils/schedules/exponential_schedule.py,sha256=nyZs9t8Ertg-QdakTH4bmKIIMNVTDX2afRvEHMZyZLc,1833 +ray/rllib/utils/schedules/linear_schedule.py,sha256=9Dn7AW7rmXNL4yeEYSKlQMymnLEiPlmEVshisb211_o,528 +ray/rllib/utils/schedules/piecewise_schedule.py,sha256=bQBq-nEVPfLv53A8EsxJsppI9E-Q2htzBzBPH1FdxB8,4172 +ray/rllib/utils/schedules/polynomial_schedule.py,sha256=7qamzs2z_cJ-aYiLl-yQjGx4qxPS_IQKMncX6Z5U3qk,2215 +ray/rllib/utils/schedules/schedule.py,sha256=27P7t8oIWDI4Op9KKurscfdSiCU0OUO5OC30ZPqZTzQ,2265 +ray/rllib/utils/schedules/scheduler.py,sha256=VgChXIEkgGzbOpe0zmOGuViq0oF--7xBy-ahuUSTdpg,6826 +ray/rllib/utils/serialization.py,sha256=7wgBEGBdn3XNo1grOBHMgHjkQyPOsSsD1_gTN3fpPN8,13448 +ray/rllib/utils/sgd.py,sha256=1dhH_v93zIrI57O2wGf-FUlXGn929MSiBDTjlAiYWq4,4602 +ray/rllib/utils/spaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/rllib/utils/spaces/__pycache__/__init__.cpython-311.pyc,, +ray/rllib/utils/spaces/__pycache__/flexdict.cpython-311.pyc,, +ray/rllib/utils/spaces/__pycache__/repeated.cpython-311.pyc,, +ray/rllib/utils/spaces/__pycache__/simplex.cpython-311.pyc,, +ray/rllib/utils/spaces/__pycache__/space_utils.cpython-311.pyc,, +ray/rllib/utils/spaces/flexdict.py,sha256=IEl0J84bS8DSlTByosF3WcsJP6cIefPJlKJzTK94UJo,1298 +ray/rllib/utils/spaces/repeated.py,sha256=tXyq2rSD1jH91WDpeNQHTC3yohfTyRs16sAL8vJ2PYQ,1110 +ray/rllib/utils/spaces/simplex.py,sha256=75oReN-TAsFew2YKq-HZDlB9Rnt0FcW0XlxfugP8tSI,1881 +ray/rllib/utils/spaces/space_utils.py,sha256=3rZWdzsnWVZyemHotBNNqpLhZRtrQZwfkcM1S0onSaY,19524 +ray/rllib/utils/tensor_dtype.py,sha256=MbI7TFRWGwaW_ZPyFr5DzeyiaeqEpWhCPzvkL9f1yMs,1893 +ray/rllib/utils/test_utils.py,sha256=JMkp8r271zUKiYxjF5k_56Yuc6CLDGJiiyob7aeSnF0,70291 +ray/rllib/utils/tf_run_builder.py,sha256=2r4AQDAiX0kUH7wRMak7QXXzJgwft0xSFHSivwzORUo,3879 +ray/rllib/utils/tf_utils.py,sha256=ziJOiiyx6XJ_nDtfLdSxTNLSC9DrI37vaJzjvThTfl4,28362 +ray/rllib/utils/threading.py,sha256=e91Bv1KdeXLbaa7xx7Rfb1CMpx-dq34vTuaos6XWOGo,1032 +ray/rllib/utils/torch_utils.py,sha256=71tWt8mkQMir_sp2GgZPd1BXG1QzWX-uQ5guVjopRW0,24313 +ray/rllib/utils/typing.py,sha256=Uf1jk7y1jcpa7LehD9tRPsAYqP2hXBt5QOmcMZWsc2Y,10980 +ray/runtime_context.py,sha256=kxyjjV8zgKme4kEubCNGhaVxwtvysCxMB_sxqYHPf8A,19199 +ray/runtime_env/__init__.py,sha256=Rh-TUBk-hx47LmevBkL7E8oDCqwYZM7GhTv2XTei8Eg,230 +ray/runtime_env/__pycache__/__init__.cpython-311.pyc,, +ray/runtime_env/__pycache__/runtime_env.cpython-311.pyc,, +ray/runtime_env/runtime_env.py,sha256=r65_iLKmSWte5JEzJ_3fAmmKxBbIF0BIx1cIFZ8zS1Y,25446 +ray/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/scripts/__pycache__/__init__.cpython-311.pyc,, +ray/scripts/__pycache__/scripts.cpython-311.pyc,, +ray/scripts/scripts.py,sha256=dbR96sFI-ici8PJtnwZPy_eliwaI0oQa9IhPTLQuNcY,85241 +ray/serve/__init__.py,sha256=YZDqaRcfcuScprwYZYO2Z4QvbUUxWJCpJBDAvObUek8,1308 +ray/serve/__pycache__/__init__.cpython-311.pyc,, +ray/serve/__pycache__/api.cpython-311.pyc,, +ray/serve/__pycache__/autoscaling_policy.cpython-311.pyc,, +ray/serve/__pycache__/batching.cpython-311.pyc,, +ray/serve/__pycache__/config.cpython-311.pyc,, +ray/serve/__pycache__/context.cpython-311.pyc,, +ray/serve/__pycache__/dag.cpython-311.pyc,, +ray/serve/__pycache__/deployment.cpython-311.pyc,, +ray/serve/__pycache__/exceptions.cpython-311.pyc,, +ray/serve/__pycache__/gradio_integrations.cpython-311.pyc,, +ray/serve/__pycache__/grpc_util.cpython-311.pyc,, +ray/serve/__pycache__/handle.cpython-311.pyc,, +ray/serve/__pycache__/metrics.cpython-311.pyc,, +ray/serve/__pycache__/multiplex.cpython-311.pyc,, +ray/serve/__pycache__/schema.cpython-311.pyc,, +ray/serve/__pycache__/scripts.cpython-311.pyc,, +ray/serve/_private/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/serve/_private/__pycache__/__init__.cpython-311.pyc,, +ray/serve/_private/__pycache__/api.cpython-311.pyc,, +ray/serve/_private/__pycache__/application_state.cpython-311.pyc,, +ray/serve/_private/__pycache__/autoscaling_state.cpython-311.pyc,, +ray/serve/_private/__pycache__/build_app.cpython-311.pyc,, +ray/serve/_private/__pycache__/client.cpython-311.pyc,, +ray/serve/_private/__pycache__/cluster_node_info_cache.cpython-311.pyc,, +ray/serve/_private/__pycache__/common.cpython-311.pyc,, +ray/serve/_private/__pycache__/config.cpython-311.pyc,, +ray/serve/_private/__pycache__/constants.cpython-311.pyc,, +ray/serve/_private/__pycache__/controller.cpython-311.pyc,, +ray/serve/_private/__pycache__/default_impl.cpython-311.pyc,, +ray/serve/_private/__pycache__/deploy_utils.cpython-311.pyc,, +ray/serve/_private/__pycache__/deployment_info.cpython-311.pyc,, +ray/serve/_private/__pycache__/deployment_node.cpython-311.pyc,, +ray/serve/_private/__pycache__/deployment_scheduler.cpython-311.pyc,, +ray/serve/_private/__pycache__/deployment_state.cpython-311.pyc,, +ray/serve/_private/__pycache__/endpoint_state.cpython-311.pyc,, +ray/serve/_private/__pycache__/grpc_util.cpython-311.pyc,, +ray/serve/_private/__pycache__/handle_options.cpython-311.pyc,, +ray/serve/_private/__pycache__/http_util.cpython-311.pyc,, +ray/serve/_private/__pycache__/local_testing_mode.cpython-311.pyc,, +ray/serve/_private/__pycache__/logging_utils.cpython-311.pyc,, +ray/serve/_private/__pycache__/long_poll.cpython-311.pyc,, +ray/serve/_private/__pycache__/metrics_utils.cpython-311.pyc,, +ray/serve/_private/__pycache__/proxy.cpython-311.pyc,, +ray/serve/_private/__pycache__/proxy_request_response.cpython-311.pyc,, +ray/serve/_private/__pycache__/proxy_response_generator.cpython-311.pyc,, +ray/serve/_private/__pycache__/proxy_router.cpython-311.pyc,, +ray/serve/_private/__pycache__/proxy_state.cpython-311.pyc,, +ray/serve/_private/__pycache__/replica.cpython-311.pyc,, +ray/serve/_private/__pycache__/replica_result.cpython-311.pyc,, +ray/serve/_private/__pycache__/router.cpython-311.pyc,, +ray/serve/_private/__pycache__/test_utils.cpython-311.pyc,, +ray/serve/_private/__pycache__/usage.cpython-311.pyc,, +ray/serve/_private/__pycache__/utils.cpython-311.pyc,, +ray/serve/_private/__pycache__/version.cpython-311.pyc,, +ray/serve/_private/api.py,sha256=rmJqN-dEOVB2vU9FdlL85kq9b6wdlUP6d5-r07BTZuY,10858 +ray/serve/_private/application_state.py,sha256=7svLUMg5DKZUkZoYR164tnbENzVcK5MOo3BN4VX3Zks,52228 +ray/serve/_private/autoscaling_state.py,sha256=jWhysUHeTe54P1BVFYHinXYWf6TTl4P7QIvXY-qVfv8,16604 +ray/serve/_private/benchmarks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/serve/_private/benchmarks/__pycache__/__init__.cpython-311.pyc,, +ray/serve/_private/benchmarks/__pycache__/common.cpython-311.pyc,, +ray/serve/_private/benchmarks/__pycache__/handle_noop_latency.cpython-311.pyc,, +ray/serve/_private/benchmarks/__pycache__/handle_throughput.cpython-311.pyc,, +ray/serve/_private/benchmarks/__pycache__/http_noop_latency.cpython-311.pyc,, +ray/serve/_private/benchmarks/__pycache__/microbenchmark.cpython-311.pyc,, +ray/serve/_private/benchmarks/__pycache__/proxy_benchmark.cpython-311.pyc,, +ray/serve/_private/benchmarks/common.py,sha256=bASdRsNcG0f47rXIwS7Njml1mq5Twp9QCmfV0ROKYJQ,7899 +ray/serve/_private/benchmarks/handle_noop_latency.py,sha256=8ujbO6wDskL3OYEpUHR85Rg5RKETg2THaxOxIAh3dD8,943 +ray/serve/_private/benchmarks/handle_throughput.py,sha256=jvGCdtFk35hL8fcXzg1wrtnev6EiEf9rJULYMfaZ600,1460 +ray/serve/_private/benchmarks/http_noop_latency.py,sha256=4txfJbA9s8RPUG69rOIu9NZM15wNRYrQgoDjVcApl8E,897 +ray/serve/_private/benchmarks/microbenchmark.py,sha256=KzNS7CUr9qPWBbx_Grvoj9mGgDC8HJQaHWl0mwF7cig,5273 +ray/serve/_private/benchmarks/proxy_benchmark.py,sha256=Ak659vgj7ExXe_L8ha5GP0i5bCsZMmE1D_8GKPfDa8E,8993 +ray/serve/_private/benchmarks/serialization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/serve/_private/benchmarks/serialization/__pycache__/__init__.cpython-311.pyc,, +ray/serve/_private/benchmarks/serialization/__pycache__/common.cpython-311.pyc,, +ray/serve/_private/benchmarks/serialization/__pycache__/serialization_benchmark.cpython-311.pyc,, +ray/serve/_private/benchmarks/serialization/common.py,sha256=iu6KBTA1iUX0O9Uiz3T1qRcLHiSqhhMwwjO8reL_-T8,802 +ray/serve/_private/benchmarks/serialization/serialization_benchmark.py,sha256=3Ul6UYDtnBVMnYeqB4Jso_KH7d6q_V6-NwAaRmcnYL4,3796 +ray/serve/_private/benchmarks/streaming/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/serve/_private/benchmarks/streaming/__pycache__/__init__.cpython-311.pyc,, +ray/serve/_private/benchmarks/streaming/__pycache__/common.cpython-311.pyc,, +ray/serve/_private/benchmarks/streaming/__pycache__/streaming_core_throughput.cpython-311.pyc,, +ray/serve/_private/benchmarks/streaming/__pycache__/streaming_grpc_throughput.cpython-311.pyc,, +ray/serve/_private/benchmarks/streaming/__pycache__/streaming_handle_throughput.cpython-311.pyc,, +ray/serve/_private/benchmarks/streaming/__pycache__/streaming_http_throughput.cpython-311.pyc,, +ray/serve/_private/benchmarks/streaming/_grpc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/serve/_private/benchmarks/streaming/_grpc/__pycache__/__init__.cpython-311.pyc,, +ray/serve/_private/benchmarks/streaming/_grpc/__pycache__/grpc_server.cpython-311.pyc,, +ray/serve/_private/benchmarks/streaming/_grpc/__pycache__/test_server_pb2_grpc.cpython-311.pyc,, +ray/serve/_private/benchmarks/streaming/_grpc/grpc_server.py,sha256=fgNQLAikGwUac2gWCot9IKPCaWzFO0BoDsxIOlTZcGc,1860 +ray/serve/_private/benchmarks/streaming/_grpc/test_server_pb2_grpc.py,sha256=jMH9tTMpZKGJ2fzoJtGyGVGzxZKseo81fd9FQ6rels8,8850 +ray/serve/_private/benchmarks/streaming/common.py,sha256=YBC2Uhk-quzsK2Ib0Mzz4bn6JD6GadrUvMteQ-sY-SA,3627 +ray/serve/_private/benchmarks/streaming/streaming_core_throughput.py,sha256=wtuA4VUjFCqs4tkjRk4ww3UKje5wFm4f10VCW6aD-kg,2350 +ray/serve/_private/benchmarks/streaming/streaming_grpc_throughput.py,sha256=OswRDb00-hcvwKvgGNYt825ETWc7EMvXI79ynIgDOTM,6015 +ray/serve/_private/benchmarks/streaming/streaming_handle_throughput.py,sha256=sR-N6tXV7yymHl0SG29c5gvXEqiEwuUGHfKblt8QqJw,2363 +ray/serve/_private/benchmarks/streaming/streaming_http_throughput.py,sha256=6sxqagqQpR48eJ0ha9q9OwT1aYm_0KbdCcHc7F6U0U8,3701 +ray/serve/_private/build_app.py,sha256=NyemnWj19r20G5-Nh0t_9zLTrsV--5n6z3hYyL2KM1o,7789 +ray/serve/_private/client.py,sha256=qEPenY8-an6MhHxD1Rl4WpdG5HVa4J-8r7lEO0LTyVk,18507 +ray/serve/_private/cluster_node_info_cache.py,sha256=hP6w2i4oO145VNar-27TvT2dwYHGDxTflfOu65dQ6b0,3666 +ray/serve/_private/common.py,sha256=JUm2EHCNojnoCPFu-fNi-on0Emw9MSGG4avlILVUdUE,25498 +ray/serve/_private/config.py,sha256=61OFamz8zM74iAc-Yrl8oS9Qh0GLTUSB8aSUiBu-Abs,28602 +ray/serve/_private/constants.py,sha256=oy3OTqb99f4Wsrh5Zu4f-2ie01VuXodEi8yoDKka2yk,13917 +ray/serve/_private/controller.py,sha256=rR6kUSbd97WZnZH40Y0l3kfJGam7ZudA8JI6418QB20,47257 +ray/serve/_private/default_impl.py,sha256=ckM04R9vLaFcK5lkh1C456ILG1-767iKLFPRdWSD9vo,7558 +ray/serve/_private/deploy_utils.py,sha256=XXTo5KbZYYS3owJj1pKf99pJuS-ia9-CHQJTrh3NPFU,3697 +ray/serve/_private/deployment_info.py,sha256=Mi_G5w2rE5Ma0yzmsXjpcWR1-R0NnH9ROv3_yLbSEJQ,6373 +ray/serve/_private/deployment_node.py,sha256=gv1qjTmG17li46BHpKqwroOfh6sx3L9b5mKPUMaVZ0Y,1770 +ray/serve/_private/deployment_scheduler.py,sha256=TzneDA_W2SYqUtFuObGVcfIQZRQciEhb1c0nwJX9yLA,31049 +ray/serve/_private/deployment_state.py,sha256=GyriLHi7g4xHrOm4H8t-Uo2D3kMX1i55bOfQd6cKdl8,114382 +ray/serve/_private/endpoint_state.py,sha256=snU37WHweQZN59NPxGEhu2G88z6RgrCV1r1lqmxYc7g,3806 +ray/serve/_private/grpc_util.py,sha256=gu8ectKAne7kVrcHvy3kKRK8hv3OrcOWadHmIYCLVeM,2933 +ray/serve/_private/handle_options.py,sha256=teKCtch3H8eBxrIxFXpSbEZcVoBFpiUOiIenDYwW7Ng,2073 +ray/serve/_private/http_util.py,sha256=hS5F3AaC3SHKIfU1o2iVU7WYyKx3v2pyZruHDD9oTFg,19761 +ray/serve/_private/local_testing_mode.py,sha256=iviTTqCX_je_wuNbQceehwqi7TsxAeaoWpZwysvilk0,10968 +ray/serve/_private/logging_utils.py,sha256=yGv8XGHLcF3UsSBe-ugqJFUDQmuMkV--4mFNbASMSec,18618 +ray/serve/_private/long_poll.py,sha256=awPxYsmwpw-M88fhWy8QAJ-oW3s5wY8IiYPl5cSYqXM,19056 +ray/serve/_private/metrics_utils.py,sha256=1S9PHAwOzTzXCI5Au9ERSO36NTv9ty1o4HJTay-19n0,7382 +ray/serve/_private/proxy.py,sha256=5Ht3AdGxS5kt9mEmD_Mj4_nQVrm1mfVQ66szb8MpUVQ,59419 +ray/serve/_private/proxy_request_response.py,sha256=tcyQv3wzoRdIrIY8jyBWoV9ITYoAX-qtEQ-jCmXsC2c,6058 +ray/serve/_private/proxy_response_generator.py,sha256=p3IzNFsTCPpAVLsDwPfIl80DDnBomLhS4bCn2gKZank,5742 +ray/serve/_private/proxy_router.py,sha256=pYiROyB3iwb8AKNG_3nzGHV4NPWI-qjghpxAgZKZ720,6792 +ray/serve/_private/proxy_state.py,sha256=2whlVtxNiA35v4x003c739tu_EJ-sr-xLDgqHiPWbx0,28851 +ray/serve/_private/replica.py,sha256=OLfXgVYqMYQatZ25FlAvasuf-OxY2rXIE-A-vunVhwI,65459 +ray/serve/_private/replica_result.py,sha256=goAcxgHCTRBaW5gPY-GKR6krh6qGjkS5xg_GVPIUs5U,6370 +ray/serve/_private/replica_scheduler/__init__.py,sha256=yszIu1Yuszs0bhlDlPiK-6B9LSrqwOQl06gC9x6Zw88,417 +ray/serve/_private/replica_scheduler/__pycache__/__init__.cpython-311.pyc,, +ray/serve/_private/replica_scheduler/__pycache__/common.cpython-311.pyc,, +ray/serve/_private/replica_scheduler/__pycache__/pow_2_scheduler.cpython-311.pyc,, +ray/serve/_private/replica_scheduler/__pycache__/replica_scheduler.cpython-311.pyc,, +ray/serve/_private/replica_scheduler/__pycache__/replica_wrapper.cpython-311.pyc,, +ray/serve/_private/replica_scheduler/common.py,sha256=LM6O59ZWSn8DGaaxR5X6QeA8xqpi5qKJDm1vc8aLQeo,2573 +ray/serve/_private/replica_scheduler/pow_2_scheduler.py,sha256=gEtr3l9QP8ttCaiGHGC80DHszoG7MUqMBtsi83zFT4w,37881 +ray/serve/_private/replica_scheduler/replica_scheduler.py,sha256=As4UOz2DkA0-hLB7oavMq8JGF_VG9rmx96sWODS2wts,1533 +ray/serve/_private/replica_scheduler/replica_wrapper.py,sha256=qms7QI039T0whb4iBi6nYeA1YWUFjpPZ5wWCAB9_RMg,7238 +ray/serve/_private/router.py,sha256=dAjvgvu6VLY9GeMLFywNOK6H3mMiMTimm-HgmaCD__o,31625 +ray/serve/_private/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/serve/_private/storage/__pycache__/__init__.cpython-311.pyc,, +ray/serve/_private/storage/__pycache__/kv_store.cpython-311.pyc,, +ray/serve/_private/storage/__pycache__/kv_store_base.cpython-311.pyc,, +ray/serve/_private/storage/kv_store.py,sha256=1t5Kwt3PS6P_dfQhR-alGgP64-6K-jmx00N9XYVJ5CE,3538 +ray/serve/_private/storage/kv_store_base.py,sha256=UwhSwo1fYAWDB77qJ2ksHpDIdSA5r7T41o9dESUUVOA,1532 +ray/serve/_private/test_utils.py,sha256=EGnjipepVhcOLeQUiedoxHZvTkcywluDOvMxuqQVBas,21115 +ray/serve/_private/thirdparty/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/serve/_private/thirdparty/__pycache__/__init__.cpython-311.pyc,, +ray/serve/_private/thirdparty/__pycache__/get_asgi_route_name.cpython-311.pyc,, +ray/serve/_private/thirdparty/get_asgi_route_name.py,sha256=TTBIEwNC0kPZaw5kkL3MtbYOkP0BpgYM0e0i5y_G_u4,3883 +ray/serve/_private/usage.py,sha256=jf4xU0MZ6kdMM_mSVLdhc4R_PC2zzd8BX0C3tsdoOA0,2221 +ray/serve/_private/utils.py,sha256=4Ui05IEHqCxWrkzjTXCwjXmXq__UTWygSZKTZHRa-Ak,19300 +ray/serve/_private/version.py,sha256=7dOMA_q3mA3EaK63fwRM9fohPlgd2g5ocaLjuKgwiRw,8495 +ray/serve/api.py,sha256=HrsRvI5zjkqYgd0PIafR1xTBJCr6cGXqw3UvdkCtUFY,33418 +ray/serve/autoscaling_policy.py,sha256=pDItuDLkFVr6eupR8HjUno5DH_06GT0w6-SuSzLA47o,6518 +ray/serve/batching.py,sha256=ZemjjBv_aANj4BLa1CRUQUAnUzvbabmqub64J2yt2zg,25126 +ray/serve/config.py,sha256=uTazTOYxBktLZuxSC18oOgZObClKr-x7WEE0LXyMp_g,12140 +ray/serve/context.py,sha256=ep3KtteNgaeDXKVo91j2B7mJUVi4rlcTe0ptpuw50So,8643 +ray/serve/dag.py,sha256=6rXZdW60pdKgF0FltQvqduwR9NCLkwfHJ6rIBbe8aQg,73 +ray/serve/deployment.py,sha256=qrmNxbPn5kGwVB9d-hkWv5FaYRmCHF15oOHnzrWgnwM,18620 +ray/serve/exceptions.py,sha256=n0USHAS9MY6HaQpplTS0l8j7mhqy8swZ1e4TTBxE0a0,1702 +ray/serve/generated/__pycache__/serve_pb2.cpython-311.pyc,, +ray/serve/generated/__pycache__/serve_pb2_grpc.cpython-311.pyc,, +ray/serve/generated/serve_pb2.py,sha256=I-hCMkTaFd2E-B3v_GTN8Cx8tZop5xaCXqhfZmCQoJk,35730 +ray/serve/generated/serve_pb2_grpc.py,sha256=uwqOT_p3A5WEdTvbGJ1m9WeSLGVRYMn0zLh41ZFG9oA,18527 +ray/serve/gradio_integrations.py,sha256=1IJAUrR_tB7xwwfI5dVNTgrslb3jkfDEb1kVKOqAAu0,968 +ray/serve/grpc_util.py,sha256=_PerJkRXomCdc9hT6bN_XkUUqztT5yPLVnUy3vOAQos,5909 +ray/serve/handle.py,sha256=fzdF_ZdiFCa9AXVSSqg0sxLVpiPwNbGtP7jIlAuoZUo,26306 +ray/serve/metrics.py,sha256=0fd0A1-ODcv8JlcBNNRlceO38wVoMbdo-BcUig0i8AQ,9272 +ray/serve/multiplex.py,sha256=DG5xO6UivFwrr1Y4ua-hkzthjISpJ5RHoW5DLrja2L8,10835 +ray/serve/schema.py,sha256=SisWXhVzFr0eWvJrWyxdoUrwFkbsNtQ2K4QVoVQRqmg,41100 +ray/serve/scripts.py,sha256=2Eb2_ZQaSgbn6aFHo6L8O9yI8-BWjACPdzHjo2NexlQ,27834 +ray/setup-dev.py,sha256=xGcshJy5n3WgOAjkaPQCDUH8Ze-upxzzNNXjD-i8ntU,6171 +ray/thirdparty_files/colorama-0.4.6.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +ray/thirdparty_files/colorama-0.4.6.dist-info/METADATA,sha256=e67SnrUMOym9sz_4TjF3vxvAV4T3aF7NyqRHHH3YEMw,17158 +ray/thirdparty_files/colorama-0.4.6.dist-info/RECORD,sha256=aAtqkfEOO-VWyUbc0Hf9vNi5V5cGB2BCPIPKaoN8sYM,2263 +ray/thirdparty_files/colorama-0.4.6.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/thirdparty_files/colorama-0.4.6.dist-info/WHEEL,sha256=cdcF4Fbd0FPtw2EMIOwH-3rSOTUdTCeOSXRMD1iLUb8,105 +ray/thirdparty_files/colorama-0.4.6.dist-info/licenses/LICENSE.txt,sha256=ysNcAmhuXQSlpxQL-zs25zrtSWZW6JEQLkKIhteTAxg,1491 +ray/thirdparty_files/colorama/__init__.py,sha256=wePQA4U20tKgYARySLEC047ucNX-g8pRLpYBuiHlLb8,266 +ray/thirdparty_files/colorama/__pycache__/__init__.cpython-311.pyc,, +ray/thirdparty_files/colorama/__pycache__/ansi.cpython-311.pyc,, +ray/thirdparty_files/colorama/__pycache__/ansitowin32.cpython-311.pyc,, +ray/thirdparty_files/colorama/__pycache__/initialise.cpython-311.pyc,, +ray/thirdparty_files/colorama/__pycache__/win32.cpython-311.pyc,, +ray/thirdparty_files/colorama/__pycache__/winterm.cpython-311.pyc,, +ray/thirdparty_files/colorama/ansi.py,sha256=Top4EeEuaQdBWdteKMEcGOTeKeF19Q-Wo_6_Cj5kOzQ,2522 +ray/thirdparty_files/colorama/ansitowin32.py,sha256=vPNYa3OZbxjbuFyaVo0Tmhmy1FZ1lKMWCnT7odXpItk,11128 +ray/thirdparty_files/colorama/initialise.py,sha256=-hIny86ClXo39ixh5iSCfUIa2f_h_bgKRDW7gqs-KLU,3325 +ray/thirdparty_files/colorama/win32.py,sha256=YQOKwMTwtGBbsY4dL5HYTvwTeP9wIQra5MvPNddpxZs,6181 +ray/thirdparty_files/colorama/winterm.py,sha256=XCQFDHjPi6AHYNdZwy0tA02H-Jh48Jp-HvCjeLeLp3U,7134 +ray/thirdparty_files/psutil-6.1.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +ray/thirdparty_files/psutil-6.1.1.dist-info/LICENSE,sha256=uJwGOzeG4o4MCjjxkx22H-015p3SopZvvs_-4PRsjRA,1548 +ray/thirdparty_files/psutil-6.1.1.dist-info/METADATA,sha256=BmJ_eRw5cHEIkb3lwUXfm6xLZDoVKeIdJajBxnmspAQ,22377 +ray/thirdparty_files/psutil-6.1.1.dist-info/RECORD,sha256=CsgYubI6H0nByUimij5CkZI-L1D3udU1QZp4wkwRQjA,4516 +ray/thirdparty_files/psutil-6.1.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/thirdparty_files/psutil-6.1.1.dist-info/WHEEL,sha256=rgpVBmjjvbINeGKCkWEGd3f40VHMTsDkQj1Lgil82zE,221 +ray/thirdparty_files/psutil-6.1.1.dist-info/top_level.txt,sha256=gCNhn57wzksDjSAISmgMJ0aiXzQulk0GJhb2-BAyYgw,7 +ray/thirdparty_files/psutil/__init__.py,sha256=6iEjSGFQplxGDfmFcEjjYtoFSfiSuiCW1VV-KBdUPOQ,89154 +ray/thirdparty_files/psutil/__pycache__/__init__.cpython-311.pyc,, +ray/thirdparty_files/psutil/__pycache__/_common.cpython-311.pyc,, +ray/thirdparty_files/psutil/__pycache__/_compat.cpython-311.pyc,, +ray/thirdparty_files/psutil/__pycache__/_psaix.cpython-311.pyc,, +ray/thirdparty_files/psutil/__pycache__/_psbsd.cpython-311.pyc,, +ray/thirdparty_files/psutil/__pycache__/_pslinux.cpython-311.pyc,, +ray/thirdparty_files/psutil/__pycache__/_psosx.cpython-311.pyc,, +ray/thirdparty_files/psutil/__pycache__/_psposix.cpython-311.pyc,, +ray/thirdparty_files/psutil/__pycache__/_pssunos.cpython-311.pyc,, +ray/thirdparty_files/psutil/__pycache__/_pswindows.cpython-311.pyc,, +ray/thirdparty_files/psutil/_common.py,sha256=VNozj9CPxOdvWL-ZQlFK11y45Vr-Pc6BmvfPIj8lpkI,29739 +ray/thirdparty_files/psutil/_compat.py,sha256=sZrxGYsKyvsPJBNeKhBsrmpH8M7B6DpS9Xowc8Mx3-I,15270 +ray/thirdparty_files/psutil/_psaix.py,sha256=auBiK5gCD4fOjqrjTwckg7wfOHw6vv3f0hIkGvNcBC4,18663 +ray/thirdparty_files/psutil/_psbsd.py,sha256=g9FLvFyX-ApMZrKn1EnYY1q4gz3K9EvEnR0vux_K0Ls,32205 +ray/thirdparty_files/psutil/_pslinux.py,sha256=b4g8D-e8s2g5yMuLwy16wpS-n1SVsZov_hULRnGKP3w,88798 +ray/thirdparty_files/psutil/_psosx.py,sha256=js281YWrza5x0_EeYhjLLypDqzmiehZASGpUkxNhKqw,16136 +ray/thirdparty_files/psutil/_psposix.py,sha256=X9rd7WHKQ6mUAn2ihb03MCnzrBtQsrPRkCouExmuagQ,8235 +ray/thirdparty_files/psutil/_pssunos.py,sha256=KO9YQena9rX7vOBoBq8lgFUzl7aqDdRhI5s6QHaJVV0,25479 +ray/thirdparty_files/psutil/_psutil_linux.abi3.so,sha256=LXawFmZUbygGCJ1vTvCPAF2wu0ENiTpU1GOnsPi3J-I,115336 +ray/thirdparty_files/psutil/_psutil_posix.abi3.so,sha256=bLoKDfoWp8Pmo_QGNDssv7kIOLk2hnF6HZHYlRWatOI,71640 +ray/thirdparty_files/psutil/_pswindows.py,sha256=SZdCQ22YYWs8CWatwcYQJ6gwFJzx4NGn9JlR9l3Z6m8,38098 +ray/thirdparty_files/setproctitle-1.2.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +ray/thirdparty_files/setproctitle-1.2.2.dist-info/METADATA,sha256=FFhJMjb-VT6QB94FksWKoQkg-sZy52OTBXC_KG3_hf8,9051 +ray/thirdparty_files/setproctitle-1.2.2.dist-info/RECORD,sha256=CiQADHHOqjswTNs6jPTKUCRtadP3xdJwfwdCYwAOIGY,612 +ray/thirdparty_files/setproctitle-1.2.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/thirdparty_files/setproctitle-1.2.2.dist-info/WHEEL,sha256=HDBMQ19ZtMFARwRc3ZGC21o8Tu11IBK6tQtXGgqOICs,104 +ray/thirdparty_files/setproctitle-1.2.2.dist-info/top_level.txt,sha256=khlu2SuNEK2Ct594XhMTT62ll8p0oFza-4dmzUFTBhQ,13 +ray/thirdparty_files/setproctitle.cpython-311-x86_64-linux-gnu.so,sha256=sOhOZH3jZQWd3CIHW_KKe8qLZZm-YPo86kISUM-MZkM,69120 +ray/train/__init__.py,sha256=RlmbvYrc8-Betd1wziUHxY3iOJFYF4yOrBWyDgLryLs,2599 +ray/train/__pycache__/__init__.cpython-311.pyc,, +ray/train/__pycache__/_checkpoint.cpython-311.pyc,, +ray/train/__pycache__/backend.cpython-311.pyc,, +ray/train/__pycache__/base_trainer.cpython-311.pyc,, +ray/train/__pycache__/constants.cpython-311.pyc,, +ray/train/__pycache__/context.cpython-311.pyc,, +ray/train/__pycache__/data_parallel_trainer.cpython-311.pyc,, +ray/train/__pycache__/error.cpython-311.pyc,, +ray/train/__pycache__/predictor.cpython-311.pyc,, +ray/train/__pycache__/session.cpython-311.pyc,, +ray/train/__pycache__/trainer.cpython-311.pyc,, +ray/train/__pycache__/utils.cpython-311.pyc,, +ray/train/_checkpoint.py,sha256=YWOQiql-um_YqqlfgytVa8ABkxQU8lk7sxZE-QR4IAQ,17068 +ray/train/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/_internal/__pycache__/__init__.cpython-311.pyc,, +ray/train/_internal/__pycache__/accelerator.cpython-311.pyc,, +ray/train/_internal/__pycache__/backend_executor.cpython-311.pyc,, +ray/train/_internal/__pycache__/checkpoint_manager.cpython-311.pyc,, +ray/train/_internal/__pycache__/data_config.cpython-311.pyc,, +ray/train/_internal/__pycache__/dl_predictor.cpython-311.pyc,, +ray/train/_internal/__pycache__/framework_checkpoint.cpython-311.pyc,, +ray/train/_internal/__pycache__/session.cpython-311.pyc,, +ray/train/_internal/__pycache__/storage.cpython-311.pyc,, +ray/train/_internal/__pycache__/syncer.cpython-311.pyc,, +ray/train/_internal/__pycache__/utils.cpython-311.pyc,, +ray/train/_internal/__pycache__/worker_group.cpython-311.pyc,, +ray/train/_internal/accelerator.py,sha256=Dko-pPYKMhpcmuSH6cKW-hJvqx8brgmuB0_aCLxcXX8,107 +ray/train/_internal/backend_executor.py,sha256=-asr5uQBpj_hU6bM43eCzK_BzPtfMOiv60v75t1FFIo,30401 +ray/train/_internal/checkpoint_manager.py,sha256=B71JmU8E1gaRCy7xmPtIRhx-frbN_mCyhPzMZNPTwo4,7268 +ray/train/_internal/data_config.py,sha256=dfrjScrqgsYvUkf3-sdwdBf2tkkdOvrwMMW5DXKmQHQ,5642 +ray/train/_internal/dl_predictor.py,sha256=821wcP_AxBj0fDRCyhgJD0U9nI2qdCLd4eezmiuvRTk,3570 +ray/train/_internal/framework_checkpoint.py,sha256=0BRqUgnpm7szh3P_yLv72jnOab43USX1ra-wcF2FzPo,1492 +ray/train/_internal/session.py,sha256=_fF6x0hB1lSeO9xd4px-utV2o8qeXEVkdSX-_Z_0q68,39458 +ray/train/_internal/state/__init__.py,sha256=MmAOOS_XhXYiecXSy9TQmY_4WHYsXjmH7dBlevWKwpQ,315 +ray/train/_internal/state/__pycache__/__init__.cpython-311.pyc,, +ray/train/_internal/state/__pycache__/schema.cpython-311.pyc,, +ray/train/_internal/state/__pycache__/state_actor.cpython-311.pyc,, +ray/train/_internal/state/__pycache__/state_manager.cpython-311.pyc,, +ray/train/_internal/state/schema.py,sha256=8igE4XAK-Dy3ftau60b9QqgoxovnA5p1Pz5vKpJSKuw,4876 +ray/train/_internal/state/state_actor.py,sha256=tH3_-1P1E1Qo-L1ihe89s0nUF1g412YhC_8_ckoubYE,1876 +ray/train/_internal/state/state_manager.py,sha256=xBHaIXv95J6g36WFWMfdqQgAtvBodSdrLFR7IyncnEQ,4135 +ray/train/_internal/storage.py,sha256=P37TN8KPZkrfDiJtyDKGdEC6OaDTlSWoT-3FJwV3ogA,27689 +ray/train/_internal/syncer.py,sha256=17DDX1RgnRxpawWhFhqjj_cbhlovqIFgO1yI71ZXhHo,17444 +ray/train/_internal/utils.py,sha256=6Yh4vn8Rc3x46685RWn_NTYo4WuS5Sw1C_PFk_WsMQ8,7184 +ray/train/_internal/worker_group.py,sha256=Nx5uDPHt_OL0PXynecjzs5iatgCSVVMoGbp-O-SDuXY,15155 +ray/train/backend.py,sha256=Dt9XjIM7N0-NGgBEIxGxNxC7AnAU0eUGuYPiczik0QY,1740 +ray/train/base_trainer.py,sha256=AUD-EcU84J747nuPNzacxJHRGXgSmAAeWDyXibFfLpg,33322 +ray/train/constants.py,sha256=gGGMjoY5w_WrexpMhqxTZ3powxcobdcp0FXIGskgLeI,4477 +ray/train/context.py,sha256=mHrw5_ZRjKZrsNC9wOQcs7gBn5eQKZNo4BTE0xnSS6o,4653 +ray/train/data_parallel_trainer.py,sha256=BDY01jHHxdxCm5R98kqqkrBdn2iIJiG9ribIEqd8gOI,22625 +ray/train/error.py,sha256=euJNlXHzrvcM40f831icdRoX5zV4SjRTJNEC-G2BOo8,183 +ray/train/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/examples/__pycache__/__init__.cpython-311.pyc,, +ray/train/examples/__pycache__/mlflow_simple_example.cpython-311.pyc,, +ray/train/examples/horovod/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/examples/horovod/__pycache__/__init__.cpython-311.pyc,, +ray/train/examples/horovod/__pycache__/horovod_cifar_pbt_example.cpython-311.pyc,, +ray/train/examples/horovod/__pycache__/horovod_example.cpython-311.pyc,, +ray/train/examples/horovod/__pycache__/horovod_pytorch_example.cpython-311.pyc,, +ray/train/examples/horovod/__pycache__/horovod_tune_example.cpython-311.pyc,, +ray/train/examples/horovod/horovod_cifar_pbt_example.py,sha256=F72hlgT2ExRqX45wkszERP3YD6rZ9jE3IjldN5RGvBs,6796 +ray/train/examples/horovod/horovod_example.py,sha256=uhCeg40nFaOiilucOSBedHkjRSqk-3VmTvAo-23Z4Xg,8286 +ray/train/examples/horovod/horovod_pytorch_example.py,sha256=IcdBk7RVE38cHHP048ryxQlzQgqu4mHC1P7frW4jRuA,8268 +ray/train/examples/horovod/horovod_tune_example.py,sha256=L0cCd0DX55eX2PpaGrFaWR3u7CLxEIjdrMmhwHfn0a0,3946 +ray/train/examples/mlflow_simple_example.py,sha256=OGRLn5d0sM6Ydjpc9dfA5n-U42jK5Lyqk2Q41Y2aRCA,1449 +ray/train/examples/pytorch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/examples/pytorch/__pycache__/__init__.cpython-311.pyc,, +ray/train/examples/pytorch/__pycache__/torch_fashion_mnist_example.cpython-311.pyc,, +ray/train/examples/pytorch/__pycache__/torch_linear_example.cpython-311.pyc,, +ray/train/examples/pytorch/__pycache__/torch_quick_start.cpython-311.pyc,, +ray/train/examples/pytorch/__pycache__/torch_regression_example.cpython-311.pyc,, +ray/train/examples/pytorch/__pycache__/tune_cifar_torch_pbt_example.cpython-311.pyc,, +ray/train/examples/pytorch/__pycache__/tune_torch_regression_example.cpython-311.pyc,, +ray/train/examples/pytorch/torch_data_prefetch_benchmark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/examples/pytorch/torch_data_prefetch_benchmark/__pycache__/__init__.cpython-311.pyc,, +ray/train/examples/pytorch/torch_data_prefetch_benchmark/__pycache__/auto_pipeline_for_host_to_device_data_transfer.cpython-311.pyc,, +ray/train/examples/pytorch/torch_data_prefetch_benchmark/auto_pipeline_for_host_to_device_data_transfer.py,sha256=WIwsCRd0Ry1RK7W0cCBFJcpye4B-FXcXxd7yL8zEkas,4444 +ray/train/examples/pytorch/torch_fashion_mnist_example.py,sha256=QtmW0ZBC_xtulWdnFAFc2TFgm__T5piyf203b0cGb0s,4797 +ray/train/examples/pytorch/torch_linear_example.py,sha256=uwgchCs6CUWVz41ppWocEmJDyXEYMQifMEeo7qSNmfw,4264 +ray/train/examples/pytorch/torch_quick_start.py,sha256=vQ5E5SN5D4BlRnVUe2b28NWYqMHvYWFV_fifg_fCtc0,2882 +ray/train/examples/pytorch/torch_regression_example.py,sha256=14bDt9IsfQC_BKXBc3Rspcp4LkOO9GAgflUCF_z31wg,4683 +ray/train/examples/pytorch/tune_cifar_torch_pbt_example.py,sha256=Q-JE8h4-3snDbK5Mi369J8MqaZT2Yfb1mTLmpAwmp84,8471 +ray/train/examples/pytorch/tune_torch_regression_example.py,sha256=fcW76EhhLPTH-NtmPnrGWehtXUaVY7UE53jNdrgcLgE,2429 +ray/train/examples/pytorch_geometric/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/examples/pytorch_geometric/__pycache__/__init__.cpython-311.pyc,, +ray/train/examples/pytorch_geometric/__pycache__/distributed_sage_example.cpython-311.pyc,, +ray/train/examples/pytorch_geometric/distributed_sage_example.py,sha256=3Zv-gcOtb4eKmX-k8wJ1OI4R7GnzXku3agX5FkFUsC8,8004 +ray/train/examples/tf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/examples/tf/__pycache__/__init__.cpython-311.pyc,, +ray/train/examples/tf/__pycache__/tensorflow_autoencoder_example.cpython-311.pyc,, +ray/train/examples/tf/__pycache__/tensorflow_mnist_example.cpython-311.pyc,, +ray/train/examples/tf/__pycache__/tensorflow_quick_start.cpython-311.pyc,, +ray/train/examples/tf/__pycache__/tensorflow_regression_example.cpython-311.pyc,, +ray/train/examples/tf/__pycache__/tune_tensorflow_autoencoder_example.cpython-311.pyc,, +ray/train/examples/tf/__pycache__/tune_tensorflow_mnist_example.cpython-311.pyc,, +ray/train/examples/tf/tensorflow_autoencoder_example.py,sha256=7ewtUQmk-43J5vB9Yo2ZBIPnji7q1rD1sqC2qSQrBE8,5553 +ray/train/examples/tf/tensorflow_mnist_example.py,sha256=K594Xnvg8tYe6vjwhjjA-t7Edktt4I00uCPwcuVMTk4,4302 +ray/train/examples/tf/tensorflow_quick_start.py,sha256=OWZ1LcqSuIzpkP_HyY6axDHYTBnvv-b_HBSCfVmUtrI,2789 +ray/train/examples/tf/tensorflow_regression_example.py,sha256=Z-NjeTV0K4nO3We_eIb4PINZTIRJQAEU_UmqvEY76eE,3507 +ray/train/examples/tf/tune_tensorflow_autoencoder_example.py,sha256=BKq5rSn09_y7XDAGpcAtr5oYOxhwO1MUuQFGOEhlKV8,2305 +ray/train/examples/tf/tune_tensorflow_mnist_example.py,sha256=wgFFwUSklDzSBLv6JnARyEXePcQ1FgSCxP706unJCRM,2369 +ray/train/horovod/__init__.py,sha256=tm8swrwj4TENah8D-Eqj4CGGu_-BRjnANP9gmty7XXw,712 +ray/train/horovod/__pycache__/__init__.cpython-311.pyc,, +ray/train/horovod/__pycache__/config.cpython-311.pyc,, +ray/train/horovod/__pycache__/horovod_trainer.cpython-311.pyc,, +ray/train/horovod/config.py,sha256=jZklwLywJNVdVbmgBVBuZqKy0qFFAMdSwllTIQzoFW8,5820 +ray/train/horovod/horovod_trainer.py,sha256=YYTj5ztxOvOHbTTO5v7majg7-0R07pFBlcbAaXla530,7972 +ray/train/huggingface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/huggingface/__pycache__/__init__.cpython-311.pyc,, +ray/train/huggingface/transformers/__init__.py,sha256=Ib3o0MSFGA4LlFDVM6O3tWTSIqz1ylXHNcmIDUGMooQ,229 +ray/train/huggingface/transformers/__pycache__/__init__.cpython-311.pyc,, +ray/train/huggingface/transformers/__pycache__/_transformers_utils.cpython-311.pyc,, +ray/train/huggingface/transformers/_transformers_utils.py,sha256=9NH3WLyvV8ONik5TYHL3BidPUoSSwpd2G-1EYYXoduM,5457 +ray/train/lightgbm/__init__.py,sha256=y8EULNIpuDPvPMNzMGkYgP_jwejLLy2CgrBfqa0op7I,597 +ray/train/lightgbm/__pycache__/__init__.cpython-311.pyc,, +ray/train/lightgbm/__pycache__/_lightgbm_utils.cpython-311.pyc,, +ray/train/lightgbm/__pycache__/config.cpython-311.pyc,, +ray/train/lightgbm/__pycache__/lightgbm_checkpoint.cpython-311.pyc,, +ray/train/lightgbm/__pycache__/lightgbm_predictor.cpython-311.pyc,, +ray/train/lightgbm/__pycache__/lightgbm_trainer.cpython-311.pyc,, +ray/train/lightgbm/__pycache__/v2.cpython-311.pyc,, +ray/train/lightgbm/_lightgbm_utils.py,sha256=jtsRAwjczzmGSqbSWI6mguQghUz_maEJy2bjG-MQsWw,6446 +ray/train/lightgbm/config.py,sha256=sGjLzMT9HqsqhgEN8_Q_avSNN9vOHhzyiV8fUaNZWUA,3017 +ray/train/lightgbm/lightgbm_checkpoint.py,sha256=NnrtGgFh_KBOnQ44234942wXk55agWRiLWUAi3AEBYc,2545 +ray/train/lightgbm/lightgbm_predictor.py,sha256=d8DAunQQMGGl9wdOBflYeUqPQiAFXt12Lfsm4L5trXc,5626 +ray/train/lightgbm/lightgbm_trainer.py,sha256=uFjBSd7cddzZe1bdReMFGngOe8b9Oq4HQ4Uhh45Iv5M,8662 +ray/train/lightgbm/v2.py,sha256=ZLbteXVmEwdutqGHSK2d2bB4tUf3rNx250rIEHxTQ-s,5785 +ray/train/lightning/__init__.py,sha256=MGQPOeLRAOQQJ3ZBp0TMWa925z9iNZypU46bsjWuNUU,956 +ray/train/lightning/__pycache__/__init__.cpython-311.pyc,, +ray/train/lightning/__pycache__/_lightning_utils.cpython-311.pyc,, +ray/train/lightning/_lightning_utils.py,sha256=8XVCvvQ2AWpmAN-V-auRLPlTxj7nDLLO455kgED8sMk,10448 +ray/train/predictor.py,sha256=-lOEGjYnh2VwkQNo707T8nCa4yWLNn6Z6Mg3VEV4QxA,9685 +ray/train/session.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/tensorflow/__init__.py,sha256=iTXFUv6FkmBiggPhqFXt-ZrE5P_mtdVmRqT0Ek4mflk,966 +ray/train/tensorflow/__pycache__/__init__.cpython-311.pyc,, +ray/train/tensorflow/__pycache__/config.cpython-311.pyc,, +ray/train/tensorflow/__pycache__/keras.cpython-311.pyc,, +ray/train/tensorflow/__pycache__/tensorflow_checkpoint.cpython-311.pyc,, +ray/train/tensorflow/__pycache__/tensorflow_predictor.cpython-311.pyc,, +ray/train/tensorflow/__pycache__/tensorflow_trainer.cpython-311.pyc,, +ray/train/tensorflow/__pycache__/train_loop_utils.cpython-311.pyc,, +ray/train/tensorflow/config.py,sha256=gtprOsU10ea7I9b6AjcVldRLfbG7xseD-lzRbWegqLQ,1771 +ray/train/tensorflow/keras.py,sha256=lqf9UKCRvqVdVtLNaRZqVDT-QXh6W2R7sg2d4ChCNZk,132 +ray/train/tensorflow/tensorflow_checkpoint.py,sha256=k_9YVg5Z3KpakG8WwjI8M5d8X3WNHFO4i3ehyiPSHyk,5524 +ray/train/tensorflow/tensorflow_predictor.py,sha256=_P7ncCJJ4YPuu-1es9RWvt04HevQPuQbP24GEpSifn0,9625 +ray/train/tensorflow/tensorflow_trainer.py,sha256=AMHuC7rrGSierLUvodMhwRK20sePpwngbbd3jJa7HOE,7383 +ray/train/tensorflow/train_loop_utils.py,sha256=d6_L-_lvVp1Jgqm5fncHLKNAJvplkITt-7kVtIgVcN0,934 +ray/train/torch/__init__.py,sha256=oOCuxEMKqataXm9FMCIGgLY3b18emMzxRoYmCdolbVo,1438 +ray/train/torch/__pycache__/__init__.cpython-311.pyc,, +ray/train/torch/__pycache__/config.cpython-311.pyc,, +ray/train/torch/__pycache__/torch_checkpoint.cpython-311.pyc,, +ray/train/torch/__pycache__/torch_detection_predictor.cpython-311.pyc,, +ray/train/torch/__pycache__/torch_predictor.cpython-311.pyc,, +ray/train/torch/__pycache__/torch_trainer.cpython-311.pyc,, +ray/train/torch/__pycache__/train_loop_utils.cpython-311.pyc,, +ray/train/torch/config.py,sha256=pJzm3mfRibGSfLbxbtptHAprSdi1mOjZjN0RtGVxbvI,7641 +ray/train/torch/torch_checkpoint.py,sha256=t8SS2WcFk7BgfGR7FrG4eMje1DSv7Bs1h-ToPlvbR1A,6254 +ray/train/torch/torch_detection_predictor.py,sha256=KqM3SA2BMoydM3_llTLtOJqzDAFsF-S9mNuv3zMtrHw,2931 +ray/train/torch/torch_predictor.py,sha256=XgS64FwseUrsv9Q4J4zcb9RLEraPArFGec9lCYyrkPE,9649 +ray/train/torch/torch_trainer.py,sha256=B8BgexHRb7XGO2W4Tpd65J49DybxVGJZn22EnE8InTA,8517 +ray/train/torch/train_loop_utils.py,sha256=26uoViM2K3oZeA2_-WKCIwM7Nw0pObElmaptdRDgYRI,28906 +ray/train/torch/xla/__init__.py,sha256=HqATrA5R9ncndEv6qkWLkMrCp29Veq9w0cSm6eQpxtw,91 +ray/train/torch/xla/__pycache__/__init__.cpython-311.pyc,, +ray/train/torch/xla/__pycache__/config.cpython-311.pyc,, +ray/train/torch/xla/config.py,sha256=UJqvrQ0snqXFZOcUv1En1pNYbYSG1GTO8IS8Kj7rcQk,6430 +ray/train/trainer.py,sha256=UJZBObNzL7TdMYFu37S4ocq72rc4T01Uhw1gK_FjIfQ,6812 +ray/train/util/__init__.py,sha256=u2lUO6NB3zYSKFaBUQerR3Zy3WwdH8CZIdattA23ZtA,130 +ray/train/util/__pycache__/__init__.cpython-311.pyc,, +ray/train/utils.py,sha256=r9RY4gLjtcUVDODGFRbO_D_6xG-T71QOwVyZCqWMH1o,340 +ray/train/v2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/v2/__pycache__/__init__.cpython-311.pyc,, +ray/train/v2/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/v2/_internal/__pycache__/__init__.cpython-311.pyc,, +ray/train/v2/_internal/__pycache__/constants.cpython-311.pyc,, +ray/train/v2/_internal/__pycache__/exceptions.cpython-311.pyc,, +ray/train/v2/_internal/__pycache__/util.cpython-311.pyc,, +ray/train/v2/_internal/callbacks/__init__.py,sha256=eKh-zM5_376UD56SGnzz0LBsflnmgVRC33gKZgVugR8,386 +ray/train/v2/_internal/callbacks/__pycache__/__init__.cpython-311.pyc,, +ray/train/v2/_internal/callbacks/__pycache__/accelerators.cpython-311.pyc,, +ray/train/v2/_internal/callbacks/__pycache__/backend_setup.cpython-311.pyc,, +ray/train/v2/_internal/callbacks/__pycache__/datasets.cpython-311.pyc,, +ray/train/v2/_internal/callbacks/__pycache__/metrics.cpython-311.pyc,, +ray/train/v2/_internal/callbacks/__pycache__/user_callback.cpython-311.pyc,, +ray/train/v2/_internal/callbacks/__pycache__/working_dir_setup.cpython-311.pyc,, +ray/train/v2/_internal/callbacks/accelerators.py,sha256=aTrUeL6kifq2099X0O1qPjoXhekNLBLonJu-XvkDTe4,5372 +ray/train/v2/_internal/callbacks/backend_setup.py,sha256=3eUrS42MELgFf_rCscIX4d1elT2jio1ATypVLIwp8iY,1056 +ray/train/v2/_internal/callbacks/datasets.py,sha256=a35JtlFXznNI5P0-DpzabhBRSNE-bj-Zy-qoH1a33mg,3004 +ray/train/v2/_internal/callbacks/metrics.py,sha256=pxtMfCHsEqxsCxow7NSL96yaG6LkipvIGoM5bu2aC0g,9657 +ray/train/v2/_internal/callbacks/user_callback.py,sha256=TRMp3onOJM9YpGmEN-oV2jfh1VngYRHgjIILQ5LCFvw,1654 +ray/train/v2/_internal/callbacks/working_dir_setup.py,sha256=3hkjCiTRG7KlRTxgckwWNMC3Y_5D2d7Vq_XN_bNczl0,933 +ray/train/v2/_internal/constants.py,sha256=okmFrsMj9VnaN4s3ZVukUFWRxLqGUWAG8gPYQK9dHHU,3168 +ray/train/v2/_internal/exceptions.py,sha256=qKb_22iOQNbNtTlLyCy9zXwl9SOslBlB4G3RR315Nlo,6113 +ray/train/v2/_internal/execution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/v2/_internal/execution/__pycache__/__init__.cpython-311.pyc,, +ray/train/v2/_internal/execution/__pycache__/callback.cpython-311.pyc,, +ray/train/v2/_internal/execution/__pycache__/context.cpython-311.pyc,, +ray/train/v2/_internal/execution/__pycache__/controller.cpython-311.pyc,, +ray/train/v2/_internal/execution/__pycache__/storage.cpython-311.pyc,, +ray/train/v2/_internal/execution/callback.py,sha256=Paf3fFVbVSOm2gOZmQvfmYvEXty1G8f6bF2wM0yZo-g,4492 +ray/train/v2/_internal/execution/checkpoint/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/v2/_internal/execution/checkpoint/__pycache__/__init__.cpython-311.pyc,, +ray/train/v2/_internal/execution/checkpoint/__pycache__/checkpoint_manager.cpython-311.pyc,, +ray/train/v2/_internal/execution/checkpoint/__pycache__/report_handler.cpython-311.pyc,, +ray/train/v2/_internal/execution/checkpoint/__pycache__/sync_actor.cpython-311.pyc,, +ray/train/v2/_internal/execution/checkpoint/checkpoint_manager.py,sha256=c52Lg4RXKcMSKMaJFzPXO43k1epIZIBKpjiIegzLD8o,10759 +ray/train/v2/_internal/execution/checkpoint/report_handler.py,sha256=2otqyv67Ie0EXzQqkJy-FkD_KRv17R7PFoy9ZnghmbY,5032 +ray/train/v2/_internal/execution/checkpoint/sync_actor.py,sha256=sQzJaZiA-dSjFa_iCRng_GZnGyYTrjAyep7j5whJLFg,8126 +ray/train/v2/_internal/execution/context.py,sha256=A7VaW7v0FYh_UIdZ8-ulsfCJ_l6TpX3Tc47KtZ6zCJ0,9776 +ray/train/v2/_internal/execution/controller.py,sha256=DFpmBOvq6HnejLiIbzwlCwEUWeUbHIEHG-c7-77q-Ts,14752 +ray/train/v2/_internal/execution/failure_handling/__init__.py,sha256=38KZGMtyxQi79wQD6HN8sWbPnXXRFYGNmn90j3a4lgk,327 +ray/train/v2/_internal/execution/failure_handling/__pycache__/__init__.cpython-311.pyc,, +ray/train/v2/_internal/execution/failure_handling/__pycache__/default.cpython-311.pyc,, +ray/train/v2/_internal/execution/failure_handling/__pycache__/factory.cpython-311.pyc,, +ray/train/v2/_internal/execution/failure_handling/__pycache__/failure_policy.cpython-311.pyc,, +ray/train/v2/_internal/execution/failure_handling/default.py,sha256=nGaOXhHqgSJSZpVvTRxNE3WfaE3XbhEgSDN4bC1VBxU,1579 +ray/train/v2/_internal/execution/failure_handling/factory.py,sha256=lH2CoyIxNJVXVv2pCl8csLZccu88noxIQWeUrJx3-tw,417 +ray/train/v2/_internal/execution/failure_handling/failure_policy.py,sha256=jFAqvvSLH7ZFrwNr9wECOi6DbOCGihjIkGmCeebp9WU,684 +ray/train/v2/_internal/execution/scaling_policy/__init__.py,sha256=ErmB335ru4RLODjGWtJz0YxlkUph-_fiePI8Qsly0XI,394 +ray/train/v2/_internal/execution/scaling_policy/__pycache__/__init__.cpython-311.pyc,, +ray/train/v2/_internal/execution/scaling_policy/__pycache__/factory.cpython-311.pyc,, +ray/train/v2/_internal/execution/scaling_policy/__pycache__/fixed.cpython-311.pyc,, +ray/train/v2/_internal/execution/scaling_policy/__pycache__/scaling_policy.cpython-311.pyc,, +ray/train/v2/_internal/execution/scaling_policy/factory.py,sha256=nxQKnFbjUuHbElXBVWdRYXzgp4KFEYbgPfWsKO5zQ9Q,423 +ray/train/v2/_internal/execution/scaling_policy/fixed.py,sha256=P886sL33JwWDdTEUDpU79pr8mb2bnhdKq0zxlYiTBBU,733 +ray/train/v2/_internal/execution/scaling_policy/scaling_policy.py,sha256=zrC9lkyR1s9r9EaVGMJI0yhZnPkuUvE-wNGXyApkj_w,1517 +ray/train/v2/_internal/execution/storage.py,sha256=-q2-ooYDtLEbofvuIHF7o_0mFHqSfQJOGpGtRBDv2Jw,20945 +ray/train/v2/_internal/execution/worker_group/__init__.py,sha256=KNkKgDJJ3l_mJ3tIakraev5wDDXoJnaZBtBGaxieIgA,265 +ray/train/v2/_internal/execution/worker_group/__pycache__/__init__.cpython-311.pyc,, +ray/train/v2/_internal/execution/worker_group/__pycache__/thread_runner.cpython-311.pyc,, +ray/train/v2/_internal/execution/worker_group/__pycache__/worker.cpython-311.pyc,, +ray/train/v2/_internal/execution/worker_group/__pycache__/worker_group.cpython-311.pyc,, +ray/train/v2/_internal/execution/worker_group/thread_runner.py,sha256=nYM3wA5QrFbgoGyQcXrMjFoYOBKXNbrdjla2NXHUcDQ,2376 +ray/train/v2/_internal/execution/worker_group/worker.py,sha256=PVbmClinTiDfXupoaIWBl8NiJCw0F-Q-fOxeCTln5ao,6905 +ray/train/v2/_internal/execution/worker_group/worker_group.py,sha256=loKDyqcALFtaXzBaC8LZwItBz3Wk1iQd6gs5Fn4k3v4,25476 +ray/train/v2/_internal/logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/v2/_internal/logging/__pycache__/__init__.cpython-311.pyc,, +ray/train/v2/_internal/logging/__pycache__/logging.cpython-311.pyc,, +ray/train/v2/_internal/logging/__pycache__/patch_print.cpython-311.pyc,, +ray/train/v2/_internal/logging/logging.py,sha256=RXkwhotefNcdfUhiaZdTAdDE3Tg813JAmqVDzZdImkU,9252 +ray/train/v2/_internal/logging/patch_print.py,sha256=K5G6wcBiR95fDceFGPBZ9PIWoAfduKk3eLTQXLXUFtw,2563 +ray/train/v2/_internal/util.py,sha256=U8gjEN2Dvb7K-8IrG27IgXFxQw2VVu1-Jj6HEoEIFIA,5061 +ray/train/v2/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/v2/api/__pycache__/__init__.cpython-311.pyc,, +ray/train/v2/api/__pycache__/callback.cpython-311.pyc,, +ray/train/v2/api/__pycache__/config.cpython-311.pyc,, +ray/train/v2/api/__pycache__/data_parallel_trainer.cpython-311.pyc,, +ray/train/v2/api/__pycache__/result.cpython-311.pyc,, +ray/train/v2/api/__pycache__/train_fn_utils.cpython-311.pyc,, +ray/train/v2/api/callback.py,sha256=V3tu9O6RjRiV7pzqBp2pVSG9f-km1IyS4RseXRZDsFk,1716 +ray/train/v2/api/config.py,sha256=5srcawG-6KB19JjxDPY3FmQB3c9I8lmca8WukCmLWo8,6928 +ray/train/v2/api/data_parallel_trainer.py,sha256=hWtH8iV6PsBKs6RQA9rgIqFswJd92Jo6kG-ii45oh7A,10055 +ray/train/v2/api/result.py,sha256=zbXvuvAmC8FngelHNy5Bv70nrkBu-M0VnMmut7Q4274,843 +ray/train/v2/api/train_fn_utils.py,sha256=MaqZArTy5e8usEb7QrhpOHQjXYVXph2TKMgWVSymHxk,1087 +ray/train/v2/horovod/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/v2/horovod/__pycache__/__init__.cpython-311.pyc,, +ray/train/v2/horovod/__pycache__/horovod_trainer.cpython-311.pyc,, +ray/train/v2/horovod/horovod_trainer.py,sha256=eK14nQkIbrDuvSdywEhZrygf1Zkgz6BuwOLyezfH30o,1453 +ray/train/v2/lightgbm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/v2/lightgbm/__pycache__/__init__.cpython-311.pyc,, +ray/train/v2/lightgbm/__pycache__/lightgbm_trainer.cpython-311.pyc,, +ray/train/v2/lightgbm/lightgbm_trainer.py,sha256=YkdJKrc-xThCq2UWbfKQxcB-F_9Iozajtv1cplFf1RE,6691 +ray/train/v2/lightning/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/v2/lightning/__pycache__/__init__.cpython-311.pyc,, +ray/train/v2/lightning/__pycache__/lightning_utils.cpython-311.pyc,, +ray/train/v2/lightning/lightning_utils.py,sha256=8GKp7OFc1rmWGKTOMw590tHsSs1M-fHCdpR6dFJap4s,2499 +ray/train/v2/tensorflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/v2/tensorflow/__pycache__/__init__.cpython-311.pyc,, +ray/train/v2/tensorflow/__pycache__/tensorflow_trainer.cpython-311.pyc,, +ray/train/v2/tensorflow/tensorflow_trainer.py,sha256=VE7SRrdH57Owu7BnvXG4OStSFlhFi_qH6gBAkC6mVH4,7720 +ray/train/v2/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/v2/torch/__pycache__/__init__.cpython-311.pyc,, +ray/train/v2/torch/__pycache__/torch_trainer.cpython-311.pyc,, +ray/train/v2/torch/__pycache__/train_loop_utils.cpython-311.pyc,, +ray/train/v2/torch/torch_trainer.py,sha256=cobuVtkIPHUURIOdJC58rRdF2CeH7WKm34dGvZcvHIw,8693 +ray/train/v2/torch/train_loop_utils.py,sha256=AN_Q7xOthfhV8bya1--pjI8KtbyrtOFDjbL0TXFO6sQ,11242 +ray/train/v2/xgboost/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/train/v2/xgboost/__pycache__/__init__.cpython-311.pyc,, +ray/train/v2/xgboost/__pycache__/xgboost_trainer.cpython-311.pyc,, +ray/train/v2/xgboost/xgboost_trainer.py,sha256=OI2VzYQJmaO33yMYGAWemPO5V5FxyRYV1XcEUEbvdQI,6547 +ray/train/xgboost/__init__.py,sha256=yP5xyms_bcoA49SWVmTIINWixBFLIVdXzBsLmNVYEnM,652 +ray/train/xgboost/__pycache__/__init__.cpython-311.pyc,, +ray/train/xgboost/__pycache__/_xgboost_utils.cpython-311.pyc,, +ray/train/xgboost/__pycache__/config.cpython-311.pyc,, +ray/train/xgboost/__pycache__/v2.cpython-311.pyc,, +ray/train/xgboost/__pycache__/xgboost_checkpoint.cpython-311.pyc,, +ray/train/xgboost/__pycache__/xgboost_predictor.cpython-311.pyc,, +ray/train/xgboost/__pycache__/xgboost_trainer.cpython-311.pyc,, +ray/train/xgboost/_xgboost_utils.py,sha256=ribDScYVcVPoFkYdT1HqPvanlQqDR1rakNpuab75cYY,7671 +ray/train/xgboost/config.py,sha256=O3YW5-lMb0bQAwusa3HdB9mAd69oqOeoyXtbSLJWei0,6947 +ray/train/xgboost/v2.py,sha256=jWzNg22eOJcZjJxIXwpw98oQNBwHYrr67FItPIInOw4,5722 +ray/train/xgboost/xgboost_checkpoint.py,sha256=svToFi-g7Uko5_R2C9-0B4ILJn1ep0tnOUi4YJP9yhs,2591 +ray/train/xgboost/xgboost_predictor.py,sha256=wZwT2pS1C1TQo-JLzZ4rNgP89qTlFOK-Sju5wnI2qIA,5718 +ray/train/xgboost/xgboost_trainer.py,sha256=NKMc87Glao9YGN6Zc96Dyslgm_5ya7jNPAhtwXbrtnw,8699 +ray/tune/__init__.py,sha256=5l5j7vKDKcDLitSVEj4NNv2SKlruW-AHNYhkDGaxm80,3018 +ray/tune/__pycache__/__init__.cpython-311.pyc,, +ray/tune/__pycache__/callback.cpython-311.pyc,, +ray/tune/__pycache__/constants.cpython-311.pyc,, +ray/tune/__pycache__/context.cpython-311.pyc,, +ray/tune/__pycache__/error.cpython-311.pyc,, +ray/tune/__pycache__/progress_reporter.cpython-311.pyc,, +ray/tune/__pycache__/registry.cpython-311.pyc,, +ray/tune/__pycache__/resources.cpython-311.pyc,, +ray/tune/__pycache__/result.cpython-311.pyc,, +ray/tune/__pycache__/result_grid.cpython-311.pyc,, +ray/tune/__pycache__/syncer.cpython-311.pyc,, +ray/tune/__pycache__/tune.cpython-311.pyc,, +ray/tune/__pycache__/tune_config.cpython-311.pyc,, +ray/tune/__pycache__/tuner.cpython-311.pyc,, +ray/tune/analysis/__init__.py,sha256=Sxr-eFig0Rj8jDrCJa32Daqjv_DO128TqnFqEdkG7Kg,103 +ray/tune/analysis/__pycache__/__init__.cpython-311.pyc,, +ray/tune/analysis/__pycache__/experiment_analysis.cpython-311.pyc,, +ray/tune/analysis/experiment_analysis.py,sha256=HgnBw4hC6XvN2B8xjhwE2FFBCU6h3RyDrg_WOKc91o8,27762 +ray/tune/automl/__init__.py,sha256=UqhsT-DhBbmz6AOlDYz3ag6DZYRzRHo8htgqnIxmvlU,72 +ray/tune/automl/__pycache__/__init__.cpython-311.pyc,, +ray/tune/callback.py,sha256=azrLcsZX02LinUWXx2ZnwogcxlQ0hrY99WtX2mqtopU,17056 +ray/tune/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/tune/cli/__pycache__/__init__.cpython-311.pyc,, +ray/tune/cli/__pycache__/commands.cpython-311.pyc,, +ray/tune/cli/__pycache__/scripts.cpython-311.pyc,, +ray/tune/cli/commands.py,sha256=F8VgBXl7mDHSMkxHE_cYr9yIncpjeYYmq0LRerTQ8YE,9995 +ray/tune/cli/scripts.py,sha256=k3eklucFbN8SOEeLz2EBElrtZPG8G6abXzfjgY3FsIU,2826 +ray/tune/constants.py,sha256=FAIsWOBV8U5zqs7yMYkKY_afwBrlokogKsUSrHOuL2g,1163 +ray/tune/context.py,sha256=CkM4YjYn03PRuzA_qD_vLNkpOkSyhFtytuFB_dKVQXg,3816 +ray/tune/error.py,sha256=16nO4FFJyHaxN-hjwaljJ8qCqjL7NV7oabY-DsTYDcM,1115 +ray/tune/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/tune/examples/__pycache__/__init__.cpython-311.pyc,, +ray/tune/examples/__pycache__/async_hyperband_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/ax_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/bayesopt_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/bohb_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/cifar10_pytorch.cpython-311.pyc,, +ray/tune/examples/__pycache__/custom_func_checkpointing.cpython-311.pyc,, +ray/tune/examples/__pycache__/hyperband_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/hyperband_function_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/hyperopt_conditional_search_space_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/lightgbm_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/logging_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/mlflow_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/mlflow_ptl.cpython-311.pyc,, +ray/tune/examples/__pycache__/mnist_ptl_mini.cpython-311.pyc,, +ray/tune/examples/__pycache__/mnist_pytorch.cpython-311.pyc,, +ray/tune/examples/__pycache__/mnist_pytorch_trainable.cpython-311.pyc,, +ray/tune/examples/__pycache__/nevergrad_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/optuna_define_by_run_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/optuna_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/optuna_multiobjective_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/pb2_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/pb2_ppo_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/pbt_convnet_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/pbt_convnet_function_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/pbt_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/pbt_function.cpython-311.pyc,, +ray/tune/examples/__pycache__/pbt_memnn_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/pbt_ppo_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/pbt_tune_cifar10_with_keras.cpython-311.pyc,, +ray/tune/examples/__pycache__/tf_mnist_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/tune_basic_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/tune_mnist_keras.cpython-311.pyc,, +ray/tune/examples/__pycache__/utils.cpython-311.pyc,, +ray/tune/examples/__pycache__/xgboost_dynamic_resources_example.cpython-311.pyc,, +ray/tune/examples/__pycache__/xgboost_example.cpython-311.pyc,, +ray/tune/examples/async_hyperband_example.py,sha256=yjJOtD432A7oA2JBqTDnwOzmvk4vHlfPjXbIUCYLClc,1835 +ray/tune/examples/ax_example.py,sha256=TSYNIWRCI1zbGJW-7IlFzW72fVzUV6F5sjDj1GqsOJI,2819 +ray/tune/examples/bayesopt_example.py,sha256=cmNHR_sc0-lBhQf_mo-nFNLCApliL1EkLiVlefjsYo4,1977 +ray/tune/examples/bohb_example.py,sha256=2YuoVRwOYmbSu8iUjzAvdPIUxnlRsOuphl7AKaT1aEo,3211 +ray/tune/examples/cifar10_pytorch.py,sha256=64hzAvqycVU-qMcyHvX94VcytUinsrT_IKCOOu3o8mo,9343 +ray/tune/examples/custom_func_checkpointing.py,sha256=hOrV99HimUaeK0C7YSQEh6HUuaKwr3DMs3hhKcmZAzQ,2274 +ray/tune/examples/hyperband_example.py,sha256=dg1OxFoc2NVFD_h1aNx_vNIgkUSffIdOkzf4N6vnW58,1446 +ray/tune/examples/hyperband_function_example.py,sha256=7x3Wa_iFGkiiTnd1n9_tqQAe4rcXYUAHMgBmZMyPxdw,2511 +ray/tune/examples/hyperopt_conditional_search_space_example.py,sha256=6w2eIgtfXakrT50HnS-ii-FiwKynJzTjMkqiDUiNdFo,3054 +ray/tune/examples/lightgbm_example.py,sha256=eGvX7tjNPqStokkevNkaLk8G9WvifNBHeaavxuyoPzc,3190 +ray/tune/examples/logging_example.py,sha256=lB0dXDsRjg5k_aWEEyJiGZBElbRYmwRMUCD47ihz8lQ,1886 +ray/tune/examples/mlflow_example.py,sha256=DsFtnnK2vU3215qw7699Y3EFTaHcCXRyQRV_8Zq4gMk,3844 +ray/tune/examples/mlflow_ptl.py,sha256=esXgIzkyQ_PkFjJmglxxLPO4967VDvGjEk3hDa3E798,3161 +ray/tune/examples/mnist_ptl_mini.py,sha256=tkggbTBN8kWQ9J6xWhdg_pbzEW0SvBjz3BRlz28RwRo,5535 +ray/tune/examples/mnist_pytorch.py,sha256=VzPMPvig9FRuufWJd3A1_tX3KJ5A5G-xDa36SE2moCA,5055 +ray/tune/examples/mnist_pytorch_trainable.py,sha256=L6yoX3EDIoRwT5skEb7dpQ8WulruRiwbpHLF9RkLcrM,3115 +ray/tune/examples/nevergrad_example.py,sha256=L_THKOGyqFTMtomuMvlrC9tNVY0ob8bt7ut8OuxC3O8,2338 +ray/tune/examples/optuna_define_by_run_example.py,sha256=F-5_ynfdiqBL0uKql9bStIrj6QT8Dl8GpCkzsO34I4k,2977 +ray/tune/examples/optuna_example.py,sha256=prJZPK13iRs90IufviJ9zm84iHpgLcVcnVUVkOBuK6U,2173 +ray/tune/examples/optuna_multiobjective_example.py,sha256=Hn-1Hihqx4Z_mG3GEDL0N0-aWm4gC80yt0bkh5DI46o,2260 +ray/tune/examples/pb2_example.py,sha256=26-zXwddKpGvSSIeH7JDlKdto0uwPyaAd9jdAxfkcB0,1827 +ray/tune/examples/pb2_ppo_example.py,sha256=_Cwb-o332TRH2kIBtDbH9oWT_GmKR5w9EPjvM2nB7wM,5391 +ray/tune/examples/pbt_convnet_example.py,sha256=ThHAKHfPhnKCGV1uiuJhc5t-DFSX04_W8c6JMEVg6q0,4184 +ray/tune/examples/pbt_convnet_function_example.py,sha256=YPs92bTXBu48yiCalVYsT92_f7UdMVDug_NyGPsRz8c,4657 +ray/tune/examples/pbt_dcgan_mnist/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/tune/examples/pbt_dcgan_mnist/__pycache__/__init__.cpython-311.pyc,, +ray/tune/examples/pbt_dcgan_mnist/__pycache__/common.cpython-311.pyc,, +ray/tune/examples/pbt_dcgan_mnist/__pycache__/pbt_dcgan_mnist_func.cpython-311.pyc,, +ray/tune/examples/pbt_dcgan_mnist/__pycache__/pbt_dcgan_mnist_trainable.cpython-311.pyc,, +ray/tune/examples/pbt_dcgan_mnist/common.py,sha256=5gPJpCvAEdwRYOCaR47Xl5L_xQjcQdLl1lPBD8snriE,8099 +ray/tune/examples/pbt_dcgan_mnist/pbt_dcgan_mnist_func.py,sha256=9ubk_w-QdMNjVfyeFOzrtl8YgLH0TeVzzzVWR9ZN5xA,5976 +ray/tune/examples/pbt_dcgan_mnist/pbt_dcgan_mnist_trainable.py,sha256=PEXRqe4R7NwAcno2-LbYBi4vqSZ6lvDiLNnYow_Zjr0,5831 +ray/tune/examples/pbt_example.py,sha256=XS3PBCRAotwkFSJvbV0uv3LCZvP_Pjpbug_LzKJa0WU,5079 +ray/tune/examples/pbt_function.py,sha256=h5H7xRX6ytpzO1VTUaWLXnF9BYBU_yGOgR-cccPFP7E,6703 +ray/tune/examples/pbt_memnn_example.py,sha256=GaBtiKM9rwbYLqhIEfNbgKaij_zLHGfD6_uvhZSO7pg,11107 +ray/tune/examples/pbt_ppo_example.py,sha256=A_d4aBooRsHYQdXXdX-IIft345qzS0S7ezIaXVz7fpw,2677 +ray/tune/examples/pbt_transformers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/tune/examples/pbt_transformers/__pycache__/__init__.cpython-311.pyc,, +ray/tune/examples/pbt_transformers/__pycache__/pbt_transformers.cpython-311.pyc,, +ray/tune/examples/pbt_transformers/__pycache__/utils.cpython-311.pyc,, +ray/tune/examples/pbt_transformers/pbt_transformers.py,sha256=CFBViOx4AB0VzYUnmb-eoOdqfC8qp75LF_OGIzUmt_o,4953 +ray/tune/examples/pbt_transformers/utils.py,sha256=yx8y1lSDfDNKSivZGj6FTpeabxJhknsXJTjuLFERd9I,1571 +ray/tune/examples/pbt_tune_cifar10_with_keras.py,sha256=HncRhC4f8IwI0Fv_pbVAleroRiW5g19CFY5Z-OyBytQ,7584 +ray/tune/examples/tf_mnist_example.py,sha256=B3v_ua-tjwrMWoFZEuTy-cz4ZuEmX5xSWUmCt75fpSU,5068 +ray/tune/examples/tune_basic_example.py,sha256=5AU14xJqiS81tUdhN-W5GUC-XwosHqjpvLv4z5b3jEU,1831 +ray/tune/examples/tune_mnist_keras.py,sha256=JA9KcKr7rDyP45sYtFvdFAOzqi9xTBnpHtO6-UuO5n4,2824 +ray/tune/examples/utils.py,sha256=G0HzAiN4HikUGD-zkR2zwdkJbXFjUs4LyeUwvhCT6wA,747 +ray/tune/examples/xgboost_dynamic_resources_example.py,sha256=Or4QUsP3SpJjNaC12_eDvbKkUXuJF1n0BZeKXUQvMGo,6526 +ray/tune/examples/xgboost_example.py,sha256=LAsrIrQ1rOVEDgIsz7KoiSbIxcEcLNNtivnrtnlACiQ,3993 +ray/tune/execution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/tune/execution/__pycache__/__init__.cpython-311.pyc,, +ray/tune/execution/__pycache__/class_cache.cpython-311.pyc,, +ray/tune/execution/__pycache__/cluster_info.cpython-311.pyc,, +ray/tune/execution/__pycache__/experiment_state.cpython-311.pyc,, +ray/tune/execution/__pycache__/insufficient_resources_manager.cpython-311.pyc,, +ray/tune/execution/__pycache__/placement_groups.cpython-311.pyc,, +ray/tune/execution/__pycache__/tune_controller.cpython-311.pyc,, +ray/tune/execution/class_cache.py,sha256=bf3E672_X6ZQXidavDoAFzGe_CKwlXBcK2lAke94GPU,2377 +ray/tune/execution/cluster_info.py,sha256=rwJC-i6hwLzF38tTVzjgYs64Xc6vwPJxGxU4QIVno7o,326 +ray/tune/execution/experiment_state.py,sha256=DBGYLLlFmw68rVLSzfivrOGmcfUMCwMObg0_WsJUO_o,11784 +ray/tune/execution/insufficient_resources_manager.py,sha256=P8L-ogsvuySa7Wti6rUpjM-OSCQWMX5rGzk5HtK3K9k,5982 +ray/tune/execution/placement_groups.py,sha256=C3SN1LfQ-x0Ia6zDNGyffABc9lObdD9p26Bsn7dBF9o,4197 +ray/tune/execution/tune_controller.py,sha256=Q_vvVx3Uo-tui8JqpOedn9scWREnOt5x3husDynvq_k,84418 +ray/tune/experiment/__init__.py,sha256=dSHNyUYJumOR_g6a3q945P960PsUc3LK34wJBkHyZMA,193 +ray/tune/experiment/__pycache__/__init__.cpython-311.pyc,, +ray/tune/experiment/__pycache__/config_parser.cpython-311.pyc,, +ray/tune/experiment/__pycache__/experiment.cpython-311.pyc,, +ray/tune/experiment/__pycache__/trial.cpython-311.pyc,, +ray/tune/experiment/config_parser.py,sha256=Y2DuAHnKeFsUaSCAU5UBJAQ0TBF-YthUVofhBNAOT6Q,6998 +ray/tune/experiment/experiment.py,sha256=CsLm131KjtUaEYT8cyUhRpPZknGNuthZ5P9CZDhSLRA,16047 +ray/tune/experiment/trial.py,sha256=XBx-n04AoZfu2RR1ygFTRNNl8ZCKDbos25BVNph7K4k,38612 +ray/tune/experimental/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/tune/experimental/__pycache__/__init__.cpython-311.pyc,, +ray/tune/experimental/__pycache__/output.cpython-311.pyc,, +ray/tune/experimental/output.py,sha256=DkP2Q4jfYOuvrO_vX0xKHNoEhAFJsDmTOBi8KZ2a6MA,32554 +ray/tune/impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/tune/impl/__pycache__/__init__.cpython-311.pyc,, +ray/tune/impl/__pycache__/config.cpython-311.pyc,, +ray/tune/impl/__pycache__/out_of_band_serialize_dataset.cpython-311.pyc,, +ray/tune/impl/__pycache__/placeholder.cpython-311.pyc,, +ray/tune/impl/__pycache__/test_utils.cpython-311.pyc,, +ray/tune/impl/__pycache__/tuner_internal.cpython-311.pyc,, +ray/tune/impl/config.py,sha256=8VBHzXTeHNOmbt3LR4x9h1PuzGLbgyYE9btSU7wX1ds,1637 +ray/tune/impl/out_of_band_serialize_dataset.py,sha256=NbgL8paX7IN3XPn9hy63qjvwdundFh-D5SWmHzrZ2VI,1056 +ray/tune/impl/placeholder.py,sha256=IWgvbFGRSty6tQnWL6CJljpGBxXgUFyT_9npR87j28w,8813 +ray/tune/impl/test_utils.py,sha256=PKz9t7zWSEp3Aq2DW__6OLI1GOy0A30yWxc_WYnxEm0,2211 +ray/tune/impl/tuner_internal.py,sha256=oaL5P9Y-w8v3eS3KRnIFy1w52ou6jolQLem0OSDd_5A,27109 +ray/tune/integration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/tune/integration/__pycache__/__init__.cpython-311.pyc,, +ray/tune/integration/__pycache__/keras.cpython-311.pyc,, +ray/tune/integration/__pycache__/lightgbm.cpython-311.pyc,, +ray/tune/integration/__pycache__/pytorch_lightning.cpython-311.pyc,, +ray/tune/integration/__pycache__/ray_train.cpython-311.pyc,, +ray/tune/integration/__pycache__/xgboost.cpython-311.pyc,, +ray/tune/integration/keras.py,sha256=yXfwfWM_JBRHDRvZxF311OFXfFogmhCH4onVf3QM_sE,845 +ray/tune/integration/lightgbm.py,sha256=5ONPTvqRjY_LJCfXDrDkcMozRDGL3Py7diQzSI7Hq9g,479 +ray/tune/integration/pytorch_lightning.py,sha256=HHJWmuCDpYK5ke46KyKnpck2_avau3lgWv0ji9bPBIU,7135 +ray/tune/integration/ray_train.py,sha256=a6zokYsAfyL9pX-JJoIHJCVeVgB0zYHSiPnqaQq2ERU,1139 +ray/tune/integration/xgboost.py,sha256=qJo7Pxefck9JPCuQOywLXapXnGADYFZUNUgTW2Piae8,477 +ray/tune/logger/__init__.py,sha256=ec5n9fHOC6AYFe6mVK3_JQVsEm9QEQpiSUSDnChkjIQ,765 +ray/tune/logger/__pycache__/__init__.cpython-311.pyc,, +ray/tune/logger/__pycache__/aim.cpython-311.pyc,, +ray/tune/logger/__pycache__/comet.cpython-311.pyc,, +ray/tune/logger/__pycache__/csv.cpython-311.pyc,, +ray/tune/logger/__pycache__/json.cpython-311.pyc,, +ray/tune/logger/__pycache__/logger.cpython-311.pyc,, +ray/tune/logger/__pycache__/mlflow.cpython-311.pyc,, +ray/tune/logger/__pycache__/noop.cpython-311.pyc,, +ray/tune/logger/__pycache__/tensorboardx.cpython-311.pyc,, +ray/tune/logger/__pycache__/unified.cpython-311.pyc,, +ray/tune/logger/__pycache__/wandb.cpython-311.pyc,, +ray/tune/logger/aim.py,sha256=Dr0sTPvOYY4IbMo0sVHve5qQ20bAskfu8FvR176s0s8,6820 +ray/tune/logger/comet.py,sha256=09ZFx30_O-Ixa438gkpdb2VXyQaL6R9i6z6gJwqaiPw,117 +ray/tune/logger/csv.py,sha256=y412dEU18vaRZCCMDQ_pQ1lBLuD7l5ToY_f2ZTaGgtI,4149 +ray/tune/logger/json.py,sha256=bWXvg9cP-q4BNLxO53XGHZmeVHkYrKM7V7Q-upKPHCc,4179 +ray/tune/logger/logger.py,sha256=27FXI7Z9pBazie_NMhU0ERXk28jVJZh_SJhLBIs0oRc,8122 +ray/tune/logger/mlflow.py,sha256=iyOkDQZjyMwfBVvjBjWnwRyumU_Z63qTzUqjy3EMWCc,121 +ray/tune/logger/noop.py,sha256=j_LlYmHYMOELf6Umqyu5H4z3MoVd7WF33ozGYcgIM_I,246 +ray/tune/logger/tensorboardx.py,sha256=bE3Py7OaYAI8tUZgIKww6qka3AvYKJaA8nnwdf_sltY,12347 +ray/tune/logger/unified.py,sha256=GdRmhAZI9PgEb_U_X0gWqSz78xHi0EcBnCKzDvJhEmk,2318 +ray/tune/logger/wandb.py,sha256=huF0YInAclUPEwJ2nFnvv54eZ-Lz_dkRM-5PbCth5p0,117 +ray/tune/progress_reporter.py,sha256=gqH1bTbk4vQUSRA39NfaH3mhx9Qna6FdWykG2Upvv00,58719 +ray/tune/registry.py,sha256=xQe-WMWvoH-i_W1Il0QrkNLlRzBLCDrNPtrmKsNaKVg,9270 +ray/tune/resources.py,sha256=W54BRyE7POQi4xErotDBEDHPy_Cqb3EdkcLVFwk2N9o,2535 +ray/tune/result.py,sha256=BCyS4NQkXLnABeAMJsjw22Cluf1k_gMuftgYMQZy5GY,3484 +ray/tune/result_grid.py,sha256=oP0eXPwwXvE2VOs6jU358X5GjgeIwZTGkGwCIhmObFw,10516 +ray/tune/schedulers/__init__.py,sha256=2rh5jBaGOnTVfetdWqV0uzeTmJjEPBGQ_9HseYYU4Zo,3022 +ray/tune/schedulers/__pycache__/__init__.cpython-311.pyc,, +ray/tune/schedulers/__pycache__/async_hyperband.cpython-311.pyc,, +ray/tune/schedulers/__pycache__/hb_bohb.cpython-311.pyc,, +ray/tune/schedulers/__pycache__/hyperband.cpython-311.pyc,, +ray/tune/schedulers/__pycache__/median_stopping_rule.cpython-311.pyc,, +ray/tune/schedulers/__pycache__/pb2.cpython-311.pyc,, +ray/tune/schedulers/__pycache__/pb2_utils.cpython-311.pyc,, +ray/tune/schedulers/__pycache__/pbt.cpython-311.pyc,, +ray/tune/schedulers/__pycache__/resource_changing_scheduler.cpython-311.pyc,, +ray/tune/schedulers/__pycache__/trial_scheduler.cpython-311.pyc,, +ray/tune/schedulers/__pycache__/util.cpython-311.pyc,, +ray/tune/schedulers/async_hyperband.py,sha256=aKMF2Gptft3k4uB92HlP6iel8gGtZdj6leqovh_5I9Q,10201 +ray/tune/schedulers/hb_bohb.py,sha256=NkeBKbw8YlG8TV8QnlHeDtpiTh7neX5emedfIng6YZY,7700 +ray/tune/schedulers/hyperband.py,sha256=lIZxmYc4rMoNRaMy3Ybj6jTHP0KnbQK7AEXs_yB_nOw,24762 +ray/tune/schedulers/median_stopping_rule.py,sha256=Hsdw1N04HSfxoek_lx-RSmDQCfbFiO7ZJy-uYg3c9WY,8420 +ray/tune/schedulers/pb2.py,sha256=B9pdab2Yg6vnYGIyE9gJA3pst9HINESNZEx_if69S3M,19672 +ray/tune/schedulers/pb2_utils.py,sha256=DJh_vANYbvsjpCTTi7Gpqw-1Gz1Kun9vQruF7FIHJfA,5744 +ray/tune/schedulers/pbt.py,sha256=SiVyRcdYuJqnaGukjyTM35wk447h6nOVU_j8mpUY9YI,48728 +ray/tune/schedulers/resource_changing_scheduler.py,sha256=872qzWmz2-7XktCkNHcYgHR2w5RgT4-mntEErecEy38,34329 +ray/tune/schedulers/trial_scheduler.py,sha256=xnUinLLItShYuayPJtr-sEnJPgT0rXajApJsOyEw1XY,5484 +ray/tune/schedulers/util.py,sha256=37XMePBGzv0-pOfOMQZ2GVOtY_XeLNJ7QpsdUrwz6Yg,918 +ray/tune/search/__init__.py,sha256=ys0hrHK23w6wcR2HmMnp1dOsxRsR8j595XWPsqWK1_U,4486 +ray/tune/search/__pycache__/__init__.cpython-311.pyc,, +ray/tune/search/__pycache__/_mock.cpython-311.pyc,, +ray/tune/search/__pycache__/basic_variant.cpython-311.pyc,, +ray/tune/search/__pycache__/concurrency_limiter.cpython-311.pyc,, +ray/tune/search/__pycache__/repeater.cpython-311.pyc,, +ray/tune/search/__pycache__/sample.cpython-311.pyc,, +ray/tune/search/__pycache__/search_algorithm.cpython-311.pyc,, +ray/tune/search/__pycache__/search_generator.cpython-311.pyc,, +ray/tune/search/__pycache__/searcher.cpython-311.pyc,, +ray/tune/search/__pycache__/util.cpython-311.pyc,, +ray/tune/search/__pycache__/variant_generator.cpython-311.pyc,, +ray/tune/search/_mock.py,sha256=sC3y8LmTi2zqoPmGy67nsM1iC5NWiSldVXHwdVwbVR8,1744 +ray/tune/search/ax/__init__.py,sha256=FGvbOwy-mtT3_YS6ZMBHJ7Msbnk9jEr_zbOPyMp4-SY,74 +ray/tune/search/ax/__pycache__/__init__.cpython-311.pyc,, +ray/tune/search/ax/__pycache__/ax_search.cpython-311.pyc,, +ray/tune/search/ax/ax_search.py,sha256=Y5dEwv4o4Awdh7UBeihdjzFLInc8qszl5fVFJ3c0c4g,15682 +ray/tune/search/basic_variant.py,sha256=o9fiFpEIlfVfEiJjupUCT3F9CXLxYGNkkA6anizPFQM,15379 +ray/tune/search/bayesopt/__init__.py,sha256=3DznYC9QeZGRzZGjZYr7cKhBm1nVEX2xbnkKmgqoYLU,98 +ray/tune/search/bayesopt/__pycache__/__init__.cpython-311.pyc,, +ray/tune/search/bayesopt/__pycache__/bayesopt_search.cpython-311.pyc,, +ray/tune/search/bayesopt/bayesopt_search.py,sha256=tkpwbTlcc2TCalJb9D2lq8gVANM54MeQ57li2BfJrHI,16238 +ray/tune/search/bohb/__init__.py,sha256=eKU452gquD3_rEMMumU38h4Z1lHuzWW_6NFgz6MArWI,92 +ray/tune/search/bohb/__pycache__/__init__.cpython-311.pyc,, +ray/tune/search/bohb/__pycache__/bohb_search.cpython-311.pyc,, +ray/tune/search/bohb/bohb_search.py,sha256=vUxGJGPYjUfT0ZVV8NNvjCLx3s5Bph3nfhsfNqawSug,13730 +ray/tune/search/concurrency_limiter.py,sha256=f7L2xdhYUe-Knbuu993zwvEWJ7w3Ev4VvOOChAfxoyQ,6325 +ray/tune/search/hebo/__init__.py,sha256=f9h2WIEtOVo_cYCBccYXV_kptAZU78xwUoB90__OyKE,82 +ray/tune/search/hebo/__pycache__/__init__.cpython-311.pyc,, +ray/tune/search/hebo/__pycache__/hebo_search.cpython-311.pyc,, +ray/tune/search/hebo/hebo_search.py,sha256=XBPHa-PQGbCFPSXX9HEBFrqu7y7CdLbfVJHp3guLtyE,16940 +ray/tune/search/hyperopt/__init__.py,sha256=wImM0x3WS0f-1MTuKfzwXQa6drX4gmofGidJJJTdJ8Q,98 +ray/tune/search/hyperopt/__pycache__/__init__.cpython-311.pyc,, +ray/tune/search/hyperopt/__pycache__/hyperopt_search.cpython-311.pyc,, +ray/tune/search/hyperopt/hyperopt_search.py,sha256=RMNDbrAxWjUp8GhVwgM0b4HKNqATbD657CzqOqop3rw,21121 +ray/tune/search/nevergrad/__init__.py,sha256=vNDjYIDWJVHqmZqMVbO-Dc0FMD5bLtzDluwrcOtQFYs,102 +ray/tune/search/nevergrad/__pycache__/__init__.cpython-311.pyc,, +ray/tune/search/nevergrad/__pycache__/nevergrad_search.cpython-311.pyc,, +ray/tune/search/nevergrad/nevergrad_search.py,sha256=R-h1QmGvLne_HrakDp14A0ZXRQBvlwj2F6WRXQsf4MY,13533 +ray/tune/search/optuna/__init__.py,sha256=3DqongrESbcBwTYXC1QGWvWczh84NJZHx5ddXC45SpM,90 +ray/tune/search/optuna/__pycache__/__init__.cpython-311.pyc,, +ray/tune/search/optuna/__pycache__/optuna_search.cpython-311.pyc,, +ray/tune/search/optuna/optuna_search.py,sha256=zB6w1Pl9oUokzuNNAKzI57TaD1ZPmTo6u54dqVIG2UM,26650 +ray/tune/search/repeater.py,sha256=sYH0yj6SyH8KVxNuxeG-3tc5abdaIEmzr9V2wXzUnaU,7007 +ray/tune/search/sample.py,sha256=hxIjZ7Fmfui88gdgtmSYX9EG3tl7GHhza39YQKla3Ww,23803 +ray/tune/search/search_algorithm.py,sha256=3IkZPXBSthMLAFCMDESjg-8hqMroSypeE1k8zp8aJXA,3941 +ray/tune/search/search_generator.py,sha256=U1lqGxnB009bC-yONENTWeuG_KXSM3xtbOaiokgZuF4,8185 +ray/tune/search/searcher.py,sha256=slaSNL0HSwnN4UsF2q_Y5ARCJzJwW9R28zoE-ux7E1c,21390 +ray/tune/search/util.py,sha256=KGL7-NTlMaSVTsJFId1jYXdr18NEzCTTthDxSyh64NM,976 +ray/tune/search/variant_generator.py,sha256=4NwCGyDO24_XF2c1OTo9-ZcUpbtKljNOB1zwK0A5gnU,17419 +ray/tune/search/zoopt/__init__.py,sha256=DzlNJOuxvCW1ETYkol-xIqW3BVTv5LCR8-ZCmfCoHko,86 +ray/tune/search/zoopt/__pycache__/__init__.cpython-311.pyc,, +ray/tune/search/zoopt/__pycache__/zoopt_search.cpython-311.pyc,, +ray/tune/search/zoopt/zoopt_search.py,sha256=fPFwLCOY4FSqN28IdD465_iuCG2FFlFrJduCfAH1F7o,12457 +ray/tune/stopper/__init__.py,sha256=h0MRFnWskA0aPSK4Jz38W6fOOsuFX1PNkuZA2tkGYkk,636 +ray/tune/stopper/__pycache__/__init__.cpython-311.pyc,, +ray/tune/stopper/__pycache__/experiment_plateau.cpython-311.pyc,, +ray/tune/stopper/__pycache__/function_stopper.cpython-311.pyc,, +ray/tune/stopper/__pycache__/maximum_iteration.cpython-311.pyc,, +ray/tune/stopper/__pycache__/noop.cpython-311.pyc,, +ray/tune/stopper/__pycache__/stopper.cpython-311.pyc,, +ray/tune/stopper/__pycache__/timeout.cpython-311.pyc,, +ray/tune/stopper/__pycache__/trial_plateau.cpython-311.pyc,, +ray/tune/stopper/experiment_plateau.py,sha256=FTcNkmHOlX-xs7SupuTx7kIiTZZcSB2TjFuCsEIxATQ,3208 +ray/tune/stopper/function_stopper.py,sha256=YtkP6O6j5cmgwwGEwEmaJUvAJuG_4pN6eSSqdl0O2vQ,1142 +ray/tune/stopper/maximum_iteration.py,sha256=zhZ3_KbpwKYzSJEi_5iD6RX-UGVOzsvJXqNiBy5V5CE,656 +ray/tune/stopper/noop.py,sha256=e4Pj9GzYi6grdb8InDn_GaVbiXKK8QtuPGZO7X4Ey1M,238 +ray/tune/stopper/stopper.py,sha256=ZOMTieHPed4d4KBHhIXLVVhPON56r7jUORRWuMKRt18,3097 +ray/tune/stopper/timeout.py,sha256=6LUpKtjDA9ettjv43CZHLLP-HA9Wab8bImmKuwoStwI,1814 +ray/tune/stopper/trial_plateau.py,sha256=RjnRrBt3xyyy0UZ4N7K--jr0GY2ikQB9v2gVVX5VRuc,3332 +ray/tune/syncer.py,sha256=gYcLKukNSXyXC297QigCi_AR8DojuPZgx1wltbFp3vw,453 +ray/tune/trainable/__init__.py,sha256=Px0KvVAvgKo53W5CxXO0hl1ss7sbKapwLdB47rz1XOQ,287 +ray/tune/trainable/__pycache__/__init__.cpython-311.pyc,, +ray/tune/trainable/__pycache__/function_trainable.cpython-311.pyc,, +ray/tune/trainable/__pycache__/metadata.cpython-311.pyc,, +ray/tune/trainable/__pycache__/trainable.cpython-311.pyc,, +ray/tune/trainable/__pycache__/trainable_fn_utils.cpython-311.pyc,, +ray/tune/trainable/__pycache__/util.cpython-311.pyc,, +ray/tune/trainable/function_trainable.py,sha256=NnuENNHQ3xAx_YJdzEL-QC97MZSTZoI4wgQ0yjatHe8,10470 +ray/tune/trainable/metadata.py,sha256=qa-8UdMYEwmFPQyKwwf8MlcEmNCZVxTZP1Yokxvuxws,3522 +ray/tune/trainable/trainable.py,sha256=8sA2SwrnaxS-aEHXwKxQJ6VGSxKPT_WrvDW2QxRSVsk,37217 +ray/tune/trainable/trainable_fn_utils.py,sha256=B0X-KOuaAzeopI6sLHJ3Ahau0SMkNcGE-TZ54JP354E,2072 +ray/tune/trainable/util.py,sha256=1yKDR2gJCbsktPAEmKq9AkOr1SMY5ENKEFJkCtLrLWI,7756 +ray/tune/tune.py,sha256=wn9f5uHhIb4Fh-334t7FCXdPpwTyo7HhIFv4bbAEhFg,47428 +ray/tune/tune_config.py,sha256=e_EtXwnV2mrxUjTPGFV0Q01nQciF5xGEyNDadm9dTsA,4718 +ray/tune/tuner.py,sha256=cbfr619wSpBEEtDSrDiQ2ZUPCzylaRmz-Uir38ohhXQ,16894 +ray/tune/utils/__init__.py,sha256=lj3-3FcZUD9njRCJNAcysjTyeWE79vQiKN35JQkTO98,523 +ray/tune/utils/__pycache__/__init__.cpython-311.pyc,, +ray/tune/utils/__pycache__/callback.cpython-311.pyc,, +ray/tune/utils/__pycache__/file_transfer.cpython-311.pyc,, +ray/tune/utils/__pycache__/log.cpython-311.pyc,, +ray/tune/utils/__pycache__/mock.cpython-311.pyc,, +ray/tune/utils/__pycache__/mock_trainable.cpython-311.pyc,, +ray/tune/utils/__pycache__/object_cache.cpython-311.pyc,, +ray/tune/utils/__pycache__/release_test_util.cpython-311.pyc,, +ray/tune/utils/__pycache__/resource_updater.cpython-311.pyc,, +ray/tune/utils/__pycache__/serialization.cpython-311.pyc,, +ray/tune/utils/__pycache__/util.cpython-311.pyc,, +ray/tune/utils/callback.py,sha256=aux9-2A0mlghAxh7cppuC9lDC_EH_XsyCnvhZuKWwnI,5011 +ray/tune/utils/file_transfer.py,sha256=9RjXT0l8ESNJ1nI7qxEd19otseGxyd0gHHuuUU-IWbk,17429 +ray/tune/utils/log.py,sha256=3Yco2YXLRj-4hi_LX40jCs9s7jMeIrMntNArPr9_REI,1462 +ray/tune/utils/mock.py,sha256=QvIWuqMDJWUvgzB4Pmg6A7yk--afZiX5KLJLFzmXwUE,4004 +ray/tune/utils/mock_trainable.py,sha256=z60orHWJyU9TBPGAsSmpeb40Ib37n3ERMRpbgw6Cs-U,1884 +ray/tune/utils/object_cache.py,sha256=pIwWqbGTjF9t0vXgZMj3BqrqcQN-R-kg3LDzfg7o6SU,5512 +ray/tune/utils/release_test_util.py,sha256=AAfftGdl8uG8MYZpWOAsogBvR4SwWdtV8aruP8fY5WQ,5785 +ray/tune/utils/resource_updater.py,sha256=egN_nCBbKFsbH_2k4I9QBCm1r1Z-WPLpbw_bLBpX4l4,12895 +ray/tune/utils/serialization.py,sha256=vwhYZFmO_wKDhW7ZV0y5YzuNLAOS0r4XG0WHzSmT4Ns,1344 +ray/tune/utils/util.py,sha256=rrTBH6vgYswnbwNTtP6bdv1bCSweCaIDRNtv5p_o4Co,19672 +ray/types.py,sha256=2cbqnQ29__PbiqmZDvTOtMn_Gkrpaab21Gil84vWtGg,412 +ray/util/__init__.py,sha256=IkrA8iezhL2YhZOLfT9IeINfFzFHO509aLBL5A37SO8,2344 +ray/util/__pycache__/__init__.cpython-311.pyc,, +ray/util/__pycache__/actor_group.cpython-311.pyc,, +ray/util/__pycache__/actor_pool.cpython-311.pyc,, +ray/util/__pycache__/annotations.cpython-311.pyc,, +ray/util/__pycache__/check_open_ports.cpython-311.pyc,, +ray/util/__pycache__/check_serialize.cpython-311.pyc,, +ray/util/__pycache__/client_connect.cpython-311.pyc,, +ray/util/__pycache__/debug.cpython-311.pyc,, +ray/util/__pycache__/debugpy.cpython-311.pyc,, +ray/util/__pycache__/iter.cpython-311.pyc,, +ray/util/__pycache__/iter_metrics.cpython-311.pyc,, +ray/util/__pycache__/metrics.cpython-311.pyc,, +ray/util/__pycache__/placement_group.cpython-311.pyc,, +ray/util/__pycache__/queue.cpython-311.pyc,, +ray/util/__pycache__/rpdb.cpython-311.pyc,, +ray/util/__pycache__/scheduling_strategies.cpython-311.pyc,, +ray/util/__pycache__/serialization.cpython-311.pyc,, +ray/util/__pycache__/serialization_addons.cpython-311.pyc,, +ray/util/__pycache__/timer.cpython-311.pyc,, +ray/util/accelerators/__init__.py,sha256=P-5cdGB9Ns1MZyJ20WFIQemoFocYTpD2S98EJPXP69w,1791 +ray/util/accelerators/__pycache__/__init__.cpython-311.pyc,, +ray/util/accelerators/__pycache__/accelerators.cpython-311.pyc,, +ray/util/accelerators/__pycache__/tpu.cpython-311.pyc,, +ray/util/accelerators/accelerators.py,sha256=1eJGqaWKapmbHBOHyqOSaQCakmlg6JccK9NjBBIwRkA,1136 +ray/util/accelerators/tpu.py,sha256=qVTs35wiNNvDbLhlKYD0NEUmzJEI-VJv6CFuN_fyczw,1190 +ray/util/actor_group.py,sha256=TBUfZVdmzQ-1Sf2ZEwjoTo28vhxSwKw4AvpmPpxZ8rs,7981 +ray/util/actor_pool.py,sha256=f7j_y-7fHI8MpFe51t03XRNvYASOVtqYmhzSE7Ya5ZE,14542 +ray/util/annotations.py,sha256=ATky2BuwxL0eRHlz-wOD9nVMY6R5QMfNh31uvcIwl_A,7988 +ray/util/check_open_ports.py,sha256=Z6GgY9lNUnIJsKk7X1Qj2BaiiocMIqFB_2f8NbiZpMU,5951 +ray/util/check_serialize.py,sha256=DDiSY3yTEJMOzkHi_-EN8uGuGi9m96gLkkEgRJ_ijJc,8439 +ray/util/client/__init__.py,sha256=nPZ2X1QT8A6PupIYIQK9gNZEdPfa25hjTQSwRXJ-SSU,10615 +ray/util/client/__pycache__/__init__.cpython-311.pyc,, +ray/util/client/__pycache__/api.cpython-311.pyc,, +ray/util/client/__pycache__/client_app.cpython-311.pyc,, +ray/util/client/__pycache__/client_pickler.cpython-311.pyc,, +ray/util/client/__pycache__/common.cpython-311.pyc,, +ray/util/client/__pycache__/dataclient.cpython-311.pyc,, +ray/util/client/__pycache__/logsclient.cpython-311.pyc,, +ray/util/client/__pycache__/options.cpython-311.pyc,, +ray/util/client/__pycache__/ray_client_helpers.cpython-311.pyc,, +ray/util/client/__pycache__/runtime_context.cpython-311.pyc,, +ray/util/client/__pycache__/worker.cpython-311.pyc,, +ray/util/client/api.py,sha256=asnDQPzT0z1211WbOuOWEe75Z3VRNSIrPjqPqrUloQk,15344 +ray/util/client/client_app.py,sha256=Ov6GaUQUa9P3TuWu1NbQbKFSjB5CrPUqZ7uz5KoQGI0,1822 +ray/util/client/client_pickler.py,sha256=WScPUo1o5_GB6OEADSYZssA_0zbVf_dpicEZQcZM_SA,6269 +ray/util/client/common.py,sha256=3HP8KPJsguFW-EyFlU0NtlvioZEgHivs4lGqvgZZzWU,35256 +ray/util/client/dataclient.py,sha256=7jjsUnQ6uK4VXao3jaz0J_Bctk2mhzwoNq-pGmpwx5A,22951 +ray/util/client/logsclient.py,sha256=96PLK-7rwzeVkrhwrY9ixjDMhgAQHzcgadKc2kIv46c,4946 +ray/util/client/options.py,sha256=Q8gmLTXb4qg15iqskR3zpPNOs65OmMTF_K4aWpzvkZ4,1887 +ray/util/client/ray_client_helpers.py,sha256=RdiJ5nmqBI9EOTohCjqL216VQIFXSfi-47Pc0fjn_Tg,3448 +ray/util/client/runtime_context.py,sha256=vKvFyO1hK03BmaovPUziiyI2HgXqzi1eoFYlYeOn7fs,1886 +ray/util/client/server/__init__.py,sha256=og0t86nF86MB8dm80ZrQ3A9og0aUvf6TXKeH0I5Z6AA,56 +ray/util/client/server/__main__.py,sha256=Oj32656eOno-hNr_Hqq47_oQn0TfFBkXnIGeRrYhk94,90 +ray/util/client/server/__pycache__/__init__.cpython-311.pyc,, +ray/util/client/server/__pycache__/__main__.cpython-311.pyc,, +ray/util/client/server/__pycache__/dataservicer.cpython-311.pyc,, +ray/util/client/server/__pycache__/logservicer.cpython-311.pyc,, +ray/util/client/server/__pycache__/proxier.cpython-311.pyc,, +ray/util/client/server/__pycache__/server.cpython-311.pyc,, +ray/util/client/server/__pycache__/server_pickler.cpython-311.pyc,, +ray/util/client/server/__pycache__/server_stubs.cpython-311.pyc,, +ray/util/client/server/dataservicer.py,sha256=Gu6lGUHalA5pdiFfw5z3nkjEvS0kBRGKrvD80autNCc,18839 +ray/util/client/server/logservicer.py,sha256=8vBPneYS4lGKclmmGwz1TdpgNNOULAgajpXhfyP3MHw,4278 +ray/util/client/server/proxier.py,sha256=l23t0-wkNvrcwY6sbYjk_06pjCKE90pFHSMR1j9qc94,34787 +ray/util/client/server/server.py,sha256=Vhp4xCd44gRunVXgXSJLo-2Q8SlPWChQgX0wjiQWQ2c,38657 +ray/util/client/server/server_pickler.py,sha256=DKLfE8E0sODOMBkeuylbemOTGulj3PXODuDvuecxaNA,4503 +ray/util/client/server/server_stubs.py,sha256=5GgmZIysuwWQmmTaPiM_eCwi9q9XJlbw2ztrW0Ll_Kg,1732 +ray/util/client/worker.py,sha256=9Ttjw79dCCAgqze4OP7ZBP8gTxgfkvHO-RiMofx7npM,36972 +ray/util/client_connect.py,sha256=P9jM4NwjBNwQ8MQQWQy0n--fz2dW6vWq9G6ni5Uwfkk,2604 +ray/util/collective/__init__.py,sha256=L63nzXRmqDCg57D1BZmToPIeUOZbfQZHvGlnjN1RAGM,1038 +ray/util/collective/__pycache__/__init__.cpython-311.pyc,, +ray/util/collective/__pycache__/collective.cpython-311.pyc,, +ray/util/collective/__pycache__/const.cpython-311.pyc,, +ray/util/collective/__pycache__/types.cpython-311.pyc,, +ray/util/collective/__pycache__/util.cpython-311.pyc,, +ray/util/collective/collective.py,sha256=v1cQeS2NoK_WjvZwPINngtSxUSpgqAPCDfS56lkiN1c,25187 +ray/util/collective/collective_group/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/util/collective/collective_group/__pycache__/__init__.cpython-311.pyc,, +ray/util/collective/collective_group/__pycache__/base_collective_group.cpython-311.pyc,, +ray/util/collective/collective_group/__pycache__/cuda_stream.cpython-311.pyc,, +ray/util/collective/collective_group/__pycache__/gloo_collective_group.cpython-311.pyc,, +ray/util/collective/collective_group/__pycache__/gloo_util.cpython-311.pyc,, +ray/util/collective/collective_group/__pycache__/nccl_collective_group.cpython-311.pyc,, +ray/util/collective/collective_group/__pycache__/nccl_util.cpython-311.pyc,, +ray/util/collective/collective_group/base_collective_group.py,sha256=dvPfIzUSHbYLlL7rPuNOWQA3CLLT1TU25SNKh0n-m5Q,2277 +ray/util/collective/collective_group/cuda_stream.py,sha256=nfvbwjRJkCiMo4s0x08i_AqGDj4deaPv0hgD22nhHzA,2969 +ray/util/collective/collective_group/gloo_collective_group.py,sha256=biRFnX8MBgfC2rP0551-YNxIuhFQ7LFOWN6ZVh__Q4o,19785 +ray/util/collective/collective_group/gloo_util.py,sha256=-PwZMr6f78H030x6BYGCWkL8WRPhLYfgVwi8-w88bM8,10270 +ray/util/collective/collective_group/nccl_collective_group.py,sha256=vyZn2DYj_cj2qaVbIkw9DhaAHhR0TFrcWcvKH7mYuZE,30567 +ray/util/collective/collective_group/nccl_util.py,sha256=jf1f5RyM65iunuP8NwnUwEAvYvZFVsmxfhm3_DvdsRI,9192 +ray/util/collective/const.py,sha256=J9r6vjcBtLpvZt6LM-LqWenEX1ThZgF8ClQS6r5lf9A,865 +ray/util/collective/types.py,sha256=SZqNwVEgRQHfd8pCuSCMV3sgAzOLLMCuNO-H9miC6cg,2154 +ray/util/collective/util.py,sha256=xLWz1mrtCscezOkUyBz0DsuuVWs5xeocHpFocRxo-dM,1667 +ray/util/dask/__init__.py,sha256=IrJe50-Z-Pf2U7xyPj_Go4OoFPRLT6p0Emhjl9d0bIo,1489 +ray/util/dask/__pycache__/__init__.cpython-311.pyc,, +ray/util/dask/__pycache__/callbacks.cpython-311.pyc,, +ray/util/dask/__pycache__/common.cpython-311.pyc,, +ray/util/dask/__pycache__/optimizations.cpython-311.pyc,, +ray/util/dask/__pycache__/scheduler.cpython-311.pyc,, +ray/util/dask/__pycache__/scheduler_utils.cpython-311.pyc,, +ray/util/dask/callbacks.py,sha256=EnaIZ2ynzhWWZ_mTiW7zhXa5KQSqq05GZzBPB689DGQ,10534 +ray/util/dask/common.py,sha256=ZzOPrGCOfJOS3Zy5L3zENn7Nl32TrZp90_zxpAa1g44,2673 +ray/util/dask/optimizations.py,sha256=ISPB333x0J2jbY4e192tTrOA-YoplZiTZyF_t2SiZjk,5904 +ray/util/dask/scheduler.py,sha256=MtnPpuQqiUH80cQ7WUXKKbnA8VFs-Ue0xsp5ZneJ7SE,22978 +ray/util/dask/scheduler_utils.py,sha256=oynBwA0Z0RLx09RwcA7sddzQJEW3FO0zZqZK12k_uE0,11423 +ray/util/debug.py,sha256=NHoV7jJFy067JZpVeGribCJlVBdI5X9oOsZIYcmIOrg,8643 +ray/util/debugpy.py,sha256=2aSaewt_C7AaVBx2Rh3ntA6A5ZAdXiAEsSiwgRSUxqA,4054 +ray/util/horovod/__init__.py,sha256=eHQd2sGhmlA42dukBrIGIOj0k8k5f5BExabycshR5yE,172 +ray/util/horovod/__pycache__/__init__.cpython-311.pyc,, +ray/util/iter.py,sha256=P9dWumFhzkYU71L304tMD5ysB4zqN4vjNRL3y7RywTg,46939 +ray/util/iter_metrics.py,sha256=U_7iDnbTItUA20EYx_8Q2Kg7a9TCM8eVd57qr4pY8so,2227 +ray/util/joblib/__init__.py,sha256=ze4lZZU0ltg367PHT2svbmEcnKfuz1OPdq_E4afv5eg,588 +ray/util/joblib/__pycache__/__init__.cpython-311.pyc,, +ray/util/joblib/__pycache__/ray_backend.cpython-311.pyc,, +ray/util/joblib/ray_backend.py,sha256=_9VJPN00sh0c7EndRqfzkwrvHIu6uqkisOxBxlnI7uI,3344 +ray/util/lightgbm/__init__.py,sha256=qSTKqnmHoVx06HHOmxZOoBDFjbP7fStk32Us_YOz6jM,179 +ray/util/lightgbm/__pycache__/__init__.cpython-311.pyc,, +ray/util/metrics.py,sha256=b0oUyua4RL4UeFALWx4Yp6OuMW00QFA5M3FdNY4wj3Q,10128 +ray/util/multiprocessing/__init__.py,sha256=ERlZV37JQKBF2x4do6IKgua3ukNMXGwD4-QO4ig_lUE,133 +ray/util/multiprocessing/__pycache__/__init__.cpython-311.pyc,, +ray/util/multiprocessing/__pycache__/pool.cpython-311.pyc,, +ray/util/multiprocessing/pool.py,sha256=Vc2uEYw2vUpLCxTLYo_Qfdq5UAGJNAU-9-0ZH4fAfzo,36851 +ray/util/placement_group.py,sha256=GfabdBnywPoh-z1apAfN4lYBLu4gaLo-8z7VdB6P8AA,19521 +ray/util/queue.py,sha256=CpURduHUZ_yb9BNBg6AZfnlXO9rxN6cn3qMWPHUJwbU,10131 +ray/util/rpdb.py,sha256=j2uQeu35Oa12HcHS6bUicrwR9G6pcws7y1C93atDi8U,11985 +ray/util/scheduling_strategies.py,sha256=Lv74tIMJ4EjVK4K7bORrJtin6KItwKGiSqDa_OZ4GrI,6472 +ray/util/serialization.py,sha256=l4lV_6Uk1xqWoN6zJZ15GMIeW1BFl-r1DjBYk61IMG8,2009 +ray/util/serialization_addons.py,sha256=J13cc4VWSXsaZoXXFOeUTfLQ11nD-16z0fvoyqXtRTs,1094 +ray/util/sgd/__init__.py,sha256=XhFzqjBfLVHFPk0-z2kBrIOSCxmuiKlsomJdzNp6fM0,152 +ray/util/sgd/__pycache__/__init__.cpython-311.pyc,, +ray/util/spark/__init__.py,sha256=qOvIEq-ekJDrXg6ySDlpXfvQcqXW9ibSSRXDJu3L8uk,277 +ray/util/spark/__pycache__/__init__.cpython-311.pyc,, +ray/util/spark/__pycache__/cluster_init.cpython-311.pyc,, +ray/util/spark/__pycache__/databricks_hook.cpython-311.pyc,, +ray/util/spark/__pycache__/start_hook_base.cpython-311.pyc,, +ray/util/spark/__pycache__/start_ray_node.cpython-311.pyc,, +ray/util/spark/__pycache__/utils.cpython-311.pyc,, +ray/util/spark/cluster_init.py,sha256=Y2NQTMoGaAawC4HLEN6r8LkTwzygiscM8ZkpbPSc_mg,76704 +ray/util/spark/databricks_hook.py,sha256=x4Eoq7KwDg9GjQwAI9KVXOVHWfZSMCUGit6gWBGepFU,8866 +ray/util/spark/start_hook_base.py,sha256=Pn71SPD5ujBSfeAabw5frTc6Aun923CKjdHRMTKXL3A,417 +ray/util/spark/start_ray_node.py,sha256=WUwzAPjz8QaBaSMWo2zRSD7v254aE55IAs8jahhM9pE,8192 +ray/util/spark/utils.py,sha256=sJcalZppwk6J72v6J6Ja04SDpfDHGKfdGDGwR5Ax808,16962 +ray/util/state/__init__.py,sha256=b9mmszz1mNaohO675p46a8iZ5r1RVzdBx3Ni6eglx5o,901 +ray/util/state/__pycache__/__init__.cpython-311.pyc,, +ray/util/state/__pycache__/api.cpython-311.pyc,, +ray/util/state/__pycache__/common.cpython-311.pyc,, +ray/util/state/__pycache__/custom_types.cpython-311.pyc,, +ray/util/state/__pycache__/exception.cpython-311.pyc,, +ray/util/state/__pycache__/state_cli.cpython-311.pyc,, +ray/util/state/__pycache__/state_manager.cpython-311.pyc,, +ray/util/state/__pycache__/util.cpython-311.pyc,, +ray/util/state/api.py,sha256=H0svrBEMSaxKDrIeJS6CMQu4rCE8k5J2DPcwwruioak,54212 +ray/util/state/common.py,sha256=sBmNH6T-pzR9RkdJz7M6uK_nLif3zuyyjS8TJQskgJU,66273 +ray/util/state/custom_types.py,sha256=et6ekfOu5LOhLmBhVlB6Z2xsHtPqVO--ykO4fZn9Iws,3860 +ray/util/state/exception.py,sha256=SQWb86M80lNy4-TBfy1LoPjWJEBat-knpYCSHORZ8UY,268 +ray/util/state/state_cli.py,sha256=OS9hosnkcv4E82fdUivA8fn5Gmw17sBv4tb1xWhiyk0,35446 +ray/util/state/state_manager.py,sha256=0YOrY_QY9537wYiaEo_dBHZFwTa1vkNtmLhYV0pC9Z8,20226 +ray/util/state/util.py,sha256=3jat-Ok7jrdWUugOxDG7HBPZI9I-OJxfl7t4qVm-prY,1932 +ray/util/timer.py,sha256=enqflszQt04fVHtcQLyE4XsfeFlNxpSFXKuHHMvAgs8,1877 +ray/util/tracing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ray/util/tracing/__pycache__/__init__.cpython-311.pyc,, +ray/util/tracing/__pycache__/setup_local_tmp_tracing.cpython-311.pyc,, +ray/util/tracing/__pycache__/setup_tempo_tracing.cpython-311.pyc,, +ray/util/tracing/__pycache__/tracing_helper.cpython-311.pyc,, +ray/util/tracing/setup_local_tmp_tracing.py,sha256=Zayd7EjAUhfzls2xxUrKJza5xd1fp-pBj3jZo2RvPF0,827 +ray/util/tracing/setup_tempo_tracing.py,sha256=so8_RI9_BBDOHSzX6Flz9Lf2lGP-uefOdRdVLevgV2A,860 +ray/util/tracing/tracing_helper.py,sha256=8UbU7BSTMBJG8rSxxl1M_6z1LaTUfEUgMSRA89UBLTU,19057 +ray/util/xgboost/__init__.py,sha256=fiAT1Q_R0kf1TNR3QBZXzB-Z3xXxff8w9NCOkJhX_0M,176 +ray/util/xgboost/__pycache__/__init__.cpython-311.pyc,, +ray/widgets/__init__.py,sha256=mKmmZs53_ii5nlBmT26kDX1x7a4RyfPvjc6XFvZ_EKI,138 +ray/widgets/__pycache__/__init__.cpython-311.pyc,, +ray/widgets/__pycache__/render.cpython-311.pyc,, +ray/widgets/__pycache__/util.cpython-311.pyc,, +ray/widgets/render.py,sha256=CdxaN0PMIrPF-tp24Zqqv9Z5sB3MdzIxh-2Yh4SaoZA,1226 +ray/widgets/templates/context.html.j2,sha256=GJ5t67VpG9DWYqvMqIlG0kVf5Jl8w5sBZ7eBTlw_mKA,235 +ray/widgets/templates/context_dashrow.html.j2,sha256=0sod0SSVgvvBtGmJkbdjH29aBb8c_0s5ygz-Navqeuc,182 +ray/widgets/templates/context_logo.html.j2,sha256=2eq4DsgvKXyTZx4LQwp2hvA4Ix7v0HDM1yQ45bBCuIo,5571 +ray/widgets/templates/context_table.html.j2,sha256=G2BmWG2Mra_eEC53UOb7UEpA0vr8LX1dHbg-1DK6C3E,475 +ray/widgets/templates/divider.html.j2,sha256=YWaWbc6yc3AhN4kpOlvIFz0-8eIsKpQ1OXDxiw34I3c,210 +ray/widgets/templates/rendered_html_common.html.j2,sha256=6e3NaDpVWHzniqTOI0ywpnoS3YcgraMwUHh3_N6VurM,59 +ray/widgets/templates/run_config.html.j2,sha256=3Txr5nDnn20wx1iwd8tpBJPGzTQXrBB1_yDfaDdVj48,325 +ray/widgets/templates/scrollableTable.html.j2,sha256=TAOV7gvFXvG1WD9gyt2ZBmDvzra1Mbu6Nl5yaNAW3h8,367 +ray/widgets/templates/title_data.html.j2,sha256=j_B2qxqblbBvoiysGrjZZzKTp8Xw5cYSdUn5b-VJiYo,255 +ray/widgets/templates/title_data_mini.html.j2,sha256=w04_i3wa7yKK7QN39TqWyF25mF3Mm0nVvPbGJuqjClo,100 +ray/widgets/templates/trial_progress.html.j2,sha256=7dRrXFrsMyj4PBSLaNgoaUVttEv-pX0-nblnUvR30lI,277 +ray/widgets/templates/tune_status.html.j2,sha256=zzyLLQhWzhW5n1tIuX8Zkq3STVnvQPCH_5w_7bDdPLg,1097 +ray/widgets/templates/tune_status_messages.html.j2,sha256=0jm-6FxHpop1liapLUKvlpxiO-E-hIjWG5x1RJupLKU,507 +ray/widgets/util.py,sha256=swpokHhNLkM1MWFQJfOS05oeH_GgdagnNgxGrgQALRs,6345 +ray/workflow/__init__.py,sha256=xyuiyCmIDnVFWBFRpmLoO4wrsyTijZn35-SAw7ArWhI,987 +ray/workflow/__pycache__/__init__.cpython-311.pyc,, +ray/workflow/__pycache__/api.cpython-311.pyc,, +ray/workflow/__pycache__/common.cpython-311.pyc,, +ray/workflow/__pycache__/debug_utils.cpython-311.pyc,, +ray/workflow/__pycache__/event_listener.cpython-311.pyc,, +ray/workflow/__pycache__/exceptions.cpython-311.pyc,, +ray/workflow/__pycache__/http_event_provider.cpython-311.pyc,, +ray/workflow/__pycache__/serialization.cpython-311.pyc,, +ray/workflow/__pycache__/serialization_context.cpython-311.pyc,, +ray/workflow/__pycache__/task_executor.cpython-311.pyc,, +ray/workflow/__pycache__/workflow_access.cpython-311.pyc,, +ray/workflow/__pycache__/workflow_context.cpython-311.pyc,, +ray/workflow/__pycache__/workflow_executor.cpython-311.pyc,, +ray/workflow/__pycache__/workflow_state.cpython-311.pyc,, +ray/workflow/__pycache__/workflow_state_from_dag.cpython-311.pyc,, +ray/workflow/__pycache__/workflow_state_from_storage.cpython-311.pyc,, +ray/workflow/__pycache__/workflow_storage.cpython-311.pyc,, +ray/workflow/api.py,sha256=2lvIvN9DSWEsco_aBcyBcPKanqt9GXBZKek_yaonbqc,29494 +ray/workflow/common.py,sha256=PqJNYe1-Afc2s4E89wpTANdcewxdcEiX5cfi7FrnBYU,5703 +ray/workflow/debug_utils.py,sha256=xXjFkbJzw83p-1KER0rhqxCcyQ6zAF98Sfar8f0iLq4,1720 +ray/workflow/event_listener.py,sha256=mLZb6WXOvmEu9ch5IuTj0oF8q3GnfFbm8Yd-wWde_OE,1927 +ray/workflow/exceptions.py,sha256=R9T2w-5v8LM3tKh77PRTuaLZZEczlEgaQap-q3WLVm8,1935 +ray/workflow/http_event_provider.py,sha256=3r2c8FzB5ZcSk6SJNXUfPAF151TEoRx2FkhQTJ61m2k,10344 +ray/workflow/serialization.py,sha256=G3ZbEWHA-6QUST_6iPAFjKvAVbHB6hnOGc7PSUeeKsE,7256 +ray/workflow/serialization_context.py,sha256=e_VRhCFLMoQuQ1P22fy6O3TTNODNlefYpnHDHxObe8k,3618 +ray/workflow/storage/__init__.py,sha256=--7V8juNmKneKIbNpp5g51JWJucYjTX7gjpocOe22Pg,227 +ray/workflow/storage/__pycache__/__init__.cpython-311.pyc,, +ray/workflow/storage/__pycache__/base.cpython-311.pyc,, +ray/workflow/storage/__pycache__/debug.cpython-311.pyc,, +ray/workflow/storage/__pycache__/filesystem.cpython-311.pyc,, +ray/workflow/storage/base.py,sha256=04KOTJoIamk6bLHBxj5GC8EFALTPp1lEpTwyEkKSh5s,1771 +ray/workflow/storage/debug.py,sha256=O3QfoIu5mBMSxsGRRgCK6rJn-SUvYJxYEOSdpL7zGc8,6813 +ray/workflow/storage/filesystem.py,sha256=slD5oD-E1AeXw4lu7esd7_xTrchh8DmbSjuTN9fqeg4,5580 +ray/workflow/task_executor.py,sha256=0Yg5XsP-tVB6KsrJdeeYFIr4AohAJFrcwUNW9ABLGQU,5996 +ray/workflow/workflow_access.py,sha256=1rlDT1LBg9GqyWId-rLDtTMkmgoxBZDCX0yvoCKvVvw,15190 +ray/workflow/workflow_context.py,sha256=JTvKid-P-Op9XkIK4Ai7BKytMr0nxsI7JpKG3Wzt150,3437 +ray/workflow/workflow_executor.py,sha256=RzynKfKEtI6aZ-xpOG8T5YLNZs8aAF9FZ3k9YqgeFi8,17680 +ray/workflow/workflow_state.py,sha256=S031AtfKT4G8ox7fumjQMeuwL5KSgtP776RfYQw6dK4,11170 +ray/workflow/workflow_state_from_dag.py,sha256=uRP1OtSHgoSpX7PKeuvb0Adi7mELfXNdwmnJEN4JphM,8543 +ray/workflow/workflow_state_from_storage.py,sha256=vfgs-V4Q0XqC5mv9o6yrDl5fB0Ylo7du6vGEM-TM8bA,2817 +ray/workflow/workflow_storage.py,sha256=2q4LIOw7DRoG3GU2ZKPPIwcb2zikUr1jwPsyGtuQ7Bg,32518 diff --git a/.venv/lib/python3.11/site-packages/ray-2.42.0.dist-info/entry_points.txt b/.venv/lib/python3.11/site-packages/ray-2.42.0.dist-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..b48cc567cd0a4f5eda8af8e202bb381f835de5d0 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/ray-2.42.0.dist-info/entry_points.txt @@ -0,0 +1,4 @@ +[console_scripts] +ray = ray.scripts.scripts:main +serve = ray.serve.scripts:cli +tune = ray.tune.cli.scripts:cli diff --git a/.venv/lib/python3.11/site-packages/ray-2.42.0.dist-info/top_level.txt b/.venv/lib/python3.11/site-packages/ray-2.42.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..e0275631807fc1c22cd3593cd1c48d29d1bbaff9 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/ray-2.42.0.dist-info/top_level.txt @@ -0,0 +1 @@ +ray diff --git a/.venv/lib/python3.11/site-packages/requests/__init__.py b/.venv/lib/python3.11/site-packages/requests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..051cda1340effaa0706b46dd68ac002ceda3d45c --- /dev/null +++ b/.venv/lib/python3.11/site-packages/requests/__init__.py @@ -0,0 +1,184 @@ +# __ +# /__) _ _ _ _ _/ _ +# / ( (- (/ (/ (- _) / _) +# / + +""" +Requests HTTP Library +~~~~~~~~~~~~~~~~~~~~~ + +Requests is an HTTP library, written in Python, for human beings. +Basic GET usage: + + >>> import requests + >>> r = requests.get('https://www.python.org') + >>> r.status_code + 200 + >>> b'Python is a programming language' in r.content + True + +... or POST: + + >>> payload = dict(key1='value1', key2='value2') + >>> r = requests.post('https://httpbin.org/post', data=payload) + >>> print(r.text) + { + ... + "form": { + "key1": "value1", + "key2": "value2" + }, + ... + } + +The other HTTP methods are supported - see `requests.api`. Full documentation +is at . + +:copyright: (c) 2017 by Kenneth Reitz. +:license: Apache 2.0, see LICENSE for more details. +""" + +import warnings + +import urllib3 + +from .exceptions import RequestsDependencyWarning + +try: + from charset_normalizer import __version__ as charset_normalizer_version +except ImportError: + charset_normalizer_version = None + +try: + from chardet import __version__ as chardet_version +except ImportError: + chardet_version = None + + +def check_compatibility(urllib3_version, chardet_version, charset_normalizer_version): + urllib3_version = urllib3_version.split(".") + assert urllib3_version != ["dev"] # Verify urllib3 isn't installed from git. + + # Sometimes, urllib3 only reports its version as 16.1. + if len(urllib3_version) == 2: + urllib3_version.append("0") + + # Check urllib3 for compatibility. + major, minor, patch = urllib3_version # noqa: F811 + major, minor, patch = int(major), int(minor), int(patch) + # urllib3 >= 1.21.1 + assert major >= 1 + if major == 1: + assert minor >= 21 + + # Check charset_normalizer for compatibility. + if chardet_version: + major, minor, patch = chardet_version.split(".")[:3] + major, minor, patch = int(major), int(minor), int(patch) + # chardet_version >= 3.0.2, < 6.0.0 + assert (3, 0, 2) <= (major, minor, patch) < (6, 0, 0) + elif charset_normalizer_version: + major, minor, patch = charset_normalizer_version.split(".")[:3] + major, minor, patch = int(major), int(minor), int(patch) + # charset_normalizer >= 2.0.0 < 4.0.0 + assert (2, 0, 0) <= (major, minor, patch) < (4, 0, 0) + else: + warnings.warn( + "Unable to find acceptable character detection dependency " + "(chardet or charset_normalizer).", + RequestsDependencyWarning, + ) + + +def _check_cryptography(cryptography_version): + # cryptography < 1.3.4 + try: + cryptography_version = list(map(int, cryptography_version.split("."))) + except ValueError: + return + + if cryptography_version < [1, 3, 4]: + warning = "Old version of cryptography ({}) may cause slowdown.".format( + cryptography_version + ) + warnings.warn(warning, RequestsDependencyWarning) + + +# Check imported dependencies for compatibility. +try: + check_compatibility( + urllib3.__version__, chardet_version, charset_normalizer_version + ) +except (AssertionError, ValueError): + warnings.warn( + "urllib3 ({}) or chardet ({})/charset_normalizer ({}) doesn't match a supported " + "version!".format( + urllib3.__version__, chardet_version, charset_normalizer_version + ), + RequestsDependencyWarning, + ) + +# Attempt to enable urllib3's fallback for SNI support +# if the standard library doesn't support SNI or the +# 'ssl' library isn't available. +try: + try: + import ssl + except ImportError: + ssl = None + + if not getattr(ssl, "HAS_SNI", False): + from urllib3.contrib import pyopenssl + + pyopenssl.inject_into_urllib3() + + # Check cryptography version + from cryptography import __version__ as cryptography_version + + _check_cryptography(cryptography_version) +except ImportError: + pass + +# urllib3's DependencyWarnings should be silenced. +from urllib3.exceptions import DependencyWarning + +warnings.simplefilter("ignore", DependencyWarning) + +# Set default logging handler to avoid "No handler found" warnings. +import logging +from logging import NullHandler + +from . import packages, utils +from .__version__ import ( + __author__, + __author_email__, + __build__, + __cake__, + __copyright__, + __description__, + __license__, + __title__, + __url__, + __version__, +) +from .api import delete, get, head, options, patch, post, put, request +from .exceptions import ( + ConnectionError, + ConnectTimeout, + FileModeWarning, + HTTPError, + JSONDecodeError, + ReadTimeout, + RequestException, + Timeout, + TooManyRedirects, + URLRequired, +) +from .models import PreparedRequest, Request, Response +from .sessions import Session, session +from .status_codes import codes + +logging.getLogger(__name__).addHandler(NullHandler()) + +# FileModeWarnings go off per the default. +warnings.simplefilter("default", FileModeWarning, append=True) diff --git a/.venv/lib/python3.11/site-packages/requests/__pycache__/_internal_utils.cpython-311.pyc b/.venv/lib/python3.11/site-packages/requests/__pycache__/_internal_utils.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c150c2dee06e2cad3158c8e0238ce0e25409607b Binary files /dev/null and b/.venv/lib/python3.11/site-packages/requests/__pycache__/_internal_utils.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/requests/__pycache__/adapters.cpython-311.pyc b/.venv/lib/python3.11/site-packages/requests/__pycache__/adapters.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6db7e8dcb1380232c410e0d8e7f40e59cef804ed Binary files /dev/null and b/.venv/lib/python3.11/site-packages/requests/__pycache__/adapters.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/requests/__pycache__/help.cpython-311.pyc b/.venv/lib/python3.11/site-packages/requests/__pycache__/help.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..100a795861dc172d9149da47eded8b5454b07ddd Binary files /dev/null and b/.venv/lib/python3.11/site-packages/requests/__pycache__/help.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/requests/__pycache__/models.cpython-311.pyc b/.venv/lib/python3.11/site-packages/requests/__pycache__/models.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..089894d6e90cc58a96e907f690d71503503cf3fa Binary files /dev/null and b/.venv/lib/python3.11/site-packages/requests/__pycache__/models.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/requests/__pycache__/packages.cpython-311.pyc b/.venv/lib/python3.11/site-packages/requests/__pycache__/packages.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..48710c8af426973069dced1ffd66ff7638cbbb54 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/requests/__pycache__/packages.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/requests/__pycache__/sessions.cpython-311.pyc b/.venv/lib/python3.11/site-packages/requests/__pycache__/sessions.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b7db76d1bfca4b8cd37980b8881cc15194e5d0b9 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/requests/__pycache__/sessions.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/requests/__pycache__/status_codes.cpython-311.pyc b/.venv/lib/python3.11/site-packages/requests/__pycache__/status_codes.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3bd610c0b7f658867c27363b19fa377b1ea696a2 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/requests/__pycache__/status_codes.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/requests/__pycache__/structures.cpython-311.pyc b/.venv/lib/python3.11/site-packages/requests/__pycache__/structures.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..53107b024f5caa6b6db8703f1ada6593848eb7c1 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/requests/__pycache__/structures.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/requests/__pycache__/utils.cpython-311.pyc b/.venv/lib/python3.11/site-packages/requests/__pycache__/utils.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..313da16b191fcdaddcb4327438c639bba2610d69 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/requests/__pycache__/utils.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/requests/__version__.py b/.venv/lib/python3.11/site-packages/requests/__version__.py new file mode 100644 index 0000000000000000000000000000000000000000..2c105aca7d48ce1c35a456785cc75f97f076a426 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/requests/__version__.py @@ -0,0 +1,14 @@ +# .-. .-. .-. . . .-. .-. .-. .-. +# |( |- |.| | | |- `-. | `-. +# ' ' `-' `-`.`-' `-' `-' ' `-' + +__title__ = "requests" +__description__ = "Python HTTP for Humans." +__url__ = "https://requests.readthedocs.io" +__version__ = "2.32.3" +__build__ = 0x023203 +__author__ = "Kenneth Reitz" +__author_email__ = "me@kennethreitz.org" +__license__ = "Apache-2.0" +__copyright__ = "Copyright Kenneth Reitz" +__cake__ = "\u2728 \U0001f370 \u2728" diff --git a/.venv/lib/python3.11/site-packages/requests/_internal_utils.py b/.venv/lib/python3.11/site-packages/requests/_internal_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..f2cf635e2937ee9b123a1498c5c5f723a6e20084 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/requests/_internal_utils.py @@ -0,0 +1,50 @@ +""" +requests._internal_utils +~~~~~~~~~~~~~~ + +Provides utility functions that are consumed internally by Requests +which depend on extremely few external helpers (such as compat) +""" +import re + +from .compat import builtin_str + +_VALID_HEADER_NAME_RE_BYTE = re.compile(rb"^[^:\s][^:\r\n]*$") +_VALID_HEADER_NAME_RE_STR = re.compile(r"^[^:\s][^:\r\n]*$") +_VALID_HEADER_VALUE_RE_BYTE = re.compile(rb"^\S[^\r\n]*$|^$") +_VALID_HEADER_VALUE_RE_STR = re.compile(r"^\S[^\r\n]*$|^$") + +_HEADER_VALIDATORS_STR = (_VALID_HEADER_NAME_RE_STR, _VALID_HEADER_VALUE_RE_STR) +_HEADER_VALIDATORS_BYTE = (_VALID_HEADER_NAME_RE_BYTE, _VALID_HEADER_VALUE_RE_BYTE) +HEADER_VALIDATORS = { + bytes: _HEADER_VALIDATORS_BYTE, + str: _HEADER_VALIDATORS_STR, +} + + +def to_native_string(string, encoding="ascii"): + """Given a string object, regardless of type, returns a representation of + that string in the native string type, encoding and decoding where + necessary. This assumes ASCII unless told otherwise. + """ + if isinstance(string, builtin_str): + out = string + else: + out = string.decode(encoding) + + return out + + +def unicode_is_ascii(u_string): + """Determine if unicode string only contains ASCII characters. + + :param str u_string: unicode string to check. Must be unicode + and not Python 2 `str`. + :rtype: bool + """ + assert isinstance(u_string, str) + try: + u_string.encode("ascii") + return True + except UnicodeEncodeError: + return False diff --git a/.venv/lib/python3.11/site-packages/requests/adapters.py b/.venv/lib/python3.11/site-packages/requests/adapters.py new file mode 100644 index 0000000000000000000000000000000000000000..9a58b1602532f9bee41afb0dfadaa7eb548e98c1 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/requests/adapters.py @@ -0,0 +1,719 @@ +""" +requests.adapters +~~~~~~~~~~~~~~~~~ + +This module contains the transport adapters that Requests uses to define +and maintain connections. +""" + +import os.path +import socket # noqa: F401 +import typing +import warnings + +from urllib3.exceptions import ClosedPoolError, ConnectTimeoutError +from urllib3.exceptions import HTTPError as _HTTPError +from urllib3.exceptions import InvalidHeader as _InvalidHeader +from urllib3.exceptions import ( + LocationValueError, + MaxRetryError, + NewConnectionError, + ProtocolError, +) +from urllib3.exceptions import ProxyError as _ProxyError +from urllib3.exceptions import ReadTimeoutError, ResponseError +from urllib3.exceptions import SSLError as _SSLError +from urllib3.poolmanager import PoolManager, proxy_from_url +from urllib3.util import Timeout as TimeoutSauce +from urllib3.util import parse_url +from urllib3.util.retry import Retry +from urllib3.util.ssl_ import create_urllib3_context + +from .auth import _basic_auth_str +from .compat import basestring, urlparse +from .cookies import extract_cookies_to_jar +from .exceptions import ( + ConnectionError, + ConnectTimeout, + InvalidHeader, + InvalidProxyURL, + InvalidSchema, + InvalidURL, + ProxyError, + ReadTimeout, + RetryError, + SSLError, +) +from .models import Response +from .structures import CaseInsensitiveDict +from .utils import ( + DEFAULT_CA_BUNDLE_PATH, + extract_zipped_paths, + get_auth_from_url, + get_encoding_from_headers, + prepend_scheme_if_needed, + select_proxy, + urldefragauth, +) + +try: + from urllib3.contrib.socks import SOCKSProxyManager +except ImportError: + + def SOCKSProxyManager(*args, **kwargs): + raise InvalidSchema("Missing dependencies for SOCKS support.") + + +if typing.TYPE_CHECKING: + from .models import PreparedRequest + + +DEFAULT_POOLBLOCK = False +DEFAULT_POOLSIZE = 10 +DEFAULT_RETRIES = 0 +DEFAULT_POOL_TIMEOUT = None + + +try: + import ssl # noqa: F401 + + _preloaded_ssl_context = create_urllib3_context() + _preloaded_ssl_context.load_verify_locations( + extract_zipped_paths(DEFAULT_CA_BUNDLE_PATH) + ) +except ImportError: + # Bypass default SSLContext creation when Python + # interpreter isn't built with the ssl module. + _preloaded_ssl_context = None + + +def _urllib3_request_context( + request: "PreparedRequest", + verify: "bool | str | None", + client_cert: "typing.Tuple[str, str] | str | None", + poolmanager: "PoolManager", +) -> "(typing.Dict[str, typing.Any], typing.Dict[str, typing.Any])": + host_params = {} + pool_kwargs = {} + parsed_request_url = urlparse(request.url) + scheme = parsed_request_url.scheme.lower() + port = parsed_request_url.port + + # Determine if we have and should use our default SSLContext + # to optimize performance on standard requests. + poolmanager_kwargs = getattr(poolmanager, "connection_pool_kw", {}) + has_poolmanager_ssl_context = poolmanager_kwargs.get("ssl_context") + should_use_default_ssl_context = ( + _preloaded_ssl_context is not None and not has_poolmanager_ssl_context + ) + + cert_reqs = "CERT_REQUIRED" + if verify is False: + cert_reqs = "CERT_NONE" + elif verify is True and should_use_default_ssl_context: + pool_kwargs["ssl_context"] = _preloaded_ssl_context + elif isinstance(verify, str): + if not os.path.isdir(verify): + pool_kwargs["ca_certs"] = verify + else: + pool_kwargs["ca_cert_dir"] = verify + pool_kwargs["cert_reqs"] = cert_reqs + if client_cert is not None: + if isinstance(client_cert, tuple) and len(client_cert) == 2: + pool_kwargs["cert_file"] = client_cert[0] + pool_kwargs["key_file"] = client_cert[1] + else: + # According to our docs, we allow users to specify just the client + # cert path + pool_kwargs["cert_file"] = client_cert + host_params = { + "scheme": scheme, + "host": parsed_request_url.hostname, + "port": port, + } + return host_params, pool_kwargs + + +class BaseAdapter: + """The Base Transport Adapter""" + + def __init__(self): + super().__init__() + + def send( + self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None + ): + """Sends PreparedRequest object. Returns Response object. + + :param request: The :class:`PreparedRequest ` being sent. + :param stream: (optional) Whether to stream the request content. + :param timeout: (optional) How long to wait for the server to send + data before giving up, as a float, or a :ref:`(connect timeout, + read timeout) ` tuple. + :type timeout: float or tuple + :param verify: (optional) Either a boolean, in which case it controls whether we verify + the server's TLS certificate, or a string, in which case it must be a path + to a CA bundle to use + :param cert: (optional) Any user-provided SSL certificate to be trusted. + :param proxies: (optional) The proxies dictionary to apply to the request. + """ + raise NotImplementedError + + def close(self): + """Cleans up adapter specific items.""" + raise NotImplementedError + + +class HTTPAdapter(BaseAdapter): + """The built-in HTTP Adapter for urllib3. + + Provides a general-case interface for Requests sessions to contact HTTP and + HTTPS urls by implementing the Transport Adapter interface. This class will + usually be created by the :class:`Session ` class under the + covers. + + :param pool_connections: The number of urllib3 connection pools to cache. + :param pool_maxsize: The maximum number of connections to save in the pool. + :param max_retries: The maximum number of retries each connection + should attempt. Note, this applies only to failed DNS lookups, socket + connections and connection timeouts, never to requests where data has + made it to the server. By default, Requests does not retry failed + connections. If you need granular control over the conditions under + which we retry a request, import urllib3's ``Retry`` class and pass + that instead. + :param pool_block: Whether the connection pool should block for connections. + + Usage:: + + >>> import requests + >>> s = requests.Session() + >>> a = requests.adapters.HTTPAdapter(max_retries=3) + >>> s.mount('http://', a) + """ + + __attrs__ = [ + "max_retries", + "config", + "_pool_connections", + "_pool_maxsize", + "_pool_block", + ] + + def __init__( + self, + pool_connections=DEFAULT_POOLSIZE, + pool_maxsize=DEFAULT_POOLSIZE, + max_retries=DEFAULT_RETRIES, + pool_block=DEFAULT_POOLBLOCK, + ): + if max_retries == DEFAULT_RETRIES: + self.max_retries = Retry(0, read=False) + else: + self.max_retries = Retry.from_int(max_retries) + self.config = {} + self.proxy_manager = {} + + super().__init__() + + self._pool_connections = pool_connections + self._pool_maxsize = pool_maxsize + self._pool_block = pool_block + + self.init_poolmanager(pool_connections, pool_maxsize, block=pool_block) + + def __getstate__(self): + return {attr: getattr(self, attr, None) for attr in self.__attrs__} + + def __setstate__(self, state): + # Can't handle by adding 'proxy_manager' to self.__attrs__ because + # self.poolmanager uses a lambda function, which isn't pickleable. + self.proxy_manager = {} + self.config = {} + + for attr, value in state.items(): + setattr(self, attr, value) + + self.init_poolmanager( + self._pool_connections, self._pool_maxsize, block=self._pool_block + ) + + def init_poolmanager( + self, connections, maxsize, block=DEFAULT_POOLBLOCK, **pool_kwargs + ): + """Initializes a urllib3 PoolManager. + + This method should not be called from user code, and is only + exposed for use when subclassing the + :class:`HTTPAdapter `. + + :param connections: The number of urllib3 connection pools to cache. + :param maxsize: The maximum number of connections to save in the pool. + :param block: Block when no free connections are available. + :param pool_kwargs: Extra keyword arguments used to initialize the Pool Manager. + """ + # save these values for pickling + self._pool_connections = connections + self._pool_maxsize = maxsize + self._pool_block = block + + self.poolmanager = PoolManager( + num_pools=connections, + maxsize=maxsize, + block=block, + **pool_kwargs, + ) + + def proxy_manager_for(self, proxy, **proxy_kwargs): + """Return urllib3 ProxyManager for the given proxy. + + This method should not be called from user code, and is only + exposed for use when subclassing the + :class:`HTTPAdapter `. + + :param proxy: The proxy to return a urllib3 ProxyManager for. + :param proxy_kwargs: Extra keyword arguments used to configure the Proxy Manager. + :returns: ProxyManager + :rtype: urllib3.ProxyManager + """ + if proxy in self.proxy_manager: + manager = self.proxy_manager[proxy] + elif proxy.lower().startswith("socks"): + username, password = get_auth_from_url(proxy) + manager = self.proxy_manager[proxy] = SOCKSProxyManager( + proxy, + username=username, + password=password, + num_pools=self._pool_connections, + maxsize=self._pool_maxsize, + block=self._pool_block, + **proxy_kwargs, + ) + else: + proxy_headers = self.proxy_headers(proxy) + manager = self.proxy_manager[proxy] = proxy_from_url( + proxy, + proxy_headers=proxy_headers, + num_pools=self._pool_connections, + maxsize=self._pool_maxsize, + block=self._pool_block, + **proxy_kwargs, + ) + + return manager + + def cert_verify(self, conn, url, verify, cert): + """Verify a SSL certificate. This method should not be called from user + code, and is only exposed for use when subclassing the + :class:`HTTPAdapter `. + + :param conn: The urllib3 connection object associated with the cert. + :param url: The requested URL. + :param verify: Either a boolean, in which case it controls whether we verify + the server's TLS certificate, or a string, in which case it must be a path + to a CA bundle to use + :param cert: The SSL certificate to verify. + """ + if url.lower().startswith("https") and verify: + conn.cert_reqs = "CERT_REQUIRED" + + # Only load the CA certificates if 'verify' is a string indicating the CA bundle to use. + # Otherwise, if verify is a boolean, we don't load anything since + # the connection will be using a context with the default certificates already loaded, + # and this avoids a call to the slow load_verify_locations() + if verify is not True: + # `verify` must be a str with a path then + cert_loc = verify + + if not os.path.exists(cert_loc): + raise OSError( + f"Could not find a suitable TLS CA certificate bundle, " + f"invalid path: {cert_loc}" + ) + + if not os.path.isdir(cert_loc): + conn.ca_certs = cert_loc + else: + conn.ca_cert_dir = cert_loc + else: + conn.cert_reqs = "CERT_NONE" + conn.ca_certs = None + conn.ca_cert_dir = None + + if cert: + if not isinstance(cert, basestring): + conn.cert_file = cert[0] + conn.key_file = cert[1] + else: + conn.cert_file = cert + conn.key_file = None + if conn.cert_file and not os.path.exists(conn.cert_file): + raise OSError( + f"Could not find the TLS certificate file, " + f"invalid path: {conn.cert_file}" + ) + if conn.key_file and not os.path.exists(conn.key_file): + raise OSError( + f"Could not find the TLS key file, invalid path: {conn.key_file}" + ) + + def build_response(self, req, resp): + """Builds a :class:`Response ` object from a urllib3 + response. This should not be called from user code, and is only exposed + for use when subclassing the + :class:`HTTPAdapter ` + + :param req: The :class:`PreparedRequest ` used to generate the response. + :param resp: The urllib3 response object. + :rtype: requests.Response + """ + response = Response() + + # Fallback to None if there's no status_code, for whatever reason. + response.status_code = getattr(resp, "status", None) + + # Make headers case-insensitive. + response.headers = CaseInsensitiveDict(getattr(resp, "headers", {})) + + # Set encoding. + response.encoding = get_encoding_from_headers(response.headers) + response.raw = resp + response.reason = response.raw.reason + + if isinstance(req.url, bytes): + response.url = req.url.decode("utf-8") + else: + response.url = req.url + + # Add new cookies from the server. + extract_cookies_to_jar(response.cookies, req, resp) + + # Give the Response some context. + response.request = req + response.connection = self + + return response + + def build_connection_pool_key_attributes(self, request, verify, cert=None): + """Build the PoolKey attributes used by urllib3 to return a connection. + + This looks at the PreparedRequest, the user-specified verify value, + and the value of the cert parameter to determine what PoolKey values + to use to select a connection from a given urllib3 Connection Pool. + + The SSL related pool key arguments are not consistently set. As of + this writing, use the following to determine what keys may be in that + dictionary: + + * If ``verify`` is ``True``, ``"ssl_context"`` will be set and will be the + default Requests SSL Context + * If ``verify`` is ``False``, ``"ssl_context"`` will not be set but + ``"cert_reqs"`` will be set + * If ``verify`` is a string, (i.e., it is a user-specified trust bundle) + ``"ca_certs"`` will be set if the string is not a directory recognized + by :py:func:`os.path.isdir`, otherwise ``"ca_certs_dir"`` will be + set. + * If ``"cert"`` is specified, ``"cert_file"`` will always be set. If + ``"cert"`` is a tuple with a second item, ``"key_file"`` will also + be present + + To override these settings, one may subclass this class, call this + method and use the above logic to change parameters as desired. For + example, if one wishes to use a custom :py:class:`ssl.SSLContext` one + must both set ``"ssl_context"`` and based on what else they require, + alter the other keys to ensure the desired behaviour. + + :param request: + The PreparedReqest being sent over the connection. + :type request: + :class:`~requests.models.PreparedRequest` + :param verify: + Either a boolean, in which case it controls whether + we verify the server's TLS certificate, or a string, in which case it + must be a path to a CA bundle to use. + :param cert: + (optional) Any user-provided SSL certificate for client + authentication (a.k.a., mTLS). This may be a string (i.e., just + the path to a file which holds both certificate and key) or a + tuple of length 2 with the certificate file path and key file + path. + :returns: + A tuple of two dictionaries. The first is the "host parameters" + portion of the Pool Key including scheme, hostname, and port. The + second is a dictionary of SSLContext related parameters. + """ + return _urllib3_request_context(request, verify, cert, self.poolmanager) + + def get_connection_with_tls_context(self, request, verify, proxies=None, cert=None): + """Returns a urllib3 connection for the given request and TLS settings. + This should not be called from user code, and is only exposed for use + when subclassing the :class:`HTTPAdapter `. + + :param request: + The :class:`PreparedRequest ` object to be sent + over the connection. + :param verify: + Either a boolean, in which case it controls whether we verify the + server's TLS certificate, or a string, in which case it must be a + path to a CA bundle to use. + :param proxies: + (optional) The proxies dictionary to apply to the request. + :param cert: + (optional) Any user-provided SSL certificate to be used for client + authentication (a.k.a., mTLS). + :rtype: + urllib3.ConnectionPool + """ + proxy = select_proxy(request.url, proxies) + try: + host_params, pool_kwargs = self.build_connection_pool_key_attributes( + request, + verify, + cert, + ) + except ValueError as e: + raise InvalidURL(e, request=request) + if proxy: + proxy = prepend_scheme_if_needed(proxy, "http") + proxy_url = parse_url(proxy) + if not proxy_url.host: + raise InvalidProxyURL( + "Please check proxy URL. It is malformed " + "and could be missing the host." + ) + proxy_manager = self.proxy_manager_for(proxy) + conn = proxy_manager.connection_from_host( + **host_params, pool_kwargs=pool_kwargs + ) + else: + # Only scheme should be lower case + conn = self.poolmanager.connection_from_host( + **host_params, pool_kwargs=pool_kwargs + ) + + return conn + + def get_connection(self, url, proxies=None): + """DEPRECATED: Users should move to `get_connection_with_tls_context` + for all subclasses of HTTPAdapter using Requests>=2.32.2. + + Returns a urllib3 connection for the given URL. This should not be + called from user code, and is only exposed for use when subclassing the + :class:`HTTPAdapter `. + + :param url: The URL to connect to. + :param proxies: (optional) A Requests-style dictionary of proxies used on this request. + :rtype: urllib3.ConnectionPool + """ + warnings.warn( + ( + "`get_connection` has been deprecated in favor of " + "`get_connection_with_tls_context`. Custom HTTPAdapter subclasses " + "will need to migrate for Requests>=2.32.2. Please see " + "https://github.com/psf/requests/pull/6710 for more details." + ), + DeprecationWarning, + ) + proxy = select_proxy(url, proxies) + + if proxy: + proxy = prepend_scheme_if_needed(proxy, "http") + proxy_url = parse_url(proxy) + if not proxy_url.host: + raise InvalidProxyURL( + "Please check proxy URL. It is malformed " + "and could be missing the host." + ) + proxy_manager = self.proxy_manager_for(proxy) + conn = proxy_manager.connection_from_url(url) + else: + # Only scheme should be lower case + parsed = urlparse(url) + url = parsed.geturl() + conn = self.poolmanager.connection_from_url(url) + + return conn + + def close(self): + """Disposes of any internal state. + + Currently, this closes the PoolManager and any active ProxyManager, + which closes any pooled connections. + """ + self.poolmanager.clear() + for proxy in self.proxy_manager.values(): + proxy.clear() + + def request_url(self, request, proxies): + """Obtain the url to use when making the final request. + + If the message is being sent through a HTTP proxy, the full URL has to + be used. Otherwise, we should only use the path portion of the URL. + + This should not be called from user code, and is only exposed for use + when subclassing the + :class:`HTTPAdapter `. + + :param request: The :class:`PreparedRequest ` being sent. + :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs. + :rtype: str + """ + proxy = select_proxy(request.url, proxies) + scheme = urlparse(request.url).scheme + + is_proxied_http_request = proxy and scheme != "https" + using_socks_proxy = False + if proxy: + proxy_scheme = urlparse(proxy).scheme.lower() + using_socks_proxy = proxy_scheme.startswith("socks") + + url = request.path_url + if url.startswith("//"): # Don't confuse urllib3 + url = f"/{url.lstrip('/')}" + + if is_proxied_http_request and not using_socks_proxy: + url = urldefragauth(request.url) + + return url + + def add_headers(self, request, **kwargs): + """Add any headers needed by the connection. As of v2.0 this does + nothing by default, but is left for overriding by users that subclass + the :class:`HTTPAdapter `. + + This should not be called from user code, and is only exposed for use + when subclassing the + :class:`HTTPAdapter `. + + :param request: The :class:`PreparedRequest ` to add headers to. + :param kwargs: The keyword arguments from the call to send(). + """ + pass + + def proxy_headers(self, proxy): + """Returns a dictionary of the headers to add to any request sent + through a proxy. This works with urllib3 magic to ensure that they are + correctly sent to the proxy, rather than in a tunnelled request if + CONNECT is being used. + + This should not be called from user code, and is only exposed for use + when subclassing the + :class:`HTTPAdapter `. + + :param proxy: The url of the proxy being used for this request. + :rtype: dict + """ + headers = {} + username, password = get_auth_from_url(proxy) + + if username: + headers["Proxy-Authorization"] = _basic_auth_str(username, password) + + return headers + + def send( + self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None + ): + """Sends PreparedRequest object. Returns Response object. + + :param request: The :class:`PreparedRequest ` being sent. + :param stream: (optional) Whether to stream the request content. + :param timeout: (optional) How long to wait for the server to send + data before giving up, as a float, or a :ref:`(connect timeout, + read timeout) ` tuple. + :type timeout: float or tuple or urllib3 Timeout object + :param verify: (optional) Either a boolean, in which case it controls whether + we verify the server's TLS certificate, or a string, in which case it + must be a path to a CA bundle to use + :param cert: (optional) Any user-provided SSL certificate to be trusted. + :param proxies: (optional) The proxies dictionary to apply to the request. + :rtype: requests.Response + """ + + try: + conn = self.get_connection_with_tls_context( + request, verify, proxies=proxies, cert=cert + ) + except LocationValueError as e: + raise InvalidURL(e, request=request) + + self.cert_verify(conn, request.url, verify, cert) + url = self.request_url(request, proxies) + self.add_headers( + request, + stream=stream, + timeout=timeout, + verify=verify, + cert=cert, + proxies=proxies, + ) + + chunked = not (request.body is None or "Content-Length" in request.headers) + + if isinstance(timeout, tuple): + try: + connect, read = timeout + timeout = TimeoutSauce(connect=connect, read=read) + except ValueError: + raise ValueError( + f"Invalid timeout {timeout}. Pass a (connect, read) timeout tuple, " + f"or a single float to set both timeouts to the same value." + ) + elif isinstance(timeout, TimeoutSauce): + pass + else: + timeout = TimeoutSauce(connect=timeout, read=timeout) + + try: + resp = conn.urlopen( + method=request.method, + url=url, + body=request.body, + headers=request.headers, + redirect=False, + assert_same_host=False, + preload_content=False, + decode_content=False, + retries=self.max_retries, + timeout=timeout, + chunked=chunked, + ) + + except (ProtocolError, OSError) as err: + raise ConnectionError(err, request=request) + + except MaxRetryError as e: + if isinstance(e.reason, ConnectTimeoutError): + # TODO: Remove this in 3.0.0: see #2811 + if not isinstance(e.reason, NewConnectionError): + raise ConnectTimeout(e, request=request) + + if isinstance(e.reason, ResponseError): + raise RetryError(e, request=request) + + if isinstance(e.reason, _ProxyError): + raise ProxyError(e, request=request) + + if isinstance(e.reason, _SSLError): + # This branch is for urllib3 v1.22 and later. + raise SSLError(e, request=request) + + raise ConnectionError(e, request=request) + + except ClosedPoolError as e: + raise ConnectionError(e, request=request) + + except _ProxyError as e: + raise ProxyError(e) + + except (_SSLError, _HTTPError) as e: + if isinstance(e, _SSLError): + # This branch is for urllib3 versions earlier than v1.22 + raise SSLError(e, request=request) + elif isinstance(e, ReadTimeoutError): + raise ReadTimeout(e, request=request) + elif isinstance(e, _InvalidHeader): + raise InvalidHeader(e, request=request) + else: + raise + + return self.build_response(request, resp) diff --git a/.venv/lib/python3.11/site-packages/requests/api.py b/.venv/lib/python3.11/site-packages/requests/api.py new file mode 100644 index 0000000000000000000000000000000000000000..5960744552e7f8eea815429e7bdad38b0cc2741d --- /dev/null +++ b/.venv/lib/python3.11/site-packages/requests/api.py @@ -0,0 +1,157 @@ +""" +requests.api +~~~~~~~~~~~~ + +This module implements the Requests API. + +:copyright: (c) 2012 by Kenneth Reitz. +:license: Apache2, see LICENSE for more details. +""" + +from . import sessions + + +def request(method, url, **kwargs): + """Constructs and sends a :class:`Request `. + + :param method: method for the new :class:`Request` object: ``GET``, ``OPTIONS``, ``HEAD``, ``POST``, ``PUT``, ``PATCH``, or ``DELETE``. + :param url: URL for the new :class:`Request` object. + :param params: (optional) Dictionary, list of tuples or bytes to send + in the query string for the :class:`Request`. + :param data: (optional) Dictionary, list of tuples, bytes, or file-like + object to send in the body of the :class:`Request`. + :param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`. + :param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`. + :param cookies: (optional) Dict or CookieJar object to send with the :class:`Request`. + :param files: (optional) Dictionary of ``'name': file-like-objects`` (or ``{'name': file-tuple}``) for multipart encoding upload. + ``file-tuple`` can be a 2-tuple ``('filename', fileobj)``, 3-tuple ``('filename', fileobj, 'content_type')`` + or a 4-tuple ``('filename', fileobj, 'content_type', custom_headers)``, where ``'content_type'`` is a string + defining the content type of the given file and ``custom_headers`` a dict-like object containing additional headers + to add for the file. + :param auth: (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth. + :param timeout: (optional) How many seconds to wait for the server to send data + before giving up, as a float, or a :ref:`(connect timeout, read + timeout) ` tuple. + :type timeout: float or tuple + :param allow_redirects: (optional) Boolean. Enable/disable GET/OPTIONS/POST/PUT/PATCH/DELETE/HEAD redirection. Defaults to ``True``. + :type allow_redirects: bool + :param proxies: (optional) Dictionary mapping protocol to the URL of the proxy. + :param verify: (optional) Either a boolean, in which case it controls whether we verify + the server's TLS certificate, or a string, in which case it must be a path + to a CA bundle to use. Defaults to ``True``. + :param stream: (optional) if ``False``, the response content will be immediately downloaded. + :param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair. + :return: :class:`Response ` object + :rtype: requests.Response + + Usage:: + + >>> import requests + >>> req = requests.request('GET', 'https://httpbin.org/get') + >>> req + + """ + + # By using the 'with' statement we are sure the session is closed, thus we + # avoid leaving sockets open which can trigger a ResourceWarning in some + # cases, and look like a memory leak in others. + with sessions.Session() as session: + return session.request(method=method, url=url, **kwargs) + + +def get(url, params=None, **kwargs): + r"""Sends a GET request. + + :param url: URL for the new :class:`Request` object. + :param params: (optional) Dictionary, list of tuples or bytes to send + in the query string for the :class:`Request`. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :return: :class:`Response ` object + :rtype: requests.Response + """ + + return request("get", url, params=params, **kwargs) + + +def options(url, **kwargs): + r"""Sends an OPTIONS request. + + :param url: URL for the new :class:`Request` object. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :return: :class:`Response ` object + :rtype: requests.Response + """ + + return request("options", url, **kwargs) + + +def head(url, **kwargs): + r"""Sends a HEAD request. + + :param url: URL for the new :class:`Request` object. + :param \*\*kwargs: Optional arguments that ``request`` takes. If + `allow_redirects` is not provided, it will be set to `False` (as + opposed to the default :meth:`request` behavior). + :return: :class:`Response ` object + :rtype: requests.Response + """ + + kwargs.setdefault("allow_redirects", False) + return request("head", url, **kwargs) + + +def post(url, data=None, json=None, **kwargs): + r"""Sends a POST request. + + :param url: URL for the new :class:`Request` object. + :param data: (optional) Dictionary, list of tuples, bytes, or file-like + object to send in the body of the :class:`Request`. + :param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :return: :class:`Response ` object + :rtype: requests.Response + """ + + return request("post", url, data=data, json=json, **kwargs) + + +def put(url, data=None, **kwargs): + r"""Sends a PUT request. + + :param url: URL for the new :class:`Request` object. + :param data: (optional) Dictionary, list of tuples, bytes, or file-like + object to send in the body of the :class:`Request`. + :param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :return: :class:`Response ` object + :rtype: requests.Response + """ + + return request("put", url, data=data, **kwargs) + + +def patch(url, data=None, **kwargs): + r"""Sends a PATCH request. + + :param url: URL for the new :class:`Request` object. + :param data: (optional) Dictionary, list of tuples, bytes, or file-like + object to send in the body of the :class:`Request`. + :param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :return: :class:`Response ` object + :rtype: requests.Response + """ + + return request("patch", url, data=data, **kwargs) + + +def delete(url, **kwargs): + r"""Sends a DELETE request. + + :param url: URL for the new :class:`Request` object. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :return: :class:`Response ` object + :rtype: requests.Response + """ + + return request("delete", url, **kwargs) diff --git a/.venv/lib/python3.11/site-packages/requests/auth.py b/.venv/lib/python3.11/site-packages/requests/auth.py new file mode 100644 index 0000000000000000000000000000000000000000..4a7ce6dc1460e0de8aa0c38ea9123faa69bd5110 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/requests/auth.py @@ -0,0 +1,314 @@ +""" +requests.auth +~~~~~~~~~~~~~ + +This module contains the authentication handlers for Requests. +""" + +import hashlib +import os +import re +import threading +import time +import warnings +from base64 import b64encode + +from ._internal_utils import to_native_string +from .compat import basestring, str, urlparse +from .cookies import extract_cookies_to_jar +from .utils import parse_dict_header + +CONTENT_TYPE_FORM_URLENCODED = "application/x-www-form-urlencoded" +CONTENT_TYPE_MULTI_PART = "multipart/form-data" + + +def _basic_auth_str(username, password): + """Returns a Basic Auth string.""" + + # "I want us to put a big-ol' comment on top of it that + # says that this behaviour is dumb but we need to preserve + # it because people are relying on it." + # - Lukasa + # + # These are here solely to maintain backwards compatibility + # for things like ints. This will be removed in 3.0.0. + if not isinstance(username, basestring): + warnings.warn( + "Non-string usernames will no longer be supported in Requests " + "3.0.0. Please convert the object you've passed in ({!r}) to " + "a string or bytes object in the near future to avoid " + "problems.".format(username), + category=DeprecationWarning, + ) + username = str(username) + + if not isinstance(password, basestring): + warnings.warn( + "Non-string passwords will no longer be supported in Requests " + "3.0.0. Please convert the object you've passed in ({!r}) to " + "a string or bytes object in the near future to avoid " + "problems.".format(type(password)), + category=DeprecationWarning, + ) + password = str(password) + # -- End Removal -- + + if isinstance(username, str): + username = username.encode("latin1") + + if isinstance(password, str): + password = password.encode("latin1") + + authstr = "Basic " + to_native_string( + b64encode(b":".join((username, password))).strip() + ) + + return authstr + + +class AuthBase: + """Base class that all auth implementations derive from""" + + def __call__(self, r): + raise NotImplementedError("Auth hooks must be callable.") + + +class HTTPBasicAuth(AuthBase): + """Attaches HTTP Basic Authentication to the given Request object.""" + + def __init__(self, username, password): + self.username = username + self.password = password + + def __eq__(self, other): + return all( + [ + self.username == getattr(other, "username", None), + self.password == getattr(other, "password", None), + ] + ) + + def __ne__(self, other): + return not self == other + + def __call__(self, r): + r.headers["Authorization"] = _basic_auth_str(self.username, self.password) + return r + + +class HTTPProxyAuth(HTTPBasicAuth): + """Attaches HTTP Proxy Authentication to a given Request object.""" + + def __call__(self, r): + r.headers["Proxy-Authorization"] = _basic_auth_str(self.username, self.password) + return r + + +class HTTPDigestAuth(AuthBase): + """Attaches HTTP Digest Authentication to the given Request object.""" + + def __init__(self, username, password): + self.username = username + self.password = password + # Keep state in per-thread local storage + self._thread_local = threading.local() + + def init_per_thread_state(self): + # Ensure state is initialized just once per-thread + if not hasattr(self._thread_local, "init"): + self._thread_local.init = True + self._thread_local.last_nonce = "" + self._thread_local.nonce_count = 0 + self._thread_local.chal = {} + self._thread_local.pos = None + self._thread_local.num_401_calls = None + + def build_digest_header(self, method, url): + """ + :rtype: str + """ + + realm = self._thread_local.chal["realm"] + nonce = self._thread_local.chal["nonce"] + qop = self._thread_local.chal.get("qop") + algorithm = self._thread_local.chal.get("algorithm") + opaque = self._thread_local.chal.get("opaque") + hash_utf8 = None + + if algorithm is None: + _algorithm = "MD5" + else: + _algorithm = algorithm.upper() + # lambdas assume digest modules are imported at the top level + if _algorithm == "MD5" or _algorithm == "MD5-SESS": + + def md5_utf8(x): + if isinstance(x, str): + x = x.encode("utf-8") + return hashlib.md5(x).hexdigest() + + hash_utf8 = md5_utf8 + elif _algorithm == "SHA": + + def sha_utf8(x): + if isinstance(x, str): + x = x.encode("utf-8") + return hashlib.sha1(x).hexdigest() + + hash_utf8 = sha_utf8 + elif _algorithm == "SHA-256": + + def sha256_utf8(x): + if isinstance(x, str): + x = x.encode("utf-8") + return hashlib.sha256(x).hexdigest() + + hash_utf8 = sha256_utf8 + elif _algorithm == "SHA-512": + + def sha512_utf8(x): + if isinstance(x, str): + x = x.encode("utf-8") + return hashlib.sha512(x).hexdigest() + + hash_utf8 = sha512_utf8 + + KD = lambda s, d: hash_utf8(f"{s}:{d}") # noqa:E731 + + if hash_utf8 is None: + return None + + # XXX not implemented yet + entdig = None + p_parsed = urlparse(url) + #: path is request-uri defined in RFC 2616 which should not be empty + path = p_parsed.path or "/" + if p_parsed.query: + path += f"?{p_parsed.query}" + + A1 = f"{self.username}:{realm}:{self.password}" + A2 = f"{method}:{path}" + + HA1 = hash_utf8(A1) + HA2 = hash_utf8(A2) + + if nonce == self._thread_local.last_nonce: + self._thread_local.nonce_count += 1 + else: + self._thread_local.nonce_count = 1 + ncvalue = f"{self._thread_local.nonce_count:08x}" + s = str(self._thread_local.nonce_count).encode("utf-8") + s += nonce.encode("utf-8") + s += time.ctime().encode("utf-8") + s += os.urandom(8) + + cnonce = hashlib.sha1(s).hexdigest()[:16] + if _algorithm == "MD5-SESS": + HA1 = hash_utf8(f"{HA1}:{nonce}:{cnonce}") + + if not qop: + respdig = KD(HA1, f"{nonce}:{HA2}") + elif qop == "auth" or "auth" in qop.split(","): + noncebit = f"{nonce}:{ncvalue}:{cnonce}:auth:{HA2}" + respdig = KD(HA1, noncebit) + else: + # XXX handle auth-int. + return None + + self._thread_local.last_nonce = nonce + + # XXX should the partial digests be encoded too? + base = ( + f'username="{self.username}", realm="{realm}", nonce="{nonce}", ' + f'uri="{path}", response="{respdig}"' + ) + if opaque: + base += f', opaque="{opaque}"' + if algorithm: + base += f', algorithm="{algorithm}"' + if entdig: + base += f', digest="{entdig}"' + if qop: + base += f', qop="auth", nc={ncvalue}, cnonce="{cnonce}"' + + return f"Digest {base}" + + def handle_redirect(self, r, **kwargs): + """Reset num_401_calls counter on redirects.""" + if r.is_redirect: + self._thread_local.num_401_calls = 1 + + def handle_401(self, r, **kwargs): + """ + Takes the given response and tries digest-auth, if needed. + + :rtype: requests.Response + """ + + # If response is not 4xx, do not auth + # See https://github.com/psf/requests/issues/3772 + if not 400 <= r.status_code < 500: + self._thread_local.num_401_calls = 1 + return r + + if self._thread_local.pos is not None: + # Rewind the file position indicator of the body to where + # it was to resend the request. + r.request.body.seek(self._thread_local.pos) + s_auth = r.headers.get("www-authenticate", "") + + if "digest" in s_auth.lower() and self._thread_local.num_401_calls < 2: + self._thread_local.num_401_calls += 1 + pat = re.compile(r"digest ", flags=re.IGNORECASE) + self._thread_local.chal = parse_dict_header(pat.sub("", s_auth, count=1)) + + # Consume content and release the original connection + # to allow our new request to reuse the same one. + r.content + r.close() + prep = r.request.copy() + extract_cookies_to_jar(prep._cookies, r.request, r.raw) + prep.prepare_cookies(prep._cookies) + + prep.headers["Authorization"] = self.build_digest_header( + prep.method, prep.url + ) + _r = r.connection.send(prep, **kwargs) + _r.history.append(r) + _r.request = prep + + return _r + + self._thread_local.num_401_calls = 1 + return r + + def __call__(self, r): + # Initialize per-thread state, if needed + self.init_per_thread_state() + # If we have a saved nonce, skip the 401 + if self._thread_local.last_nonce: + r.headers["Authorization"] = self.build_digest_header(r.method, r.url) + try: + self._thread_local.pos = r.body.tell() + except AttributeError: + # In the case of HTTPDigestAuth being reused and the body of + # the previous request was a file-like object, pos has the + # file position of the previous body. Ensure it's set to + # None. + self._thread_local.pos = None + r.register_hook("response", self.handle_401) + r.register_hook("response", self.handle_redirect) + self._thread_local.num_401_calls = 1 + + return r + + def __eq__(self, other): + return all( + [ + self.username == getattr(other, "username", None), + self.password == getattr(other, "password", None), + ] + ) + + def __ne__(self, other): + return not self == other diff --git a/.venv/lib/python3.11/site-packages/requests/certs.py b/.venv/lib/python3.11/site-packages/requests/certs.py new file mode 100644 index 0000000000000000000000000000000000000000..be422c3e91e43bacf60ff3302688df0b28742333 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/requests/certs.py @@ -0,0 +1,17 @@ +#!/usr/bin/env python + +""" +requests.certs +~~~~~~~~~~~~~~ + +This module returns the preferred default CA certificate bundle. There is +only one — the one from the certifi package. + +If you are packaging Requests, e.g., for a Linux distribution or a managed +environment, you can change the definition of where() to return a separately +packaged CA bundle. +""" +from certifi import where + +if __name__ == "__main__": + print(where()) diff --git a/.venv/lib/python3.11/site-packages/requests/compat.py b/.venv/lib/python3.11/site-packages/requests/compat.py new file mode 100644 index 0000000000000000000000000000000000000000..095de1b6cae2f460174af54efa975411645f40c6 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/requests/compat.py @@ -0,0 +1,94 @@ +""" +requests.compat +~~~~~~~~~~~~~~~ + +This module previously handled import compatibility issues +between Python 2 and Python 3. It remains for backwards +compatibility until the next major version. +""" + +import importlib +import sys + +# ------------------- +# Character Detection +# ------------------- + + +def _resolve_char_detection(): + """Find supported character detection libraries.""" + chardet = None + for lib in ("chardet", "charset_normalizer"): + if chardet is None: + try: + chardet = importlib.import_module(lib) + except ImportError: + pass + return chardet + + +chardet = _resolve_char_detection() + +# ------- +# Pythons +# ------- + +# Syntax sugar. +_ver = sys.version_info + +#: Python 2.x? +is_py2 = _ver[0] == 2 + +#: Python 3.x? +is_py3 = _ver[0] == 3 + +# json/simplejson module import resolution +has_simplejson = False +try: + import simplejson as json + + has_simplejson = True +except ImportError: + import json + +if has_simplejson: + from simplejson import JSONDecodeError +else: + from json import JSONDecodeError + +# Keep OrderedDict for backwards compatibility. +from collections import OrderedDict +from collections.abc import Callable, Mapping, MutableMapping +from http import cookiejar as cookielib +from http.cookies import Morsel +from io import StringIO + +# -------------- +# Legacy Imports +# -------------- +from urllib.parse import ( + quote, + quote_plus, + unquote, + unquote_plus, + urldefrag, + urlencode, + urljoin, + urlparse, + urlsplit, + urlunparse, +) +from urllib.request import ( + getproxies, + getproxies_environment, + parse_http_list, + proxy_bypass, + proxy_bypass_environment, +) + +builtin_str = str +str = str +bytes = bytes +basestring = (str, bytes) +numeric_types = (int, float) +integer_types = (int,) diff --git a/.venv/lib/python3.11/site-packages/requests/cookies.py b/.venv/lib/python3.11/site-packages/requests/cookies.py new file mode 100644 index 0000000000000000000000000000000000000000..f69d0cda9e1c893401015a09f2db2de5a5960fd2 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/requests/cookies.py @@ -0,0 +1,561 @@ +""" +requests.cookies +~~~~~~~~~~~~~~~~ + +Compatibility code to be able to use `http.cookiejar.CookieJar` with requests. + +requests.utils imports from here, so be careful with imports. +""" + +import calendar +import copy +import time + +from ._internal_utils import to_native_string +from .compat import Morsel, MutableMapping, cookielib, urlparse, urlunparse + +try: + import threading +except ImportError: + import dummy_threading as threading + + +class MockRequest: + """Wraps a `requests.Request` to mimic a `urllib2.Request`. + + The code in `http.cookiejar.CookieJar` expects this interface in order to correctly + manage cookie policies, i.e., determine whether a cookie can be set, given the + domains of the request and the cookie. + + The original request object is read-only. The client is responsible for collecting + the new headers via `get_new_headers()` and interpreting them appropriately. You + probably want `get_cookie_header`, defined below. + """ + + def __init__(self, request): + self._r = request + self._new_headers = {} + self.type = urlparse(self._r.url).scheme + + def get_type(self): + return self.type + + def get_host(self): + return urlparse(self._r.url).netloc + + def get_origin_req_host(self): + return self.get_host() + + def get_full_url(self): + # Only return the response's URL if the user hadn't set the Host + # header + if not self._r.headers.get("Host"): + return self._r.url + # If they did set it, retrieve it and reconstruct the expected domain + host = to_native_string(self._r.headers["Host"], encoding="utf-8") + parsed = urlparse(self._r.url) + # Reconstruct the URL as we expect it + return urlunparse( + [ + parsed.scheme, + host, + parsed.path, + parsed.params, + parsed.query, + parsed.fragment, + ] + ) + + def is_unverifiable(self): + return True + + def has_header(self, name): + return name in self._r.headers or name in self._new_headers + + def get_header(self, name, default=None): + return self._r.headers.get(name, self._new_headers.get(name, default)) + + def add_header(self, key, val): + """cookiejar has no legitimate use for this method; add it back if you find one.""" + raise NotImplementedError( + "Cookie headers should be added with add_unredirected_header()" + ) + + def add_unredirected_header(self, name, value): + self._new_headers[name] = value + + def get_new_headers(self): + return self._new_headers + + @property + def unverifiable(self): + return self.is_unverifiable() + + @property + def origin_req_host(self): + return self.get_origin_req_host() + + @property + def host(self): + return self.get_host() + + +class MockResponse: + """Wraps a `httplib.HTTPMessage` to mimic a `urllib.addinfourl`. + + ...what? Basically, expose the parsed HTTP headers from the server response + the way `http.cookiejar` expects to see them. + """ + + def __init__(self, headers): + """Make a MockResponse for `cookiejar` to read. + + :param headers: a httplib.HTTPMessage or analogous carrying the headers + """ + self._headers = headers + + def info(self): + return self._headers + + def getheaders(self, name): + self._headers.getheaders(name) + + +def extract_cookies_to_jar(jar, request, response): + """Extract the cookies from the response into a CookieJar. + + :param jar: http.cookiejar.CookieJar (not necessarily a RequestsCookieJar) + :param request: our own requests.Request object + :param response: urllib3.HTTPResponse object + """ + if not (hasattr(response, "_original_response") and response._original_response): + return + # the _original_response field is the wrapped httplib.HTTPResponse object, + req = MockRequest(request) + # pull out the HTTPMessage with the headers and put it in the mock: + res = MockResponse(response._original_response.msg) + jar.extract_cookies(res, req) + + +def get_cookie_header(jar, request): + """ + Produce an appropriate Cookie header string to be sent with `request`, or None. + + :rtype: str + """ + r = MockRequest(request) + jar.add_cookie_header(r) + return r.get_new_headers().get("Cookie") + + +def remove_cookie_by_name(cookiejar, name, domain=None, path=None): + """Unsets a cookie by name, by default over all domains and paths. + + Wraps CookieJar.clear(), is O(n). + """ + clearables = [] + for cookie in cookiejar: + if cookie.name != name: + continue + if domain is not None and domain != cookie.domain: + continue + if path is not None and path != cookie.path: + continue + clearables.append((cookie.domain, cookie.path, cookie.name)) + + for domain, path, name in clearables: + cookiejar.clear(domain, path, name) + + +class CookieConflictError(RuntimeError): + """There are two cookies that meet the criteria specified in the cookie jar. + Use .get and .set and include domain and path args in order to be more specific. + """ + + +class RequestsCookieJar(cookielib.CookieJar, MutableMapping): + """Compatibility class; is a http.cookiejar.CookieJar, but exposes a dict + interface. + + This is the CookieJar we create by default for requests and sessions that + don't specify one, since some clients may expect response.cookies and + session.cookies to support dict operations. + + Requests does not use the dict interface internally; it's just for + compatibility with external client code. All requests code should work + out of the box with externally provided instances of ``CookieJar``, e.g. + ``LWPCookieJar`` and ``FileCookieJar``. + + Unlike a regular CookieJar, this class is pickleable. + + .. warning:: dictionary operations that are normally O(1) may be O(n). + """ + + def get(self, name, default=None, domain=None, path=None): + """Dict-like get() that also supports optional domain and path args in + order to resolve naming collisions from using one cookie jar over + multiple domains. + + .. warning:: operation is O(n), not O(1). + """ + try: + return self._find_no_duplicates(name, domain, path) + except KeyError: + return default + + def set(self, name, value, **kwargs): + """Dict-like set() that also supports optional domain and path args in + order to resolve naming collisions from using one cookie jar over + multiple domains. + """ + # support client code that unsets cookies by assignment of a None value: + if value is None: + remove_cookie_by_name( + self, name, domain=kwargs.get("domain"), path=kwargs.get("path") + ) + return + + if isinstance(value, Morsel): + c = morsel_to_cookie(value) + else: + c = create_cookie(name, value, **kwargs) + self.set_cookie(c) + return c + + def iterkeys(self): + """Dict-like iterkeys() that returns an iterator of names of cookies + from the jar. + + .. seealso:: itervalues() and iteritems(). + """ + for cookie in iter(self): + yield cookie.name + + def keys(self): + """Dict-like keys() that returns a list of names of cookies from the + jar. + + .. seealso:: values() and items(). + """ + return list(self.iterkeys()) + + def itervalues(self): + """Dict-like itervalues() that returns an iterator of values of cookies + from the jar. + + .. seealso:: iterkeys() and iteritems(). + """ + for cookie in iter(self): + yield cookie.value + + def values(self): + """Dict-like values() that returns a list of values of cookies from the + jar. + + .. seealso:: keys() and items(). + """ + return list(self.itervalues()) + + def iteritems(self): + """Dict-like iteritems() that returns an iterator of name-value tuples + from the jar. + + .. seealso:: iterkeys() and itervalues(). + """ + for cookie in iter(self): + yield cookie.name, cookie.value + + def items(self): + """Dict-like items() that returns a list of name-value tuples from the + jar. Allows client-code to call ``dict(RequestsCookieJar)`` and get a + vanilla python dict of key value pairs. + + .. seealso:: keys() and values(). + """ + return list(self.iteritems()) + + def list_domains(self): + """Utility method to list all the domains in the jar.""" + domains = [] + for cookie in iter(self): + if cookie.domain not in domains: + domains.append(cookie.domain) + return domains + + def list_paths(self): + """Utility method to list all the paths in the jar.""" + paths = [] + for cookie in iter(self): + if cookie.path not in paths: + paths.append(cookie.path) + return paths + + def multiple_domains(self): + """Returns True if there are multiple domains in the jar. + Returns False otherwise. + + :rtype: bool + """ + domains = [] + for cookie in iter(self): + if cookie.domain is not None and cookie.domain in domains: + return True + domains.append(cookie.domain) + return False # there is only one domain in jar + + def get_dict(self, domain=None, path=None): + """Takes as an argument an optional domain and path and returns a plain + old Python dict of name-value pairs of cookies that meet the + requirements. + + :rtype: dict + """ + dictionary = {} + for cookie in iter(self): + if (domain is None or cookie.domain == domain) and ( + path is None or cookie.path == path + ): + dictionary[cookie.name] = cookie.value + return dictionary + + def __contains__(self, name): + try: + return super().__contains__(name) + except CookieConflictError: + return True + + def __getitem__(self, name): + """Dict-like __getitem__() for compatibility with client code. Throws + exception if there are more than one cookie with name. In that case, + use the more explicit get() method instead. + + .. warning:: operation is O(n), not O(1). + """ + return self._find_no_duplicates(name) + + def __setitem__(self, name, value): + """Dict-like __setitem__ for compatibility with client code. Throws + exception if there is already a cookie of that name in the jar. In that + case, use the more explicit set() method instead. + """ + self.set(name, value) + + def __delitem__(self, name): + """Deletes a cookie given a name. Wraps ``http.cookiejar.CookieJar``'s + ``remove_cookie_by_name()``. + """ + remove_cookie_by_name(self, name) + + def set_cookie(self, cookie, *args, **kwargs): + if ( + hasattr(cookie.value, "startswith") + and cookie.value.startswith('"') + and cookie.value.endswith('"') + ): + cookie.value = cookie.value.replace('\\"', "") + return super().set_cookie(cookie, *args, **kwargs) + + def update(self, other): + """Updates this jar with cookies from another CookieJar or dict-like""" + if isinstance(other, cookielib.CookieJar): + for cookie in other: + self.set_cookie(copy.copy(cookie)) + else: + super().update(other) + + def _find(self, name, domain=None, path=None): + """Requests uses this method internally to get cookie values. + + If there are conflicting cookies, _find arbitrarily chooses one. + See _find_no_duplicates if you want an exception thrown if there are + conflicting cookies. + + :param name: a string containing name of cookie + :param domain: (optional) string containing domain of cookie + :param path: (optional) string containing path of cookie + :return: cookie.value + """ + for cookie in iter(self): + if cookie.name == name: + if domain is None or cookie.domain == domain: + if path is None or cookie.path == path: + return cookie.value + + raise KeyError(f"name={name!r}, domain={domain!r}, path={path!r}") + + def _find_no_duplicates(self, name, domain=None, path=None): + """Both ``__get_item__`` and ``get`` call this function: it's never + used elsewhere in Requests. + + :param name: a string containing name of cookie + :param domain: (optional) string containing domain of cookie + :param path: (optional) string containing path of cookie + :raises KeyError: if cookie is not found + :raises CookieConflictError: if there are multiple cookies + that match name and optionally domain and path + :return: cookie.value + """ + toReturn = None + for cookie in iter(self): + if cookie.name == name: + if domain is None or cookie.domain == domain: + if path is None or cookie.path == path: + if toReturn is not None: + # if there are multiple cookies that meet passed in criteria + raise CookieConflictError( + f"There are multiple cookies with name, {name!r}" + ) + # we will eventually return this as long as no cookie conflict + toReturn = cookie.value + + if toReturn: + return toReturn + raise KeyError(f"name={name!r}, domain={domain!r}, path={path!r}") + + def __getstate__(self): + """Unlike a normal CookieJar, this class is pickleable.""" + state = self.__dict__.copy() + # remove the unpickleable RLock object + state.pop("_cookies_lock") + return state + + def __setstate__(self, state): + """Unlike a normal CookieJar, this class is pickleable.""" + self.__dict__.update(state) + if "_cookies_lock" not in self.__dict__: + self._cookies_lock = threading.RLock() + + def copy(self): + """Return a copy of this RequestsCookieJar.""" + new_cj = RequestsCookieJar() + new_cj.set_policy(self.get_policy()) + new_cj.update(self) + return new_cj + + def get_policy(self): + """Return the CookiePolicy instance used.""" + return self._policy + + +def _copy_cookie_jar(jar): + if jar is None: + return None + + if hasattr(jar, "copy"): + # We're dealing with an instance of RequestsCookieJar + return jar.copy() + # We're dealing with a generic CookieJar instance + new_jar = copy.copy(jar) + new_jar.clear() + for cookie in jar: + new_jar.set_cookie(copy.copy(cookie)) + return new_jar + + +def create_cookie(name, value, **kwargs): + """Make a cookie from underspecified parameters. + + By default, the pair of `name` and `value` will be set for the domain '' + and sent on every request (this is sometimes called a "supercookie"). + """ + result = { + "version": 0, + "name": name, + "value": value, + "port": None, + "domain": "", + "path": "/", + "secure": False, + "expires": None, + "discard": True, + "comment": None, + "comment_url": None, + "rest": {"HttpOnly": None}, + "rfc2109": False, + } + + badargs = set(kwargs) - set(result) + if badargs: + raise TypeError( + f"create_cookie() got unexpected keyword arguments: {list(badargs)}" + ) + + result.update(kwargs) + result["port_specified"] = bool(result["port"]) + result["domain_specified"] = bool(result["domain"]) + result["domain_initial_dot"] = result["domain"].startswith(".") + result["path_specified"] = bool(result["path"]) + + return cookielib.Cookie(**result) + + +def morsel_to_cookie(morsel): + """Convert a Morsel object into a Cookie containing the one k/v pair.""" + + expires = None + if morsel["max-age"]: + try: + expires = int(time.time() + int(morsel["max-age"])) + except ValueError: + raise TypeError(f"max-age: {morsel['max-age']} must be integer") + elif morsel["expires"]: + time_template = "%a, %d-%b-%Y %H:%M:%S GMT" + expires = calendar.timegm(time.strptime(morsel["expires"], time_template)) + return create_cookie( + comment=morsel["comment"], + comment_url=bool(morsel["comment"]), + discard=False, + domain=morsel["domain"], + expires=expires, + name=morsel.key, + path=morsel["path"], + port=None, + rest={"HttpOnly": morsel["httponly"]}, + rfc2109=False, + secure=bool(morsel["secure"]), + value=morsel.value, + version=morsel["version"] or 0, + ) + + +def cookiejar_from_dict(cookie_dict, cookiejar=None, overwrite=True): + """Returns a CookieJar from a key/value dictionary. + + :param cookie_dict: Dict of key/values to insert into CookieJar. + :param cookiejar: (optional) A cookiejar to add the cookies to. + :param overwrite: (optional) If False, will not replace cookies + already in the jar with new ones. + :rtype: CookieJar + """ + if cookiejar is None: + cookiejar = RequestsCookieJar() + + if cookie_dict is not None: + names_from_jar = [cookie.name for cookie in cookiejar] + for name in cookie_dict: + if overwrite or (name not in names_from_jar): + cookiejar.set_cookie(create_cookie(name, cookie_dict[name])) + + return cookiejar + + +def merge_cookies(cookiejar, cookies): + """Add cookies to cookiejar and returns a merged CookieJar. + + :param cookiejar: CookieJar object to add the cookies to. + :param cookies: Dictionary or CookieJar object to be added. + :rtype: CookieJar + """ + if not isinstance(cookiejar, cookielib.CookieJar): + raise ValueError("You can only merge into CookieJar") + + if isinstance(cookies, dict): + cookiejar = cookiejar_from_dict(cookies, cookiejar=cookiejar, overwrite=False) + elif isinstance(cookies, cookielib.CookieJar): + try: + cookiejar.update(cookies) + except AttributeError: + for cookie_in_jar in cookies: + cookiejar.set_cookie(cookie_in_jar) + + return cookiejar diff --git a/.venv/lib/python3.11/site-packages/requests/exceptions.py b/.venv/lib/python3.11/site-packages/requests/exceptions.py new file mode 100644 index 0000000000000000000000000000000000000000..83986b489849131efeb7f286b328961205256fd8 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/requests/exceptions.py @@ -0,0 +1,151 @@ +""" +requests.exceptions +~~~~~~~~~~~~~~~~~~~ + +This module contains the set of Requests' exceptions. +""" +from urllib3.exceptions import HTTPError as BaseHTTPError + +from .compat import JSONDecodeError as CompatJSONDecodeError + + +class RequestException(IOError): + """There was an ambiguous exception that occurred while handling your + request. + """ + + def __init__(self, *args, **kwargs): + """Initialize RequestException with `request` and `response` objects.""" + response = kwargs.pop("response", None) + self.response = response + self.request = kwargs.pop("request", None) + if response is not None and not self.request and hasattr(response, "request"): + self.request = self.response.request + super().__init__(*args, **kwargs) + + +class InvalidJSONError(RequestException): + """A JSON error occurred.""" + + +class JSONDecodeError(InvalidJSONError, CompatJSONDecodeError): + """Couldn't decode the text into json""" + + def __init__(self, *args, **kwargs): + """ + Construct the JSONDecodeError instance first with all + args. Then use it's args to construct the IOError so that + the json specific args aren't used as IOError specific args + and the error message from JSONDecodeError is preserved. + """ + CompatJSONDecodeError.__init__(self, *args) + InvalidJSONError.__init__(self, *self.args, **kwargs) + + def __reduce__(self): + """ + The __reduce__ method called when pickling the object must + be the one from the JSONDecodeError (be it json/simplejson) + as it expects all the arguments for instantiation, not just + one like the IOError, and the MRO would by default call the + __reduce__ method from the IOError due to the inheritance order. + """ + return CompatJSONDecodeError.__reduce__(self) + + +class HTTPError(RequestException): + """An HTTP error occurred.""" + + +class ConnectionError(RequestException): + """A Connection error occurred.""" + + +class ProxyError(ConnectionError): + """A proxy error occurred.""" + + +class SSLError(ConnectionError): + """An SSL error occurred.""" + + +class Timeout(RequestException): + """The request timed out. + + Catching this error will catch both + :exc:`~requests.exceptions.ConnectTimeout` and + :exc:`~requests.exceptions.ReadTimeout` errors. + """ + + +class ConnectTimeout(ConnectionError, Timeout): + """The request timed out while trying to connect to the remote server. + + Requests that produced this error are safe to retry. + """ + + +class ReadTimeout(Timeout): + """The server did not send any data in the allotted amount of time.""" + + +class URLRequired(RequestException): + """A valid URL is required to make a request.""" + + +class TooManyRedirects(RequestException): + """Too many redirects.""" + + +class MissingSchema(RequestException, ValueError): + """The URL scheme (e.g. http or https) is missing.""" + + +class InvalidSchema(RequestException, ValueError): + """The URL scheme provided is either invalid or unsupported.""" + + +class InvalidURL(RequestException, ValueError): + """The URL provided was somehow invalid.""" + + +class InvalidHeader(RequestException, ValueError): + """The header value provided was somehow invalid.""" + + +class InvalidProxyURL(InvalidURL): + """The proxy URL provided is invalid.""" + + +class ChunkedEncodingError(RequestException): + """The server declared chunked encoding but sent an invalid chunk.""" + + +class ContentDecodingError(RequestException, BaseHTTPError): + """Failed to decode response content.""" + + +class StreamConsumedError(RequestException, TypeError): + """The content for this response was already consumed.""" + + +class RetryError(RequestException): + """Custom retries logic failed""" + + +class UnrewindableBodyError(RequestException): + """Requests encountered an error when trying to rewind a body.""" + + +# Warnings + + +class RequestsWarning(Warning): + """Base warning for Requests.""" + + +class FileModeWarning(RequestsWarning, DeprecationWarning): + """A file was opened in text mode, but Requests determined its binary length.""" + + +class RequestsDependencyWarning(RequestsWarning): + """An imported dependency doesn't match the expected version range.""" diff --git a/.venv/lib/python3.11/site-packages/requests/help.py b/.venv/lib/python3.11/site-packages/requests/help.py new file mode 100644 index 0000000000000000000000000000000000000000..8fbcd6560a8fe2c8a07e3bd1441a81e0db9cb689 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/requests/help.py @@ -0,0 +1,134 @@ +"""Module containing bug report helper(s).""" + +import json +import platform +import ssl +import sys + +import idna +import urllib3 + +from . import __version__ as requests_version + +try: + import charset_normalizer +except ImportError: + charset_normalizer = None + +try: + import chardet +except ImportError: + chardet = None + +try: + from urllib3.contrib import pyopenssl +except ImportError: + pyopenssl = None + OpenSSL = None + cryptography = None +else: + import cryptography + import OpenSSL + + +def _implementation(): + """Return a dict with the Python implementation and version. + + Provide both the name and the version of the Python implementation + currently running. For example, on CPython 3.10.3 it will return + {'name': 'CPython', 'version': '3.10.3'}. + + This function works best on CPython and PyPy: in particular, it probably + doesn't work for Jython or IronPython. Future investigation should be done + to work out the correct shape of the code for those platforms. + """ + implementation = platform.python_implementation() + + if implementation == "CPython": + implementation_version = platform.python_version() + elif implementation == "PyPy": + implementation_version = "{}.{}.{}".format( + sys.pypy_version_info.major, + sys.pypy_version_info.minor, + sys.pypy_version_info.micro, + ) + if sys.pypy_version_info.releaselevel != "final": + implementation_version = "".join( + [implementation_version, sys.pypy_version_info.releaselevel] + ) + elif implementation == "Jython": + implementation_version = platform.python_version() # Complete Guess + elif implementation == "IronPython": + implementation_version = platform.python_version() # Complete Guess + else: + implementation_version = "Unknown" + + return {"name": implementation, "version": implementation_version} + + +def info(): + """Generate information for a bug report.""" + try: + platform_info = { + "system": platform.system(), + "release": platform.release(), + } + except OSError: + platform_info = { + "system": "Unknown", + "release": "Unknown", + } + + implementation_info = _implementation() + urllib3_info = {"version": urllib3.__version__} + charset_normalizer_info = {"version": None} + chardet_info = {"version": None} + if charset_normalizer: + charset_normalizer_info = {"version": charset_normalizer.__version__} + if chardet: + chardet_info = {"version": chardet.__version__} + + pyopenssl_info = { + "version": None, + "openssl_version": "", + } + if OpenSSL: + pyopenssl_info = { + "version": OpenSSL.__version__, + "openssl_version": f"{OpenSSL.SSL.OPENSSL_VERSION_NUMBER:x}", + } + cryptography_info = { + "version": getattr(cryptography, "__version__", ""), + } + idna_info = { + "version": getattr(idna, "__version__", ""), + } + + system_ssl = ssl.OPENSSL_VERSION_NUMBER + system_ssl_info = {"version": f"{system_ssl:x}" if system_ssl is not None else ""} + + return { + "platform": platform_info, + "implementation": implementation_info, + "system_ssl": system_ssl_info, + "using_pyopenssl": pyopenssl is not None, + "using_charset_normalizer": chardet is None, + "pyOpenSSL": pyopenssl_info, + "urllib3": urllib3_info, + "chardet": chardet_info, + "charset_normalizer": charset_normalizer_info, + "cryptography": cryptography_info, + "idna": idna_info, + "requests": { + "version": requests_version, + }, + } + + +def main(): + """Pretty-print the bug information as JSON.""" + print(json.dumps(info(), sort_keys=True, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/.venv/lib/python3.11/site-packages/requests/hooks.py b/.venv/lib/python3.11/site-packages/requests/hooks.py new file mode 100644 index 0000000000000000000000000000000000000000..d181ba2ec2e55d274897315887b78fbdca757da8 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/requests/hooks.py @@ -0,0 +1,33 @@ +""" +requests.hooks +~~~~~~~~~~~~~~ + +This module provides the capabilities for the Requests hooks system. + +Available hooks: + +``response``: + The response generated from a Request. +""" +HOOKS = ["response"] + + +def default_hooks(): + return {event: [] for event in HOOKS} + + +# TODO: response is the only one + + +def dispatch_hook(key, hooks, hook_data, **kwargs): + """Dispatches a hook dictionary on a given piece of data.""" + hooks = hooks or {} + hooks = hooks.get(key) + if hooks: + if hasattr(hooks, "__call__"): + hooks = [hooks] + for hook in hooks: + _hook_data = hook(hook_data, **kwargs) + if _hook_data is not None: + hook_data = _hook_data + return hook_data diff --git a/.venv/lib/python3.11/site-packages/requests/models.py b/.venv/lib/python3.11/site-packages/requests/models.py new file mode 100644 index 0000000000000000000000000000000000000000..8f56ca7d23a9a12084df80cb649e019572308cfe --- /dev/null +++ b/.venv/lib/python3.11/site-packages/requests/models.py @@ -0,0 +1,1037 @@ +""" +requests.models +~~~~~~~~~~~~~~~ + +This module contains the primary objects that power Requests. +""" + +import datetime + +# Import encoding now, to avoid implicit import later. +# Implicit import within threads may cause LookupError when standard library is in a ZIP, +# such as in Embedded Python. See https://github.com/psf/requests/issues/3578. +import encodings.idna # noqa: F401 +from io import UnsupportedOperation + +from urllib3.exceptions import ( + DecodeError, + LocationParseError, + ProtocolError, + ReadTimeoutError, + SSLError, +) +from urllib3.fields import RequestField +from urllib3.filepost import encode_multipart_formdata +from urllib3.util import parse_url + +from ._internal_utils import to_native_string, unicode_is_ascii +from .auth import HTTPBasicAuth +from .compat import ( + Callable, + JSONDecodeError, + Mapping, + basestring, + builtin_str, + chardet, + cookielib, +) +from .compat import json as complexjson +from .compat import urlencode, urlsplit, urlunparse +from .cookies import _copy_cookie_jar, cookiejar_from_dict, get_cookie_header +from .exceptions import ( + ChunkedEncodingError, + ConnectionError, + ContentDecodingError, + HTTPError, + InvalidJSONError, + InvalidURL, +) +from .exceptions import JSONDecodeError as RequestsJSONDecodeError +from .exceptions import MissingSchema +from .exceptions import SSLError as RequestsSSLError +from .exceptions import StreamConsumedError +from .hooks import default_hooks +from .status_codes import codes +from .structures import CaseInsensitiveDict +from .utils import ( + check_header_validity, + get_auth_from_url, + guess_filename, + guess_json_utf, + iter_slices, + parse_header_links, + requote_uri, + stream_decode_response_unicode, + super_len, + to_key_val_list, +) + +#: The set of HTTP status codes that indicate an automatically +#: processable redirect. +REDIRECT_STATI = ( + codes.moved, # 301 + codes.found, # 302 + codes.other, # 303 + codes.temporary_redirect, # 307 + codes.permanent_redirect, # 308 +) + +DEFAULT_REDIRECT_LIMIT = 30 +CONTENT_CHUNK_SIZE = 10 * 1024 +ITER_CHUNK_SIZE = 512 + + +class RequestEncodingMixin: + @property + def path_url(self): + """Build the path URL to use.""" + + url = [] + + p = urlsplit(self.url) + + path = p.path + if not path: + path = "/" + + url.append(path) + + query = p.query + if query: + url.append("?") + url.append(query) + + return "".join(url) + + @staticmethod + def _encode_params(data): + """Encode parameters in a piece of data. + + Will successfully encode parameters when passed as a dict or a list of + 2-tuples. Order is retained if data is a list of 2-tuples but arbitrary + if parameters are supplied as a dict. + """ + + if isinstance(data, (str, bytes)): + return data + elif hasattr(data, "read"): + return data + elif hasattr(data, "__iter__"): + result = [] + for k, vs in to_key_val_list(data): + if isinstance(vs, basestring) or not hasattr(vs, "__iter__"): + vs = [vs] + for v in vs: + if v is not None: + result.append( + ( + k.encode("utf-8") if isinstance(k, str) else k, + v.encode("utf-8") if isinstance(v, str) else v, + ) + ) + return urlencode(result, doseq=True) + else: + return data + + @staticmethod + def _encode_files(files, data): + """Build the body for a multipart/form-data request. + + Will successfully encode files when passed as a dict or a list of + tuples. Order is retained if data is a list of tuples but arbitrary + if parameters are supplied as a dict. + The tuples may be 2-tuples (filename, fileobj), 3-tuples (filename, fileobj, contentype) + or 4-tuples (filename, fileobj, contentype, custom_headers). + """ + if not files: + raise ValueError("Files must be provided.") + elif isinstance(data, basestring): + raise ValueError("Data must not be a string.") + + new_fields = [] + fields = to_key_val_list(data or {}) + files = to_key_val_list(files or {}) + + for field, val in fields: + if isinstance(val, basestring) or not hasattr(val, "__iter__"): + val = [val] + for v in val: + if v is not None: + # Don't call str() on bytestrings: in Py3 it all goes wrong. + if not isinstance(v, bytes): + v = str(v) + + new_fields.append( + ( + field.decode("utf-8") + if isinstance(field, bytes) + else field, + v.encode("utf-8") if isinstance(v, str) else v, + ) + ) + + for k, v in files: + # support for explicit filename + ft = None + fh = None + if isinstance(v, (tuple, list)): + if len(v) == 2: + fn, fp = v + elif len(v) == 3: + fn, fp, ft = v + else: + fn, fp, ft, fh = v + else: + fn = guess_filename(v) or k + fp = v + + if isinstance(fp, (str, bytes, bytearray)): + fdata = fp + elif hasattr(fp, "read"): + fdata = fp.read() + elif fp is None: + continue + else: + fdata = fp + + rf = RequestField(name=k, data=fdata, filename=fn, headers=fh) + rf.make_multipart(content_type=ft) + new_fields.append(rf) + + body, content_type = encode_multipart_formdata(new_fields) + + return body, content_type + + +class RequestHooksMixin: + def register_hook(self, event, hook): + """Properly register a hook.""" + + if event not in self.hooks: + raise ValueError(f'Unsupported event specified, with event name "{event}"') + + if isinstance(hook, Callable): + self.hooks[event].append(hook) + elif hasattr(hook, "__iter__"): + self.hooks[event].extend(h for h in hook if isinstance(h, Callable)) + + def deregister_hook(self, event, hook): + """Deregister a previously registered hook. + Returns True if the hook existed, False if not. + """ + + try: + self.hooks[event].remove(hook) + return True + except ValueError: + return False + + +class Request(RequestHooksMixin): + """A user-created :class:`Request ` object. + + Used to prepare a :class:`PreparedRequest `, which is sent to the server. + + :param method: HTTP method to use. + :param url: URL to send. + :param headers: dictionary of headers to send. + :param files: dictionary of {filename: fileobject} files to multipart upload. + :param data: the body to attach to the request. If a dictionary or + list of tuples ``[(key, value)]`` is provided, form-encoding will + take place. + :param json: json for the body to attach to the request (if files or data is not specified). + :param params: URL parameters to append to the URL. If a dictionary or + list of tuples ``[(key, value)]`` is provided, form-encoding will + take place. + :param auth: Auth handler or (user, pass) tuple. + :param cookies: dictionary or CookieJar of cookies to attach to this request. + :param hooks: dictionary of callback hooks, for internal usage. + + Usage:: + + >>> import requests + >>> req = requests.Request('GET', 'https://httpbin.org/get') + >>> req.prepare() + + """ + + def __init__( + self, + method=None, + url=None, + headers=None, + files=None, + data=None, + params=None, + auth=None, + cookies=None, + hooks=None, + json=None, + ): + # Default empty dicts for dict params. + data = [] if data is None else data + files = [] if files is None else files + headers = {} if headers is None else headers + params = {} if params is None else params + hooks = {} if hooks is None else hooks + + self.hooks = default_hooks() + for k, v in list(hooks.items()): + self.register_hook(event=k, hook=v) + + self.method = method + self.url = url + self.headers = headers + self.files = files + self.data = data + self.json = json + self.params = params + self.auth = auth + self.cookies = cookies + + def __repr__(self): + return f"" + + def prepare(self): + """Constructs a :class:`PreparedRequest ` for transmission and returns it.""" + p = PreparedRequest() + p.prepare( + method=self.method, + url=self.url, + headers=self.headers, + files=self.files, + data=self.data, + json=self.json, + params=self.params, + auth=self.auth, + cookies=self.cookies, + hooks=self.hooks, + ) + return p + + +class PreparedRequest(RequestEncodingMixin, RequestHooksMixin): + """The fully mutable :class:`PreparedRequest ` object, + containing the exact bytes that will be sent to the server. + + Instances are generated from a :class:`Request ` object, and + should not be instantiated manually; doing so may produce undesirable + effects. + + Usage:: + + >>> import requests + >>> req = requests.Request('GET', 'https://httpbin.org/get') + >>> r = req.prepare() + >>> r + + + >>> s = requests.Session() + >>> s.send(r) + + """ + + def __init__(self): + #: HTTP verb to send to the server. + self.method = None + #: HTTP URL to send the request to. + self.url = None + #: dictionary of HTTP headers. + self.headers = None + # The `CookieJar` used to create the Cookie header will be stored here + # after prepare_cookies is called + self._cookies = None + #: request body to send to the server. + self.body = None + #: dictionary of callback hooks, for internal usage. + self.hooks = default_hooks() + #: integer denoting starting position of a readable file-like body. + self._body_position = None + + def prepare( + self, + method=None, + url=None, + headers=None, + files=None, + data=None, + params=None, + auth=None, + cookies=None, + hooks=None, + json=None, + ): + """Prepares the entire request with the given parameters.""" + + self.prepare_method(method) + self.prepare_url(url, params) + self.prepare_headers(headers) + self.prepare_cookies(cookies) + self.prepare_body(data, files, json) + self.prepare_auth(auth, url) + + # Note that prepare_auth must be last to enable authentication schemes + # such as OAuth to work on a fully prepared request. + + # This MUST go after prepare_auth. Authenticators could add a hook + self.prepare_hooks(hooks) + + def __repr__(self): + return f"" + + def copy(self): + p = PreparedRequest() + p.method = self.method + p.url = self.url + p.headers = self.headers.copy() if self.headers is not None else None + p._cookies = _copy_cookie_jar(self._cookies) + p.body = self.body + p.hooks = self.hooks + p._body_position = self._body_position + return p + + def prepare_method(self, method): + """Prepares the given HTTP method.""" + self.method = method + if self.method is not None: + self.method = to_native_string(self.method.upper()) + + @staticmethod + def _get_idna_encoded_host(host): + import idna + + try: + host = idna.encode(host, uts46=True).decode("utf-8") + except idna.IDNAError: + raise UnicodeError + return host + + def prepare_url(self, url, params): + """Prepares the given HTTP URL.""" + #: Accept objects that have string representations. + #: We're unable to blindly call unicode/str functions + #: as this will include the bytestring indicator (b'') + #: on python 3.x. + #: https://github.com/psf/requests/pull/2238 + if isinstance(url, bytes): + url = url.decode("utf8") + else: + url = str(url) + + # Remove leading whitespaces from url + url = url.lstrip() + + # Don't do any URL preparation for non-HTTP schemes like `mailto`, + # `data` etc to work around exceptions from `url_parse`, which + # handles RFC 3986 only. + if ":" in url and not url.lower().startswith("http"): + self.url = url + return + + # Support for unicode domain names and paths. + try: + scheme, auth, host, port, path, query, fragment = parse_url(url) + except LocationParseError as e: + raise InvalidURL(*e.args) + + if not scheme: + raise MissingSchema( + f"Invalid URL {url!r}: No scheme supplied. " + f"Perhaps you meant https://{url}?" + ) + + if not host: + raise InvalidURL(f"Invalid URL {url!r}: No host supplied") + + # In general, we want to try IDNA encoding the hostname if the string contains + # non-ASCII characters. This allows users to automatically get the correct IDNA + # behaviour. For strings containing only ASCII characters, we need to also verify + # it doesn't start with a wildcard (*), before allowing the unencoded hostname. + if not unicode_is_ascii(host): + try: + host = self._get_idna_encoded_host(host) + except UnicodeError: + raise InvalidURL("URL has an invalid label.") + elif host.startswith(("*", ".")): + raise InvalidURL("URL has an invalid label.") + + # Carefully reconstruct the network location + netloc = auth or "" + if netloc: + netloc += "@" + netloc += host + if port: + netloc += f":{port}" + + # Bare domains aren't valid URLs. + if not path: + path = "/" + + if isinstance(params, (str, bytes)): + params = to_native_string(params) + + enc_params = self._encode_params(params) + if enc_params: + if query: + query = f"{query}&{enc_params}" + else: + query = enc_params + + url = requote_uri(urlunparse([scheme, netloc, path, None, query, fragment])) + self.url = url + + def prepare_headers(self, headers): + """Prepares the given HTTP headers.""" + + self.headers = CaseInsensitiveDict() + if headers: + for header in headers.items(): + # Raise exception on invalid header value. + check_header_validity(header) + name, value = header + self.headers[to_native_string(name)] = value + + def prepare_body(self, data, files, json=None): + """Prepares the given HTTP body data.""" + + # Check if file, fo, generator, iterator. + # If not, run through normal process. + + # Nottin' on you. + body = None + content_type = None + + if not data and json is not None: + # urllib3 requires a bytes-like body. Python 2's json.dumps + # provides this natively, but Python 3 gives a Unicode string. + content_type = "application/json" + + try: + body = complexjson.dumps(json, allow_nan=False) + except ValueError as ve: + raise InvalidJSONError(ve, request=self) + + if not isinstance(body, bytes): + body = body.encode("utf-8") + + is_stream = all( + [ + hasattr(data, "__iter__"), + not isinstance(data, (basestring, list, tuple, Mapping)), + ] + ) + + if is_stream: + try: + length = super_len(data) + except (TypeError, AttributeError, UnsupportedOperation): + length = None + + body = data + + if getattr(body, "tell", None) is not None: + # Record the current file position before reading. + # This will allow us to rewind a file in the event + # of a redirect. + try: + self._body_position = body.tell() + except OSError: + # This differentiates from None, allowing us to catch + # a failed `tell()` later when trying to rewind the body + self._body_position = object() + + if files: + raise NotImplementedError( + "Streamed bodies and files are mutually exclusive." + ) + + if length: + self.headers["Content-Length"] = builtin_str(length) + else: + self.headers["Transfer-Encoding"] = "chunked" + else: + # Multi-part file uploads. + if files: + (body, content_type) = self._encode_files(files, data) + else: + if data: + body = self._encode_params(data) + if isinstance(data, basestring) or hasattr(data, "read"): + content_type = None + else: + content_type = "application/x-www-form-urlencoded" + + self.prepare_content_length(body) + + # Add content-type if it wasn't explicitly provided. + if content_type and ("content-type" not in self.headers): + self.headers["Content-Type"] = content_type + + self.body = body + + def prepare_content_length(self, body): + """Prepare Content-Length header based on request method and body""" + if body is not None: + length = super_len(body) + if length: + # If length exists, set it. Otherwise, we fallback + # to Transfer-Encoding: chunked. + self.headers["Content-Length"] = builtin_str(length) + elif ( + self.method not in ("GET", "HEAD") + and self.headers.get("Content-Length") is None + ): + # Set Content-Length to 0 for methods that can have a body + # but don't provide one. (i.e. not GET or HEAD) + self.headers["Content-Length"] = "0" + + def prepare_auth(self, auth, url=""): + """Prepares the given HTTP auth data.""" + + # If no Auth is explicitly provided, extract it from the URL first. + if auth is None: + url_auth = get_auth_from_url(self.url) + auth = url_auth if any(url_auth) else None + + if auth: + if isinstance(auth, tuple) and len(auth) == 2: + # special-case basic HTTP auth + auth = HTTPBasicAuth(*auth) + + # Allow auth to make its changes. + r = auth(self) + + # Update self to reflect the auth changes. + self.__dict__.update(r.__dict__) + + # Recompute Content-Length + self.prepare_content_length(self.body) + + def prepare_cookies(self, cookies): + """Prepares the given HTTP cookie data. + + This function eventually generates a ``Cookie`` header from the + given cookies using cookielib. Due to cookielib's design, the header + will not be regenerated if it already exists, meaning this function + can only be called once for the life of the + :class:`PreparedRequest ` object. Any subsequent calls + to ``prepare_cookies`` will have no actual effect, unless the "Cookie" + header is removed beforehand. + """ + if isinstance(cookies, cookielib.CookieJar): + self._cookies = cookies + else: + self._cookies = cookiejar_from_dict(cookies) + + cookie_header = get_cookie_header(self._cookies, self) + if cookie_header is not None: + self.headers["Cookie"] = cookie_header + + def prepare_hooks(self, hooks): + """Prepares the given hooks.""" + # hooks can be passed as None to the prepare method and to this + # method. To prevent iterating over None, simply use an empty list + # if hooks is False-y + hooks = hooks or [] + for event in hooks: + self.register_hook(event, hooks[event]) + + +class Response: + """The :class:`Response ` object, which contains a + server's response to an HTTP request. + """ + + __attrs__ = [ + "_content", + "status_code", + "headers", + "url", + "history", + "encoding", + "reason", + "cookies", + "elapsed", + "request", + ] + + def __init__(self): + self._content = False + self._content_consumed = False + self._next = None + + #: Integer Code of responded HTTP Status, e.g. 404 or 200. + self.status_code = None + + #: Case-insensitive Dictionary of Response Headers. + #: For example, ``headers['content-encoding']`` will return the + #: value of a ``'Content-Encoding'`` response header. + self.headers = CaseInsensitiveDict() + + #: File-like object representation of response (for advanced usage). + #: Use of ``raw`` requires that ``stream=True`` be set on the request. + #: This requirement does not apply for use internally to Requests. + self.raw = None + + #: Final URL location of Response. + self.url = None + + #: Encoding to decode with when accessing r.text. + self.encoding = None + + #: A list of :class:`Response ` objects from + #: the history of the Request. Any redirect responses will end + #: up here. The list is sorted from the oldest to the most recent request. + self.history = [] + + #: Textual reason of responded HTTP Status, e.g. "Not Found" or "OK". + self.reason = None + + #: A CookieJar of Cookies the server sent back. + self.cookies = cookiejar_from_dict({}) + + #: The amount of time elapsed between sending the request + #: and the arrival of the response (as a timedelta). + #: This property specifically measures the time taken between sending + #: the first byte of the request and finishing parsing the headers. It + #: is therefore unaffected by consuming the response content or the + #: value of the ``stream`` keyword argument. + self.elapsed = datetime.timedelta(0) + + #: The :class:`PreparedRequest ` object to which this + #: is a response. + self.request = None + + def __enter__(self): + return self + + def __exit__(self, *args): + self.close() + + def __getstate__(self): + # Consume everything; accessing the content attribute makes + # sure the content has been fully read. + if not self._content_consumed: + self.content + + return {attr: getattr(self, attr, None) for attr in self.__attrs__} + + def __setstate__(self, state): + for name, value in state.items(): + setattr(self, name, value) + + # pickled objects do not have .raw + setattr(self, "_content_consumed", True) + setattr(self, "raw", None) + + def __repr__(self): + return f"" + + def __bool__(self): + """Returns True if :attr:`status_code` is less than 400. + + This attribute checks if the status code of the response is between + 400 and 600 to see if there was a client error or a server error. If + the status code, is between 200 and 400, this will return True. This + is **not** a check to see if the response code is ``200 OK``. + """ + return self.ok + + def __nonzero__(self): + """Returns True if :attr:`status_code` is less than 400. + + This attribute checks if the status code of the response is between + 400 and 600 to see if there was a client error or a server error. If + the status code, is between 200 and 400, this will return True. This + is **not** a check to see if the response code is ``200 OK``. + """ + return self.ok + + def __iter__(self): + """Allows you to use a response as an iterator.""" + return self.iter_content(128) + + @property + def ok(self): + """Returns True if :attr:`status_code` is less than 400, False if not. + + This attribute checks if the status code of the response is between + 400 and 600 to see if there was a client error or a server error. If + the status code is between 200 and 400, this will return True. This + is **not** a check to see if the response code is ``200 OK``. + """ + try: + self.raise_for_status() + except HTTPError: + return False + return True + + @property + def is_redirect(self): + """True if this Response is a well-formed HTTP redirect that could have + been processed automatically (by :meth:`Session.resolve_redirects`). + """ + return "location" in self.headers and self.status_code in REDIRECT_STATI + + @property + def is_permanent_redirect(self): + """True if this Response one of the permanent versions of redirect.""" + return "location" in self.headers and self.status_code in ( + codes.moved_permanently, + codes.permanent_redirect, + ) + + @property + def next(self): + """Returns a PreparedRequest for the next request in a redirect chain, if there is one.""" + return self._next + + @property + def apparent_encoding(self): + """The apparent encoding, provided by the charset_normalizer or chardet libraries.""" + if chardet is not None: + return chardet.detect(self.content)["encoding"] + else: + # If no character detection library is available, we'll fall back + # to a standard Python utf-8 str. + return "utf-8" + + def iter_content(self, chunk_size=1, decode_unicode=False): + """Iterates over the response data. When stream=True is set on the + request, this avoids reading the content at once into memory for + large responses. The chunk size is the number of bytes it should + read into memory. This is not necessarily the length of each item + returned as decoding can take place. + + chunk_size must be of type int or None. A value of None will + function differently depending on the value of `stream`. + stream=True will read data as it arrives in whatever size the + chunks are received. If stream=False, data is returned as + a single chunk. + + If decode_unicode is True, content will be decoded using the best + available encoding based on the response. + """ + + def generate(): + # Special case for urllib3. + if hasattr(self.raw, "stream"): + try: + yield from self.raw.stream(chunk_size, decode_content=True) + except ProtocolError as e: + raise ChunkedEncodingError(e) + except DecodeError as e: + raise ContentDecodingError(e) + except ReadTimeoutError as e: + raise ConnectionError(e) + except SSLError as e: + raise RequestsSSLError(e) + else: + # Standard file-like object. + while True: + chunk = self.raw.read(chunk_size) + if not chunk: + break + yield chunk + + self._content_consumed = True + + if self._content_consumed and isinstance(self._content, bool): + raise StreamConsumedError() + elif chunk_size is not None and not isinstance(chunk_size, int): + raise TypeError( + f"chunk_size must be an int, it is instead a {type(chunk_size)}." + ) + # simulate reading small chunks of the content + reused_chunks = iter_slices(self._content, chunk_size) + + stream_chunks = generate() + + chunks = reused_chunks if self._content_consumed else stream_chunks + + if decode_unicode: + chunks = stream_decode_response_unicode(chunks, self) + + return chunks + + def iter_lines( + self, chunk_size=ITER_CHUNK_SIZE, decode_unicode=False, delimiter=None + ): + """Iterates over the response data, one line at a time. When + stream=True is set on the request, this avoids reading the + content at once into memory for large responses. + + .. note:: This method is not reentrant safe. + """ + + pending = None + + for chunk in self.iter_content( + chunk_size=chunk_size, decode_unicode=decode_unicode + ): + if pending is not None: + chunk = pending + chunk + + if delimiter: + lines = chunk.split(delimiter) + else: + lines = chunk.splitlines() + + if lines and lines[-1] and chunk and lines[-1][-1] == chunk[-1]: + pending = lines.pop() + else: + pending = None + + yield from lines + + if pending is not None: + yield pending + + @property + def content(self): + """Content of the response, in bytes.""" + + if self._content is False: + # Read the contents. + if self._content_consumed: + raise RuntimeError("The content for this response was already consumed") + + if self.status_code == 0 or self.raw is None: + self._content = None + else: + self._content = b"".join(self.iter_content(CONTENT_CHUNK_SIZE)) or b"" + + self._content_consumed = True + # don't need to release the connection; that's been handled by urllib3 + # since we exhausted the data. + return self._content + + @property + def text(self): + """Content of the response, in unicode. + + If Response.encoding is None, encoding will be guessed using + ``charset_normalizer`` or ``chardet``. + + The encoding of the response content is determined based solely on HTTP + headers, following RFC 2616 to the letter. If you can take advantage of + non-HTTP knowledge to make a better guess at the encoding, you should + set ``r.encoding`` appropriately before accessing this property. + """ + + # Try charset from content-type + content = None + encoding = self.encoding + + if not self.content: + return "" + + # Fallback to auto-detected encoding. + if self.encoding is None: + encoding = self.apparent_encoding + + # Decode unicode from given encoding. + try: + content = str(self.content, encoding, errors="replace") + except (LookupError, TypeError): + # A LookupError is raised if the encoding was not found which could + # indicate a misspelling or similar mistake. + # + # A TypeError can be raised if encoding is None + # + # So we try blindly encoding. + content = str(self.content, errors="replace") + + return content + + def json(self, **kwargs): + r"""Returns the json-encoded content of a response, if any. + + :param \*\*kwargs: Optional arguments that ``json.loads`` takes. + :raises requests.exceptions.JSONDecodeError: If the response body does not + contain valid json. + """ + + if not self.encoding and self.content and len(self.content) > 3: + # No encoding set. JSON RFC 4627 section 3 states we should expect + # UTF-8, -16 or -32. Detect which one to use; If the detection or + # decoding fails, fall back to `self.text` (using charset_normalizer to make + # a best guess). + encoding = guess_json_utf(self.content) + if encoding is not None: + try: + return complexjson.loads(self.content.decode(encoding), **kwargs) + except UnicodeDecodeError: + # Wrong UTF codec detected; usually because it's not UTF-8 + # but some other 8-bit codec. This is an RFC violation, + # and the server didn't bother to tell us what codec *was* + # used. + pass + except JSONDecodeError as e: + raise RequestsJSONDecodeError(e.msg, e.doc, e.pos) + + try: + return complexjson.loads(self.text, **kwargs) + except JSONDecodeError as e: + # Catch JSON-related errors and raise as requests.JSONDecodeError + # This aliases json.JSONDecodeError and simplejson.JSONDecodeError + raise RequestsJSONDecodeError(e.msg, e.doc, e.pos) + + @property + def links(self): + """Returns the parsed header links of the response, if any.""" + + header = self.headers.get("link") + + resolved_links = {} + + if header: + links = parse_header_links(header) + + for link in links: + key = link.get("rel") or link.get("url") + resolved_links[key] = link + + return resolved_links + + def raise_for_status(self): + """Raises :class:`HTTPError`, if one occurred.""" + + http_error_msg = "" + if isinstance(self.reason, bytes): + # We attempt to decode utf-8 first because some servers + # choose to localize their reason strings. If the string + # isn't utf-8, we fall back to iso-8859-1 for all other + # encodings. (See PR #3538) + try: + reason = self.reason.decode("utf-8") + except UnicodeDecodeError: + reason = self.reason.decode("iso-8859-1") + else: + reason = self.reason + + if 400 <= self.status_code < 500: + http_error_msg = ( + f"{self.status_code} Client Error: {reason} for url: {self.url}" + ) + + elif 500 <= self.status_code < 600: + http_error_msg = ( + f"{self.status_code} Server Error: {reason} for url: {self.url}" + ) + + if http_error_msg: + raise HTTPError(http_error_msg, response=self) + + def close(self): + """Releases the connection back to the pool. Once this method has been + called the underlying ``raw`` object must not be accessed again. + + *Note: Should not normally need to be called explicitly.* + """ + if not self._content_consumed: + self.raw.close() + + release_conn = getattr(self.raw, "release_conn", None) + if release_conn is not None: + release_conn() diff --git a/.venv/lib/python3.11/site-packages/requests/packages.py b/.venv/lib/python3.11/site-packages/requests/packages.py new file mode 100644 index 0000000000000000000000000000000000000000..5ab3d8e250de8475cb22553f564e5444e02c7460 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/requests/packages.py @@ -0,0 +1,23 @@ +import sys + +from .compat import chardet + +# This code exists for backwards compatibility reasons. +# I don't like it either. Just look the other way. :) + +for package in ("urllib3", "idna"): + locals()[package] = __import__(package) + # This traversal is apparently necessary such that the identities are + # preserved (requests.packages.urllib3.* is urllib3.*) + for mod in list(sys.modules): + if mod == package or mod.startswith(f"{package}."): + sys.modules[f"requests.packages.{mod}"] = sys.modules[mod] + +if chardet is not None: + target = chardet.__name__ + for mod in list(sys.modules): + if mod == target or mod.startswith(f"{target}."): + imported_mod = sys.modules[mod] + sys.modules[f"requests.packages.{mod}"] = imported_mod + mod = mod.replace(target, "chardet") + sys.modules[f"requests.packages.{mod}"] = imported_mod diff --git a/.venv/lib/python3.11/site-packages/requests/sessions.py b/.venv/lib/python3.11/site-packages/requests/sessions.py new file mode 100644 index 0000000000000000000000000000000000000000..b387bc36df7bc064b502adcb3c1a4527dd401fda --- /dev/null +++ b/.venv/lib/python3.11/site-packages/requests/sessions.py @@ -0,0 +1,831 @@ +""" +requests.sessions +~~~~~~~~~~~~~~~~~ + +This module provides a Session object to manage and persist settings across +requests (cookies, auth, proxies). +""" +import os +import sys +import time +from collections import OrderedDict +from datetime import timedelta + +from ._internal_utils import to_native_string +from .adapters import HTTPAdapter +from .auth import _basic_auth_str +from .compat import Mapping, cookielib, urljoin, urlparse +from .cookies import ( + RequestsCookieJar, + cookiejar_from_dict, + extract_cookies_to_jar, + merge_cookies, +) +from .exceptions import ( + ChunkedEncodingError, + ContentDecodingError, + InvalidSchema, + TooManyRedirects, +) +from .hooks import default_hooks, dispatch_hook + +# formerly defined here, reexposed here for backward compatibility +from .models import ( # noqa: F401 + DEFAULT_REDIRECT_LIMIT, + REDIRECT_STATI, + PreparedRequest, + Request, +) +from .status_codes import codes +from .structures import CaseInsensitiveDict +from .utils import ( # noqa: F401 + DEFAULT_PORTS, + default_headers, + get_auth_from_url, + get_environ_proxies, + get_netrc_auth, + requote_uri, + resolve_proxies, + rewind_body, + should_bypass_proxies, + to_key_val_list, +) + +# Preferred clock, based on which one is more accurate on a given system. +if sys.platform == "win32": + preferred_clock = time.perf_counter +else: + preferred_clock = time.time + + +def merge_setting(request_setting, session_setting, dict_class=OrderedDict): + """Determines appropriate setting for a given request, taking into account + the explicit setting on that request, and the setting in the session. If a + setting is a dictionary, they will be merged together using `dict_class` + """ + + if session_setting is None: + return request_setting + + if request_setting is None: + return session_setting + + # Bypass if not a dictionary (e.g. verify) + if not ( + isinstance(session_setting, Mapping) and isinstance(request_setting, Mapping) + ): + return request_setting + + merged_setting = dict_class(to_key_val_list(session_setting)) + merged_setting.update(to_key_val_list(request_setting)) + + # Remove keys that are set to None. Extract keys first to avoid altering + # the dictionary during iteration. + none_keys = [k for (k, v) in merged_setting.items() if v is None] + for key in none_keys: + del merged_setting[key] + + return merged_setting + + +def merge_hooks(request_hooks, session_hooks, dict_class=OrderedDict): + """Properly merges both requests and session hooks. + + This is necessary because when request_hooks == {'response': []}, the + merge breaks Session hooks entirely. + """ + if session_hooks is None or session_hooks.get("response") == []: + return request_hooks + + if request_hooks is None or request_hooks.get("response") == []: + return session_hooks + + return merge_setting(request_hooks, session_hooks, dict_class) + + +class SessionRedirectMixin: + def get_redirect_target(self, resp): + """Receives a Response. Returns a redirect URI or ``None``""" + # Due to the nature of how requests processes redirects this method will + # be called at least once upon the original response and at least twice + # on each subsequent redirect response (if any). + # If a custom mixin is used to handle this logic, it may be advantageous + # to cache the redirect location onto the response object as a private + # attribute. + if resp.is_redirect: + location = resp.headers["location"] + # Currently the underlying http module on py3 decode headers + # in latin1, but empirical evidence suggests that latin1 is very + # rarely used with non-ASCII characters in HTTP headers. + # It is more likely to get UTF8 header rather than latin1. + # This causes incorrect handling of UTF8 encoded location headers. + # To solve this, we re-encode the location in latin1. + location = location.encode("latin1") + return to_native_string(location, "utf8") + return None + + def should_strip_auth(self, old_url, new_url): + """Decide whether Authorization header should be removed when redirecting""" + old_parsed = urlparse(old_url) + new_parsed = urlparse(new_url) + if old_parsed.hostname != new_parsed.hostname: + return True + # Special case: allow http -> https redirect when using the standard + # ports. This isn't specified by RFC 7235, but is kept to avoid + # breaking backwards compatibility with older versions of requests + # that allowed any redirects on the same host. + if ( + old_parsed.scheme == "http" + and old_parsed.port in (80, None) + and new_parsed.scheme == "https" + and new_parsed.port in (443, None) + ): + return False + + # Handle default port usage corresponding to scheme. + changed_port = old_parsed.port != new_parsed.port + changed_scheme = old_parsed.scheme != new_parsed.scheme + default_port = (DEFAULT_PORTS.get(old_parsed.scheme, None), None) + if ( + not changed_scheme + and old_parsed.port in default_port + and new_parsed.port in default_port + ): + return False + + # Standard case: root URI must match + return changed_port or changed_scheme + + def resolve_redirects( + self, + resp, + req, + stream=False, + timeout=None, + verify=True, + cert=None, + proxies=None, + yield_requests=False, + **adapter_kwargs, + ): + """Receives a Response. Returns a generator of Responses or Requests.""" + + hist = [] # keep track of history + + url = self.get_redirect_target(resp) + previous_fragment = urlparse(req.url).fragment + while url: + prepared_request = req.copy() + + # Update history and keep track of redirects. + # resp.history must ignore the original request in this loop + hist.append(resp) + resp.history = hist[1:] + + try: + resp.content # Consume socket so it can be released + except (ChunkedEncodingError, ContentDecodingError, RuntimeError): + resp.raw.read(decode_content=False) + + if len(resp.history) >= self.max_redirects: + raise TooManyRedirects( + f"Exceeded {self.max_redirects} redirects.", response=resp + ) + + # Release the connection back into the pool. + resp.close() + + # Handle redirection without scheme (see: RFC 1808 Section 4) + if url.startswith("//"): + parsed_rurl = urlparse(resp.url) + url = ":".join([to_native_string(parsed_rurl.scheme), url]) + + # Normalize url case and attach previous fragment if needed (RFC 7231 7.1.2) + parsed = urlparse(url) + if parsed.fragment == "" and previous_fragment: + parsed = parsed._replace(fragment=previous_fragment) + elif parsed.fragment: + previous_fragment = parsed.fragment + url = parsed.geturl() + + # Facilitate relative 'location' headers, as allowed by RFC 7231. + # (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource') + # Compliant with RFC3986, we percent encode the url. + if not parsed.netloc: + url = urljoin(resp.url, requote_uri(url)) + else: + url = requote_uri(url) + + prepared_request.url = to_native_string(url) + + self.rebuild_method(prepared_request, resp) + + # https://github.com/psf/requests/issues/1084 + if resp.status_code not in ( + codes.temporary_redirect, + codes.permanent_redirect, + ): + # https://github.com/psf/requests/issues/3490 + purged_headers = ("Content-Length", "Content-Type", "Transfer-Encoding") + for header in purged_headers: + prepared_request.headers.pop(header, None) + prepared_request.body = None + + headers = prepared_request.headers + headers.pop("Cookie", None) + + # Extract any cookies sent on the response to the cookiejar + # in the new request. Because we've mutated our copied prepared + # request, use the old one that we haven't yet touched. + extract_cookies_to_jar(prepared_request._cookies, req, resp.raw) + merge_cookies(prepared_request._cookies, self.cookies) + prepared_request.prepare_cookies(prepared_request._cookies) + + # Rebuild auth and proxy information. + proxies = self.rebuild_proxies(prepared_request, proxies) + self.rebuild_auth(prepared_request, resp) + + # A failed tell() sets `_body_position` to `object()`. This non-None + # value ensures `rewindable` will be True, allowing us to raise an + # UnrewindableBodyError, instead of hanging the connection. + rewindable = prepared_request._body_position is not None and ( + "Content-Length" in headers or "Transfer-Encoding" in headers + ) + + # Attempt to rewind consumed file-like object. + if rewindable: + rewind_body(prepared_request) + + # Override the original request. + req = prepared_request + + if yield_requests: + yield req + else: + resp = self.send( + req, + stream=stream, + timeout=timeout, + verify=verify, + cert=cert, + proxies=proxies, + allow_redirects=False, + **adapter_kwargs, + ) + + extract_cookies_to_jar(self.cookies, prepared_request, resp.raw) + + # extract redirect url, if any, for the next loop + url = self.get_redirect_target(resp) + yield resp + + def rebuild_auth(self, prepared_request, response): + """When being redirected we may want to strip authentication from the + request to avoid leaking credentials. This method intelligently removes + and reapplies authentication where possible to avoid credential loss. + """ + headers = prepared_request.headers + url = prepared_request.url + + if "Authorization" in headers and self.should_strip_auth( + response.request.url, url + ): + # If we get redirected to a new host, we should strip out any + # authentication headers. + del headers["Authorization"] + + # .netrc might have more auth for us on our new host. + new_auth = get_netrc_auth(url) if self.trust_env else None + if new_auth is not None: + prepared_request.prepare_auth(new_auth) + + def rebuild_proxies(self, prepared_request, proxies): + """This method re-evaluates the proxy configuration by considering the + environment variables. If we are redirected to a URL covered by + NO_PROXY, we strip the proxy configuration. Otherwise, we set missing + proxy keys for this URL (in case they were stripped by a previous + redirect). + + This method also replaces the Proxy-Authorization header where + necessary. + + :rtype: dict + """ + headers = prepared_request.headers + scheme = urlparse(prepared_request.url).scheme + new_proxies = resolve_proxies(prepared_request, proxies, self.trust_env) + + if "Proxy-Authorization" in headers: + del headers["Proxy-Authorization"] + + try: + username, password = get_auth_from_url(new_proxies[scheme]) + except KeyError: + username, password = None, None + + # urllib3 handles proxy authorization for us in the standard adapter. + # Avoid appending this to TLS tunneled requests where it may be leaked. + if not scheme.startswith("https") and username and password: + headers["Proxy-Authorization"] = _basic_auth_str(username, password) + + return new_proxies + + def rebuild_method(self, prepared_request, response): + """When being redirected we may want to change the method of the request + based on certain specs or browser behavior. + """ + method = prepared_request.method + + # https://tools.ietf.org/html/rfc7231#section-6.4.4 + if response.status_code == codes.see_other and method != "HEAD": + method = "GET" + + # Do what the browsers do, despite standards... + # First, turn 302s into GETs. + if response.status_code == codes.found and method != "HEAD": + method = "GET" + + # Second, if a POST is responded to with a 301, turn it into a GET. + # This bizarre behaviour is explained in Issue 1704. + if response.status_code == codes.moved and method == "POST": + method = "GET" + + prepared_request.method = method + + +class Session(SessionRedirectMixin): + """A Requests session. + + Provides cookie persistence, connection-pooling, and configuration. + + Basic Usage:: + + >>> import requests + >>> s = requests.Session() + >>> s.get('https://httpbin.org/get') + + + Or as a context manager:: + + >>> with requests.Session() as s: + ... s.get('https://httpbin.org/get') + + """ + + __attrs__ = [ + "headers", + "cookies", + "auth", + "proxies", + "hooks", + "params", + "verify", + "cert", + "adapters", + "stream", + "trust_env", + "max_redirects", + ] + + def __init__(self): + #: A case-insensitive dictionary of headers to be sent on each + #: :class:`Request ` sent from this + #: :class:`Session `. + self.headers = default_headers() + + #: Default Authentication tuple or object to attach to + #: :class:`Request `. + self.auth = None + + #: Dictionary mapping protocol or protocol and host to the URL of the proxy + #: (e.g. {'http': 'foo.bar:3128', 'http://host.name': 'foo.bar:4012'}) to + #: be used on each :class:`Request `. + self.proxies = {} + + #: Event-handling hooks. + self.hooks = default_hooks() + + #: Dictionary of querystring data to attach to each + #: :class:`Request `. The dictionary values may be lists for + #: representing multivalued query parameters. + self.params = {} + + #: Stream response content default. + self.stream = False + + #: SSL Verification default. + #: Defaults to `True`, requiring requests to verify the TLS certificate at the + #: remote end. + #: If verify is set to `False`, requests will accept any TLS certificate + #: presented by the server, and will ignore hostname mismatches and/or + #: expired certificates, which will make your application vulnerable to + #: man-in-the-middle (MitM) attacks. + #: Only set this to `False` for testing. + self.verify = True + + #: SSL client certificate default, if String, path to ssl client + #: cert file (.pem). If Tuple, ('cert', 'key') pair. + self.cert = None + + #: Maximum number of redirects allowed. If the request exceeds this + #: limit, a :class:`TooManyRedirects` exception is raised. + #: This defaults to requests.models.DEFAULT_REDIRECT_LIMIT, which is + #: 30. + self.max_redirects = DEFAULT_REDIRECT_LIMIT + + #: Trust environment settings for proxy configuration, default + #: authentication and similar. + self.trust_env = True + + #: A CookieJar containing all currently outstanding cookies set on this + #: session. By default it is a + #: :class:`RequestsCookieJar `, but + #: may be any other ``cookielib.CookieJar`` compatible object. + self.cookies = cookiejar_from_dict({}) + + # Default connection adapters. + self.adapters = OrderedDict() + self.mount("https://", HTTPAdapter()) + self.mount("http://", HTTPAdapter()) + + def __enter__(self): + return self + + def __exit__(self, *args): + self.close() + + def prepare_request(self, request): + """Constructs a :class:`PreparedRequest ` for + transmission and returns it. The :class:`PreparedRequest` has settings + merged from the :class:`Request ` instance and those of the + :class:`Session`. + + :param request: :class:`Request` instance to prepare with this + session's settings. + :rtype: requests.PreparedRequest + """ + cookies = request.cookies or {} + + # Bootstrap CookieJar. + if not isinstance(cookies, cookielib.CookieJar): + cookies = cookiejar_from_dict(cookies) + + # Merge with session cookies + merged_cookies = merge_cookies( + merge_cookies(RequestsCookieJar(), self.cookies), cookies + ) + + # Set environment's basic authentication if not explicitly set. + auth = request.auth + if self.trust_env and not auth and not self.auth: + auth = get_netrc_auth(request.url) + + p = PreparedRequest() + p.prepare( + method=request.method.upper(), + url=request.url, + files=request.files, + data=request.data, + json=request.json, + headers=merge_setting( + request.headers, self.headers, dict_class=CaseInsensitiveDict + ), + params=merge_setting(request.params, self.params), + auth=merge_setting(auth, self.auth), + cookies=merged_cookies, + hooks=merge_hooks(request.hooks, self.hooks), + ) + return p + + def request( + self, + method, + url, + params=None, + data=None, + headers=None, + cookies=None, + files=None, + auth=None, + timeout=None, + allow_redirects=True, + proxies=None, + hooks=None, + stream=None, + verify=None, + cert=None, + json=None, + ): + """Constructs a :class:`Request `, prepares it and sends it. + Returns :class:`Response ` object. + + :param method: method for the new :class:`Request` object. + :param url: URL for the new :class:`Request` object. + :param params: (optional) Dictionary or bytes to be sent in the query + string for the :class:`Request`. + :param data: (optional) Dictionary, list of tuples, bytes, or file-like + object to send in the body of the :class:`Request`. + :param json: (optional) json to send in the body of the + :class:`Request`. + :param headers: (optional) Dictionary of HTTP Headers to send with the + :class:`Request`. + :param cookies: (optional) Dict or CookieJar object to send with the + :class:`Request`. + :param files: (optional) Dictionary of ``'filename': file-like-objects`` + for multipart encoding upload. + :param auth: (optional) Auth tuple or callable to enable + Basic/Digest/Custom HTTP Auth. + :param timeout: (optional) How long to wait for the server to send + data before giving up, as a float, or a :ref:`(connect timeout, + read timeout) ` tuple. + :type timeout: float or tuple + :param allow_redirects: (optional) Set to True by default. + :type allow_redirects: bool + :param proxies: (optional) Dictionary mapping protocol or protocol and + hostname to the URL of the proxy. + :param hooks: (optional) Dictionary mapping hook name to one event or + list of events, event must be callable. + :param stream: (optional) whether to immediately download the response + content. Defaults to ``False``. + :param verify: (optional) Either a boolean, in which case it controls whether we verify + the server's TLS certificate, or a string, in which case it must be a path + to a CA bundle to use. Defaults to ``True``. When set to + ``False``, requests will accept any TLS certificate presented by + the server, and will ignore hostname mismatches and/or expired + certificates, which will make your application vulnerable to + man-in-the-middle (MitM) attacks. Setting verify to ``False`` + may be useful during local development or testing. + :param cert: (optional) if String, path to ssl client cert file (.pem). + If Tuple, ('cert', 'key') pair. + :rtype: requests.Response + """ + # Create the Request. + req = Request( + method=method.upper(), + url=url, + headers=headers, + files=files, + data=data or {}, + json=json, + params=params or {}, + auth=auth, + cookies=cookies, + hooks=hooks, + ) + prep = self.prepare_request(req) + + proxies = proxies or {} + + settings = self.merge_environment_settings( + prep.url, proxies, stream, verify, cert + ) + + # Send the request. + send_kwargs = { + "timeout": timeout, + "allow_redirects": allow_redirects, + } + send_kwargs.update(settings) + resp = self.send(prep, **send_kwargs) + + return resp + + def get(self, url, **kwargs): + r"""Sends a GET request. Returns :class:`Response` object. + + :param url: URL for the new :class:`Request` object. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :rtype: requests.Response + """ + + kwargs.setdefault("allow_redirects", True) + return self.request("GET", url, **kwargs) + + def options(self, url, **kwargs): + r"""Sends a OPTIONS request. Returns :class:`Response` object. + + :param url: URL for the new :class:`Request` object. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :rtype: requests.Response + """ + + kwargs.setdefault("allow_redirects", True) + return self.request("OPTIONS", url, **kwargs) + + def head(self, url, **kwargs): + r"""Sends a HEAD request. Returns :class:`Response` object. + + :param url: URL for the new :class:`Request` object. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :rtype: requests.Response + """ + + kwargs.setdefault("allow_redirects", False) + return self.request("HEAD", url, **kwargs) + + def post(self, url, data=None, json=None, **kwargs): + r"""Sends a POST request. Returns :class:`Response` object. + + :param url: URL for the new :class:`Request` object. + :param data: (optional) Dictionary, list of tuples, bytes, or file-like + object to send in the body of the :class:`Request`. + :param json: (optional) json to send in the body of the :class:`Request`. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :rtype: requests.Response + """ + + return self.request("POST", url, data=data, json=json, **kwargs) + + def put(self, url, data=None, **kwargs): + r"""Sends a PUT request. Returns :class:`Response` object. + + :param url: URL for the new :class:`Request` object. + :param data: (optional) Dictionary, list of tuples, bytes, or file-like + object to send in the body of the :class:`Request`. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :rtype: requests.Response + """ + + return self.request("PUT", url, data=data, **kwargs) + + def patch(self, url, data=None, **kwargs): + r"""Sends a PATCH request. Returns :class:`Response` object. + + :param url: URL for the new :class:`Request` object. + :param data: (optional) Dictionary, list of tuples, bytes, or file-like + object to send in the body of the :class:`Request`. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :rtype: requests.Response + """ + + return self.request("PATCH", url, data=data, **kwargs) + + def delete(self, url, **kwargs): + r"""Sends a DELETE request. Returns :class:`Response` object. + + :param url: URL for the new :class:`Request` object. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :rtype: requests.Response + """ + + return self.request("DELETE", url, **kwargs) + + def send(self, request, **kwargs): + """Send a given PreparedRequest. + + :rtype: requests.Response + """ + # Set defaults that the hooks can utilize to ensure they always have + # the correct parameters to reproduce the previous request. + kwargs.setdefault("stream", self.stream) + kwargs.setdefault("verify", self.verify) + kwargs.setdefault("cert", self.cert) + if "proxies" not in kwargs: + kwargs["proxies"] = resolve_proxies(request, self.proxies, self.trust_env) + + # It's possible that users might accidentally send a Request object. + # Guard against that specific failure case. + if isinstance(request, Request): + raise ValueError("You can only send PreparedRequests.") + + # Set up variables needed for resolve_redirects and dispatching of hooks + allow_redirects = kwargs.pop("allow_redirects", True) + stream = kwargs.get("stream") + hooks = request.hooks + + # Get the appropriate adapter to use + adapter = self.get_adapter(url=request.url) + + # Start time (approximately) of the request + start = preferred_clock() + + # Send the request + r = adapter.send(request, **kwargs) + + # Total elapsed time of the request (approximately) + elapsed = preferred_clock() - start + r.elapsed = timedelta(seconds=elapsed) + + # Response manipulation hooks + r = dispatch_hook("response", hooks, r, **kwargs) + + # Persist cookies + if r.history: + # If the hooks create history then we want those cookies too + for resp in r.history: + extract_cookies_to_jar(self.cookies, resp.request, resp.raw) + + extract_cookies_to_jar(self.cookies, request, r.raw) + + # Resolve redirects if allowed. + if allow_redirects: + # Redirect resolving generator. + gen = self.resolve_redirects(r, request, **kwargs) + history = [resp for resp in gen] + else: + history = [] + + # Shuffle things around if there's history. + if history: + # Insert the first (original) request at the start + history.insert(0, r) + # Get the last request made + r = history.pop() + r.history = history + + # If redirects aren't being followed, store the response on the Request for Response.next(). + if not allow_redirects: + try: + r._next = next( + self.resolve_redirects(r, request, yield_requests=True, **kwargs) + ) + except StopIteration: + pass + + if not stream: + r.content + + return r + + def merge_environment_settings(self, url, proxies, stream, verify, cert): + """ + Check the environment and merge it with some settings. + + :rtype: dict + """ + # Gather clues from the surrounding environment. + if self.trust_env: + # Set environment's proxies. + no_proxy = proxies.get("no_proxy") if proxies is not None else None + env_proxies = get_environ_proxies(url, no_proxy=no_proxy) + for k, v in env_proxies.items(): + proxies.setdefault(k, v) + + # Look for requests environment configuration + # and be compatible with cURL. + if verify is True or verify is None: + verify = ( + os.environ.get("REQUESTS_CA_BUNDLE") + or os.environ.get("CURL_CA_BUNDLE") + or verify + ) + + # Merge all the kwargs. + proxies = merge_setting(proxies, self.proxies) + stream = merge_setting(stream, self.stream) + verify = merge_setting(verify, self.verify) + cert = merge_setting(cert, self.cert) + + return {"proxies": proxies, "stream": stream, "verify": verify, "cert": cert} + + def get_adapter(self, url): + """ + Returns the appropriate connection adapter for the given URL. + + :rtype: requests.adapters.BaseAdapter + """ + for prefix, adapter in self.adapters.items(): + if url.lower().startswith(prefix.lower()): + return adapter + + # Nothing matches :-/ + raise InvalidSchema(f"No connection adapters were found for {url!r}") + + def close(self): + """Closes all adapters and as such the session""" + for v in self.adapters.values(): + v.close() + + def mount(self, prefix, adapter): + """Registers a connection adapter to a prefix. + + Adapters are sorted in descending order by prefix length. + """ + self.adapters[prefix] = adapter + keys_to_move = [k for k in self.adapters if len(k) < len(prefix)] + + for key in keys_to_move: + self.adapters[key] = self.adapters.pop(key) + + def __getstate__(self): + state = {attr: getattr(self, attr, None) for attr in self.__attrs__} + return state + + def __setstate__(self, state): + for attr, value in state.items(): + setattr(self, attr, value) + + +def session(): + """ + Returns a :class:`Session` for context-management. + + .. deprecated:: 1.0.0 + + This method has been deprecated since version 1.0.0 and is only kept for + backwards compatibility. New code should use :class:`~requests.sessions.Session` + to create a session. This may be removed at a future date. + + :rtype: Session + """ + return Session() diff --git a/.venv/lib/python3.11/site-packages/requests/status_codes.py b/.venv/lib/python3.11/site-packages/requests/status_codes.py new file mode 100644 index 0000000000000000000000000000000000000000..c7945a2f06897ed980cc575df2f48d9e6c1a9f7e --- /dev/null +++ b/.venv/lib/python3.11/site-packages/requests/status_codes.py @@ -0,0 +1,128 @@ +r""" +The ``codes`` object defines a mapping from common names for HTTP statuses +to their numerical codes, accessible either as attributes or as dictionary +items. + +Example:: + + >>> import requests + >>> requests.codes['temporary_redirect'] + 307 + >>> requests.codes.teapot + 418 + >>> requests.codes['\o/'] + 200 + +Some codes have multiple names, and both upper- and lower-case versions of +the names are allowed. For example, ``codes.ok``, ``codes.OK``, and +``codes.okay`` all correspond to the HTTP status code 200. +""" + +from .structures import LookupDict + +_codes = { + # Informational. + 100: ("continue",), + 101: ("switching_protocols",), + 102: ("processing", "early-hints"), + 103: ("checkpoint",), + 122: ("uri_too_long", "request_uri_too_long"), + 200: ("ok", "okay", "all_ok", "all_okay", "all_good", "\\o/", "✓"), + 201: ("created",), + 202: ("accepted",), + 203: ("non_authoritative_info", "non_authoritative_information"), + 204: ("no_content",), + 205: ("reset_content", "reset"), + 206: ("partial_content", "partial"), + 207: ("multi_status", "multiple_status", "multi_stati", "multiple_stati"), + 208: ("already_reported",), + 226: ("im_used",), + # Redirection. + 300: ("multiple_choices",), + 301: ("moved_permanently", "moved", "\\o-"), + 302: ("found",), + 303: ("see_other", "other"), + 304: ("not_modified",), + 305: ("use_proxy",), + 306: ("switch_proxy",), + 307: ("temporary_redirect", "temporary_moved", "temporary"), + 308: ( + "permanent_redirect", + "resume_incomplete", + "resume", + ), # "resume" and "resume_incomplete" to be removed in 3.0 + # Client Error. + 400: ("bad_request", "bad"), + 401: ("unauthorized",), + 402: ("payment_required", "payment"), + 403: ("forbidden",), + 404: ("not_found", "-o-"), + 405: ("method_not_allowed", "not_allowed"), + 406: ("not_acceptable",), + 407: ("proxy_authentication_required", "proxy_auth", "proxy_authentication"), + 408: ("request_timeout", "timeout"), + 409: ("conflict",), + 410: ("gone",), + 411: ("length_required",), + 412: ("precondition_failed", "precondition"), + 413: ("request_entity_too_large", "content_too_large"), + 414: ("request_uri_too_large", "uri_too_long"), + 415: ("unsupported_media_type", "unsupported_media", "media_type"), + 416: ( + "requested_range_not_satisfiable", + "requested_range", + "range_not_satisfiable", + ), + 417: ("expectation_failed",), + 418: ("im_a_teapot", "teapot", "i_am_a_teapot"), + 421: ("misdirected_request",), + 422: ("unprocessable_entity", "unprocessable", "unprocessable_content"), + 423: ("locked",), + 424: ("failed_dependency", "dependency"), + 425: ("unordered_collection", "unordered", "too_early"), + 426: ("upgrade_required", "upgrade"), + 428: ("precondition_required", "precondition"), + 429: ("too_many_requests", "too_many"), + 431: ("header_fields_too_large", "fields_too_large"), + 444: ("no_response", "none"), + 449: ("retry_with", "retry"), + 450: ("blocked_by_windows_parental_controls", "parental_controls"), + 451: ("unavailable_for_legal_reasons", "legal_reasons"), + 499: ("client_closed_request",), + # Server Error. + 500: ("internal_server_error", "server_error", "/o\\", "✗"), + 501: ("not_implemented",), + 502: ("bad_gateway",), + 503: ("service_unavailable", "unavailable"), + 504: ("gateway_timeout",), + 505: ("http_version_not_supported", "http_version"), + 506: ("variant_also_negotiates",), + 507: ("insufficient_storage",), + 509: ("bandwidth_limit_exceeded", "bandwidth"), + 510: ("not_extended",), + 511: ("network_authentication_required", "network_auth", "network_authentication"), +} + +codes = LookupDict(name="status_codes") + + +def _init(): + for code, titles in _codes.items(): + for title in titles: + setattr(codes, title, code) + if not title.startswith(("\\", "/")): + setattr(codes, title.upper(), code) + + def doc(code): + names = ", ".join(f"``{n}``" for n in _codes[code]) + return "* %d: %s" % (code, names) + + global __doc__ + __doc__ = ( + __doc__ + "\n" + "\n".join(doc(code) for code in sorted(_codes)) + if __doc__ is not None + else None + ) + + +_init() diff --git a/.venv/lib/python3.11/site-packages/requests/structures.py b/.venv/lib/python3.11/site-packages/requests/structures.py new file mode 100644 index 0000000000000000000000000000000000000000..188e13e4829591facb23ae0e2eda84b9807cb818 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/requests/structures.py @@ -0,0 +1,99 @@ +""" +requests.structures +~~~~~~~~~~~~~~~~~~~ + +Data structures that power Requests. +""" + +from collections import OrderedDict + +from .compat import Mapping, MutableMapping + + +class CaseInsensitiveDict(MutableMapping): + """A case-insensitive ``dict``-like object. + + Implements all methods and operations of + ``MutableMapping`` as well as dict's ``copy``. Also + provides ``lower_items``. + + All keys are expected to be strings. The structure remembers the + case of the last key to be set, and ``iter(instance)``, + ``keys()``, ``items()``, ``iterkeys()``, and ``iteritems()`` + will contain case-sensitive keys. However, querying and contains + testing is case insensitive:: + + cid = CaseInsensitiveDict() + cid['Accept'] = 'application/json' + cid['aCCEPT'] == 'application/json' # True + list(cid) == ['Accept'] # True + + For example, ``headers['content-encoding']`` will return the + value of a ``'Content-Encoding'`` response header, regardless + of how the header name was originally stored. + + If the constructor, ``.update``, or equality comparison + operations are given keys that have equal ``.lower()``s, the + behavior is undefined. + """ + + def __init__(self, data=None, **kwargs): + self._store = OrderedDict() + if data is None: + data = {} + self.update(data, **kwargs) + + def __setitem__(self, key, value): + # Use the lowercased key for lookups, but store the actual + # key alongside the value. + self._store[key.lower()] = (key, value) + + def __getitem__(self, key): + return self._store[key.lower()][1] + + def __delitem__(self, key): + del self._store[key.lower()] + + def __iter__(self): + return (casedkey for casedkey, mappedvalue in self._store.values()) + + def __len__(self): + return len(self._store) + + def lower_items(self): + """Like iteritems(), but with all lowercase keys.""" + return ((lowerkey, keyval[1]) for (lowerkey, keyval) in self._store.items()) + + def __eq__(self, other): + if isinstance(other, Mapping): + other = CaseInsensitiveDict(other) + else: + return NotImplemented + # Compare insensitively + return dict(self.lower_items()) == dict(other.lower_items()) + + # Copy is required + def copy(self): + return CaseInsensitiveDict(self._store.values()) + + def __repr__(self): + return str(dict(self.items())) + + +class LookupDict(dict): + """Dictionary lookup object.""" + + def __init__(self, name=None): + self.name = name + super().__init__() + + def __repr__(self): + return f"" + + def __getitem__(self, key): + # We allow fall-through here, so values default to None + + return self.__dict__.get(key, None) + + def get(self, key, default=None): + return self.__dict__.get(key, default) diff --git a/.venv/lib/python3.11/site-packages/requests/utils.py b/.venv/lib/python3.11/site-packages/requests/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..ae6c42f6cb48d2beaa3b7352bc1d130db3e4e3be --- /dev/null +++ b/.venv/lib/python3.11/site-packages/requests/utils.py @@ -0,0 +1,1096 @@ +""" +requests.utils +~~~~~~~~~~~~~~ + +This module provides utility functions that are used within Requests +that are also useful for external consumption. +""" + +import codecs +import contextlib +import io +import os +import re +import socket +import struct +import sys +import tempfile +import warnings +import zipfile +from collections import OrderedDict + +from urllib3.util import make_headers, parse_url + +from . import certs +from .__version__ import __version__ + +# to_native_string is unused here, but imported here for backwards compatibility +from ._internal_utils import ( # noqa: F401 + _HEADER_VALIDATORS_BYTE, + _HEADER_VALIDATORS_STR, + HEADER_VALIDATORS, + to_native_string, +) +from .compat import ( + Mapping, + basestring, + bytes, + getproxies, + getproxies_environment, + integer_types, +) +from .compat import parse_http_list as _parse_list_header +from .compat import ( + proxy_bypass, + proxy_bypass_environment, + quote, + str, + unquote, + urlparse, + urlunparse, +) +from .cookies import cookiejar_from_dict +from .exceptions import ( + FileModeWarning, + InvalidHeader, + InvalidURL, + UnrewindableBodyError, +) +from .structures import CaseInsensitiveDict + +NETRC_FILES = (".netrc", "_netrc") + +DEFAULT_CA_BUNDLE_PATH = certs.where() + +DEFAULT_PORTS = {"http": 80, "https": 443} + +# Ensure that ', ' is used to preserve previous delimiter behavior. +DEFAULT_ACCEPT_ENCODING = ", ".join( + re.split(r",\s*", make_headers(accept_encoding=True)["accept-encoding"]) +) + + +if sys.platform == "win32": + # provide a proxy_bypass version on Windows without DNS lookups + + def proxy_bypass_registry(host): + try: + import winreg + except ImportError: + return False + + try: + internetSettings = winreg.OpenKey( + winreg.HKEY_CURRENT_USER, + r"Software\Microsoft\Windows\CurrentVersion\Internet Settings", + ) + # ProxyEnable could be REG_SZ or REG_DWORD, normalizing it + proxyEnable = int(winreg.QueryValueEx(internetSettings, "ProxyEnable")[0]) + # ProxyOverride is almost always a string + proxyOverride = winreg.QueryValueEx(internetSettings, "ProxyOverride")[0] + except (OSError, ValueError): + return False + if not proxyEnable or not proxyOverride: + return False + + # make a check value list from the registry entry: replace the + # '' string by the localhost entry and the corresponding + # canonical entry. + proxyOverride = proxyOverride.split(";") + # filter out empty strings to avoid re.match return true in the following code. + proxyOverride = filter(None, proxyOverride) + # now check if we match one of the registry values. + for test in proxyOverride: + if test == "": + if "." not in host: + return True + test = test.replace(".", r"\.") # mask dots + test = test.replace("*", r".*") # change glob sequence + test = test.replace("?", r".") # change glob char + if re.match(test, host, re.I): + return True + return False + + def proxy_bypass(host): # noqa + """Return True, if the host should be bypassed. + + Checks proxy settings gathered from the environment, if specified, + or the registry. + """ + if getproxies_environment(): + return proxy_bypass_environment(host) + else: + return proxy_bypass_registry(host) + + +def dict_to_sequence(d): + """Returns an internal sequence dictionary update.""" + + if hasattr(d, "items"): + d = d.items() + + return d + + +def super_len(o): + total_length = None + current_position = 0 + + if isinstance(o, str): + o = o.encode("utf-8") + + if hasattr(o, "__len__"): + total_length = len(o) + + elif hasattr(o, "len"): + total_length = o.len + + elif hasattr(o, "fileno"): + try: + fileno = o.fileno() + except (io.UnsupportedOperation, AttributeError): + # AttributeError is a surprising exception, seeing as how we've just checked + # that `hasattr(o, 'fileno')`. It happens for objects obtained via + # `Tarfile.extractfile()`, per issue 5229. + pass + else: + total_length = os.fstat(fileno).st_size + + # Having used fstat to determine the file length, we need to + # confirm that this file was opened up in binary mode. + if "b" not in o.mode: + warnings.warn( + ( + "Requests has determined the content-length for this " + "request using the binary size of the file: however, the " + "file has been opened in text mode (i.e. without the 'b' " + "flag in the mode). This may lead to an incorrect " + "content-length. In Requests 3.0, support will be removed " + "for files in text mode." + ), + FileModeWarning, + ) + + if hasattr(o, "tell"): + try: + current_position = o.tell() + except OSError: + # This can happen in some weird situations, such as when the file + # is actually a special file descriptor like stdin. In this + # instance, we don't know what the length is, so set it to zero and + # let requests chunk it instead. + if total_length is not None: + current_position = total_length + else: + if hasattr(o, "seek") and total_length is None: + # StringIO and BytesIO have seek but no usable fileno + try: + # seek to end of file + o.seek(0, 2) + total_length = o.tell() + + # seek back to current position to support + # partially read file-like objects + o.seek(current_position or 0) + except OSError: + total_length = 0 + + if total_length is None: + total_length = 0 + + return max(0, total_length - current_position) + + +def get_netrc_auth(url, raise_errors=False): + """Returns the Requests tuple auth for a given url from netrc.""" + + netrc_file = os.environ.get("NETRC") + if netrc_file is not None: + netrc_locations = (netrc_file,) + else: + netrc_locations = (f"~/{f}" for f in NETRC_FILES) + + try: + from netrc import NetrcParseError, netrc + + netrc_path = None + + for f in netrc_locations: + try: + loc = os.path.expanduser(f) + except KeyError: + # os.path.expanduser can fail when $HOME is undefined and + # getpwuid fails. See https://bugs.python.org/issue20164 & + # https://github.com/psf/requests/issues/1846 + return + + if os.path.exists(loc): + netrc_path = loc + break + + # Abort early if there isn't one. + if netrc_path is None: + return + + ri = urlparse(url) + + # Strip port numbers from netloc. This weird `if...encode`` dance is + # used for Python 3.2, which doesn't support unicode literals. + splitstr = b":" + if isinstance(url, str): + splitstr = splitstr.decode("ascii") + host = ri.netloc.split(splitstr)[0] + + try: + _netrc = netrc(netrc_path).authenticators(host) + if _netrc: + # Return with login / password + login_i = 0 if _netrc[0] else 1 + return (_netrc[login_i], _netrc[2]) + except (NetrcParseError, OSError): + # If there was a parsing error or a permissions issue reading the file, + # we'll just skip netrc auth unless explicitly asked to raise errors. + if raise_errors: + raise + + # App Engine hackiness. + except (ImportError, AttributeError): + pass + + +def guess_filename(obj): + """Tries to guess the filename of the given object.""" + name = getattr(obj, "name", None) + if name and isinstance(name, basestring) and name[0] != "<" and name[-1] != ">": + return os.path.basename(name) + + +def extract_zipped_paths(path): + """Replace nonexistent paths that look like they refer to a member of a zip + archive with the location of an extracted copy of the target, or else + just return the provided path unchanged. + """ + if os.path.exists(path): + # this is already a valid path, no need to do anything further + return path + + # find the first valid part of the provided path and treat that as a zip archive + # assume the rest of the path is the name of a member in the archive + archive, member = os.path.split(path) + while archive and not os.path.exists(archive): + archive, prefix = os.path.split(archive) + if not prefix: + # If we don't check for an empty prefix after the split (in other words, archive remains unchanged after the split), + # we _can_ end up in an infinite loop on a rare corner case affecting a small number of users + break + member = "/".join([prefix, member]) + + if not zipfile.is_zipfile(archive): + return path + + zip_file = zipfile.ZipFile(archive) + if member not in zip_file.namelist(): + return path + + # we have a valid zip archive and a valid member of that archive + tmp = tempfile.gettempdir() + extracted_path = os.path.join(tmp, member.split("/")[-1]) + if not os.path.exists(extracted_path): + # use read + write to avoid the creating nested folders, we only want the file, avoids mkdir racing condition + with atomic_open(extracted_path) as file_handler: + file_handler.write(zip_file.read(member)) + return extracted_path + + +@contextlib.contextmanager +def atomic_open(filename): + """Write a file to the disk in an atomic fashion""" + tmp_descriptor, tmp_name = tempfile.mkstemp(dir=os.path.dirname(filename)) + try: + with os.fdopen(tmp_descriptor, "wb") as tmp_handler: + yield tmp_handler + os.replace(tmp_name, filename) + except BaseException: + os.remove(tmp_name) + raise + + +def from_key_val_list(value): + """Take an object and test to see if it can be represented as a + dictionary. Unless it can not be represented as such, return an + OrderedDict, e.g., + + :: + + >>> from_key_val_list([('key', 'val')]) + OrderedDict([('key', 'val')]) + >>> from_key_val_list('string') + Traceback (most recent call last): + ... + ValueError: cannot encode objects that are not 2-tuples + >>> from_key_val_list({'key': 'val'}) + OrderedDict([('key', 'val')]) + + :rtype: OrderedDict + """ + if value is None: + return None + + if isinstance(value, (str, bytes, bool, int)): + raise ValueError("cannot encode objects that are not 2-tuples") + + return OrderedDict(value) + + +def to_key_val_list(value): + """Take an object and test to see if it can be represented as a + dictionary. If it can be, return a list of tuples, e.g., + + :: + + >>> to_key_val_list([('key', 'val')]) + [('key', 'val')] + >>> to_key_val_list({'key': 'val'}) + [('key', 'val')] + >>> to_key_val_list('string') + Traceback (most recent call last): + ... + ValueError: cannot encode objects that are not 2-tuples + + :rtype: list + """ + if value is None: + return None + + if isinstance(value, (str, bytes, bool, int)): + raise ValueError("cannot encode objects that are not 2-tuples") + + if isinstance(value, Mapping): + value = value.items() + + return list(value) + + +# From mitsuhiko/werkzeug (used with permission). +def parse_list_header(value): + """Parse lists as described by RFC 2068 Section 2. + + In particular, parse comma-separated lists where the elements of + the list may include quoted-strings. A quoted-string could + contain a comma. A non-quoted string could have quotes in the + middle. Quotes are removed automatically after parsing. + + It basically works like :func:`parse_set_header` just that items + may appear multiple times and case sensitivity is preserved. + + The return value is a standard :class:`list`: + + >>> parse_list_header('token, "quoted value"') + ['token', 'quoted value'] + + To create a header from the :class:`list` again, use the + :func:`dump_header` function. + + :param value: a string with a list header. + :return: :class:`list` + :rtype: list + """ + result = [] + for item in _parse_list_header(value): + if item[:1] == item[-1:] == '"': + item = unquote_header_value(item[1:-1]) + result.append(item) + return result + + +# From mitsuhiko/werkzeug (used with permission). +def parse_dict_header(value): + """Parse lists of key, value pairs as described by RFC 2068 Section 2 and + convert them into a python dict: + + >>> d = parse_dict_header('foo="is a fish", bar="as well"') + >>> type(d) is dict + True + >>> sorted(d.items()) + [('bar', 'as well'), ('foo', 'is a fish')] + + If there is no value for a key it will be `None`: + + >>> parse_dict_header('key_without_value') + {'key_without_value': None} + + To create a header from the :class:`dict` again, use the + :func:`dump_header` function. + + :param value: a string with a dict header. + :return: :class:`dict` + :rtype: dict + """ + result = {} + for item in _parse_list_header(value): + if "=" not in item: + result[item] = None + continue + name, value = item.split("=", 1) + if value[:1] == value[-1:] == '"': + value = unquote_header_value(value[1:-1]) + result[name] = value + return result + + +# From mitsuhiko/werkzeug (used with permission). +def unquote_header_value(value, is_filename=False): + r"""Unquotes a header value. (Reversal of :func:`quote_header_value`). + This does not use the real unquoting but what browsers are actually + using for quoting. + + :param value: the header value to unquote. + :rtype: str + """ + if value and value[0] == value[-1] == '"': + # this is not the real unquoting, but fixing this so that the + # RFC is met will result in bugs with internet explorer and + # probably some other browsers as well. IE for example is + # uploading files with "C:\foo\bar.txt" as filename + value = value[1:-1] + + # if this is a filename and the starting characters look like + # a UNC path, then just return the value without quotes. Using the + # replace sequence below on a UNC path has the effect of turning + # the leading double slash into a single slash and then + # _fix_ie_filename() doesn't work correctly. See #458. + if not is_filename or value[:2] != "\\\\": + return value.replace("\\\\", "\\").replace('\\"', '"') + return value + + +def dict_from_cookiejar(cj): + """Returns a key/value dictionary from a CookieJar. + + :param cj: CookieJar object to extract cookies from. + :rtype: dict + """ + + cookie_dict = {cookie.name: cookie.value for cookie in cj} + return cookie_dict + + +def add_dict_to_cookiejar(cj, cookie_dict): + """Returns a CookieJar from a key/value dictionary. + + :param cj: CookieJar to insert cookies into. + :param cookie_dict: Dict of key/values to insert into CookieJar. + :rtype: CookieJar + """ + + return cookiejar_from_dict(cookie_dict, cj) + + +def get_encodings_from_content(content): + """Returns encodings from given content string. + + :param content: bytestring to extract encodings from. + """ + warnings.warn( + ( + "In requests 3.0, get_encodings_from_content will be removed. For " + "more information, please see the discussion on issue #2266. (This" + " warning should only appear once.)" + ), + DeprecationWarning, + ) + + charset_re = re.compile(r']', flags=re.I) + pragma_re = re.compile(r']', flags=re.I) + xml_re = re.compile(r'^<\?xml.*?encoding=["\']*(.+?)["\'>]') + + return ( + charset_re.findall(content) + + pragma_re.findall(content) + + xml_re.findall(content) + ) + + +def _parse_content_type_header(header): + """Returns content type and parameters from given header + + :param header: string + :return: tuple containing content type and dictionary of + parameters + """ + + tokens = header.split(";") + content_type, params = tokens[0].strip(), tokens[1:] + params_dict = {} + items_to_strip = "\"' " + + for param in params: + param = param.strip() + if param: + key, value = param, True + index_of_equals = param.find("=") + if index_of_equals != -1: + key = param[:index_of_equals].strip(items_to_strip) + value = param[index_of_equals + 1 :].strip(items_to_strip) + params_dict[key.lower()] = value + return content_type, params_dict + + +def get_encoding_from_headers(headers): + """Returns encodings from given HTTP Header Dict. + + :param headers: dictionary to extract encoding from. + :rtype: str + """ + + content_type = headers.get("content-type") + + if not content_type: + return None + + content_type, params = _parse_content_type_header(content_type) + + if "charset" in params: + return params["charset"].strip("'\"") + + if "text" in content_type: + return "ISO-8859-1" + + if "application/json" in content_type: + # Assume UTF-8 based on RFC 4627: https://www.ietf.org/rfc/rfc4627.txt since the charset was unset + return "utf-8" + + +def stream_decode_response_unicode(iterator, r): + """Stream decodes an iterator.""" + + if r.encoding is None: + yield from iterator + return + + decoder = codecs.getincrementaldecoder(r.encoding)(errors="replace") + for chunk in iterator: + rv = decoder.decode(chunk) + if rv: + yield rv + rv = decoder.decode(b"", final=True) + if rv: + yield rv + + +def iter_slices(string, slice_length): + """Iterate over slices of a string.""" + pos = 0 + if slice_length is None or slice_length <= 0: + slice_length = len(string) + while pos < len(string): + yield string[pos : pos + slice_length] + pos += slice_length + + +def get_unicode_from_response(r): + """Returns the requested content back in unicode. + + :param r: Response object to get unicode content from. + + Tried: + + 1. charset from content-type + 2. fall back and replace all unicode characters + + :rtype: str + """ + warnings.warn( + ( + "In requests 3.0, get_unicode_from_response will be removed. For " + "more information, please see the discussion on issue #2266. (This" + " warning should only appear once.)" + ), + DeprecationWarning, + ) + + tried_encodings = [] + + # Try charset from content-type + encoding = get_encoding_from_headers(r.headers) + + if encoding: + try: + return str(r.content, encoding) + except UnicodeError: + tried_encodings.append(encoding) + + # Fall back: + try: + return str(r.content, encoding, errors="replace") + except TypeError: + return r.content + + +# The unreserved URI characters (RFC 3986) +UNRESERVED_SET = frozenset( + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789-._~" +) + + +def unquote_unreserved(uri): + """Un-escape any percent-escape sequences in a URI that are unreserved + characters. This leaves all reserved, illegal and non-ASCII bytes encoded. + + :rtype: str + """ + parts = uri.split("%") + for i in range(1, len(parts)): + h = parts[i][0:2] + if len(h) == 2 and h.isalnum(): + try: + c = chr(int(h, 16)) + except ValueError: + raise InvalidURL(f"Invalid percent-escape sequence: '{h}'") + + if c in UNRESERVED_SET: + parts[i] = c + parts[i][2:] + else: + parts[i] = f"%{parts[i]}" + else: + parts[i] = f"%{parts[i]}" + return "".join(parts) + + +def requote_uri(uri): + """Re-quote the given URI. + + This function passes the given URI through an unquote/quote cycle to + ensure that it is fully and consistently quoted. + + :rtype: str + """ + safe_with_percent = "!#$%&'()*+,/:;=?@[]~" + safe_without_percent = "!#$&'()*+,/:;=?@[]~" + try: + # Unquote only the unreserved characters + # Then quote only illegal characters (do not quote reserved, + # unreserved, or '%') + return quote(unquote_unreserved(uri), safe=safe_with_percent) + except InvalidURL: + # We couldn't unquote the given URI, so let's try quoting it, but + # there may be unquoted '%'s in the URI. We need to make sure they're + # properly quoted so they do not cause issues elsewhere. + return quote(uri, safe=safe_without_percent) + + +def address_in_network(ip, net): + """This function allows you to check if an IP belongs to a network subnet + + Example: returns True if ip = 192.168.1.1 and net = 192.168.1.0/24 + returns False if ip = 192.168.1.1 and net = 192.168.100.0/24 + + :rtype: bool + """ + ipaddr = struct.unpack("=L", socket.inet_aton(ip))[0] + netaddr, bits = net.split("/") + netmask = struct.unpack("=L", socket.inet_aton(dotted_netmask(int(bits))))[0] + network = struct.unpack("=L", socket.inet_aton(netaddr))[0] & netmask + return (ipaddr & netmask) == (network & netmask) + + +def dotted_netmask(mask): + """Converts mask from /xx format to xxx.xxx.xxx.xxx + + Example: if mask is 24 function returns 255.255.255.0 + + :rtype: str + """ + bits = 0xFFFFFFFF ^ (1 << 32 - mask) - 1 + return socket.inet_ntoa(struct.pack(">I", bits)) + + +def is_ipv4_address(string_ip): + """ + :rtype: bool + """ + try: + socket.inet_aton(string_ip) + except OSError: + return False + return True + + +def is_valid_cidr(string_network): + """ + Very simple check of the cidr format in no_proxy variable. + + :rtype: bool + """ + if string_network.count("/") == 1: + try: + mask = int(string_network.split("/")[1]) + except ValueError: + return False + + if mask < 1 or mask > 32: + return False + + try: + socket.inet_aton(string_network.split("/")[0]) + except OSError: + return False + else: + return False + return True + + +@contextlib.contextmanager +def set_environ(env_name, value): + """Set the environment variable 'env_name' to 'value' + + Save previous value, yield, and then restore the previous value stored in + the environment variable 'env_name'. + + If 'value' is None, do nothing""" + value_changed = value is not None + if value_changed: + old_value = os.environ.get(env_name) + os.environ[env_name] = value + try: + yield + finally: + if value_changed: + if old_value is None: + del os.environ[env_name] + else: + os.environ[env_name] = old_value + + +def should_bypass_proxies(url, no_proxy): + """ + Returns whether we should bypass proxies or not. + + :rtype: bool + """ + + # Prioritize lowercase environment variables over uppercase + # to keep a consistent behaviour with other http projects (curl, wget). + def get_proxy(key): + return os.environ.get(key) or os.environ.get(key.upper()) + + # First check whether no_proxy is defined. If it is, check that the URL + # we're getting isn't in the no_proxy list. + no_proxy_arg = no_proxy + if no_proxy is None: + no_proxy = get_proxy("no_proxy") + parsed = urlparse(url) + + if parsed.hostname is None: + # URLs don't always have hostnames, e.g. file:/// urls. + return True + + if no_proxy: + # We need to check whether we match here. We need to see if we match + # the end of the hostname, both with and without the port. + no_proxy = (host for host in no_proxy.replace(" ", "").split(",") if host) + + if is_ipv4_address(parsed.hostname): + for proxy_ip in no_proxy: + if is_valid_cidr(proxy_ip): + if address_in_network(parsed.hostname, proxy_ip): + return True + elif parsed.hostname == proxy_ip: + # If no_proxy ip was defined in plain IP notation instead of cidr notation & + # matches the IP of the index + return True + else: + host_with_port = parsed.hostname + if parsed.port: + host_with_port += f":{parsed.port}" + + for host in no_proxy: + if parsed.hostname.endswith(host) or host_with_port.endswith(host): + # The URL does match something in no_proxy, so we don't want + # to apply the proxies on this URL. + return True + + with set_environ("no_proxy", no_proxy_arg): + # parsed.hostname can be `None` in cases such as a file URI. + try: + bypass = proxy_bypass(parsed.hostname) + except (TypeError, socket.gaierror): + bypass = False + + if bypass: + return True + + return False + + +def get_environ_proxies(url, no_proxy=None): + """ + Return a dict of environment proxies. + + :rtype: dict + """ + if should_bypass_proxies(url, no_proxy=no_proxy): + return {} + else: + return getproxies() + + +def select_proxy(url, proxies): + """Select a proxy for the url, if applicable. + + :param url: The url being for the request + :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs + """ + proxies = proxies or {} + urlparts = urlparse(url) + if urlparts.hostname is None: + return proxies.get(urlparts.scheme, proxies.get("all")) + + proxy_keys = [ + urlparts.scheme + "://" + urlparts.hostname, + urlparts.scheme, + "all://" + urlparts.hostname, + "all", + ] + proxy = None + for proxy_key in proxy_keys: + if proxy_key in proxies: + proxy = proxies[proxy_key] + break + + return proxy + + +def resolve_proxies(request, proxies, trust_env=True): + """This method takes proxy information from a request and configuration + input to resolve a mapping of target proxies. This will consider settings + such as NO_PROXY to strip proxy configurations. + + :param request: Request or PreparedRequest + :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs + :param trust_env: Boolean declaring whether to trust environment configs + + :rtype: dict + """ + proxies = proxies if proxies is not None else {} + url = request.url + scheme = urlparse(url).scheme + no_proxy = proxies.get("no_proxy") + new_proxies = proxies.copy() + + if trust_env and not should_bypass_proxies(url, no_proxy=no_proxy): + environ_proxies = get_environ_proxies(url, no_proxy=no_proxy) + + proxy = environ_proxies.get(scheme, environ_proxies.get("all")) + + if proxy: + new_proxies.setdefault(scheme, proxy) + return new_proxies + + +def default_user_agent(name="python-requests"): + """ + Return a string representing the default user agent. + + :rtype: str + """ + return f"{name}/{__version__}" + + +def default_headers(): + """ + :rtype: requests.structures.CaseInsensitiveDict + """ + return CaseInsensitiveDict( + { + "User-Agent": default_user_agent(), + "Accept-Encoding": DEFAULT_ACCEPT_ENCODING, + "Accept": "*/*", + "Connection": "keep-alive", + } + ) + + +def parse_header_links(value): + """Return a list of parsed link headers proxies. + + i.e. Link: ; rel=front; type="image/jpeg",; rel=back;type="image/jpeg" + + :rtype: list + """ + + links = [] + + replace_chars = " '\"" + + value = value.strip(replace_chars) + if not value: + return links + + for val in re.split(", *<", value): + try: + url, params = val.split(";", 1) + except ValueError: + url, params = val, "" + + link = {"url": url.strip("<> '\"")} + + for param in params.split(";"): + try: + key, value = param.split("=") + except ValueError: + break + + link[key.strip(replace_chars)] = value.strip(replace_chars) + + links.append(link) + + return links + + +# Null bytes; no need to recreate these on each call to guess_json_utf +_null = "\x00".encode("ascii") # encoding to ASCII for Python 3 +_null2 = _null * 2 +_null3 = _null * 3 + + +def guess_json_utf(data): + """ + :rtype: str + """ + # JSON always starts with two ASCII characters, so detection is as + # easy as counting the nulls and from their location and count + # determine the encoding. Also detect a BOM, if present. + sample = data[:4] + if sample in (codecs.BOM_UTF32_LE, codecs.BOM_UTF32_BE): + return "utf-32" # BOM included + if sample[:3] == codecs.BOM_UTF8: + return "utf-8-sig" # BOM included, MS style (discouraged) + if sample[:2] in (codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE): + return "utf-16" # BOM included + nullcount = sample.count(_null) + if nullcount == 0: + return "utf-8" + if nullcount == 2: + if sample[::2] == _null2: # 1st and 3rd are null + return "utf-16-be" + if sample[1::2] == _null2: # 2nd and 4th are null + return "utf-16-le" + # Did not detect 2 valid UTF-16 ascii-range characters + if nullcount == 3: + if sample[:3] == _null3: + return "utf-32-be" + if sample[1:] == _null3: + return "utf-32-le" + # Did not detect a valid UTF-32 ascii-range character + return None + + +def prepend_scheme_if_needed(url, new_scheme): + """Given a URL that may or may not have a scheme, prepend the given scheme. + Does not replace a present scheme with the one provided as an argument. + + :rtype: str + """ + parsed = parse_url(url) + scheme, auth, host, port, path, query, fragment = parsed + + # A defect in urlparse determines that there isn't a netloc present in some + # urls. We previously assumed parsing was overly cautious, and swapped the + # netloc and path. Due to a lack of tests on the original defect, this is + # maintained with parse_url for backwards compatibility. + netloc = parsed.netloc + if not netloc: + netloc, path = path, netloc + + if auth: + # parse_url doesn't provide the netloc with auth + # so we'll add it ourselves. + netloc = "@".join([auth, netloc]) + if scheme is None: + scheme = new_scheme + if path is None: + path = "" + + return urlunparse((scheme, netloc, path, "", query, fragment)) + + +def get_auth_from_url(url): + """Given a url with authentication components, extract them into a tuple of + username,password. + + :rtype: (str,str) + """ + parsed = urlparse(url) + + try: + auth = (unquote(parsed.username), unquote(parsed.password)) + except (AttributeError, TypeError): + auth = ("", "") + + return auth + + +def check_header_validity(header): + """Verifies that header parts don't contain leading whitespace + reserved characters, or return characters. + + :param header: tuple, in the format (name, value). + """ + name, value = header + _validate_header_part(header, name, 0) + _validate_header_part(header, value, 1) + + +def _validate_header_part(header, header_part, header_validator_index): + if isinstance(header_part, str): + validator = _HEADER_VALIDATORS_STR[header_validator_index] + elif isinstance(header_part, bytes): + validator = _HEADER_VALIDATORS_BYTE[header_validator_index] + else: + raise InvalidHeader( + f"Header part ({header_part!r}) from {header} " + f"must be of type str or bytes, not {type(header_part)}" + ) + + if not validator.match(header_part): + header_kind = "name" if header_validator_index == 0 else "value" + raise InvalidHeader( + f"Invalid leading whitespace, reserved character(s), or return " + f"character(s) in header {header_kind}: {header_part!r}" + ) + + +def urldefragauth(url): + """ + Given a url remove the fragment and the authentication part. + + :rtype: str + """ + scheme, netloc, path, params, query, fragment = urlparse(url) + + # see func:`prepend_scheme_if_needed` + if not netloc: + netloc, path = path, netloc + + netloc = netloc.rsplit("@", 1)[-1] + + return urlunparse((scheme, netloc, path, params, query, "")) + + +def rewind_body(prepared_request): + """Move file pointer back to its recorded starting position + so it can be read again on redirect. + """ + body_seek = getattr(prepared_request.body, "seek", None) + if body_seek is not None and isinstance( + prepared_request._body_position, integer_types + ): + try: + body_seek(prepared_request._body_position) + except OSError: + raise UnrewindableBodyError( + "An error occurred when rewinding request body for redirect." + ) + else: + raise UnrewindableBodyError("Unable to rewind request body for redirect.")