diff --git a/env-llmeval/lib/python3.10/site-packages/fsspec/asyn.py b/env-llmeval/lib/python3.10/site-packages/fsspec/asyn.py new file mode 100644 index 0000000000000000000000000000000000000000..fb4e05e7446e1fa449060786db29945e0a3f61b1 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/fsspec/asyn.py @@ -0,0 +1,1081 @@ +import asyncio +import asyncio.events +import functools +import inspect +import io +import numbers +import os +import re +import threading +from contextlib import contextmanager +from glob import has_magic +from typing import TYPE_CHECKING, Iterable + +from .callbacks import DEFAULT_CALLBACK +from .exceptions import FSTimeoutError +from .implementations.local import LocalFileSystem, make_path_posix, trailing_sep +from .spec import AbstractBufferedFile, AbstractFileSystem +from .utils import glob_translate, is_exception, other_paths + +private = re.compile("_[^_]") +iothread = [None] # dedicated fsspec IO thread +loop = [None] # global event loop for any non-async instance +_lock = None # global lock placeholder +get_running_loop = asyncio.get_running_loop + + +def get_lock(): + """Allocate or return a threading lock. + + The lock is allocated on first use to allow setting one lock per forked process. + """ + global _lock + if not _lock: + _lock = threading.Lock() + return _lock + + +def reset_lock(): + """Reset the global lock. + + This should be called only on the init of a forked process to reset the lock to + None, enabling the new forked process to get a new lock. + """ + global _lock + + iothread[0] = None + loop[0] = None + _lock = None + + +async def _runner(event, coro, result, timeout=None): + timeout = timeout if timeout else None # convert 0 or 0.0 to None + if timeout is not None: + coro = asyncio.wait_for(coro, timeout=timeout) + try: + result[0] = await coro + except Exception as ex: + result[0] = ex + finally: + event.set() + + +def sync(loop, func, *args, timeout=None, **kwargs): + """ + Make loop run coroutine until it returns. Runs in other thread + + Examples + -------- + >>> fsspec.asyn.sync(fsspec.asyn.get_loop(), func, *args, + timeout=timeout, **kwargs) + """ + timeout = timeout if timeout else None # convert 0 or 0.0 to None + # NB: if the loop is not running *yet*, it is OK to submit work + # and we will wait for it + if loop is None or loop.is_closed(): + raise RuntimeError("Loop is not running") + try: + loop0 = asyncio.events.get_running_loop() + if loop0 is loop: + raise NotImplementedError("Calling sync() from within a running loop") + except NotImplementedError: + raise + except RuntimeError: + pass + coro = func(*args, **kwargs) + result = [None] + event = threading.Event() + asyncio.run_coroutine_threadsafe(_runner(event, coro, result, timeout), loop) + while True: + # this loops allows thread to get interrupted + if event.wait(1): + break + if timeout is not None: + timeout -= 1 + if timeout < 0: + raise FSTimeoutError + + return_result = result[0] + if isinstance(return_result, asyncio.TimeoutError): + # suppress asyncio.TimeoutError, raise FSTimeoutError + raise FSTimeoutError from return_result + elif isinstance(return_result, BaseException): + raise return_result + else: + return return_result + + +def sync_wrapper(func, obj=None): + """Given a function, make so can be called in blocking contexts + + Leave obj=None if defining within a class. Pass the instance if attaching + as an attribute of the instance. + """ + + @functools.wraps(func) + def wrapper(*args, **kwargs): + self = obj or args[0] + return sync(self.loop, func, *args, **kwargs) + + return wrapper + + +@contextmanager +def _selector_policy(): + original_policy = asyncio.get_event_loop_policy() + try: + if os.name == "nt" and hasattr(asyncio, "WindowsSelectorEventLoopPolicy"): + asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy()) + + yield + finally: + asyncio.set_event_loop_policy(original_policy) + + +def get_loop(): + """Create or return the default fsspec IO loop + + The loop will be running on a separate thread. + """ + if loop[0] is None: + with get_lock(): + # repeat the check just in case the loop got filled between the + # previous two calls from another thread + if loop[0] is None: + with _selector_policy(): + loop[0] = asyncio.new_event_loop() + th = threading.Thread(target=loop[0].run_forever, name="fsspecIO") + th.daemon = True + th.start() + iothread[0] = th + return loop[0] + + +if TYPE_CHECKING: + import resource + + ResourceError = resource.error +else: + try: + import resource + except ImportError: + resource = None + ResourceError = OSError + else: + ResourceError = getattr(resource, "error", OSError) + +_DEFAULT_BATCH_SIZE = 128 +_NOFILES_DEFAULT_BATCH_SIZE = 1280 + + +def _get_batch_size(nofiles=False): + from fsspec.config import conf + + if nofiles: + if "nofiles_gather_batch_size" in conf: + return conf["nofiles_gather_batch_size"] + else: + if "gather_batch_size" in conf: + return conf["gather_batch_size"] + if nofiles: + return _NOFILES_DEFAULT_BATCH_SIZE + if resource is None: + return _DEFAULT_BATCH_SIZE + + try: + soft_limit, _ = resource.getrlimit(resource.RLIMIT_NOFILE) + except (ImportError, ValueError, ResourceError): + return _DEFAULT_BATCH_SIZE + + if soft_limit == resource.RLIM_INFINITY: + return -1 + else: + return soft_limit // 8 + + +def running_async() -> bool: + """Being executed by an event loop?""" + try: + asyncio.get_running_loop() + return True + except RuntimeError: + return False + + +async def _run_coros_in_chunks( + coros, + batch_size=None, + callback=DEFAULT_CALLBACK, + timeout=None, + return_exceptions=False, + nofiles=False, +): + """Run the given coroutines in chunks. + + Parameters + ---------- + coros: list of coroutines to run + batch_size: int or None + Number of coroutines to submit/wait on simultaneously. + If -1, then it will not be any throttling. If + None, it will be inferred from _get_batch_size() + callback: fsspec.callbacks.Callback instance + Gets a relative_update when each coroutine completes + timeout: number or None + If given, each coroutine times out after this time. Note that, since + there are multiple batches, the total run time of this function will in + general be longer + return_exceptions: bool + Same meaning as in asyncio.gather + nofiles: bool + If inferring the batch_size, does this operation involve local files? + If yes, you normally expect smaller batches. + """ + + if batch_size is None: + batch_size = _get_batch_size(nofiles=nofiles) + + if batch_size == -1: + batch_size = len(coros) + + assert batch_size > 0 + results = [] + for start in range(0, len(coros), batch_size): + chunk = [ + asyncio.Task(asyncio.wait_for(c, timeout=timeout)) + for c in coros[start : start + batch_size] + ] + if callback is not DEFAULT_CALLBACK: + [ + t.add_done_callback(lambda *_, **__: callback.relative_update(1)) + for t in chunk + ] + results.extend( + await asyncio.gather(*chunk, return_exceptions=return_exceptions), + ) + return results + + +# these methods should be implemented as async by any async-able backend +async_methods = [ + "_ls", + "_cat_file", + "_get_file", + "_put_file", + "_rm_file", + "_cp_file", + "_pipe_file", + "_expand_path", + "_info", + "_isfile", + "_isdir", + "_exists", + "_walk", + "_glob", + "_find", + "_du", + "_size", + "_mkdir", + "_makedirs", +] + + +class AsyncFileSystem(AbstractFileSystem): + """Async file operations, default implementations + + Passes bulk operations to asyncio.gather for concurrent operation. + + Implementations that have concurrent batch operations and/or async methods + should inherit from this class instead of AbstractFileSystem. Docstrings are + copied from the un-underscored method in AbstractFileSystem, if not given. + """ + + # note that methods do not have docstring here; they will be copied + # for _* methods and inferred for overridden methods. + + async_impl = True + mirror_sync_methods = True + disable_throttling = False + + def __init__(self, *args, asynchronous=False, loop=None, batch_size=None, **kwargs): + self.asynchronous = asynchronous + self._pid = os.getpid() + if not asynchronous: + self._loop = loop or get_loop() + else: + self._loop = None + self.batch_size = batch_size + super().__init__(*args, **kwargs) + + @property + def loop(self): + if self._pid != os.getpid(): + raise RuntimeError("This class is not fork-safe") + return self._loop + + async def _rm_file(self, path, **kwargs): + raise NotImplementedError + + async def _rm(self, path, recursive=False, batch_size=None, **kwargs): + # TODO: implement on_error + batch_size = batch_size or self.batch_size + path = await self._expand_path(path, recursive=recursive) + return await _run_coros_in_chunks( + [self._rm_file(p, **kwargs) for p in reversed(path)], + batch_size=batch_size, + nofiles=True, + ) + + async def _cp_file(self, path1, path2, **kwargs): + raise NotImplementedError + + async def _copy( + self, + path1, + path2, + recursive=False, + on_error=None, + maxdepth=None, + batch_size=None, + **kwargs, + ): + if on_error is None and recursive: + on_error = "ignore" + elif on_error is None: + on_error = "raise" + + if isinstance(path1, list) and isinstance(path2, list): + # No need to expand paths when both source and destination + # are provided as lists + paths1 = path1 + paths2 = path2 + else: + source_is_str = isinstance(path1, str) + paths1 = await self._expand_path( + path1, maxdepth=maxdepth, recursive=recursive + ) + if source_is_str and (not recursive or maxdepth is not None): + # Non-recursive glob does not copy directories + paths1 = [ + p for p in paths1 if not (trailing_sep(p) or await self._isdir(p)) + ] + if not paths1: + return + + source_is_file = len(paths1) == 1 + dest_is_dir = isinstance(path2, str) and ( + trailing_sep(path2) or await self._isdir(path2) + ) + + exists = source_is_str and ( + (has_magic(path1) and source_is_file) + or (not has_magic(path1) and dest_is_dir and not trailing_sep(path1)) + ) + paths2 = other_paths( + paths1, + path2, + exists=exists, + flatten=not source_is_str, + ) + + batch_size = batch_size or self.batch_size + coros = [self._cp_file(p1, p2, **kwargs) for p1, p2 in zip(paths1, paths2)] + result = await _run_coros_in_chunks( + coros, batch_size=batch_size, return_exceptions=True, nofiles=True + ) + + for ex in filter(is_exception, result): + if on_error == "ignore" and isinstance(ex, FileNotFoundError): + continue + raise ex + + async def _pipe_file(self, path, value, **kwargs): + raise NotImplementedError + + async def _pipe(self, path, value=None, batch_size=None, **kwargs): + if isinstance(path, str): + path = {path: value} + batch_size = batch_size or self.batch_size + return await _run_coros_in_chunks( + [self._pipe_file(k, v, **kwargs) for k, v in path.items()], + batch_size=batch_size, + nofiles=True, + ) + + async def _process_limits(self, url, start, end): + """Helper for "Range"-based _cat_file""" + size = None + suff = False + if start is not None and start < 0: + # if start is negative and end None, end is the "suffix length" + if end is None: + end = -start + start = "" + suff = True + else: + size = size or (await self._info(url))["size"] + start = size + start + elif start is None: + start = 0 + if not suff: + if end is not None and end < 0: + if start is not None: + size = size or (await self._info(url))["size"] + end = size + end + elif end is None: + end = "" + if isinstance(end, numbers.Integral): + end -= 1 # bytes range is inclusive + return f"bytes={start}-{end}" + + async def _cat_file(self, path, start=None, end=None, **kwargs): + raise NotImplementedError + + async def _cat( + self, path, recursive=False, on_error="raise", batch_size=None, **kwargs + ): + paths = await self._expand_path(path, recursive=recursive) + coros = [self._cat_file(path, **kwargs) for path in paths] + batch_size = batch_size or self.batch_size + out = await _run_coros_in_chunks( + coros, batch_size=batch_size, nofiles=True, return_exceptions=True + ) + if on_error == "raise": + ex = next(filter(is_exception, out), False) + if ex: + raise ex + if ( + len(paths) > 1 + or isinstance(path, list) + or paths[0] != self._strip_protocol(path) + ): + return { + k: v + for k, v in zip(paths, out) + if on_error != "omit" or not is_exception(v) + } + else: + return out[0] + + async def _cat_ranges( + self, + paths, + starts, + ends, + max_gap=None, + batch_size=None, + on_error="return", + **kwargs, + ): + """Get the contents of byte ranges from one or more files + + Parameters + ---------- + paths: list + A list of of filepaths on this filesystems + starts, ends: int or list + Bytes limits of the read. If using a single int, the same value will be + used to read all the specified files. + """ + # TODO: on_error + if max_gap is not None: + # use utils.merge_offset_ranges + raise NotImplementedError + if not isinstance(paths, list): + raise TypeError + if not isinstance(starts, Iterable): + starts = [starts] * len(paths) + if not isinstance(ends, Iterable): + ends = [ends] * len(paths) + if len(starts) != len(paths) or len(ends) != len(paths): + raise ValueError + coros = [ + self._cat_file(p, start=s, end=e, **kwargs) + for p, s, e in zip(paths, starts, ends) + ] + batch_size = batch_size or self.batch_size + return await _run_coros_in_chunks( + coros, batch_size=batch_size, nofiles=True, return_exceptions=True + ) + + async def _put_file(self, lpath, rpath, **kwargs): + raise NotImplementedError + + async def _put( + self, + lpath, + rpath, + recursive=False, + callback=DEFAULT_CALLBACK, + batch_size=None, + maxdepth=None, + **kwargs, + ): + """Copy file(s) from local. + + Copies a specific file or tree of files (if recursive=True). If rpath + ends with a "/", it will be assumed to be a directory, and target files + will go within. + + The put_file method will be called concurrently on a batch of files. The + batch_size option can configure the amount of futures that can be executed + at the same time. If it is -1, then all the files will be uploaded concurrently. + The default can be set for this instance by passing "batch_size" in the + constructor, or for all instances by setting the "gather_batch_size" key + in ``fsspec.config.conf``, falling back to 1/8th of the system limit . + """ + if isinstance(lpath, list) and isinstance(rpath, list): + # No need to expand paths when both source and destination + # are provided as lists + rpaths = rpath + lpaths = lpath + else: + source_is_str = isinstance(lpath, str) + if source_is_str: + lpath = make_path_posix(lpath) + fs = LocalFileSystem() + lpaths = fs.expand_path(lpath, recursive=recursive, maxdepth=maxdepth) + if source_is_str and (not recursive or maxdepth is not None): + # Non-recursive glob does not copy directories + lpaths = [p for p in lpaths if not (trailing_sep(p) or fs.isdir(p))] + if not lpaths: + return + + source_is_file = len(lpaths) == 1 + dest_is_dir = isinstance(rpath, str) and ( + trailing_sep(rpath) or await self._isdir(rpath) + ) + + rpath = self._strip_protocol(rpath) + exists = source_is_str and ( + (has_magic(lpath) and source_is_file) + or (not has_magic(lpath) and dest_is_dir and not trailing_sep(lpath)) + ) + rpaths = other_paths( + lpaths, + rpath, + exists=exists, + flatten=not source_is_str, + ) + + is_dir = {l: os.path.isdir(l) for l in lpaths} + rdirs = [r for l, r in zip(lpaths, rpaths) if is_dir[l]] + file_pairs = [(l, r) for l, r in zip(lpaths, rpaths) if not is_dir[l]] + + await asyncio.gather(*[self._makedirs(d, exist_ok=True) for d in rdirs]) + batch_size = batch_size or self.batch_size + + coros = [] + callback.set_size(len(file_pairs)) + for lfile, rfile in file_pairs: + put_file = callback.branch_coro(self._put_file) + coros.append(put_file(lfile, rfile, **kwargs)) + + return await _run_coros_in_chunks( + coros, batch_size=batch_size, callback=callback + ) + + async def _get_file(self, rpath, lpath, **kwargs): + raise NotImplementedError + + async def _get( + self, + rpath, + lpath, + recursive=False, + callback=DEFAULT_CALLBACK, + maxdepth=None, + **kwargs, + ): + """Copy file(s) to local. + + Copies a specific file or tree of files (if recursive=True). If lpath + ends with a "/", it will be assumed to be a directory, and target files + will go within. Can submit a list of paths, which may be glob-patterns + and will be expanded. + + The get_file method will be called concurrently on a batch of files. The + batch_size option can configure the amount of futures that can be executed + at the same time. If it is -1, then all the files will be uploaded concurrently. + The default can be set for this instance by passing "batch_size" in the + constructor, or for all instances by setting the "gather_batch_size" key + in ``fsspec.config.conf``, falling back to 1/8th of the system limit . + """ + if isinstance(lpath, list) and isinstance(rpath, list): + # No need to expand paths when both source and destination + # are provided as lists + rpaths = rpath + lpaths = lpath + else: + source_is_str = isinstance(rpath, str) + # First check for rpath trailing slash as _strip_protocol removes it. + source_not_trailing_sep = source_is_str and not trailing_sep(rpath) + rpath = self._strip_protocol(rpath) + rpaths = await self._expand_path( + rpath, recursive=recursive, maxdepth=maxdepth + ) + if source_is_str and (not recursive or maxdepth is not None): + # Non-recursive glob does not copy directories + rpaths = [ + p for p in rpaths if not (trailing_sep(p) or await self._isdir(p)) + ] + if not rpaths: + return + + lpath = make_path_posix(lpath) + source_is_file = len(rpaths) == 1 + dest_is_dir = isinstance(lpath, str) and ( + trailing_sep(lpath) or LocalFileSystem().isdir(lpath) + ) + + exists = source_is_str and ( + (has_magic(rpath) and source_is_file) + or (not has_magic(rpath) and dest_is_dir and source_not_trailing_sep) + ) + lpaths = other_paths( + rpaths, + lpath, + exists=exists, + flatten=not source_is_str, + ) + + [os.makedirs(os.path.dirname(lp), exist_ok=True) for lp in lpaths] + batch_size = kwargs.pop("batch_size", self.batch_size) + + coros = [] + callback.set_size(len(lpaths)) + for lpath, rpath in zip(lpaths, rpaths): + get_file = callback.branch_coro(self._get_file) + coros.append(get_file(rpath, lpath, **kwargs)) + return await _run_coros_in_chunks( + coros, batch_size=batch_size, callback=callback + ) + + async def _isfile(self, path): + try: + return (await self._info(path))["type"] == "file" + except: # noqa: E722 + return False + + async def _isdir(self, path): + try: + return (await self._info(path))["type"] == "directory" + except OSError: + return False + + async def _size(self, path): + return (await self._info(path)).get("size", None) + + async def _sizes(self, paths, batch_size=None): + batch_size = batch_size or self.batch_size + return await _run_coros_in_chunks( + [self._size(p) for p in paths], batch_size=batch_size + ) + + async def _exists(self, path, **kwargs): + try: + await self._info(path, **kwargs) + return True + except FileNotFoundError: + return False + + async def _info(self, path, **kwargs): + raise NotImplementedError + + async def _ls(self, path, detail=True, **kwargs): + raise NotImplementedError + + async def _walk(self, path, maxdepth=None, on_error="omit", **kwargs): + if maxdepth is not None and maxdepth < 1: + raise ValueError("maxdepth must be at least 1") + + path = self._strip_protocol(path) + full_dirs = {} + dirs = {} + files = {} + + detail = kwargs.pop("detail", False) + try: + listing = await self._ls(path, detail=True, **kwargs) + except (FileNotFoundError, OSError) as e: + if on_error == "raise": + raise + elif callable(on_error): + on_error(e) + if detail: + yield path, {}, {} + else: + yield path, [], [] + return + + for info in listing: + # each info name must be at least [path]/part , but here + # we check also for names like [path]/part/ + pathname = info["name"].rstrip("/") + name = pathname.rsplit("/", 1)[-1] + if info["type"] == "directory" and pathname != path: + # do not include "self" path + full_dirs[name] = pathname + dirs[name] = info + elif pathname == path: + # file-like with same name as give path + files[""] = info + else: + files[name] = info + + if detail: + yield path, dirs, files + else: + yield path, list(dirs), list(files) + + if maxdepth is not None: + maxdepth -= 1 + if maxdepth < 1: + return + + for d in dirs: + async for _ in self._walk( + full_dirs[d], maxdepth=maxdepth, detail=detail, **kwargs + ): + yield _ + + async def _glob(self, path, maxdepth=None, **kwargs): + if maxdepth is not None and maxdepth < 1: + raise ValueError("maxdepth must be at least 1") + + import re + + seps = (os.path.sep, os.path.altsep) if os.path.altsep else (os.path.sep,) + ends_with_sep = path.endswith(seps) # _strip_protocol strips trailing slash + path = self._strip_protocol(path) + append_slash_to_dirname = ends_with_sep or path.endswith( + tuple(sep + "**" for sep in seps) + ) + idx_star = path.find("*") if path.find("*") >= 0 else len(path) + idx_qmark = path.find("?") if path.find("?") >= 0 else len(path) + idx_brace = path.find("[") if path.find("[") >= 0 else len(path) + + min_idx = min(idx_star, idx_qmark, idx_brace) + + detail = kwargs.pop("detail", False) + + if not has_magic(path): + if await self._exists(path, **kwargs): + if not detail: + return [path] + else: + return {path: await self._info(path, **kwargs)} + else: + if not detail: + return [] # glob of non-existent returns empty + else: + return {} + elif "/" in path[:min_idx]: + min_idx = path[:min_idx].rindex("/") + root = path[: min_idx + 1] + depth = path[min_idx + 1 :].count("/") + 1 + else: + root = "" + depth = path[min_idx + 1 :].count("/") + 1 + + if "**" in path: + if maxdepth is not None: + idx_double_stars = path.find("**") + depth_double_stars = path[idx_double_stars:].count("/") + 1 + depth = depth - depth_double_stars + maxdepth + else: + depth = None + + allpaths = await self._find( + root, maxdepth=depth, withdirs=True, detail=True, **kwargs + ) + + pattern = glob_translate(path + ("/" if ends_with_sep else "")) + pattern = re.compile(pattern) + + out = { + p: info + for p, info in sorted(allpaths.items()) + if pattern.match( + ( + p + "/" + if append_slash_to_dirname and info["type"] == "directory" + else p + ) + ) + } + + if detail: + return out + else: + return list(out) + + async def _du(self, path, total=True, maxdepth=None, **kwargs): + sizes = {} + # async for? + for f in await self._find(path, maxdepth=maxdepth, **kwargs): + info = await self._info(f) + sizes[info["name"]] = info["size"] + if total: + return sum(sizes.values()) + else: + return sizes + + async def _find(self, path, maxdepth=None, withdirs=False, **kwargs): + path = self._strip_protocol(path) + out = {} + detail = kwargs.pop("detail", False) + + # Add the root directory if withdirs is requested + # This is needed for posix glob compliance + if withdirs and path != "" and await self._isdir(path): + out[path] = await self._info(path) + + # async for? + async for _, dirs, files in self._walk(path, maxdepth, detail=True, **kwargs): + if withdirs: + files.update(dirs) + out.update({info["name"]: info for name, info in files.items()}) + if not out and (await self._isfile(path)): + # walk works on directories, but find should also return [path] + # when path happens to be a file + out[path] = {} + names = sorted(out) + if not detail: + return names + else: + return {name: out[name] for name in names} + + async def _expand_path(self, path, recursive=False, maxdepth=None): + if maxdepth is not None and maxdepth < 1: + raise ValueError("maxdepth must be at least 1") + + if isinstance(path, str): + out = await self._expand_path([path], recursive, maxdepth) + else: + out = set() + path = [self._strip_protocol(p) for p in path] + for p in path: # can gather here + if has_magic(p): + bit = set(await self._glob(p, maxdepth=maxdepth)) + out |= bit + if recursive: + # glob call above expanded one depth so if maxdepth is defined + # then decrement it in expand_path call below. If it is zero + # after decrementing then avoid expand_path call. + if maxdepth is not None and maxdepth <= 1: + continue + out |= set( + await self._expand_path( + list(bit), + recursive=recursive, + maxdepth=maxdepth - 1 if maxdepth is not None else None, + ) + ) + continue + elif recursive: + rec = set(await self._find(p, maxdepth=maxdepth, withdirs=True)) + out |= rec + if p not in out and (recursive is False or (await self._exists(p))): + # should only check once, for the root + out.add(p) + if not out: + raise FileNotFoundError(path) + return sorted(out) + + async def _mkdir(self, path, create_parents=True, **kwargs): + pass # not necessary to implement, may not have directories + + async def _makedirs(self, path, exist_ok=False): + pass # not necessary to implement, may not have directories + + async def open_async(self, path, mode="rb", **kwargs): + if "b" not in mode or kwargs.get("compression"): + raise ValueError + raise NotImplementedError + + +def mirror_sync_methods(obj): + """Populate sync and async methods for obj + + For each method will create a sync version if the name refers to an async method + (coroutine) and there is no override in the child class; will create an async + method for the corresponding sync method if there is no implementation. + + Uses the methods specified in + - async_methods: the set that an implementation is expected to provide + - default_async_methods: that can be derived from their sync version in + AbstractFileSystem + - AsyncFileSystem: async-specific default coroutines + """ + from fsspec import AbstractFileSystem + + for method in async_methods + dir(AsyncFileSystem): + if not method.startswith("_"): + continue + smethod = method[1:] + if private.match(method): + isco = inspect.iscoroutinefunction(getattr(obj, method, None)) + unsync = getattr(getattr(obj, smethod, False), "__func__", None) + is_default = unsync is getattr(AbstractFileSystem, smethod, "") + if isco and is_default: + mth = sync_wrapper(getattr(obj, method), obj=obj) + setattr(obj, smethod, mth) + if not mth.__doc__: + mth.__doc__ = getattr( + getattr(AbstractFileSystem, smethod, None), "__doc__", "" + ) + + +class FSSpecCoroutineCancel(Exception): + pass + + +def _dump_running_tasks( + printout=True, cancel=True, exc=FSSpecCoroutineCancel, with_task=False +): + import traceback + + tasks = [t for t in asyncio.tasks.all_tasks(loop[0]) if not t.done()] + if printout: + [task.print_stack() for task in tasks] + out = [ + { + "locals": task._coro.cr_frame.f_locals, + "file": task._coro.cr_frame.f_code.co_filename, + "firstline": task._coro.cr_frame.f_code.co_firstlineno, + "linelo": task._coro.cr_frame.f_lineno, + "stack": traceback.format_stack(task._coro.cr_frame), + "task": task if with_task else None, + } + for task in tasks + ] + if cancel: + for t in tasks: + cbs = t._callbacks + t.cancel() + asyncio.futures.Future.set_exception(t, exc) + asyncio.futures.Future.cancel(t) + [cb[0](t) for cb in cbs] # cancels any dependent concurrent.futures + try: + t._coro.throw(exc) # exits coro, unless explicitly handled + except exc: + pass + return out + + +class AbstractAsyncStreamedFile(AbstractBufferedFile): + # no read buffering, and always auto-commit + # TODO: readahead might still be useful here, but needs async version + + async def read(self, length=-1): + """ + Return data from cache, or fetch pieces as necessary + + Parameters + ---------- + length: int (-1) + Number of bytes to read; if <0, all remaining bytes. + """ + length = -1 if length is None else int(length) + if self.mode != "rb": + raise ValueError("File not in read mode") + if length < 0: + length = self.size - self.loc + if self.closed: + raise ValueError("I/O operation on closed file.") + if length == 0: + # don't even bother calling fetch + return b"" + out = await self._fetch_range(self.loc, self.loc + length) + self.loc += len(out) + return out + + async def write(self, data): + """ + Write data to buffer. + + Buffer only sent on flush() or if buffer is greater than + or equal to blocksize. + + Parameters + ---------- + data: bytes + Set of bytes to be written. + """ + if self.mode not in {"wb", "ab"}: + raise ValueError("File not in write mode") + if self.closed: + raise ValueError("I/O operation on closed file.") + if self.forced: + raise ValueError("This file has been force-flushed, can only close") + out = self.buffer.write(data) + self.loc += out + if self.buffer.tell() >= self.blocksize: + await self.flush() + return out + + async def close(self): + """Close file + + Finalizes writes, discards cache + """ + if getattr(self, "_unclosable", False): + return + if self.closed: + return + if self.mode == "rb": + self.cache = None + else: + if not self.forced: + await self.flush(force=True) + + if self.fs is not None: + self.fs.invalidate_cache(self.path) + self.fs.invalidate_cache(self.fs._parent(self.path)) + + self.closed = True + + async def flush(self, force=False): + if self.closed: + raise ValueError("Flush on closed file") + if force and self.forced: + raise ValueError("Force flush cannot be called more than once") + if force: + self.forced = True + + if self.mode not in {"wb", "ab"}: + # no-op to flush on read-mode + return + + if not force and self.buffer.tell() < self.blocksize: + # Defer write on small block + return + + if self.offset is None: + # Initialize a multipart upload + self.offset = 0 + try: + await self._initiate_upload() + except: # noqa: E722 + self.closed = True + raise + + if await self._upload_chunk(final=force) is not False: + self.offset += self.buffer.seek(0, 2) + self.buffer = io.BytesIO() + + async def __aenter__(self): + return self + + async def __aexit__(self, exc_type, exc_val, exc_tb): + await self.close() + + async def _fetch_range(self, start, end): + raise NotImplementedError + + async def _initiate_upload(self): + pass + + async def _upload_chunk(self, final=False): + raise NotImplementedError diff --git a/env-llmeval/lib/python3.10/site-packages/fsspec/callbacks.py b/env-llmeval/lib/python3.10/site-packages/fsspec/callbacks.py new file mode 100644 index 0000000000000000000000000000000000000000..7ca99ca6ac3cd69b28bcd1550f6550e8e648c5fe --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/fsspec/callbacks.py @@ -0,0 +1,324 @@ +from functools import wraps + + +class Callback: + """ + Base class and interface for callback mechanism + + This class can be used directly for monitoring file transfers by + providing ``callback=Callback(hooks=...)`` (see the ``hooks`` argument, + below), or subclassed for more specialised behaviour. + + Parameters + ---------- + size: int (optional) + Nominal quantity for the value that corresponds to a complete + transfer, e.g., total number of tiles or total number of + bytes + value: int (0) + Starting internal counter value + hooks: dict or None + A dict of named functions to be called on each update. The signature + of these must be ``f(size, value, **kwargs)`` + """ + + def __init__(self, size=None, value=0, hooks=None, **kwargs): + self.size = size + self.value = value + self.hooks = hooks or {} + self.kw = kwargs + + def __enter__(self): + return self + + def __exit__(self, *exc_args): + self.close() + + def close(self): + """Close callback.""" + + def branched(self, path_1, path_2, **kwargs): + """ + Return callback for child transfers + + If this callback is operating at a higher level, e.g., put, which may + trigger transfers that can also be monitored. The function returns a callback + that has to be passed to the child method, e.g., put_file, + as `callback=` argument. + + The implementation uses `callback.branch` for compatibility. + When implementing callbacks, it is recommended to override this function instead + of `branch` and avoid calling `super().branched(...)`. + + Prefer using this function over `branch`. + + Parameters + ---------- + path_1: str + Child's source path + path_2: str + Child's destination path + **kwargs: + Arbitrary keyword arguments + + Returns + ------- + callback: Callback + A callback instance to be passed to the child method + """ + self.branch(path_1, path_2, kwargs) + # mutate kwargs so that we can force the caller to pass "callback=" explicitly + return kwargs.pop("callback", DEFAULT_CALLBACK) + + def branch_coro(self, fn): + """ + Wraps a coroutine, and pass a new child callback to it. + """ + + @wraps(fn) + async def func(path1, path2: str, **kwargs): + with self.branched(path1, path2, **kwargs) as child: + return await fn(path1, path2, callback=child, **kwargs) + + return func + + def set_size(self, size): + """ + Set the internal maximum size attribute + + Usually called if not initially set at instantiation. Note that this + triggers a ``call()``. + + Parameters + ---------- + size: int + """ + self.size = size + self.call() + + def absolute_update(self, value): + """ + Set the internal value state + + Triggers ``call()`` + + Parameters + ---------- + value: int + """ + self.value = value + self.call() + + def relative_update(self, inc=1): + """ + Delta increment the internal counter + + Triggers ``call()`` + + Parameters + ---------- + inc: int + """ + self.value += inc + self.call() + + def call(self, hook_name=None, **kwargs): + """ + Execute hook(s) with current state + + Each function is passed the internal size and current value + + Parameters + ---------- + hook_name: str or None + If given, execute on this hook + kwargs: passed on to (all) hook(s) + """ + if not self.hooks: + return + kw = self.kw.copy() + kw.update(kwargs) + if hook_name: + if hook_name not in self.hooks: + return + return self.hooks[hook_name](self.size, self.value, **kw) + for hook in self.hooks.values() or []: + hook(self.size, self.value, **kw) + + def wrap(self, iterable): + """ + Wrap an iterable to call ``relative_update`` on each iterations + + Parameters + ---------- + iterable: Iterable + The iterable that is being wrapped + """ + for item in iterable: + self.relative_update() + yield item + + def branch(self, path_1, path_2, kwargs): + """ + Set callbacks for child transfers + + If this callback is operating at a higher level, e.g., put, which may + trigger transfers that can also be monitored. The passed kwargs are + to be *mutated* to add ``callback=``, if this class supports branching + to children. + + Parameters + ---------- + path_1: str + Child's source path + path_2: str + Child's destination path + kwargs: dict + arguments passed to child method, e.g., put_file. + + Returns + ------- + + """ + return None + + def no_op(self, *_, **__): + pass + + def __getattr__(self, item): + """ + If undefined methods are called on this class, nothing happens + """ + return self.no_op + + @classmethod + def as_callback(cls, maybe_callback=None): + """Transform callback=... into Callback instance + + For the special value of ``None``, return the global instance of + ``NoOpCallback``. This is an alternative to including + ``callback=DEFAULT_CALLBACK`` directly in a method signature. + """ + if maybe_callback is None: + return DEFAULT_CALLBACK + return maybe_callback + + +class NoOpCallback(Callback): + """ + This implementation of Callback does exactly nothing + """ + + def call(self, *args, **kwargs): + return None + + +class DotPrinterCallback(Callback): + """ + Simple example Callback implementation + + Almost identical to Callback with a hook that prints a char; here we + demonstrate how the outer layer may print "#" and the inner layer "." + """ + + def __init__(self, chr_to_print="#", **kwargs): + self.chr = chr_to_print + super().__init__(**kwargs) + + def branch(self, path_1, path_2, kwargs): + """Mutate kwargs to add new instance with different print char""" + kwargs["callback"] = DotPrinterCallback(".") + + def call(self, **kwargs): + """Just outputs a character""" + print(self.chr, end="") + + +class TqdmCallback(Callback): + """ + A callback to display a progress bar using tqdm + + Parameters + ---------- + tqdm_kwargs : dict, (optional) + Any argument accepted by the tqdm constructor. + See the `tqdm doc `_. + Will be forwarded to `tqdm_cls`. + tqdm_cls: (optional) + subclass of `tqdm.tqdm`. If not passed, it will default to `tqdm.tqdm`. + + Examples + -------- + >>> import fsspec + >>> from fsspec.callbacks import TqdmCallback + >>> fs = fsspec.filesystem("memory") + >>> path2distant_data = "/your-path" + >>> fs.upload( + ".", + path2distant_data, + recursive=True, + callback=TqdmCallback(), + ) + + You can forward args to tqdm using the ``tqdm_kwargs`` parameter. + + >>> fs.upload( + ".", + path2distant_data, + recursive=True, + callback=TqdmCallback(tqdm_kwargs={"desc": "Your tqdm description"}), + ) + + You can also customize the progress bar by passing a subclass of `tqdm`. + + .. code-block:: python + + class TqdmFormat(tqdm): + '''Provides a `total_time` format parameter''' + @property + def format_dict(self): + d = super().format_dict + total_time = d["elapsed"] * (d["total"] or 0) / max(d["n"], 1) + d.update(total_time=self.format_interval(total_time) + " in total") + return d + + >>> with TqdmCallback( + tqdm_kwargs={ + "desc": "desc", + "bar_format": "{total_time}: {percentage:.0f}%|{bar}{r_bar}", + }, + tqdm_cls=TqdmFormat, + ) as callback: + fs.upload(".", path2distant_data, recursive=True, callback=callback) + """ + + def __init__(self, tqdm_kwargs=None, *args, **kwargs): + try: + from tqdm import tqdm + + except ImportError as exce: + raise ImportError( + "Using TqdmCallback requires tqdm to be installed" + ) from exce + + self._tqdm_cls = kwargs.pop("tqdm_cls", tqdm) + self._tqdm_kwargs = tqdm_kwargs or {} + self.tqdm = None + super().__init__(*args, **kwargs) + + def call(self, *args, **kwargs): + if self.tqdm is None: + self.tqdm = self._tqdm_cls(total=self.size, **self._tqdm_kwargs) + self.tqdm.total = self.size + self.tqdm.update(self.value - self.tqdm.n) + + def close(self): + if self.tqdm is not None: + self.tqdm.close() + self.tqdm = None + + def __del__(self): + return self.close() + + +DEFAULT_CALLBACK = _DEFAULT_CALLBACK = NoOpCallback() diff --git a/env-llmeval/lib/python3.10/site-packages/fsspec/transaction.py b/env-llmeval/lib/python3.10/site-packages/fsspec/transaction.py new file mode 100644 index 0000000000000000000000000000000000000000..67584d61e8f5f86b22e19beb609ffe49ce7cc689 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/fsspec/transaction.py @@ -0,0 +1,85 @@ +from collections import deque + + +class Transaction: + """Filesystem transaction write context + + Gathers files for deferred commit or discard, so that several write + operations can be finalized semi-atomically. This works by having this + instance as the ``.transaction`` attribute of the given filesystem + """ + + def __init__(self, fs): + """ + Parameters + ---------- + fs: FileSystem instance + """ + self.fs = fs + self.files = deque() + + def __enter__(self): + self.start() + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + """End transaction and commit, if exit is not due to exception""" + # only commit if there was no exception + self.complete(commit=exc_type is None) + self.fs._intrans = False + self.fs._transaction = None + + def start(self): + """Start a transaction on this FileSystem""" + self.files = deque() # clean up after previous failed completions + self.fs._intrans = True + + def complete(self, commit=True): + """Finish transaction: commit or discard all deferred files""" + while self.files: + f = self.files.popleft() + if commit: + f.commit() + else: + f.discard() + self.fs._intrans = False + + +class FileActor: + def __init__(self): + self.files = [] + + def commit(self): + for f in self.files: + f.commit() + self.files.clear() + + def discard(self): + for f in self.files: + f.discard() + self.files.clear() + + def append(self, f): + self.files.append(f) + + +class DaskTransaction(Transaction): + def __init__(self, fs): + """ + Parameters + ---------- + fs: FileSystem instance + """ + import distributed + + super().__init__(fs) + client = distributed.default_client() + self.files = client.submit(FileActor, actor=True).result() + + def complete(self, commit=True): + """Finish transaction: commit or discard all deferred files""" + if commit: + self.files.commit().result() + else: + self.files.discard().result() + self.fs._intrans = False diff --git a/env-llmeval/lib/python3.10/site-packages/nvidia_nvtx_cu12-12.1.105.dist-info/METADATA b/env-llmeval/lib/python3.10/site-packages/nvidia_nvtx_cu12-12.1.105.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..b3e4a52e9cbba7e3fc0ffd3ac79817726cc6de5e --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/nvidia_nvtx_cu12-12.1.105.dist-info/METADATA @@ -0,0 +1,35 @@ +Metadata-Version: 2.1 +Name: nvidia-nvtx-cu12 +Version: 12.1.105 +Summary: NVIDIA Tools Extension +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 + +A C-based API for annotating events, code ranges, and resources in your applications. Applications which integrate NVTX can use the Visual Profiler to capture and visualize these events and ranges. diff --git a/env-llmeval/lib/python3.10/site-packages/nvidia_nvtx_cu12-12.1.105.dist-info/WHEEL b/env-llmeval/lib/python3.10/site-packages/nvidia_nvtx_cu12-12.1.105.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..06e355fe0e3ed7077903f119ae6928a17da8eb6f --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/nvidia_nvtx_cu12-12.1.105.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.37.1) +Root-Is-Purelib: true +Tag: py3-none-manylinux1_x86_64 + diff --git a/env-llmeval/lib/python3.10/site-packages/nvidia_nvtx_cu12-12.1.105.dist-info/top_level.txt b/env-llmeval/lib/python3.10/site-packages/nvidia_nvtx_cu12-12.1.105.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..862f7abf232cdfbb928609856247292e81c9decb --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/nvidia_nvtx_cu12-12.1.105.dist-info/top_level.txt @@ -0,0 +1 @@ +nvidia diff --git a/env-llmeval/lib/python3.10/site-packages/responses-0.18.0.dist-info/INSTALLER b/env-llmeval/lib/python3.10/site-packages/responses-0.18.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/responses-0.18.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/env-llmeval/lib/python3.10/site-packages/responses-0.18.0.dist-info/top_level.txt b/env-llmeval/lib/python3.10/site-packages/responses-0.18.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..2cb24f43db3bb3264bbf9191db620a3a6a449405 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/responses-0.18.0.dist-info/top_level.txt @@ -0,0 +1 @@ +responses diff --git a/env-llmeval/lib/python3.10/site-packages/safetensors/__init__.py b/env-llmeval/lib/python3.10/site-packages/safetensors/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c9a5d2ca92b5248ce798a19f8e14c3492992cae1 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/safetensors/__init__.py @@ -0,0 +1,9 @@ +# Re-export this +from ._safetensors_rust import ( # noqa: F401 + SafetensorError, + __version__, + deserialize, + safe_open, + serialize, + serialize_file, +) diff --git a/env-llmeval/lib/python3.10/site-packages/safetensors/__pycache__/flax.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/safetensors/__pycache__/flax.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e394f286f9360e9ba3f71fc495203d6991a938c5 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/safetensors/__pycache__/flax.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/safetensors/__pycache__/mlx.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/safetensors/__pycache__/mlx.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..31a4985a9d6e030aefadda0d821c034718ebc161 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/safetensors/__pycache__/mlx.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/safetensors/__pycache__/numpy.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/safetensors/__pycache__/numpy.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eadfaf7e177d4a76ce4bf5276a0e72fd7a6ef8c1 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/safetensors/__pycache__/numpy.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/safetensors/__pycache__/paddle.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/safetensors/__pycache__/paddle.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..020ab60dd02001236ab9793b59e6fb91e58415eb Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/safetensors/__pycache__/paddle.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/safetensors/__pycache__/tensorflow.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/safetensors/__pycache__/tensorflow.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..940efb7afcda9c942f95e3d068522aef9746562d Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/safetensors/__pycache__/tensorflow.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/safetensors/__pycache__/torch.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/safetensors/__pycache__/torch.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c7fbcecb5878d834aa04d116d5026123f69077a3 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/safetensors/__pycache__/torch.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/safetensors/flax.py b/env-llmeval/lib/python3.10/site-packages/safetensors/flax.py new file mode 100644 index 0000000000000000000000000000000000000000..d0b8375e038eff487af33fcfaa4a597aacb5743f --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/safetensors/flax.py @@ -0,0 +1,138 @@ +import os +from typing import Dict, Optional, Union + +import numpy as np + +import jax.numpy as jnp +from jax import Array +from safetensors import numpy, safe_open + + +def save(tensors: Dict[str, Array], metadata: Optional[Dict[str, str]] = None) -> bytes: + """ + Saves a dictionary of tensors into raw bytes in safetensors format. + + Args: + tensors (`Dict[str, Array]`): + The incoming tensors. Tensors need to be contiguous and dense. + metadata (`Dict[str, str]`, *optional*, defaults to `None`): + Optional text only metadata you might want to save in your header. + For instance it can be useful to specify more about the underlying + tensors. This is purely informative and does not affect tensor loading. + + Returns: + `bytes`: The raw bytes representing the format + + Example: + + ```python + from safetensors.flax import save + from jax import numpy as jnp + + tensors = {"embedding": jnp.zeros((512, 1024)), "attention": jnp.zeros((256, 256))} + byte_data = save(tensors) + ``` + """ + np_tensors = _jnp2np(tensors) + return numpy.save(np_tensors, metadata=metadata) + + +def save_file( + tensors: Dict[str, Array], + filename: Union[str, os.PathLike], + metadata: Optional[Dict[str, str]] = None, +) -> None: + """ + Saves a dictionary of tensors into raw bytes in safetensors format. + + Args: + tensors (`Dict[str, Array]`): + The incoming tensors. Tensors need to be contiguous and dense. + filename (`str`, or `os.PathLike`)): + The filename we're saving into. + metadata (`Dict[str, str]`, *optional*, defaults to `None`): + Optional text only metadata you might want to save in your header. + For instance it can be useful to specify more about the underlying + tensors. This is purely informative and does not affect tensor loading. + + Returns: + `None` + + Example: + + ```python + from safetensors.flax import save_file + from jax import numpy as jnp + + tensors = {"embedding": jnp.zeros((512, 1024)), "attention": jnp.zeros((256, 256))} + save_file(tensors, "model.safetensors") + ``` + """ + np_tensors = _jnp2np(tensors) + return numpy.save_file(np_tensors, filename, metadata=metadata) + + +def load(data: bytes) -> Dict[str, Array]: + """ + Loads a safetensors file into flax format from pure bytes. + + Args: + data (`bytes`): + The content of a safetensors file + + Returns: + `Dict[str, Array]`: dictionary that contains name as key, value as `Array` on cpu + + Example: + + ```python + from safetensors.flax import load + + file_path = "./my_folder/bert.safetensors" + with open(file_path, "rb") as f: + data = f.read() + + loaded = load(data) + ``` + """ + flat = numpy.load(data) + return _np2jnp(flat) + + +def load_file(filename: Union[str, os.PathLike]) -> Dict[str, Array]: + """ + Loads a safetensors file into flax format. + + Args: + filename (`str`, or `os.PathLike`)): + The name of the file which contains the tensors + + Returns: + `Dict[str, Array]`: dictionary that contains name as key, value as `Array` + + Example: + + ```python + from safetensors.flax import load_file + + file_path = "./my_folder/bert.safetensors" + loaded = load_file(file_path) + ``` + """ + result = {} + with safe_open(filename, framework="flax") as f: + for k in f.keys(): + result[k] = f.get_tensor(k) + return result + + +def _np2jnp(numpy_dict: Dict[str, np.ndarray]) -> Dict[str, Array]: + for k, v in numpy_dict.items(): + numpy_dict[k] = jnp.array(v) + return numpy_dict + + +def _jnp2np(jnp_dict: Dict[str, Array]) -> Dict[str, np.array]: + for k, v in jnp_dict.items(): + jnp_dict[k] = np.asarray(v) + return jnp_dict diff --git a/env-llmeval/lib/python3.10/site-packages/safetensors/paddle.py b/env-llmeval/lib/python3.10/site-packages/safetensors/paddle.py new file mode 100644 index 0000000000000000000000000000000000000000..b242237af02d6afd4518b6c2795b2123776070d3 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/safetensors/paddle.py @@ -0,0 +1,138 @@ +import os +from typing import Dict, Optional, Union + +import numpy as np + +import paddle +from safetensors import numpy + + +def save(tensors: Dict[str, paddle.Tensor], metadata: Optional[Dict[str, str]] = None) -> bytes: + """ + Saves a dictionary of tensors into raw bytes in safetensors format. + + Args: + tensors (`Dict[str, paddle.Tensor]`): + The incoming tensors. Tensors need to be contiguous and dense. + metadata (`Dict[str, str]`, *optional*, defaults to `None`): + Optional text only metadata you might want to save in your header. + For instance it can be useful to specify more about the underlying + tensors. This is purely informative and does not affect tensor loading. + + Returns: + `bytes`: The raw bytes representing the format + + Example: + + ```python + from safetensors.paddle import save + import paddle + + tensors = {"embedding": paddle.zeros((512, 1024)), "attention": paddle.zeros((256, 256))} + byte_data = save(tensors) + ``` + """ + np_tensors = _paddle2np(tensors) + return numpy.save(np_tensors, metadata=metadata) + + +def save_file( + tensors: Dict[str, paddle.Tensor], + filename: Union[str, os.PathLike], + metadata: Optional[Dict[str, str]] = None, +) -> None: + """ + Saves a dictionary of tensors into raw bytes in safetensors format. + + Args: + tensors (`Dict[str, paddle.Tensor]`): + The incoming tensors. Tensors need to be contiguous and dense. + filename (`str`, or `os.PathLike`)): + The filename we're saving into. + metadata (`Dict[str, str]`, *optional*, defaults to `None`): + Optional text only metadata you might want to save in your header. + For instance it can be useful to specify more about the underlying + tensors. This is purely informative and does not affect tensor loading. + + Returns: + `None` + + Example: + + ```python + from safetensors.paddle import save_file + import paddle + + tensors = {"embedding": paddle.zeros((512, 1024)), "attention": paddle.zeros((256, 256))} + save_file(tensors, "model.safetensors") + ``` + """ + np_tensors = _paddle2np(tensors) + return numpy.save_file(np_tensors, filename, metadata=metadata) + + +def load(data: bytes, device: str = "cpu") -> Dict[str, paddle.Tensor]: + """ + Loads a safetensors file into paddle format from pure bytes. + + Args: + data (`bytes`): + The content of a safetensors file + + Returns: + `Dict[str, paddle.Tensor]`: dictionary that contains name as key, value as `paddle.Tensor` on cpu + + Example: + + ```python + from safetensors.paddle import load + + file_path = "./my_folder/bert.safetensors" + with open(file_path, "rb") as f: + data = f.read() + + loaded = load(data) + ``` + """ + flat = numpy.load(data) + return _np2paddle(flat, device) + + +def load_file(filename: Union[str, os.PathLike], device="cpu") -> Dict[str, paddle.Tensor]: + """ + Loads a safetensors file into paddle format. + + Args: + filename (`str`, or `os.PathLike`)): + The name of the file which contains the tensors + device (`Dict[str, any]`, *optional*, defaults to `cpu`): + The device where the tensors need to be located after load. + available options are all regular paddle device locations + + Returns: + `Dict[str, paddle.Tensor]`: dictionary that contains name as key, value as `paddle.Tensor` + + Example: + + ```python + from safetensors.paddle import load_file + + file_path = "./my_folder/bert.safetensors" + loaded = load_file(file_path) + ``` + """ + flat = numpy.load_file(filename) + output = _np2paddle(flat, device) + return output + + +def _np2paddle(numpy_dict: Dict[str, np.ndarray], device: str = "cpu") -> Dict[str, paddle.Tensor]: + for k, v in numpy_dict.items(): + numpy_dict[k] = paddle.to_tensor(v, place=device) + return numpy_dict + + +def _paddle2np(paddle_dict: Dict[str, paddle.Tensor]) -> Dict[str, np.array]: + for k, v in paddle_dict.items(): + paddle_dict[k] = v.detach().cpu().numpy() + return paddle_dict diff --git a/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/INSTALLER b/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/LICENSE b/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..0744f229d697ca3ed1b1b257bfdb70e3eecf0b9e --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/LICENSE @@ -0,0 +1,153 @@ +Copyright (c) 2006-2023 SymPy Development Team + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + a. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + b. 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. + c. Neither the name of SymPy 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 REGENTS 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. + +-------------------------------------------------------------------------------- + +Patches that were taken from the Diofant project (https://github.com/diofant/diofant) +are licensed as: + +Copyright (c) 2006-2018 SymPy Development Team, + 2013-2023 Sergey B Kirpichev + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + a. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + b. 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. + c. Neither the name of Diofant or SymPy 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 REGENTS 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. + +-------------------------------------------------------------------------------- + +Submodules taken from the multipledispatch project (https://github.com/mrocklin/multipledispatch) +are licensed as: + +Copyright (c) 2014 Matthew Rocklin + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + a. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + b. 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. + c. Neither the name of multipledispatch 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 REGENTS 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. + +-------------------------------------------------------------------------------- + +The files under the directory sympy/parsing/autolev/tests/pydy-example-repo +are directly copied from PyDy project and are licensed as: + +Copyright (c) 2009-2023, PyDy Authors +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 this project 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 PYDY AUTHORS 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. + +-------------------------------------------------------------------------------- + +The files under the directory sympy/parsing/latex +are directly copied from latex2sympy project and are licensed as: + +Copyright 2016, latex2sympy + +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. diff --git a/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/METADATA b/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..6b495e976e13ab24d46fef5e950e03c81d79e5f2 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/METADATA @@ -0,0 +1,307 @@ +Metadata-Version: 2.1 +Name: sympy +Version: 1.12 +Summary: Computer algebra system (CAS) in Python +Home-page: https://sympy.org +Author: SymPy development team +Author-email: sympy@googlegroups.com +License: BSD +Project-URL: Source, https://github.com/sympy/sympy +Keywords: Math CAS +Classifier: License :: OSI Approved :: BSD License +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python +Classifier: Topic :: Scientific/Engineering +Classifier: Topic :: Scientific/Engineering :: Mathematics +Classifier: Topic :: Scientific/Engineering :: Physics +Classifier: Programming Language :: Python :: 3 +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: Programming Language :: Python :: Implementation :: CPython +Classifier: Programming Language :: Python :: Implementation :: PyPy +Requires-Python: >=3.8 +Description-Content-Type: text/markdown +License-File: LICENSE +License-File: AUTHORS +Requires-Dist: mpmath (>=0.19) + +# SymPy + +[![pypi version](https://img.shields.io/pypi/v/sympy.svg)](https://pypi.python.org/pypi/sympy) +[![Join the chat at https://gitter.im/sympy/sympy](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/sympy/sympy?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) +[![Zenodo Badge](https://zenodo.org/badge/18918/sympy/sympy.svg)](https://zenodo.org/badge/latestdoi/18918/sympy/sympy) +[![Downloads](https://pepy.tech/badge/sympy/month)](https://pepy.tech/project/sympy) +[![GitHub Issues](https://img.shields.io/badge/issue_tracking-github-blue.svg)](https://github.com/sympy/sympy/issues) +[![Git Tutorial](https://img.shields.io/badge/PR-Welcome-%23FF8300.svg?)](https://git-scm.com/book/en/v2/GitHub-Contributing-to-a-Project) +[![Powered by NumFocus](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org) +[![Commits since last release](https://img.shields.io/github/commits-since/sympy/sympy/latest.svg?longCache=true&style=flat-square&logo=git&logoColor=fff)](https://github.com/sympy/sympy/releases) + +[![SymPy Banner](https://github.com/sympy/sympy/raw/master/banner.svg)](https://sympy.org/) + + +See the [AUTHORS](AUTHORS) file for the list of authors. + +And many more people helped on the SymPy mailing list, reported bugs, +helped organize SymPy's participation in the Google Summer of Code, the +Google Highly Open Participation Contest, Google Code-In, wrote and +blogged about SymPy... + +License: New BSD License (see the [LICENSE](LICENSE) file for details) covers all +files in the sympy repository unless stated otherwise. + +Our mailing list is at +. + +We have a community chat at [Gitter](https://gitter.im/sympy/sympy). Feel +free to ask us anything there. We have a very welcoming and helpful +community. + +## Download + +The recommended installation method is through Anaconda, + + +You can also get the latest version of SymPy from + + +To get the git version do + + $ git clone https://github.com/sympy/sympy.git + +For other options (tarballs, debs, etc.), see +. + +## Documentation and Usage + +For in-depth instructions on installation and building the +documentation, see the [SymPy Documentation Style Guide](https://docs.sympy.org/dev/documentation-style-guide.html). + +Everything is at: + + + +You can generate everything at the above site in your local copy of +SymPy by: + + $ cd doc + $ make html + +Then the docs will be in \_build/html. If +you don't want to read that, here is a short usage: + +From this directory, start Python and: + +``` python +>>> from sympy import Symbol, cos +>>> x = Symbol('x') +>>> e = 1/cos(x) +>>> print(e.series(x, 0, 10)) +1 + x**2/2 + 5*x**4/24 + 61*x**6/720 + 277*x**8/8064 + O(x**10) +``` + +SymPy also comes with a console that is a simple wrapper around the +classic python console (or IPython when available) that loads the SymPy +namespace and executes some common commands for you. + +To start it, issue: + + $ bin/isympy + +from this directory, if SymPy is not installed or simply: + + $ isympy + +if SymPy is installed. + +## Installation + +SymPy has a hard dependency on the [mpmath](http://mpmath.org/) library +(version \>= 0.19). You should install it first, please refer to the +mpmath installation guide: + + + +To install SymPy using PyPI, run the following command: + + $ pip install sympy + +To install SymPy using Anaconda, run the following command: + + $ conda install -c anaconda sympy + +To install SymPy from GitHub source, first clone SymPy using `git`: + + $ git clone https://github.com/sympy/sympy.git + +Then, in the `sympy` repository that you cloned, simply run: + + $ pip install . + +See for more information. + +## Contributing + +We welcome contributions from anyone, even if you are new to open +source. Please read our [Introduction to Contributing](https://github.com/sympy/sympy/wiki/Introduction-to-contributing) +page and the [SymPy Documentation Style Guide](https://docs.sympy.org/dev/documentation-style-guide.html). If you +are new and looking for some way to contribute, a good place to start is +to look at the issues tagged [Easy to Fix](https://github.com/sympy/sympy/issues?q=is%3Aopen+is%3Aissue+label%3A%22Easy+to+Fix%22). + +Please note that all participants in this project are expected to follow +our Code of Conduct. By participating in this project you agree to abide +by its terms. See [CODE\_OF\_CONDUCT.md](CODE_OF_CONDUCT.md). + +## Tests + +To execute all tests, run: + + $./setup.py test + +in the current directory. + +For the more fine-grained running of tests or doctests, use `bin/test` +or respectively `bin/doctest`. The master branch is automatically tested +by GitHub Actions. + +To test pull requests, use +[sympy-bot](https://github.com/sympy/sympy-bot). + +## Regenerate Experimental LaTeX Parser/Lexer + +The parser and lexer were generated with the [ANTLR4](http://antlr4.org) +toolchain in `sympy/parsing/latex/_antlr` and checked into the repo. +Presently, most users should not need to regenerate these files, but +if you plan to work on this feature, you will need the `antlr4` +command-line tool (and you must ensure that it is in your `PATH`). +One way to get it is: + + $ conda install -c conda-forge antlr=4.11.1 + +Alternatively, follow the instructions on the ANTLR website and download +the `antlr-4.11.1-complete.jar`. Then export the `CLASSPATH` as instructed +and instead of creating `antlr4` as an alias, make it an executable file +with the following contents: +``` bash +#!/bin/bash +java -jar /usr/local/lib/antlr-4.11.1-complete.jar "$@" +``` + +After making changes to `sympy/parsing/latex/LaTeX.g4`, run: + + $ ./setup.py antlr + +## Clean + +To clean everything (thus getting the same tree as in the repository): + + $ git clean -Xdf + +which will clear everything ignored by `.gitignore`, and: + + $ git clean -df + +to clear all untracked files. You can revert the most recent changes in +git with: + + $ git reset --hard + +WARNING: The above commands will all clear changes you may have made, +and you will lose them forever. Be sure to check things with `git +status`, `git diff`, `git clean -Xn`, and `git clean -n` before doing any +of those. + +## Bugs + +Our issue tracker is at . Please +report any bugs that you find. Or, even better, fork the repository on +GitHub and create a pull request. We welcome all changes, big or small, +and we will help you make the pull request if you are new to git (just +ask on our mailing list or Gitter Channel). If you further have any queries, you can find answers +on Stack Overflow using the [sympy](https://stackoverflow.com/questions/tagged/sympy) tag. + +## Brief History + +SymPy was started by Ondřej Čertík in 2005, he wrote some code during +the summer, then he wrote some more code during summer 2006. In February +2007, Fabian Pedregosa joined the project and helped fix many things, +contributed documentation, and made it alive again. 5 students (Mateusz +Paprocki, Brian Jorgensen, Jason Gedge, Robert Schwarz, and Chris Wu) +improved SymPy incredibly during summer 2007 as part of the Google +Summer of Code. Pearu Peterson joined the development during the summer +2007 and he has made SymPy much more competitive by rewriting the core +from scratch, which has made it from 10x to 100x faster. Jurjen N.E. Bos +has contributed pretty-printing and other patches. Fredrik Johansson has +written mpmath and contributed a lot of patches. + +SymPy has participated in every Google Summer of Code since 2007. You +can see for +full details. Each year has improved SymPy by bounds. Most of SymPy's +development has come from Google Summer of Code students. + +In 2011, Ondřej Čertík stepped down as lead developer, with Aaron +Meurer, who also started as a Google Summer of Code student, taking his +place. Ondřej Čertík is still active in the community but is too busy +with work and family to play a lead development role. + +Since then, a lot more people have joined the development and some +people have also left. You can see the full list in doc/src/aboutus.rst, +or online at: + + + +The git history goes back to 2007 when development moved from svn to hg. +To see the history before that point, look at +. + +You can use git to see the biggest developers. The command: + + $ git shortlog -ns + +will show each developer, sorted by commits to the project. The command: + + $ git shortlog -ns --since="1 year" + +will show the top developers from the last year. + +## Citation + +To cite SymPy in publications use + +> Meurer A, Smith CP, Paprocki M, Čertík O, Kirpichev SB, Rocklin M, +> Kumar A, Ivanov S, Moore JK, Singh S, Rathnayake T, Vig S, Granger BE, +> Muller RP, Bonazzi F, Gupta H, Vats S, Johansson F, Pedregosa F, Curry +> MJ, Terrel AR, Roučka Š, Saboo A, Fernando I, Kulal S, Cimrman R, +> Scopatz A. (2017) SymPy: symbolic computing in Python. *PeerJ Computer +> Science* 3:e103 + +A BibTeX entry for LaTeX users is + +``` bibtex +@article{10.7717/peerj-cs.103, + title = {SymPy: symbolic computing in Python}, + author = {Meurer, Aaron and Smith, Christopher P. and Paprocki, Mateusz and \v{C}ert\'{i}k, Ond\v{r}ej and Kirpichev, Sergey B. and Rocklin, Matthew and Kumar, Amit and Ivanov, Sergiu and Moore, Jason K. and Singh, Sartaj and Rathnayake, Thilina and Vig, Sean and Granger, Brian E. and Muller, Richard P. and Bonazzi, Francesco and Gupta, Harsh and Vats, Shivam and Johansson, Fredrik and Pedregosa, Fabian and Curry, Matthew J. and Terrel, Andy R. and Rou\v{c}ka, \v{S}t\v{e}p\'{a}n and Saboo, Ashutosh and Fernando, Isuru and Kulal, Sumith and Cimrman, Robert and Scopatz, Anthony}, + year = 2017, + month = Jan, + keywords = {Python, Computer algebra system, Symbolics}, + abstract = { + SymPy is an open-source computer algebra system written in pure Python. It is built with a focus on extensibility and ease of use, through both interactive and programmatic applications. These characteristics have led SymPy to become a popular symbolic library for the scientific Python ecosystem. This paper presents the architecture of SymPy, a description of its features, and a discussion of select submodules. The supplementary material provides additional examples and further outlines details of the architecture and features of SymPy. + }, + volume = 3, + pages = {e103}, + journal = {PeerJ Computer Science}, + issn = {2376-5992}, + url = {https://doi.org/10.7717/peerj-cs.103}, + doi = {10.7717/peerj-cs.103} +} +``` + +SymPy is BSD licensed, so you are free to use it whatever you like, be +it academic, commercial, creating forks or derivatives, as long as you +copy the BSD statement if you redistribute it (see the LICENSE file for +details). That said, although not required by the SymPy license, if it +is convenient for you, please cite SymPy when using it in your work and +also consider contributing all your changes back, so that we can +incorporate it and all of us will benefit in the end. diff --git a/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/RECORD b/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..23f5e000ca344a8e3cb41822ba3aa1237452e425 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/RECORD @@ -0,0 +1,2932 @@ +../../../bin/isympy,sha256=59kuQYK6Gvi60cWzhDm6BmNQ26kDqo6JdVn49fsPFUo,231 +../../../share/man/man1/isympy.1,sha256=9DZdSOIQLikrATHlbkdDZ04LBQigZDUE0_oCXBDvdBs,6659 +__pycache__/isympy.cpython-310.pyc,, +isympy.py,sha256=gAoHa7OM0y9G5IBO7wO-uTpD-CPnd6sbmjJ_GGB0yzg,11207 +sympy-1.12.dist-info/AUTHORS,sha256=wlSBGC-YWljenH44cUwI510RfR4iTZamMi_aKjJwpUU,48572 +sympy-1.12.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +sympy-1.12.dist-info/LICENSE,sha256=B6XpgZ9ye0mGrSgpx6KaYyDUJXX3IOsk1xt_71c6AoY,7885 +sympy-1.12.dist-info/METADATA,sha256=PsPCJVJrEv6F-QpnHbsxepSvVwxvt2rx2RmuTXXrJqY,12577 +sympy-1.12.dist-info/RECORD,, +sympy-1.12.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92 +sympy-1.12.dist-info/entry_points.txt,sha256=Sp-vLJom4PRlhGfY6RpUre7SjYm33JNq9NCwCGeW-fQ,39 +sympy-1.12.dist-info/top_level.txt,sha256=elXb5xfjLdjgSSoQFk4_2Qu3lp2CIaglF9MQtfIoH7o,13 +sympy/__init__.py,sha256=85o5Yfq2EeAiES9e85A0ZD6n9GvrpanvEdUeu-V5e2w,29005 +sympy/__pycache__/__init__.cpython-310.pyc,, +sympy/__pycache__/abc.cpython-310.pyc,, +sympy/__pycache__/conftest.cpython-310.pyc,, +sympy/__pycache__/galgebra.cpython-310.pyc,, +sympy/__pycache__/release.cpython-310.pyc,, +sympy/__pycache__/this.cpython-310.pyc,, +sympy/abc.py,sha256=P1iQKfXl7Iut6Z5Y97QmGr_UqiAZ6qR-eoRMtYacGfA,3748 +sympy/algebras/__init__.py,sha256=7PRGOW30nlMOTeUPR7iy8l5xGoE2yCBEfRbjqDKWOgU,62 +sympy/algebras/__pycache__/__init__.cpython-310.pyc,, +sympy/algebras/__pycache__/quaternion.cpython-310.pyc,, +sympy/algebras/quaternion.py,sha256=RjAU_1jKNq7LQl4Iuf0BhQ2NtbbCOL3Ytyr_PPjxxlQ,47563 +sympy/algebras/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/algebras/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/algebras/tests/__pycache__/test_quaternion.cpython-310.pyc,, +sympy/algebras/tests/test_quaternion.py,sha256=WTnJxcMkapyNR4QYJFisbwc2kStw2ZYQuEV3hNalhYE,15921 +sympy/assumptions/__init__.py,sha256=PFS8djTqiNbGVMjg7PaPjEfwmjyZVfioXiRVzqqA3E0,550 +sympy/assumptions/__pycache__/__init__.cpython-310.pyc,, +sympy/assumptions/__pycache__/ask.cpython-310.pyc,, +sympy/assumptions/__pycache__/ask_generated.cpython-310.pyc,, +sympy/assumptions/__pycache__/assume.cpython-310.pyc,, +sympy/assumptions/__pycache__/cnf.cpython-310.pyc,, +sympy/assumptions/__pycache__/facts.cpython-310.pyc,, +sympy/assumptions/__pycache__/refine.cpython-310.pyc,, +sympy/assumptions/__pycache__/satask.cpython-310.pyc,, +sympy/assumptions/__pycache__/sathandlers.cpython-310.pyc,, +sympy/assumptions/__pycache__/wrapper.cpython-310.pyc,, +sympy/assumptions/ask.py,sha256=MQZg3JiVEvaZuzMlOUeXjPLuAQlhb5-QNDU8Mw5mNnI,18800 +sympy/assumptions/ask_generated.py,sha256=DSsSGSwjV0K3ASMvWvatFEXviYKXR-1xPwySPsLL-c4,17083 +sympy/assumptions/assume.py,sha256=_gcFc4h_YGs9-tshoD0gmLl_RtPivDQWMWhWWLX9seo,14606 +sympy/assumptions/cnf.py,sha256=axPy2EMLHkIX83_kcsKoRFlpq3x_0YxOEjzt7FHgxc4,12706 +sympy/assumptions/facts.py,sha256=q0SDVbzmU46_8mf63Uao5pYE4MgyrhR9vn94QJqQSv8,7609 +sympy/assumptions/handlers/__init__.py,sha256=lvjAfPdz0MDjTxjuzbBSGBco2OmpZRiGixSG0oaiZi0,330 +sympy/assumptions/handlers/__pycache__/__init__.cpython-310.pyc,, +sympy/assumptions/handlers/__pycache__/calculus.cpython-310.pyc,, +sympy/assumptions/handlers/__pycache__/common.cpython-310.pyc,, +sympy/assumptions/handlers/__pycache__/matrices.cpython-310.pyc,, +sympy/assumptions/handlers/__pycache__/ntheory.cpython-310.pyc,, +sympy/assumptions/handlers/__pycache__/order.cpython-310.pyc,, +sympy/assumptions/handlers/__pycache__/sets.cpython-310.pyc,, +sympy/assumptions/handlers/calculus.py,sha256=ul36wLjxrU_LUxEWX63dWklWHgHWw5xVT0d7BkZCdFE,7198 +sympy/assumptions/handlers/common.py,sha256=sW_viw2xdO9Klqf31x3YlYcGlhgRj52HV1JFmwrgtb4,4064 +sympy/assumptions/handlers/matrices.py,sha256=Gdauk2xk1hKPRr4i6RpvOMHtDnyVD34x1OyhL-Oh8Hc,22321 +sympy/assumptions/handlers/ntheory.py,sha256=2i-EhgO9q1LfDLzN3BZVzHNfaXSsce131XtBr5TEh2I,7213 +sympy/assumptions/handlers/order.py,sha256=Y6Txiykbj4gkibX0mrcUUlhtRWE27p-4lpG4WACX3Ik,12222 +sympy/assumptions/handlers/sets.py,sha256=2Jh2G6Ce1qz9Imzv5et_v-sMxY62j3rFdnp1UZ_PGB8,23818 +sympy/assumptions/predicates/__init__.py,sha256=q1C7iWpvdDymEUZNyzJvZLsLtgwSkYtCixME-fYyIDw,110 +sympy/assumptions/predicates/__pycache__/__init__.cpython-310.pyc,, +sympy/assumptions/predicates/__pycache__/calculus.cpython-310.pyc,, +sympy/assumptions/predicates/__pycache__/common.cpython-310.pyc,, +sympy/assumptions/predicates/__pycache__/matrices.cpython-310.pyc,, +sympy/assumptions/predicates/__pycache__/ntheory.cpython-310.pyc,, +sympy/assumptions/predicates/__pycache__/order.cpython-310.pyc,, +sympy/assumptions/predicates/__pycache__/sets.cpython-310.pyc,, +sympy/assumptions/predicates/calculus.py,sha256=vFnlYVYZVd6D9OwA7-3bDK_Q0jf2iCZCZiMlWenw0Vg,1889 +sympy/assumptions/predicates/common.py,sha256=zpByACpa_tF0nVNB0J_rJehnXkHtkxhchn1DvkVVS-s,2279 +sympy/assumptions/predicates/matrices.py,sha256=X3vbkEf3zwJLyanEjf6ijYXuRfFfSv-yatl1tJ25wDk,12142 +sympy/assumptions/predicates/ntheory.py,sha256=wvFNFSf0S4egbY7REw0V0ANC03CuiRU9PLmdi16VfHo,2546 +sympy/assumptions/predicates/order.py,sha256=ZI4u_WfusMPAEsMFawkSN9QvaMwI3-Jt3-U_xIcGl_8,9508 +sympy/assumptions/predicates/sets.py,sha256=anp-DeJaU2nun3K4O71G_fbqpETozSKynRGuLhiO8xI,8937 +sympy/assumptions/refine.py,sha256=GlC16HC3VNtCHFZNul1tnDCNPy-iOPKZBGjpTbTlbh4,11950 +sympy/assumptions/relation/__init__.py,sha256=t2tZNEIK7w-xXshRQIRL8tIyiNe1W5fMhN7QNRPnQFo,261 +sympy/assumptions/relation/__pycache__/__init__.cpython-310.pyc,, +sympy/assumptions/relation/__pycache__/binrel.cpython-310.pyc,, +sympy/assumptions/relation/__pycache__/equality.cpython-310.pyc,, +sympy/assumptions/relation/binrel.py,sha256=3iwnSEE53-vRsPv-bOnjydgOkCpbB12FTFR_sQ3CwvE,6313 +sympy/assumptions/relation/equality.py,sha256=RbwztgBBVlnfc9-M-IYKonybITSr8WdqWQqwlp2j3V8,7160 +sympy/assumptions/satask.py,sha256=ld_ZWQlxh9R3ElMUBjnqVfwEJ2irPYtJ6vV5mWdzSs0,11280 +sympy/assumptions/sathandlers.py,sha256=Uu_ur8XtxUH5uaAlfGQHEyx2S1-3Q00EFmezDYaGxT0,9428 +sympy/assumptions/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/assumptions/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/assumptions/tests/__pycache__/test_assumptions_2.cpython-310.pyc,, +sympy/assumptions/tests/__pycache__/test_context.cpython-310.pyc,, +sympy/assumptions/tests/__pycache__/test_matrices.cpython-310.pyc,, +sympy/assumptions/tests/__pycache__/test_query.cpython-310.pyc,, +sympy/assumptions/tests/__pycache__/test_refine.cpython-310.pyc,, +sympy/assumptions/tests/__pycache__/test_satask.cpython-310.pyc,, +sympy/assumptions/tests/__pycache__/test_sathandlers.cpython-310.pyc,, +sympy/assumptions/tests/__pycache__/test_wrapper.cpython-310.pyc,, +sympy/assumptions/tests/test_assumptions_2.py,sha256=oNgIDOoW-GpBbXxbtw05SWnE8I7sGislYmB3MDogwB4,1070 +sympy/assumptions/tests/test_context.py,sha256=I5gES7AY9_vz1-CEaCchy4MXABtX85ncNkvoRuLskG8,1153 +sympy/assumptions/tests/test_matrices.py,sha256=nzSofuawc18hNe9Nj0dN_lTeDwa2KbPjt4K2rvb3xmw,12258 +sympy/assumptions/tests/test_query.py,sha256=teHsXTfPw_q4197tXcz2Ov-scVxDHP-T_LpcELmOMnI,97999 +sympy/assumptions/tests/test_refine.py,sha256=bHxYUnCOEIzA1yPU3B2xbU9JZfhDv6RkmPm8esetisQ,8834 +sympy/assumptions/tests/test_satask.py,sha256=IIqqIxzkLfANpTNBKEsCGCp3Bm8zmDnYd23woqKh9EE,15741 +sympy/assumptions/tests/test_sathandlers.py,sha256=jMCZQb3G6pVQ5MHaSTWV_0eULHaCF8Mowu12Ll72rgs,1842 +sympy/assumptions/tests/test_wrapper.py,sha256=iE32j83rrerCz85HHt2hTolgJkqb44KddfEpI3H1Fb8,1159 +sympy/assumptions/wrapper.py,sha256=nZ3StKi-Q0q_HmdwpzZEcE7WQFcVtnB28QBvYe_O220,5514 +sympy/benchmarks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/benchmarks/__pycache__/__init__.cpython-310.pyc,, +sympy/benchmarks/__pycache__/bench_discrete_log.cpython-310.pyc,, +sympy/benchmarks/__pycache__/bench_meijerint.cpython-310.pyc,, +sympy/benchmarks/__pycache__/bench_symbench.cpython-310.pyc,, +sympy/benchmarks/bench_discrete_log.py,sha256=CNchIJ5HFMPpNlVZh2vOU0GgQ3bse6hqyqDovpDHlKE,2473 +sympy/benchmarks/bench_meijerint.py,sha256=dSNdZhoc8a4h50wRtbOxLwpmgUiuMFpe6ytTLURcplY,11610 +sympy/benchmarks/bench_symbench.py,sha256=UMD3eYf_Poht0qxjdH2_axGwwON6cZo1Sp700Ci1M1M,2997 +sympy/calculus/__init__.py,sha256=IWDc6qPbEcWyTm9QM6V8vSAs-5OtGNijimykoWz3Clc,828 +sympy/calculus/__pycache__/__init__.cpython-310.pyc,, +sympy/calculus/__pycache__/accumulationbounds.cpython-310.pyc,, +sympy/calculus/__pycache__/euler.cpython-310.pyc,, +sympy/calculus/__pycache__/finite_diff.cpython-310.pyc,, +sympy/calculus/__pycache__/singularities.cpython-310.pyc,, +sympy/calculus/__pycache__/util.cpython-310.pyc,, +sympy/calculus/accumulationbounds.py,sha256=DpFXDYbjSxx0icrx1HagArBeyVx5aSAX83vYuXSGMRI,28692 +sympy/calculus/euler.py,sha256=0QrHD9TYKlSZuO8drnU3bUFJrSu8v5SncqtkRSWLjGM,3436 +sympy/calculus/finite_diff.py,sha256=X7qZJ5GmHlHKokUUMFoaQqrqX2jLRq4b7W2G5aWntzM,17053 +sympy/calculus/singularities.py,sha256=ctVHpnE4Z7iE6tNAssMWmdXu9qWXOXzVJasLxC-cToQ,11757 +sympy/calculus/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/calculus/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/calculus/tests/__pycache__/test_accumulationbounds.cpython-310.pyc,, +sympy/calculus/tests/__pycache__/test_euler.cpython-310.pyc,, +sympy/calculus/tests/__pycache__/test_finite_diff.cpython-310.pyc,, +sympy/calculus/tests/__pycache__/test_singularities.cpython-310.pyc,, +sympy/calculus/tests/__pycache__/test_util.cpython-310.pyc,, +sympy/calculus/tests/test_accumulationbounds.py,sha256=a_Ry2nKX5WbhSe1Bk2k0W6-VWOpVTg0FnA9u8rNSIV4,11195 +sympy/calculus/tests/test_euler.py,sha256=YWpts4pWSiYEwRsi5DLQ16JgC9109-9NKZIL_IO6_Aw,2683 +sympy/calculus/tests/test_finite_diff.py,sha256=V52uNDNvarcK_FXnWrPZjifFMRWTy_2H4lt3FmvA4W4,7760 +sympy/calculus/tests/test_singularities.py,sha256=zVCHJyjVFw9xpQ_EFCsA33zBGwCQ8gSeLtbLGA9t0uQ,4215 +sympy/calculus/tests/test_util.py,sha256=S5_YEGW0z7xzzthShrSsg2wAmzE9mR4u4Ndzuzw_Gx8,15034 +sympy/calculus/util.py,sha256=ViXMvleQIIStquHN01CpTUPYxu3jgC57GaCOkuXRsoU,26097 +sympy/categories/__init__.py,sha256=XiKBVC6pbDED-OVtNlSH-fGB8dB_jWLqwCEO7wBTAyA,984 +sympy/categories/__pycache__/__init__.cpython-310.pyc,, +sympy/categories/__pycache__/baseclasses.cpython-310.pyc,, +sympy/categories/__pycache__/diagram_drawing.cpython-310.pyc,, +sympy/categories/baseclasses.py,sha256=G3wCiNCgNiTLLFZxGLd2ZFmnsbiRxhapSfZWlWSC508,31411 +sympy/categories/diagram_drawing.py,sha256=W88A89uDs8qKZlxVLqWuqmEOBwTMomtl_u8sFe9wqdU,95500 +sympy/categories/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/categories/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/categories/tests/__pycache__/test_baseclasses.cpython-310.pyc,, +sympy/categories/tests/__pycache__/test_drawing.cpython-310.pyc,, +sympy/categories/tests/test_baseclasses.py,sha256=SwD6QsfSlrEdpD2dbkcN62CPVIRP5SadjCplLrMAoa8,5767 +sympy/categories/tests/test_drawing.py,sha256=IELPpadmnQyQ2x5a5qHC8ioq5kfT1UnAl4h1vO3gbqg,27848 +sympy/codegen/__init__.py,sha256=sQcJsyLyoRh9ccOPhv2eZ-wHjQrArByOON9ndj-MYgQ,974 +sympy/codegen/__pycache__/__init__.cpython-310.pyc,, +sympy/codegen/__pycache__/abstract_nodes.cpython-310.pyc,, +sympy/codegen/__pycache__/algorithms.cpython-310.pyc,, +sympy/codegen/__pycache__/approximations.cpython-310.pyc,, +sympy/codegen/__pycache__/ast.cpython-310.pyc,, +sympy/codegen/__pycache__/cfunctions.cpython-310.pyc,, +sympy/codegen/__pycache__/cnodes.cpython-310.pyc,, +sympy/codegen/__pycache__/cutils.cpython-310.pyc,, +sympy/codegen/__pycache__/cxxnodes.cpython-310.pyc,, +sympy/codegen/__pycache__/fnodes.cpython-310.pyc,, +sympy/codegen/__pycache__/futils.cpython-310.pyc,, +sympy/codegen/__pycache__/matrix_nodes.cpython-310.pyc,, +sympy/codegen/__pycache__/numpy_nodes.cpython-310.pyc,, +sympy/codegen/__pycache__/pynodes.cpython-310.pyc,, +sympy/codegen/__pycache__/pyutils.cpython-310.pyc,, +sympy/codegen/__pycache__/rewriting.cpython-310.pyc,, +sympy/codegen/__pycache__/scipy_nodes.cpython-310.pyc,, +sympy/codegen/abstract_nodes.py,sha256=TY4ecftqnym5viYInnb59zGPPFXdeSGQwi--xTz6Pvo,490 +sympy/codegen/algorithms.py,sha256=_isSQBzQzn1xKkYhYEF7nVK1sCa7n78Qo5AoCeNs8eU,5056 +sympy/codegen/approximations.py,sha256=UnVbikz2vjJo8DtE02ipa6ZEsCe5lXOT_r16F5ByW4Q,6447 +sympy/codegen/ast.py,sha256=tBRSHBvDz4_Z_FiFy1d48x1URHPtAVCJUiwQihpc5zA,56374 +sympy/codegen/cfunctions.py,sha256=SGLPIMgGE9o9RhaThTgVcmnFCKbxNZvukqp3uvqv0Vw,11812 +sympy/codegen/cnodes.py,sha256=ZFBxHsRBUcQ14EJRURZXh9EjTsSSJGwmWubfmpE0-p4,2823 +sympy/codegen/cutils.py,sha256=vlzMs8OkC5Bu4sIP-AF2mYf_tIo7Uo4r2DAI_LNhZzM,383 +sympy/codegen/cxxnodes.py,sha256=Om-EBfYduFF97tgXOF68rr8zYbngem9kBRm9SJiKLSM,342 +sympy/codegen/fnodes.py,sha256=P7I-TD-4H4Dr4bxFNS7p46OD9bi32l8SpFEezVWutSY,18931 +sympy/codegen/futils.py,sha256=k-mxMJKr_Q_afTy6NrKNl_N2XQLBmSdZAssO5hBonNY,1792 +sympy/codegen/matrix_nodes.py,sha256=Hhip0cbBj27i-4JwVinkEt4PHRbAIe5ERxwyywoSJm8,2089 +sympy/codegen/numpy_nodes.py,sha256=23inRIlvAF2wzaJGhi1NUg8R7NRbhtDrqICDZN909jw,3137 +sympy/codegen/pynodes.py,sha256=Neo1gFQ9kC31T-gH8TeeCaDDNaDe5deIP97MRZFgMHk,243 +sympy/codegen/pyutils.py,sha256=HfF6SP710Y7yExZcSesI0usVaDiWdEPEmMtyMD3JtOY,838 +sympy/codegen/rewriting.py,sha256=EeSOC-fawTxFiueMIuMlSFPuES_97hhxC2hjoZ_6pPQ,11591 +sympy/codegen/scipy_nodes.py,sha256=hYlxtGyTM0Z64Nazm1TeMZ3Y8dMsiD_HNhNvbU9eiQY,2508 +sympy/codegen/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/codegen/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/codegen/tests/__pycache__/test_abstract_nodes.cpython-310.pyc,, +sympy/codegen/tests/__pycache__/test_algorithms.cpython-310.pyc,, +sympy/codegen/tests/__pycache__/test_applications.cpython-310.pyc,, +sympy/codegen/tests/__pycache__/test_approximations.cpython-310.pyc,, +sympy/codegen/tests/__pycache__/test_ast.cpython-310.pyc,, +sympy/codegen/tests/__pycache__/test_cfunctions.cpython-310.pyc,, +sympy/codegen/tests/__pycache__/test_cnodes.cpython-310.pyc,, +sympy/codegen/tests/__pycache__/test_cxxnodes.cpython-310.pyc,, +sympy/codegen/tests/__pycache__/test_fnodes.cpython-310.pyc,, +sympy/codegen/tests/__pycache__/test_numpy_nodes.cpython-310.pyc,, +sympy/codegen/tests/__pycache__/test_pynodes.cpython-310.pyc,, +sympy/codegen/tests/__pycache__/test_pyutils.cpython-310.pyc,, +sympy/codegen/tests/__pycache__/test_rewriting.cpython-310.pyc,, +sympy/codegen/tests/__pycache__/test_scipy_nodes.cpython-310.pyc,, +sympy/codegen/tests/test_abstract_nodes.py,sha256=a_GKf3FpeNN8zfMc-V8AaSrQtEI1oiLfJOco2VKiSKI,451 +sympy/codegen/tests/test_algorithms.py,sha256=gvDTHZnC_lZ4Uvt7BTSfjMuDTyM0Bilm-sWMUpSM06I,4700 +sympy/codegen/tests/test_applications.py,sha256=DWDpSsiVQy7S6pjnBSErWxDpPDRRLL8ncTMWWwaI3R4,2189 +sympy/codegen/tests/test_approximations.py,sha256=SZpOUzahb_bJOceD0DLdmeiw-jN37OPmf5TRp1dyRgM,2035 +sympy/codegen/tests/test_ast.py,sha256=aAWk-yAVVNAmFMkyUlYBbVA8mPlTFqULOtmXMEi3LO8,21688 +sympy/codegen/tests/test_cfunctions.py,sha256=EuRwj9U00iLc2--qtY2YD7TpICndQ0gVsCXTYHrIFhQ,4613 +sympy/codegen/tests/test_cnodes.py,sha256=FlI5XP39K3kC1QWKQ-QKkzNQw8TROjj5mKXJhK1UU2c,3039 +sympy/codegen/tests/test_cxxnodes.py,sha256=5OwN8D_ZtKN9z5uNeUwbUkyAGzNLrTgIKUlcRWmOSpE,366 +sympy/codegen/tests/test_fnodes.py,sha256=r206n8YM0D1vFP0vdjUaAR7QRpmUWw8VmqSMFxh8FU8,6643 +sympy/codegen/tests/test_numpy_nodes.py,sha256=VcG7eGVlzx9sSKRp1n9zfK0NjigxY5WOW6F_nQnnnSs,1658 +sympy/codegen/tests/test_pynodes.py,sha256=Gso18KKzSwA-1AHC55SgHPAfH1GrGUCGaN6QR7iuEO0,432 +sympy/codegen/tests/test_pyutils.py,sha256=jr5QGvUP0M1Rr2_7vHTazlMaJOoMHztqFTxT6EkBcb4,285 +sympy/codegen/tests/test_rewriting.py,sha256=ELPziNI3CsJ4VS7mUbk4QWyG_94FbgZCdBKieMN20Vc,15852 +sympy/codegen/tests/test_scipy_nodes.py,sha256=LBWpjTRfgWN5NLTchLZEp6m7IMtu7HbiKoztLc6KNGY,1495 +sympy/combinatorics/__init__.py,sha256=Dx9xakpHuTIgy4G8zVjAY6pTu8J9_K3d_jKPizRMdVo,1500 +sympy/combinatorics/__pycache__/__init__.cpython-310.pyc,, +sympy/combinatorics/__pycache__/coset_table.cpython-310.pyc,, +sympy/combinatorics/__pycache__/fp_groups.cpython-310.pyc,, +sympy/combinatorics/__pycache__/free_groups.cpython-310.pyc,, +sympy/combinatorics/__pycache__/galois.cpython-310.pyc,, +sympy/combinatorics/__pycache__/generators.cpython-310.pyc,, +sympy/combinatorics/__pycache__/graycode.cpython-310.pyc,, +sympy/combinatorics/__pycache__/group_constructs.cpython-310.pyc,, +sympy/combinatorics/__pycache__/group_numbers.cpython-310.pyc,, +sympy/combinatorics/__pycache__/homomorphisms.cpython-310.pyc,, +sympy/combinatorics/__pycache__/named_groups.cpython-310.pyc,, +sympy/combinatorics/__pycache__/partitions.cpython-310.pyc,, +sympy/combinatorics/__pycache__/pc_groups.cpython-310.pyc,, +sympy/combinatorics/__pycache__/perm_groups.cpython-310.pyc,, +sympy/combinatorics/__pycache__/permutations.cpython-310.pyc,, +sympy/combinatorics/__pycache__/polyhedron.cpython-310.pyc,, +sympy/combinatorics/__pycache__/prufer.cpython-310.pyc,, +sympy/combinatorics/__pycache__/rewritingsystem.cpython-310.pyc,, +sympy/combinatorics/__pycache__/rewritingsystem_fsm.cpython-310.pyc,, +sympy/combinatorics/__pycache__/schur_number.cpython-310.pyc,, +sympy/combinatorics/__pycache__/subsets.cpython-310.pyc,, +sympy/combinatorics/__pycache__/tensor_can.cpython-310.pyc,, +sympy/combinatorics/__pycache__/testutil.cpython-310.pyc,, +sympy/combinatorics/__pycache__/util.cpython-310.pyc,, +sympy/combinatorics/coset_table.py,sha256=A3O5l1tkFmF1mEqiab08eBcR6lAdiqKJ2uPao3Ucvlk,42935 +sympy/combinatorics/fp_groups.py,sha256=QjeCEGBfTBbMZd-WpCOY5iEUyt8O7eJXa3RDLfMC7wk,47800 +sympy/combinatorics/free_groups.py,sha256=OnsEnMF6eehIFdM5m7RHkc9R_LFIahGJL3bAEv1pR6k,39534 +sympy/combinatorics/galois.py,sha256=0kz71xGJDKgJm-9dXr4YTMkfaHPowCUImpK9x-n3VNU,17863 +sympy/combinatorics/generators.py,sha256=vUIe0FgHGVFA5omJH-qHQP6NmqmnuVVV8n2RFnpTrKc,7481 +sympy/combinatorics/graycode.py,sha256=xbtr8AaFYb4SMmwUi7mf7913U87jH-XEYF_3pGZfj0o,11207 +sympy/combinatorics/group_constructs.py,sha256=IKx12_yWJqEQ7g-oBuAWd5VRLbCOWyL0LG4PQu43BS8,2021 +sympy/combinatorics/group_numbers.py,sha256=QuB-EvXmTulg5MuI4aLE3GlmFNTGKulAP-DQW9TBXU4,3073 +sympy/combinatorics/homomorphisms.py,sha256=s8bzIv4liVXwqJT2IuYPseQW4MBW2-zDpdHUXQsf7dU,18828 +sympy/combinatorics/named_groups.py,sha256=zd_C9epKDrMG0drafGUcHuuJJkcMaDt1Nf2ik4NXNq8,8378 +sympy/combinatorics/partitions.py,sha256=ZXqVmVNjmauhMeiTWtCCqOP38b9MJg7UlBdZa-7aICQ,20841 +sympy/combinatorics/pc_groups.py,sha256=IROCLM63p4ATazWsK9qRxmx8bZjoMhWxOrTm0Q5RRpo,21351 +sympy/combinatorics/perm_groups.py,sha256=mhAE82DSVM7x2YoS4ADdwLoWxzuGLVOjeaVGJnz9EY8,185087 +sympy/combinatorics/permutations.py,sha256=2f63LyIytpdDUbPyv44DqcGUJxtbfMEJFpyGuSq4xoY,87647 +sympy/combinatorics/polyhedron.py,sha256=OYRMNVwTxT97p4sG4EScl4a2QnBIvyutIPFBzxAfCLU,35942 +sympy/combinatorics/prufer.py,sha256=v-lHZN2ZhjOTS3_jLjw44Q9F7suS3VdgXThh1Sg6CRI,12086 +sympy/combinatorics/rewritingsystem.py,sha256=XTQUZpLIr6H1UBLao_ni1UAoIMB8V5Bpfp8BBCV9g5c,17097 +sympy/combinatorics/rewritingsystem_fsm.py,sha256=CKGhLqyvxY0mlmy8_Hb4WzkSdWYPUaU2yZYhz-0iZ5w,2433 +sympy/combinatorics/schur_number.py,sha256=YdsyA7n_z9tyfRTSRfIjEjtnGo5EuDGBMUS09AQ2MxU,4437 +sympy/combinatorics/subsets.py,sha256=oxuExuGyFnvunkmktl-vBYiLbiN66A2Q2MyzwWfy46A,16047 +sympy/combinatorics/tensor_can.py,sha256=h6NTaH99oG0g1lVxhShBY2Fc4IwXyMUc0Ih31KI6kFw,40776 +sympy/combinatorics/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/combinatorics/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_coset_table.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_fp_groups.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_free_groups.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_galois.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_generators.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_graycode.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_group_constructs.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_group_numbers.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_homomorphisms.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_named_groups.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_partitions.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_pc_groups.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_perm_groups.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_permutations.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_polyhedron.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_prufer.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_rewriting.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_schur_number.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_subsets.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_tensor_can.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_testutil.cpython-310.pyc,, +sympy/combinatorics/tests/__pycache__/test_util.cpython-310.pyc,, +sympy/combinatorics/tests/test_coset_table.py,sha256=cEUF0OH6SNhN_kh069wMsq6h4eSVqbDLghrg2r9Ht48,28474 +sympy/combinatorics/tests/test_fp_groups.py,sha256=7ATMwzPvAoWiH7Cex-D63nmlOa20h70zO5TWGVisFwM,9969 +sympy/combinatorics/tests/test_free_groups.py,sha256=h3tPyjMA79M9QMc0rOlgVXU31lZ0s_xoY_YIVsVz0Fg,6161 +sympy/combinatorics/tests/test_galois.py,sha256=w35JRx8lmlXCdzUBNdocgATPYWBOEZ6LH-tAxOPwCQ8,2763 +sympy/combinatorics/tests/test_generators.py,sha256=6YpOp0i5PRGtySPNZseQ8mjSXbwpfGfz0hDB4kfk40Q,3567 +sympy/combinatorics/tests/test_graycode.py,sha256=pI4e7Y615d5Bmmxui6fdEeyca6j6KSD0YmeychV6ORk,2800 +sympy/combinatorics/tests/test_group_constructs.py,sha256=jJLwMdhuUalKv4Aql9SzV2utK8Ex-IYdMecggr95pi8,450 +sympy/combinatorics/tests/test_group_numbers.py,sha256=nRxK4R8Cdq4Ni9e_6n4fRjir3VBOmXMzAIXnlRNQD3Y,989 +sympy/combinatorics/tests/test_homomorphisms.py,sha256=UwBj5loCuZAiuvmqy5VAbwhCQTph8o6BzTaGrH0rzB4,3745 +sympy/combinatorics/tests/test_named_groups.py,sha256=tsuDVGv4iHGEZ0BVR87_ENhyAfZvFIl0M6Dv_HX1VoY,1931 +sympy/combinatorics/tests/test_partitions.py,sha256=oppszKJLLSpcEzHgespIveSmEC3fDZ0qkus1k7MBt4E,4097 +sympy/combinatorics/tests/test_pc_groups.py,sha256=wfkY_ilpG0XWrhaWMVK6r7yWMeXfM8WNTyti5oE9bdk,2728 +sympy/combinatorics/tests/test_perm_groups.py,sha256=t-bERPQXU4pKAEHR3caHemGMnQ2qh9leIOz0-hB8vjo,41191 +sympy/combinatorics/tests/test_permutations.py,sha256=IfOxSCY18glt_8lqovnjtXyz9OX02ZQaUE47aCUzKIA,20149 +sympy/combinatorics/tests/test_polyhedron.py,sha256=3SWkFQKeF-p1QWP4Iu9NIA1oTxAFo1BLRrrLerBFAhw,4180 +sympy/combinatorics/tests/test_prufer.py,sha256=OTJp0NxjiVswWkOuCIlnGFU2Gw4noRsrPpUJtp2XhEs,2649 +sympy/combinatorics/tests/test_rewriting.py,sha256=3COHq74k6knt2rqE7hfd4ZP_6whf0Kg14tYxFmTtYrI,1787 +sympy/combinatorics/tests/test_schur_number.py,sha256=wg13uTumFltWIGbVg_PEr6nhXIru19UWitsEZiakoRI,1727 +sympy/combinatorics/tests/test_subsets.py,sha256=6pyhLYV5HuXvx63r-gGVHr8LSrGRXcpDudhFn9fBqX8,2635 +sympy/combinatorics/tests/test_tensor_can.py,sha256=olH5D5wwTBOkZXjtqvLO6RKbvCG9KoMVK4__wDe95N4,24676 +sympy/combinatorics/tests/test_testutil.py,sha256=uJlO09XgD-tImCWu1qkajiC07rK3GoN91v3_OqT5-qo,1729 +sympy/combinatorics/tests/test_util.py,sha256=sOYMWHxlbM0mqalqA7jNrYMm8DKcf_GwL5YBjs96_C4,4499 +sympy/combinatorics/testutil.py,sha256=Nw0En7kI9GMjca287aht1HNaTjBFv8ulq0E1rgtpO6Q,11152 +sympy/combinatorics/util.py,sha256=LIu_8__RKMv8EfXAfkr08UKYSMq5hGJBLHyDSS5nd-8,16297 +sympy/concrete/__init__.py,sha256=2HDmg3VyLgM_ZPw3XsGpkOClGiQnyTlUNHSwVTtizA0,144 +sympy/concrete/__pycache__/__init__.cpython-310.pyc,, +sympy/concrete/__pycache__/delta.cpython-310.pyc,, +sympy/concrete/__pycache__/expr_with_intlimits.cpython-310.pyc,, +sympy/concrete/__pycache__/expr_with_limits.cpython-310.pyc,, +sympy/concrete/__pycache__/gosper.cpython-310.pyc,, +sympy/concrete/__pycache__/guess.cpython-310.pyc,, +sympy/concrete/__pycache__/products.cpython-310.pyc,, +sympy/concrete/__pycache__/summations.cpython-310.pyc,, +sympy/concrete/delta.py,sha256=xDtz1yXnd-WRIu3nnJFBIrA01PLOUT3XU1znPeVATU0,9958 +sympy/concrete/expr_with_intlimits.py,sha256=vj4PjttB9xE5aUYu37R1A4_KtGgxcPa65jzjv8-krsc,11352 +sympy/concrete/expr_with_limits.py,sha256=txn7gbh-Yqw0-ZBGvN9iFNsPW13wD2z7alf8EyQVZ4U,21832 +sympy/concrete/gosper.py,sha256=3q8gkZz_oAeBOBUfObMvwArBkBKYReHR0prVXMIqrNE,5557 +sympy/concrete/guess.py,sha256=Ha12uphLNfo3AbfsGy85JsPxhbiAXJemwpz9QXRtp48,17472 +sympy/concrete/products.py,sha256=s6E_Z0KuHx8MzbJzaJo2NP5aTpgIo3-oqGwgYh_osnE,18608 +sympy/concrete/summations.py,sha256=jhmU5WCz98Oon3oosHUsM8sp6ErjPGCz25rbKn5hqS8,55371 +sympy/concrete/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/concrete/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/concrete/tests/__pycache__/test_delta.cpython-310.pyc,, +sympy/concrete/tests/__pycache__/test_gosper.cpython-310.pyc,, +sympy/concrete/tests/__pycache__/test_guess.cpython-310.pyc,, +sympy/concrete/tests/__pycache__/test_products.cpython-310.pyc,, +sympy/concrete/tests/__pycache__/test_sums_products.cpython-310.pyc,, +sympy/concrete/tests/test_delta.py,sha256=uI7xjMx7JuVb3kkN7cLR6_pGsKS4Ulq22p-Z9oti5Jc,23869 +sympy/concrete/tests/test_gosper.py,sha256=ZHiZfYGCeCS9I-0oqN6sFbiYa-284GeFoGsNbhIWq4I,7987 +sympy/concrete/tests/test_guess.py,sha256=TPW6Hy11Po6VLZG_dx95x3sMBYl5kcQH8wjJ6TOtu-k,3370 +sympy/concrete/tests/test_products.py,sha256=caYc-xlEIrX9I_A-KPQdwp5oDprVJSbfcOaKg_qUnsM,14521 +sympy/concrete/tests/test_sums_products.py,sha256=0ti3g4D8hBpvpsSrc2CYIRxVwqLORKO5K88offDwKfM,64458 +sympy/conftest.py,sha256=3vg-GlDw8Y8MGoa324FoRJR3HaRaJhZpiXdTTVoNAoI,2245 +sympy/core/__init__.py,sha256=LQBkB1S-CYmQ3P24ei_kHcsMwtbDobn3BqzJQ-rJ1Hs,3050 +sympy/core/__pycache__/__init__.cpython-310.pyc,, +sympy/core/__pycache__/_print_helpers.cpython-310.pyc,, +sympy/core/__pycache__/add.cpython-310.pyc,, +sympy/core/__pycache__/alphabets.cpython-310.pyc,, +sympy/core/__pycache__/assumptions.cpython-310.pyc,, +sympy/core/__pycache__/assumptions_generated.cpython-310.pyc,, +sympy/core/__pycache__/backend.cpython-310.pyc,, +sympy/core/__pycache__/basic.cpython-310.pyc,, +sympy/core/__pycache__/cache.cpython-310.pyc,, +sympy/core/__pycache__/compatibility.cpython-310.pyc,, +sympy/core/__pycache__/containers.cpython-310.pyc,, +sympy/core/__pycache__/core.cpython-310.pyc,, +sympy/core/__pycache__/coreerrors.cpython-310.pyc,, +sympy/core/__pycache__/decorators.cpython-310.pyc,, +sympy/core/__pycache__/evalf.cpython-310.pyc,, +sympy/core/__pycache__/expr.cpython-310.pyc,, +sympy/core/__pycache__/exprtools.cpython-310.pyc,, +sympy/core/__pycache__/facts.cpython-310.pyc,, +sympy/core/__pycache__/function.cpython-310.pyc,, +sympy/core/__pycache__/kind.cpython-310.pyc,, +sympy/core/__pycache__/logic.cpython-310.pyc,, +sympy/core/__pycache__/mod.cpython-310.pyc,, +sympy/core/__pycache__/mul.cpython-310.pyc,, +sympy/core/__pycache__/multidimensional.cpython-310.pyc,, +sympy/core/__pycache__/numbers.cpython-310.pyc,, +sympy/core/__pycache__/operations.cpython-310.pyc,, +sympy/core/__pycache__/parameters.cpython-310.pyc,, +sympy/core/__pycache__/power.cpython-310.pyc,, +sympy/core/__pycache__/random.cpython-310.pyc,, +sympy/core/__pycache__/relational.cpython-310.pyc,, +sympy/core/__pycache__/rules.cpython-310.pyc,, +sympy/core/__pycache__/singleton.cpython-310.pyc,, +sympy/core/__pycache__/sorting.cpython-310.pyc,, +sympy/core/__pycache__/symbol.cpython-310.pyc,, +sympy/core/__pycache__/sympify.cpython-310.pyc,, +sympy/core/__pycache__/trace.cpython-310.pyc,, +sympy/core/__pycache__/traversal.cpython-310.pyc,, +sympy/core/_print_helpers.py,sha256=GQo9dI_BvAJtYHVFFfmroNr0L8d71UeI-tU7SGJgctk,2388 +sympy/core/add.py,sha256=9VDeDODPv3Y72EWa4Xiypy3i67DzbNlPUYAEZXhEwEw,43747 +sympy/core/alphabets.py,sha256=vWBs2atOvfRK6Xfg6hc5IKiB7s_0sZIiVJpcCUJL0N4,266 +sympy/core/assumptions.py,sha256=P7c11DL5VD_94v1Dc5LofIy6Atrth7FZp03rDr4ftQ4,23582 +sympy/core/assumptions_generated.py,sha256=0TJKYIHSIFyQcVHZdIHZ19b7tqst_sY7iZwjKzcvZBM,42817 +sympy/core/backend.py,sha256=AUgGtYmz0mIoVmjKVMAa5ZzlC1p5anxk-N4Sy7pePNo,3842 +sympy/core/basic.py,sha256=1wRiJLAILhJK2uVTAtuxlCFWKXCKT-PECXve4rfXWs0,72857 +sympy/core/benchmarks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/core/benchmarks/__pycache__/__init__.cpython-310.pyc,, +sympy/core/benchmarks/__pycache__/bench_arit.cpython-310.pyc,, +sympy/core/benchmarks/__pycache__/bench_assumptions.cpython-310.pyc,, +sympy/core/benchmarks/__pycache__/bench_basic.cpython-310.pyc,, +sympy/core/benchmarks/__pycache__/bench_expand.cpython-310.pyc,, +sympy/core/benchmarks/__pycache__/bench_numbers.cpython-310.pyc,, +sympy/core/benchmarks/__pycache__/bench_sympify.cpython-310.pyc,, +sympy/core/benchmarks/bench_arit.py,sha256=gfrnvKSXLCaUoFFxMgJhnLUp7rG9Pa_YT7OKgOrPP8E,412 +sympy/core/benchmarks/bench_assumptions.py,sha256=evfZzTgOUUvvvlK0DRdDZQRqxIlGLfJYzKu8QDMxSks,177 +sympy/core/benchmarks/bench_basic.py,sha256=YF0tTJ_AN_Wz11qidzM4bIhlwEhEqVc-IGVGrUx6SaA,210 +sympy/core/benchmarks/bench_expand.py,sha256=xgQYQMwqgXJtKajM4JVhuL-7AW8TLY-vdBpO6uyMDoQ,427 +sympy/core/benchmarks/bench_numbers.py,sha256=fvcbOkslXdADqiX_amiL-BEUtrXBfdiTZeOtbiI2auI,1105 +sympy/core/benchmarks/bench_sympify.py,sha256=G5iGInhhbkkxSY2pS08BNG945m9m4eZlNT1aJutGt5M,138 +sympy/core/cache.py,sha256=AyG7kganyV0jVx-aNBEUFogqRLHQqqFn8xU3ZSfJoaM,6172 +sympy/core/compatibility.py,sha256=XQH7ezmRi6l3R23qMHN2wfA-YMRWbh2YYjPY7LRo3lo,1145 +sympy/core/containers.py,sha256=ic6uSNItz5JgL8Dx8T87gcnpiGwOxvf6FaQVgIRWWoo,11315 +sympy/core/core.py,sha256=3pIrJokfb2Rn8S2XudM3JyQVEqY1vZhSEZ-1tkUmqYg,1797 +sympy/core/coreerrors.py,sha256=OKpJwk_yE3ZMext49R-QwtTudZaXZbmTspaq1ZMMpAU,272 +sympy/core/decorators.py,sha256=de6eYm3D_YdEW1rEKOIES_aEyvbjqRM98I67l8QGGVU,8217 +sympy/core/evalf.py,sha256=HL9frdDL3OXiF08CXISADkmCx7_KjcAt_nYu4m_IKyM,61889 +sympy/core/expr.py,sha256=_lGEDOkQX57uMh275-NGY3Mus6lrQP-cCW_b6xngy_w,142568 +sympy/core/exprtools.py,sha256=mCUxyyQZDSceU7eHPxV3C0mBUWI4a2Qz_LhZxJ5FXY8,51459 +sympy/core/facts.py,sha256=54pFKhJwEzU8LkO7rL25TwGjIb5y5CvZleHEy_TpD68,19546 +sympy/core/function.py,sha256=TuxxpFyc9y5s5dQH3hZnjEovhoZM0nDQNPjfKw5I4ug,115552 +sympy/core/kind.py,sha256=9kQvtDxm-SSRGi-155XsBl_rs-oN_7dw7fNNT3mDu2Q,11540 +sympy/core/logic.py,sha256=Ai2_N-pUmHngJN3usiMTNO6kfLWFVQa3WOet3VhehE8,10865 +sympy/core/mod.py,sha256=survk3e5EyNifVHKpqLZ5NUobFdS0-wEYN4XoUkzMI8,7484 +sympy/core/mul.py,sha256=d7TAZK5YQWT7dsHt84y-2K9Q17FUxi6ilpfgd0GPZ30,78458 +sympy/core/multidimensional.py,sha256=NWX1okybO_nZCl9IhIOE8QYalY1WoC0zlzsvBg_E1eE,4233 +sympy/core/numbers.py,sha256=yNkmRw8ehaQWREJAYv61YP2pGkXy1yAo7ehGrXTVamY,139169 +sympy/core/operations.py,sha256=vasCAsT4aU9XJxfrEGjL-zeVIl2FsI1ktzVtPaJq_0c,25185 +sympy/core/parameters.py,sha256=09LVewtoOyKABQvYeMaJuc-HG7TjJusyT_WMw5NQDDs,3733 +sympy/core/power.py,sha256=WYVmJPNPFsaxeec2D2M_Tb9vUrIG3K8CiAqHca1YVPE,77148 +sympy/core/random.py,sha256=miFdVpNKfutbkpYiIOzG9kVNUm5GTk-_nnmQqUhVDZs,6647 +sympy/core/relational.py,sha256=XcPZ8xUKl8pMAcGk9OBYssCcTH-7lueak2WrsTpzs8g,50608 +sympy/core/rules.py,sha256=AJuZztmYKZ_yUITLZB6rhZjDy6ROBCtajcYqPa50sjc,1496 +sympy/core/singleton.py,sha256=0TrQk5Q4U-GvSXTe4Emih6B2JJg2WMu_u0pSj92wqVA,6542 +sympy/core/sorting.py,sha256=ynZfmQPXWq5Te6WOz6CzaR8crlJfcfKTP24gzVf-QF0,10671 +sympy/core/symbol.py,sha256=eciLIZCLMlmBKBF5XcJqVRYXf2Z3M13kQ3dJ_-ok43g,28555 +sympy/core/sympify.py,sha256=pZuEWvH-kcUGNq0epaVm11G8cmXZQtMyoeoywBVcbYU,20399 +sympy/core/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/core/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_args.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_arit.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_assumptions.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_basic.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_cache.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_compatibility.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_complex.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_constructor_postprocessor.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_containers.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_count_ops.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_diff.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_equal.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_eval.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_evalf.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_expand.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_expr.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_exprtools.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_facts.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_function.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_kind.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_logic.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_match.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_multidimensional.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_noncommutative.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_numbers.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_operations.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_parameters.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_power.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_priority.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_random.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_relational.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_rules.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_singleton.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_sorting.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_subs.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_symbol.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_sympify.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_traversal.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_truediv.cpython-310.pyc,, +sympy/core/tests/__pycache__/test_var.cpython-310.pyc,, +sympy/core/tests/test_args.py,sha256=IeGS8dWg2nM8LncK-_XH4yuCyoBjSIHgemDGEpiVEnc,178389 +sympy/core/tests/test_arit.py,sha256=DwlTHtg2BllVwn0lGNJs89TsKgeAf7wdrXCZR7BkfGo,77847 +sympy/core/tests/test_assumptions.py,sha256=MjJdF_ymVL6mtgQx-aSr_rsNNxaTi2pHFLjyaPCBq5Q,41573 +sympy/core/tests/test_basic.py,sha256=cgAhl2-bLXBkx2EaV5KtnY7-MKOEL9Mov25JUoAmLSo,9496 +sympy/core/tests/test_cache.py,sha256=p6Ci75a_T-bBXE_5HVxRKla62uSay_0Vuf57gUuH6sI,2001 +sympy/core/tests/test_compatibility.py,sha256=7pvNUEGIcRrfWl3doqHlm3AdNkGlcChO69gos3Fk09A,240 +sympy/core/tests/test_complex.py,sha256=koNGFMt6UMmzahJADSja_eD24gr-GG5gGCtyDgCRtPI,21906 +sympy/core/tests/test_constructor_postprocessor.py,sha256=0d7vbVuKi3GCm3PKLtiNqv_Au7v6RYt1rzRdHiD08tM,2441 +sympy/core/tests/test_containers.py,sha256=bFaqu8Bu82-rpgpNEPU4-R3rGwhqNdlLlWCqtHsBqN0,7434 +sympy/core/tests/test_count_ops.py,sha256=eIA2WvCuWKXVBJEGfWoJrn6WfUshX_NXttrrfyLbNnI,5665 +sympy/core/tests/test_diff.py,sha256=6j4Vk9UCNRv8Oyx_4iv1ePjocwBg7_-3ftrSJ8u0cPo,5421 +sympy/core/tests/test_equal.py,sha256=RoOJuu4kMe4Rkk7eNyVOJov5S1770YHiVAiziNIKd2o,1678 +sympy/core/tests/test_eval.py,sha256=o0kZn3oaMidVYdNjeZYtx4uUKBoE3A2tWn2NS4hu72Q,2366 +sympy/core/tests/test_evalf.py,sha256=ShOta18xc-jFlSnnlHhyWsDumLyQRr91YiC1j_gL9Sw,28307 +sympy/core/tests/test_expand.py,sha256=-Rl7sRQevvVBMck3jSA8kg6jgvWeI2yxh9cbSuy0fOA,13383 +sympy/core/tests/test_expr.py,sha256=RRZ7r-AltCCz7Cxfun8is5xVVUklXjbBfDVDoFopAf0,76520 +sympy/core/tests/test_exprtools.py,sha256=L7fi319z1EeFag6pH8myqDQYQ32H193QLKMdqlxACsY,19021 +sympy/core/tests/test_facts.py,sha256=YEZMZ-116VFnFqJ48h9bQsF2flhiB65trnZvJsRSh_o,11579 +sympy/core/tests/test_function.py,sha256=vVoXYyGzdTO3EtlRu0sONxjB3fprXxZ7_9Ve6HdH84s,51420 +sympy/core/tests/test_kind.py,sha256=NLJbwCpugzlNbaSyUlbb6NHoT_9dHuoXj023EDQMrNI,2048 +sympy/core/tests/test_logic.py,sha256=_YKSIod6Q0oIz9lDs78UQQrv9LU-uKaztd7w8LWwuwY,5634 +sympy/core/tests/test_match.py,sha256=2ewD4Ao9cYNvbt2TAId8oZCU0GCNWsSDx4qO5-_Xhwc,22716 +sympy/core/tests/test_multidimensional.py,sha256=Fr-lagme3lwLrBpdaWP7O7oPezhIatn5X8fYYs-8bN8,848 +sympy/core/tests/test_noncommutative.py,sha256=IkGPcvLO4ACVj5LMT2IUgyj68F1RBvMKbm01iqTOK04,4436 +sympy/core/tests/test_numbers.py,sha256=AgFd3RJAMakI6AxCDzfOrGgSX7UeAjxvPHs3Rzk2ns4,75434 +sympy/core/tests/test_operations.py,sha256=mRxftKlrxxrn3zS3UPwqkF6Nr15l5Cv6j3c2RJX46s4,2859 +sympy/core/tests/test_parameters.py,sha256=lRZSShirTW7GRfYgU3A3LRlW79xEPqi62XtoJeaMuDs,2799 +sympy/core/tests/test_power.py,sha256=LptUWHOYrFfNg1-8cNEMxDoQzCdDtguihgVoGb0QC9M,24434 +sympy/core/tests/test_priority.py,sha256=g9dGW-qT647yL4uk1D_v3M2S8rgV1Wi4JBUFyTSwUt4,3190 +sympy/core/tests/test_random.py,sha256=H58NfH5BYeQ3RIscbDct6SZkHQVRJjichVUSuSrhvAU,1233 +sympy/core/tests/test_relational.py,sha256=jebPjr32VQsL-W3laOMxKuYkyo9SFpkdXrTFfqDL3e4,42972 +sympy/core/tests/test_rules.py,sha256=iwmMX7hxC_73CuX9BizeAci-cO4JDq-y1sicKBXEGA4,349 +sympy/core/tests/test_singleton.py,sha256=xLJJgXwmkbKhsot_qTs-o4dniMjHUh3_va0xsA5h-KA,3036 +sympy/core/tests/test_sorting.py,sha256=6BZKYqUedAR-jeHcIgsJelJHFWuougml2c1NNilxGZg,902 +sympy/core/tests/test_subs.py,sha256=7ITJFDplgWBRImkcHfjRdnHqaKgjTxWb4j4WoRysvR8,30106 +sympy/core/tests/test_symbol.py,sha256=zYhPWsdyQp7_NiLVthpoCB1RyP9pmJcNlTdTN2kMdfY,13043 +sympy/core/tests/test_sympify.py,sha256=gVUNWYtarpDrx3vk4r0Vjnrijr21YgHUUSfJmeyabCo,27866 +sympy/core/tests/test_traversal.py,sha256=cmgvMW8G-LZ20ZXy-wg5Vz5ogI_oq2p2bJSwMy9IMF0,4311 +sympy/core/tests/test_truediv.py,sha256=RYfJX39-mNhekRE3sj5TGFZXKra4ML9vGvObsRYuD3k,854 +sympy/core/tests/test_var.py,sha256=hexP-0q2nN9h_dyhKLCuvqFXgLC9e_Hroni8Ldb16Ko,1594 +sympy/core/trace.py,sha256=9WC8p3OpBL6TdHmZWMDK9jaCG-16f4uZV2VptduVH98,348 +sympy/core/traversal.py,sha256=M-ZMt-DRUgyZed_I1gikxEbSYEJLwi7mwpjd-_iFKC8,8962 +sympy/crypto/__init__.py,sha256=i8GcbScXhIPbMEe7uuMgXqh_cU2mZm2f6hspIgmW5uM,2158 +sympy/crypto/__pycache__/__init__.cpython-310.pyc,, +sympy/crypto/__pycache__/crypto.cpython-310.pyc,, +sympy/crypto/crypto.py,sha256=Qb0O_f78q-CtHabvHS7VRJmncbkuqowWTF3_drmMgxI,89426 +sympy/crypto/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/crypto/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/crypto/tests/__pycache__/test_crypto.cpython-310.pyc,, +sympy/crypto/tests/test_crypto.py,sha256=-GJYezqcuQ3KUq_IqCEJAWa-zWAPWFku2WdLj7Aonrc,19763 +sympy/diffgeom/__init__.py,sha256=cWj4N7AfNgrYcGIBexX-UrWxfd1bP9DTNqUmLWUJ9nA,991 +sympy/diffgeom/__pycache__/__init__.cpython-310.pyc,, +sympy/diffgeom/__pycache__/diffgeom.cpython-310.pyc,, +sympy/diffgeom/__pycache__/rn.cpython-310.pyc,, +sympy/diffgeom/diffgeom.py,sha256=CCkZEwNcJYrmhyuBVr94KwMFjHsbL6mOJZ2f5aGcARU,72322 +sympy/diffgeom/rn.py,sha256=kvgth6rNJWt94kzVospZwiH53C-s4VSiorktQNmMobQ,6264 +sympy/diffgeom/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/diffgeom/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/diffgeom/tests/__pycache__/test_class_structure.cpython-310.pyc,, +sympy/diffgeom/tests/__pycache__/test_diffgeom.cpython-310.pyc,, +sympy/diffgeom/tests/__pycache__/test_function_diffgeom_book.cpython-310.pyc,, +sympy/diffgeom/tests/__pycache__/test_hyperbolic_space.cpython-310.pyc,, +sympy/diffgeom/tests/test_class_structure.py,sha256=LbRyxhhp-NnnfJ2gTn1SdlgCBQn2rhyB7xApOgcd_rM,1048 +sympy/diffgeom/tests/test_diffgeom.py,sha256=3BepCr6ned-4C_3me4zScu06HXG9Qx_dBBxIpiXAvy4,14145 +sympy/diffgeom/tests/test_function_diffgeom_book.py,sha256=0YU63iHyY6O-4LR9lRS5kLZMpcMpuNxEsgqtXALV7ic,5258 +sympy/diffgeom/tests/test_hyperbolic_space.py,sha256=c4xQJ_bBS4xrMj3pfx1Ms3oC2_LwuJuNYXNZxs-cVG8,2598 +sympy/discrete/__init__.py,sha256=A_Seud0IRr2gPYlz6JMQZa3sBhRL3O7gVqhIvMRRvE0,772 +sympy/discrete/__pycache__/__init__.cpython-310.pyc,, +sympy/discrete/__pycache__/convolutions.cpython-310.pyc,, +sympy/discrete/__pycache__/recurrences.cpython-310.pyc,, +sympy/discrete/__pycache__/transforms.cpython-310.pyc,, +sympy/discrete/convolutions.py,sha256=xeXCLxPSpBNfrKNlPGGpuU3D9Azf0uR01OpDGCOAALg,14505 +sympy/discrete/recurrences.py,sha256=FqU5QG4qNNLSVBqcpL7HtKa7rQOlmHMXDQRzHZ_P_s0,5124 +sympy/discrete/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/discrete/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/discrete/tests/__pycache__/test_convolutions.cpython-310.pyc,, +sympy/discrete/tests/__pycache__/test_recurrences.cpython-310.pyc,, +sympy/discrete/tests/__pycache__/test_transforms.cpython-310.pyc,, +sympy/discrete/tests/test_convolutions.py,sha256=m6LrKCMIeNeuicfuMMFG3-Ke-7oyjTsD1QRbKdTRVYk,16626 +sympy/discrete/tests/test_recurrences.py,sha256=s5ZEZQ262gcnBLpCjJVmeKlTKQByRTQBrc-N9p_4W8c,3019 +sympy/discrete/tests/test_transforms.py,sha256=vEORFaPvxmPSsw0f4Z2hLEN1wD0FdyQOYHDEY9aVm5A,5546 +sympy/discrete/transforms.py,sha256=lf-n6IN881uCfTUAxPNjdUaSguiRbYW0omuR96vKNlE,11681 +sympy/external/__init__.py,sha256=C6s4654Elc_X-D9UgI2cUQWiQyGDt9LG3IKUc8qqzuo,578 +sympy/external/__pycache__/__init__.cpython-310.pyc,, +sympy/external/__pycache__/gmpy.cpython-310.pyc,, +sympy/external/__pycache__/importtools.cpython-310.pyc,, +sympy/external/__pycache__/pythonmpq.cpython-310.pyc,, +sympy/external/gmpy.py,sha256=V3Z0HQyg7SOgviwOvBik8dUtSxO6yiNqFqjARnjTO3I,2982 +sympy/external/importtools.py,sha256=Q7tS2cdGZ9a4NI_1sgGuoVcSDv_rIk-Av0BpFTa6EzA,7671 +sympy/external/pythonmpq.py,sha256=WOMTvHxYLXNp_vQ1F3jE_haeRlnGicbRlCTOp4ZNuo8,11243 +sympy/external/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/external/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/external/tests/__pycache__/test_autowrap.cpython-310.pyc,, +sympy/external/tests/__pycache__/test_codegen.cpython-310.pyc,, +sympy/external/tests/__pycache__/test_importtools.cpython-310.pyc,, +sympy/external/tests/__pycache__/test_numpy.cpython-310.pyc,, +sympy/external/tests/__pycache__/test_pythonmpq.cpython-310.pyc,, +sympy/external/tests/__pycache__/test_scipy.cpython-310.pyc,, +sympy/external/tests/test_autowrap.py,sha256=tRDOkHdndNTmsa9sGjlZ1lFIh1rL2Awck4ec1iolb7c,9755 +sympy/external/tests/test_codegen.py,sha256=zOgdevzcR5pK73FnXe3Su_2D6cuvrkP2FMqsro83G-c,12676 +sympy/external/tests/test_importtools.py,sha256=KrfontKYv11UvpazQ0vS1qyhxIvgZrCOXh1JFeACjeo,1394 +sympy/external/tests/test_numpy.py,sha256=7-YWZ--nbVX0h_rzah18AEjiz7JyvEzjHtklhwaAGhI,10123 +sympy/external/tests/test_pythonmpq.py,sha256=L_FdZmmk5N-VEivE_O_qZa98BZhT1WSxRfdmG817bA0,5797 +sympy/external/tests/test_scipy.py,sha256=CVaw7D0-6DORgg78Q6b35SNKn05PlKwWJuqXOuU-qdY,1172 +sympy/functions/__init__.py,sha256=fxnbVbZruEHXQxB5DaQTC6k1Qi8BrWaQ3LwBuSZZryk,5229 +sympy/functions/__pycache__/__init__.cpython-310.pyc,, +sympy/functions/combinatorial/__init__.py,sha256=WqXI3qU_TTJ7nJA8m3Z-7ZAYKoApT8f9Xs0u2bTwy_c,53 +sympy/functions/combinatorial/__pycache__/__init__.cpython-310.pyc,, +sympy/functions/combinatorial/__pycache__/factorials.cpython-310.pyc,, +sympy/functions/combinatorial/__pycache__/numbers.cpython-310.pyc,, +sympy/functions/combinatorial/factorials.py,sha256=OkQ_U2FhDCU0wnpLWyK4f6HMup-EAxh1fsQns74hYjE,37546 +sympy/functions/combinatorial/numbers.py,sha256=iXGk2kGB866puhbfk49KfFogYW8lUVTk_tm_nQw_gg4,83429 +sympy/functions/combinatorial/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/functions/combinatorial/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/functions/combinatorial/tests/__pycache__/test_comb_factorials.cpython-310.pyc,, +sympy/functions/combinatorial/tests/__pycache__/test_comb_numbers.cpython-310.pyc,, +sympy/functions/combinatorial/tests/test_comb_factorials.py,sha256=aM7qyHno3THToCxy2HMo1SJlINm4Pj7SjoLtALl6DJ0,26176 +sympy/functions/combinatorial/tests/test_comb_numbers.py,sha256=COdo810q8vjVyHiOYsgD5TcAE4G3bQUzQXlEroDWsj0,34317 +sympy/functions/elementary/__init__.py,sha256=Fj8p5qE-Rr1lqAyHI0aSgC3RYX56O-gWwo6wu-eUQYA,50 +sympy/functions/elementary/__pycache__/__init__.cpython-310.pyc,, +sympy/functions/elementary/__pycache__/_trigonometric_special.cpython-310.pyc,, +sympy/functions/elementary/__pycache__/complexes.cpython-310.pyc,, +sympy/functions/elementary/__pycache__/exponential.cpython-310.pyc,, +sympy/functions/elementary/__pycache__/hyperbolic.cpython-310.pyc,, +sympy/functions/elementary/__pycache__/integers.cpython-310.pyc,, +sympy/functions/elementary/__pycache__/miscellaneous.cpython-310.pyc,, +sympy/functions/elementary/__pycache__/piecewise.cpython-310.pyc,, +sympy/functions/elementary/__pycache__/trigonometric.cpython-310.pyc,, +sympy/functions/elementary/_trigonometric_special.py,sha256=PiQ1eg280vWAnSaMMw6RheEJI0oIiwYa4K_sHmUWEgc,7245 +sympy/functions/elementary/benchmarks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/functions/elementary/benchmarks/__pycache__/__init__.cpython-310.pyc,, +sympy/functions/elementary/benchmarks/__pycache__/bench_exp.cpython-310.pyc,, +sympy/functions/elementary/benchmarks/bench_exp.py,sha256=PFBYa9eMovH5XOFN5XTxWr1VDj1EBoKwn4mAtj-_DdM,185 +sympy/functions/elementary/complexes.py,sha256=wwyEdwEaTyps_ZPEA667W7b_VLdYwaZ2cdE2vd5d5NI,43263 +sympy/functions/elementary/exponential.py,sha256=UrXHbvLi3r-uxLw_XYWiEUAnWVF5agcgDDkqWyA_r5Q,42694 +sympy/functions/elementary/hyperbolic.py,sha256=YEnCb_IbSgyUxicldCV61qCcPTrPt-eTexR_c6LRpv8,66628 +sympy/functions/elementary/integers.py,sha256=hM3NvuUHfTH-V8tGHc2ocOwGyXhsLe1gWO_8KJGw0So,19074 +sympy/functions/elementary/miscellaneous.py,sha256=TAIoqthhfqx_wlcNbDdDHpLQrosWxX_nGy48BJk3R_w,27933 +sympy/functions/elementary/piecewise.py,sha256=o8y2TUKcn9varebhrcZSQQg-DOqjJHR2aP02CohgDEo,57858 +sympy/functions/elementary/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/functions/elementary/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/functions/elementary/tests/__pycache__/test_complexes.cpython-310.pyc,, +sympy/functions/elementary/tests/__pycache__/test_exponential.cpython-310.pyc,, +sympy/functions/elementary/tests/__pycache__/test_hyperbolic.cpython-310.pyc,, +sympy/functions/elementary/tests/__pycache__/test_integers.cpython-310.pyc,, +sympy/functions/elementary/tests/__pycache__/test_interface.cpython-310.pyc,, +sympy/functions/elementary/tests/__pycache__/test_miscellaneous.cpython-310.pyc,, +sympy/functions/elementary/tests/__pycache__/test_piecewise.cpython-310.pyc,, +sympy/functions/elementary/tests/__pycache__/test_trigonometric.cpython-310.pyc,, +sympy/functions/elementary/tests/test_complexes.py,sha256=nUSm7w9s2H_F1g8FB841ZoL0skV95PGV5w4_x8Ygh3Q,33513 +sympy/functions/elementary/tests/test_exponential.py,sha256=r8pqvffIEsu8K8VKeXCSsH4IXUJKzDa2wdx-pClsdmk,29566 +sympy/functions/elementary/tests/test_hyperbolic.py,sha256=gz7Is98WR0hCrZwDkocpi2CYWn6FqX11OzGCtpzvbZI,53361 +sympy/functions/elementary/tests/test_integers.py,sha256=g7FE4C8d8BuyZApycbQbq5uPs81eyR_4YdwP6A2P1Gc,20930 +sympy/functions/elementary/tests/test_interface.py,sha256=dBHnagyfDEXsQWlxVzWpqgCBdiJM0oUIv2QONbEYo9s,2054 +sympy/functions/elementary/tests/test_miscellaneous.py,sha256=eCL30UmsusBhjvqICQNmToa1aJTML8fXav1L1J6b7FU,17148 +sympy/functions/elementary/tests/test_piecewise.py,sha256=OOSlqsR7ZZG7drmSO7v5PlrPcbrqpv7sEt6h8pLNYyU,61520 +sympy/functions/elementary/tests/test_trigonometric.py,sha256=xsf5N30ILb_mdpx6Cb5E0o1QY5V4impDX2wqANJnXBE,86394 +sympy/functions/elementary/trigonometric.py,sha256=gnerAnDl9qfqxzvhMr2E5tRdq1GiBfdut6OLxRwuwTc,113966 +sympy/functions/special/__init__.py,sha256=5pjIq_RVCMsuCe1b-FlwIty30KxoUowZYKLmpIT9KHQ,59 +sympy/functions/special/__pycache__/__init__.cpython-310.pyc,, +sympy/functions/special/__pycache__/bessel.cpython-310.pyc,, +sympy/functions/special/__pycache__/beta_functions.cpython-310.pyc,, +sympy/functions/special/__pycache__/bsplines.cpython-310.pyc,, +sympy/functions/special/__pycache__/delta_functions.cpython-310.pyc,, +sympy/functions/special/__pycache__/elliptic_integrals.cpython-310.pyc,, +sympy/functions/special/__pycache__/error_functions.cpython-310.pyc,, +sympy/functions/special/__pycache__/gamma_functions.cpython-310.pyc,, +sympy/functions/special/__pycache__/hyper.cpython-310.pyc,, +sympy/functions/special/__pycache__/mathieu_functions.cpython-310.pyc,, +sympy/functions/special/__pycache__/polynomials.cpython-310.pyc,, +sympy/functions/special/__pycache__/singularity_functions.cpython-310.pyc,, +sympy/functions/special/__pycache__/spherical_harmonics.cpython-310.pyc,, +sympy/functions/special/__pycache__/tensor_functions.cpython-310.pyc,, +sympy/functions/special/__pycache__/zeta_functions.cpython-310.pyc,, +sympy/functions/special/benchmarks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/functions/special/benchmarks/__pycache__/__init__.cpython-310.pyc,, +sympy/functions/special/benchmarks/__pycache__/bench_special.cpython-310.pyc,, +sympy/functions/special/benchmarks/bench_special.py,sha256=wzAoKTccuEaG4xrEYTlYfIJuLi3kUTMTEJ9iA113Wog,164 +sympy/functions/special/bessel.py,sha256=3q5Ti0vVqSPQZ9oSZovJNAviFWuOXLUMbJvpRkdTxWs,63415 +sympy/functions/special/beta_functions.py,sha256=NXwFSRAtpoVkSybCUqicQDKqc8SNBeq3SOB1QS-Ge84,12603 +sympy/functions/special/bsplines.py,sha256=GxW_6tXuiuWap-pc4T0v1PMcfw8FXaq3mSEf50OkLoU,10152 +sympy/functions/special/delta_functions.py,sha256=NPneFMqLdwwMGZweS5C-Bok6ch1roYyO481ZNOiWp8I,19866 +sympy/functions/special/elliptic_integrals.py,sha256=rn4asENf-mFTc-iTpMOht-E-q_-vmhNc0Bd4xMPGfOE,14694 +sympy/functions/special/error_functions.py,sha256=syaTdbOA7xJBtMuuDSFZsOerSc2-Z5pm77SQ7Qn_eCU,77081 +sympy/functions/special/gamma_functions.py,sha256=OjPRUlD9wXr0XfBhn3Ocbwpey7Qd0H1JPyHeZkevxSc,42596 +sympy/functions/special/hyper.py,sha256=aby7IOWh0OtlCclHWv0cz3-cqKvuSIVHvQ8qFgOtQs8,37290 +sympy/functions/special/mathieu_functions.py,sha256=-3EsPJHwU1upnYz5rsc1Zy43aPpjXD1Nnmn2yA9LS6U,6606 +sympy/functions/special/polynomials.py,sha256=PBrr6UpHvs_FtYsTD_y2jre2tYNcqneOGwkm1omY2jk,46718 +sympy/functions/special/singularity_functions.py,sha256=5yDHvwQN16YS0L7C0kj34XI3o0q-_k4OgxIURo_9SZQ,7988 +sympy/functions/special/spherical_harmonics.py,sha256=Ivwi76IeFMZhukm_TnvJYT4QEqyW2DrGF5rj4_B-dJg,10997 +sympy/functions/special/tensor_functions.py,sha256=ZzMc93n_4Y4L-WVd9nmMh0nZQPYMB7uKqcnaFdupEXE,12277 +sympy/functions/special/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/functions/special/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/functions/special/tests/__pycache__/test_bessel.cpython-310.pyc,, +sympy/functions/special/tests/__pycache__/test_beta_functions.cpython-310.pyc,, +sympy/functions/special/tests/__pycache__/test_bsplines.cpython-310.pyc,, +sympy/functions/special/tests/__pycache__/test_delta_functions.cpython-310.pyc,, +sympy/functions/special/tests/__pycache__/test_elliptic_integrals.cpython-310.pyc,, +sympy/functions/special/tests/__pycache__/test_error_functions.cpython-310.pyc,, +sympy/functions/special/tests/__pycache__/test_gamma_functions.cpython-310.pyc,, +sympy/functions/special/tests/__pycache__/test_hyper.cpython-310.pyc,, +sympy/functions/special/tests/__pycache__/test_mathieu.cpython-310.pyc,, +sympy/functions/special/tests/__pycache__/test_singularity_functions.cpython-310.pyc,, +sympy/functions/special/tests/__pycache__/test_spec_polynomials.cpython-310.pyc,, +sympy/functions/special/tests/__pycache__/test_spherical_harmonics.cpython-310.pyc,, +sympy/functions/special/tests/__pycache__/test_tensor_functions.cpython-310.pyc,, +sympy/functions/special/tests/__pycache__/test_zeta_functions.cpython-310.pyc,, +sympy/functions/special/tests/test_bessel.py,sha256=Gx6cjelB0aXGDKMwG5O-wpPjyt6rFJVaNenNmD5Qb3E,34191 +sympy/functions/special/tests/test_beta_functions.py,sha256=yxfgu-wmNEeMfaFABiDHYmuZpZup9FTp0ZYerlc6hhc,3786 +sympy/functions/special/tests/test_bsplines.py,sha256=6UYg7IqXTi8fcSOut8TEzNVkxIA4ff-CyG22qJnbIYA,7145 +sympy/functions/special/tests/test_delta_functions.py,sha256=8xhSWG4SLL86z1QKFfLk_3b--bCrxjvCaxHlODBVToE,7138 +sympy/functions/special/tests/test_elliptic_integrals.py,sha256=AazZYMow9szbvC_WfK10c5j-LQRAzno6V1WJCbtp4MU,6860 +sympy/functions/special/tests/test_error_functions.py,sha256=0U78aiO9zvGOrqQ7tiVTUhqnpj0FDD9shNb-8AOhp68,31222 +sympy/functions/special/tests/test_gamma_functions.py,sha256=exHmFEtyZMJhVYTWFSBlMZhWdhQk6M2cjgNkvImD7o4,29910 +sympy/functions/special/tests/test_hyper.py,sha256=El56dyyIzJkyBV_1gH-bGX8iF6Jzn0EhpmJEK57gvKs,15990 +sympy/functions/special/tests/test_mathieu.py,sha256=pqoFbnC84NDL6EQkigFtx5OQ1RFYppckTjzsm9XT0PY,1282 +sympy/functions/special/tests/test_singularity_functions.py,sha256=tqMJQIOOsBrveXctXPkPFIYdThG-wwKsjfdRHshEpfw,5467 +sympy/functions/special/tests/test_spec_polynomials.py,sha256=wuiZaR_LwaM8SlNuGl3B1p4eOHC_-zZVSXMPNfzKRB4,19561 +sympy/functions/special/tests/test_spherical_harmonics.py,sha256=pUFtFpNPBnJTdnqou0jniSchijyh1rdzKv8H24RT9FU,3850 +sympy/functions/special/tests/test_tensor_functions.py,sha256=bblSDkPABZ6N1j1Rb2Bb5TZIzZoK1D8ks3fHizi69ZI,5546 +sympy/functions/special/tests/test_zeta_functions.py,sha256=2r59_aC0QOXQsBNXqxsHPr2PkJExusI6qvSydZBPbfw,10474 +sympy/functions/special/zeta_functions.py,sha256=IdshdejjEv60nNZ4gQOVG0RIgxyo22psmglxZnzwHHw,24064 +sympy/galgebra.py,sha256=yEosUPSnhLp9a1NWXvpCLoU20J6TQ58XNIvw07POkVk,123 +sympy/geometry/__init__.py,sha256=BU2MiKm8qJyZJ_hz1qC-3nFJTPEcuvx4hYd02jHjqSM,1240 +sympy/geometry/__pycache__/__init__.cpython-310.pyc,, +sympy/geometry/__pycache__/curve.cpython-310.pyc,, +sympy/geometry/__pycache__/ellipse.cpython-310.pyc,, +sympy/geometry/__pycache__/entity.cpython-310.pyc,, +sympy/geometry/__pycache__/exceptions.cpython-310.pyc,, +sympy/geometry/__pycache__/line.cpython-310.pyc,, +sympy/geometry/__pycache__/parabola.cpython-310.pyc,, +sympy/geometry/__pycache__/plane.cpython-310.pyc,, +sympy/geometry/__pycache__/point.cpython-310.pyc,, +sympy/geometry/__pycache__/polygon.cpython-310.pyc,, +sympy/geometry/__pycache__/util.cpython-310.pyc,, +sympy/geometry/curve.py,sha256=F7b6XrlhUZ0QWLDoZJVojWfC5LeyOU-69OTFnYAREg8,10170 +sympy/geometry/ellipse.py,sha256=MMuWG_YOUngfW5137yu6iAOugjRxehrfkgidvD1J6RM,50851 +sympy/geometry/entity.py,sha256=fvHhtSb6RvE6v-8yMyCNvm0ekLPoO7EO9J8TEsGyQGU,20668 +sympy/geometry/exceptions.py,sha256=XtUMA44UTdrBWt771jegFC-TXsobhDiI-10TDH_WNFM,131 +sympy/geometry/line.py,sha256=JSc0dcjKV2m1R6b7tIaPjffhdGz3ZdtjFKvsH72Luqo,78343 +sympy/geometry/parabola.py,sha256=JalFtxCzBR8oE09agrzDtpGI9hrP4GJ-4zkg2r8Yj94,10707 +sympy/geometry/plane.py,sha256=A-CgWLjFC9k_OjyqJFaq7kDAdsSqmYET4aZl_eH2U10,26928 +sympy/geometry/point.py,sha256=8DtGkhQUyleVIi5WfptZOEk2zn0kwVAZv5aeNI498tg,36652 +sympy/geometry/polygon.py,sha256=hI1bRJdjCgsSKlPejO69z65LKO9iakcHx9ftJfSSLFA,81664 +sympy/geometry/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/geometry/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/geometry/tests/__pycache__/test_curve.cpython-310.pyc,, +sympy/geometry/tests/__pycache__/test_ellipse.cpython-310.pyc,, +sympy/geometry/tests/__pycache__/test_entity.cpython-310.pyc,, +sympy/geometry/tests/__pycache__/test_geometrysets.cpython-310.pyc,, +sympy/geometry/tests/__pycache__/test_line.cpython-310.pyc,, +sympy/geometry/tests/__pycache__/test_parabola.cpython-310.pyc,, +sympy/geometry/tests/__pycache__/test_plane.cpython-310.pyc,, +sympy/geometry/tests/__pycache__/test_point.cpython-310.pyc,, +sympy/geometry/tests/__pycache__/test_polygon.cpython-310.pyc,, +sympy/geometry/tests/__pycache__/test_util.cpython-310.pyc,, +sympy/geometry/tests/test_curve.py,sha256=xL4uRWAal4mXZxuQhcs9QOhs6MheCbFNyH1asq_a2IQ,4479 +sympy/geometry/tests/test_ellipse.py,sha256=oe9Bvye-kLjdhP3bwJPB0N1-wDL3cmVwYLhEhrGAPHk,25735 +sympy/geometry/tests/test_entity.py,sha256=0pBKdmRIETq0pJYjxRj34B0j-o56f4iqzJy9J4buU7U,3897 +sympy/geometry/tests/test_geometrysets.py,sha256=vvOWrFrJuNAFgbrVh1wPY94o-H-85FWlnIyyo2Kst9c,1911 +sympy/geometry/tests/test_line.py,sha256=D2yAOzCt80dmd7hP_l2A7aaWS8Mtw7RCkqA99L7McXI,37421 +sympy/geometry/tests/test_parabola.py,sha256=kd0RU5sGOcfp6jgwgXMtvT2B6kG1-M3-iGOLnUJfZOw,6150 +sympy/geometry/tests/test_plane.py,sha256=QRcfoDsJtCtcvjFb18hBEHupycLgAT2OohF6GpNShyQ,12525 +sympy/geometry/tests/test_point.py,sha256=YO67zimsEVO07KGyLJVTVWa9795faGXJoFFcd2K4azc,16412 +sympy/geometry/tests/test_polygon.py,sha256=79iBkQjpX-CdO1mtMaX3lGvVfkopBiFhLC3QfWCreWA,27138 +sympy/geometry/tests/test_util.py,sha256=-LXPTiibkSQ0TO7ia6a-NYfMm2OJxw15Er7tr99dTVU,6204 +sympy/geometry/util.py,sha256=ZMXFHU2sxVAvc4_ywomdJC67hHCU-EyJN2SzW5TB9Zw,20170 +sympy/holonomic/__init__.py,sha256=BgHIokaSOo3nwJlGO_caJHz37n6yoA8GeM9Xjn4zMpc,784 +sympy/holonomic/__pycache__/__init__.cpython-310.pyc,, +sympy/holonomic/__pycache__/holonomic.cpython-310.pyc,, +sympy/holonomic/__pycache__/holonomicerrors.cpython-310.pyc,, +sympy/holonomic/__pycache__/numerical.cpython-310.pyc,, +sympy/holonomic/__pycache__/recurrence.cpython-310.pyc,, +sympy/holonomic/holonomic.py,sha256=XxLDC4TG_6ddHMQ5yZNWNJFb6s7n5Tg09kbufyiwVVw,94849 +sympy/holonomic/holonomicerrors.py,sha256=qDyUoGbrRjPtVax4SeEEf_o6-264mASEZO_rZETXH5o,1193 +sympy/holonomic/numerical.py,sha256=m35A7jO54xMNgA4w5Edn1i_SHbXWBlpQTRLMR8GgbZE,2730 +sympy/holonomic/recurrence.py,sha256=JFgSOT3hu6d7Mh9sdqvSxC3RxlVlH_cygsXpsX97YMY,10987 +sympy/holonomic/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/holonomic/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/holonomic/tests/__pycache__/test_holonomic.cpython-310.pyc,, +sympy/holonomic/tests/__pycache__/test_recurrence.cpython-310.pyc,, +sympy/holonomic/tests/test_holonomic.py,sha256=MrN7GVk7_zFWwDSfIhtD3FgoFgmFGlTpjOnnIzdP010,34760 +sympy/holonomic/tests/test_recurrence.py,sha256=HEbA3yCnIw4IDFV1rb3GjmM4SCDDZL7aYRlD7PWuQFg,1056 +sympy/integrals/__init__.py,sha256=aZr2Qn6i-gvFGH_5Hl_SRn2-Bd9Sf4zQdwo9VGLSeNY,1844 +sympy/integrals/__pycache__/__init__.cpython-310.pyc,, +sympy/integrals/__pycache__/deltafunctions.cpython-310.pyc,, +sympy/integrals/__pycache__/heurisch.cpython-310.pyc,, +sympy/integrals/__pycache__/integrals.cpython-310.pyc,, +sympy/integrals/__pycache__/intpoly.cpython-310.pyc,, +sympy/integrals/__pycache__/laplace.cpython-310.pyc,, +sympy/integrals/__pycache__/manualintegrate.cpython-310.pyc,, +sympy/integrals/__pycache__/meijerint.cpython-310.pyc,, +sympy/integrals/__pycache__/meijerint_doc.cpython-310.pyc,, +sympy/integrals/__pycache__/prde.cpython-310.pyc,, +sympy/integrals/__pycache__/quadrature.cpython-310.pyc,, +sympy/integrals/__pycache__/rationaltools.cpython-310.pyc,, +sympy/integrals/__pycache__/rde.cpython-310.pyc,, +sympy/integrals/__pycache__/risch.cpython-310.pyc,, +sympy/integrals/__pycache__/singularityfunctions.cpython-310.pyc,, +sympy/integrals/__pycache__/transforms.cpython-310.pyc,, +sympy/integrals/__pycache__/trigonometry.cpython-310.pyc,, +sympy/integrals/benchmarks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/integrals/benchmarks/__pycache__/__init__.cpython-310.pyc,, +sympy/integrals/benchmarks/__pycache__/bench_integrate.cpython-310.pyc,, +sympy/integrals/benchmarks/__pycache__/bench_trigintegrate.cpython-310.pyc,, +sympy/integrals/benchmarks/bench_integrate.py,sha256=vk6wAO1bqzFT9oW4qsW7nKGfc_gP0XaB5PMYKx5339Q,396 +sympy/integrals/benchmarks/bench_trigintegrate.py,sha256=8XU3uB3mcavigvzHQZA7H1sHI32zgT-9RkSnLa-Y3Vc,305 +sympy/integrals/deltafunctions.py,sha256=ysIQLdRBcG_YR-bVDoxt-sxEVU8TG77oSgM-J0gI0mE,7435 +sympy/integrals/heurisch.py,sha256=R3G0RXskAxXum4CyQ1AV1BNeVbcmvp_Ipg0mOcDFRPo,26296 +sympy/integrals/integrals.py,sha256=bC0WtE12WsV7WFzmZrKzct2nAbHUdbq6dKytpY7ZtlY,64606 +sympy/integrals/intpoly.py,sha256=qs1fQrEMKbsXwgfkBDUpEZ9f7x65Bdua8KS2lLBtLv4,43274 +sympy/integrals/laplace.py,sha256=eL7HjKsSLAspdo8BswrYADs2wd2U-9YEkinSD5JVjow,63518 +sympy/integrals/manualintegrate.py,sha256=E7NaMsl02Hy2lHU8mPcxNSsCQnQjVNPJqDrMyEOkAKw,75469 +sympy/integrals/meijerint.py,sha256=Yf80w6COiqdrvYLyMwS1P2-SGsNR1B7cqCmaERhx76U,80746 +sympy/integrals/meijerint_doc.py,sha256=mGlIu2CLmOulSGiN7n7kQ9w2DTcQfExJPaf-ee6HXlY,1165 +sympy/integrals/prde.py,sha256=VL_JEu6Bqhl8wSML1UY9nilOjafhkjFenVGCVV1pVbc,52021 +sympy/integrals/quadrature.py,sha256=6Bg3JmlIjIduIfaGfNVcwNfSrgEiLOszcN8WPzsXNqE,17064 +sympy/integrals/rationaltools.py,sha256=1OMhRhMBQ7igw2_YX5WR4q69QB_H0zMtGFtUkcbVD3Q,10922 +sympy/integrals/rde.py,sha256=AuiPDqP2awC4UlWJrsfNCn1l3OAQuZl64WI-lE2M5Ds,27392 +sympy/integrals/risch.py,sha256=S9r1kKx6WoJHomPWgNL2KCe73GWS8jIJ0AZt95QwBFI,67674 +sympy/integrals/singularityfunctions.py,sha256=BegUcpUW96FY9f8Yn0jHjK0LjCkM28NnCVg5S9cTWwU,2227 +sympy/integrals/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/integrals/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/integrals/tests/__pycache__/test_deltafunctions.cpython-310.pyc,, +sympy/integrals/tests/__pycache__/test_failing_integrals.cpython-310.pyc,, +sympy/integrals/tests/__pycache__/test_heurisch.cpython-310.pyc,, +sympy/integrals/tests/__pycache__/test_integrals.cpython-310.pyc,, +sympy/integrals/tests/__pycache__/test_intpoly.cpython-310.pyc,, +sympy/integrals/tests/__pycache__/test_laplace.cpython-310.pyc,, +sympy/integrals/tests/__pycache__/test_lineintegrals.cpython-310.pyc,, +sympy/integrals/tests/__pycache__/test_manual.cpython-310.pyc,, +sympy/integrals/tests/__pycache__/test_meijerint.cpython-310.pyc,, +sympy/integrals/tests/__pycache__/test_prde.cpython-310.pyc,, +sympy/integrals/tests/__pycache__/test_quadrature.cpython-310.pyc,, +sympy/integrals/tests/__pycache__/test_rationaltools.cpython-310.pyc,, +sympy/integrals/tests/__pycache__/test_rde.cpython-310.pyc,, +sympy/integrals/tests/__pycache__/test_risch.cpython-310.pyc,, +sympy/integrals/tests/__pycache__/test_singularityfunctions.cpython-310.pyc,, +sympy/integrals/tests/__pycache__/test_transforms.cpython-310.pyc,, +sympy/integrals/tests/__pycache__/test_trigonometry.cpython-310.pyc,, +sympy/integrals/tests/test_deltafunctions.py,sha256=ivFjS-WlLQ4aMqjVS7ZzMChP2Mmw_JUPnwI9otiLnvs,3709 +sympy/integrals/tests/test_failing_integrals.py,sha256=hQJc23KfK0bUmbj4W3C04QdJ0K17_ghMVfTLuKjUBPc,7074 +sympy/integrals/tests/test_heurisch.py,sha256=r4RjbSRYScuzMXA_EjrxalO1T1G0i5ZsAmDQcrhFU3s,12468 +sympy/integrals/tests/test_integrals.py,sha256=jwaCvWJoW_5_CTkDDBJeRDtLCUHdYzyzs-f7GyJDaVc,77122 +sympy/integrals/tests/test_intpoly.py,sha256=NzGhkR2pUMfd8lIU2cFR9bFa0J89RzpHs3zDggAWtXo,37445 +sympy/integrals/tests/test_laplace.py,sha256=FQoGfwyNoIwqdVc5Nk_RcOIJU70EaW-ipmoQtq7nFLk,28893 +sympy/integrals/tests/test_lineintegrals.py,sha256=zcPJ2n7DYt9KsgAe38t0gq3ARApUlb-kBahLThuRcq8,450 +sympy/integrals/tests/test_manual.py,sha256=arqxMdxUJkFIoy98rOirOTIwj623wHx9NqoupZLqkU8,33231 +sympy/integrals/tests/test_meijerint.py,sha256=jglmmX-AtkvwJgqQafBOKdaygrm14QJ8H-NfheNpFME,32265 +sympy/integrals/tests/test_prde.py,sha256=2BZmEDasdx_3l64-9hioArysDj6Nl520GpQN2xnEE_A,16360 +sympy/integrals/tests/test_quadrature.py,sha256=iFMdqck36gkL-yksLflawIOYmw-0PzO2tFj_qdK6Hjg,19919 +sympy/integrals/tests/test_rationaltools.py,sha256=6sNOkkZmOvCAPTwXrdU6hehDFleXYyakheX2KQaUHWY,5299 +sympy/integrals/tests/test_rde.py,sha256=4d3vJupa-hRN4yNDISY8IC3rSI_cZW5BbtxoZm14y-Y,9571 +sympy/integrals/tests/test_risch.py,sha256=HaWg0JnErdrNzNmVfyz2Zz4XAgZPVVpZPt6Map3sQ58,38630 +sympy/integrals/tests/test_singularityfunctions.py,sha256=CSrHie59_NjNZ9B2GaHzKPNsMzxm5Kh6GuxlYk8zTuI,1266 +sympy/integrals/tests/test_transforms.py,sha256=Of9XEpzwB0CGy722z41oOdUEbfmAscsAhMute2_8oeA,27077 +sympy/integrals/tests/test_trigonometry.py,sha256=moMYr_Prc7gaYPjBK0McLjRpTEes2veUlN0vGv9UyEA,3869 +sympy/integrals/transforms.py,sha256=R625sYSQkNC1s9MiFdk0JzROTmoYjhgBTxoFE5Pc3rQ,51636 +sympy/integrals/trigonometry.py,sha256=iOoBDGFDZx8PNbgL3XeZEd80I8ro0WAizNuC4P-u8x0,11083 +sympy/interactive/__init__.py,sha256=yokwEO2HF3eN2Xu65JSpUUsN4iYmPvvU4m_64f3Q33o,251 +sympy/interactive/__pycache__/__init__.cpython-310.pyc,, +sympy/interactive/__pycache__/printing.cpython-310.pyc,, +sympy/interactive/__pycache__/session.cpython-310.pyc,, +sympy/interactive/__pycache__/traversal.cpython-310.pyc,, +sympy/interactive/printing.py,sha256=j7iVj-AhX3qBrQibPKtDNTMToCGhF6UKTdpUO8ME5CM,22700 +sympy/interactive/session.py,sha256=sG546e0mAtT0OrFkYNVM7QGvkWrDhAQZ5E1hfx03iBQ,15329 +sympy/interactive/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/interactive/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/interactive/tests/__pycache__/test_interactive.cpython-310.pyc,, +sympy/interactive/tests/__pycache__/test_ipython.cpython-310.pyc,, +sympy/interactive/tests/test_interactive.py,sha256=Pbopy9lODrd_P46_xxlWxLwqPfG6_4J3CWWC4IqfDL4,485 +sympy/interactive/tests/test_ipython.py,sha256=iYNmuETjveHBVpOywyv_jStQWkFwf1GuEBjoZUVhxK4,11799 +sympy/interactive/traversal.py,sha256=XbccdO6msNAvrG6FFJl2n4XmIiRISnvda4QflfEPg7U,3189 +sympy/liealgebras/__init__.py,sha256=K8tw7JqG33_y6mYl1LTr8ZNtKH5L21BqkjCHfLhP4aA,79 +sympy/liealgebras/__pycache__/__init__.cpython-310.pyc,, +sympy/liealgebras/__pycache__/cartan_matrix.cpython-310.pyc,, +sympy/liealgebras/__pycache__/cartan_type.cpython-310.pyc,, +sympy/liealgebras/__pycache__/dynkin_diagram.cpython-310.pyc,, +sympy/liealgebras/__pycache__/root_system.cpython-310.pyc,, +sympy/liealgebras/__pycache__/type_a.cpython-310.pyc,, +sympy/liealgebras/__pycache__/type_b.cpython-310.pyc,, +sympy/liealgebras/__pycache__/type_c.cpython-310.pyc,, +sympy/liealgebras/__pycache__/type_d.cpython-310.pyc,, +sympy/liealgebras/__pycache__/type_e.cpython-310.pyc,, +sympy/liealgebras/__pycache__/type_f.cpython-310.pyc,, +sympy/liealgebras/__pycache__/type_g.cpython-310.pyc,, +sympy/liealgebras/__pycache__/weyl_group.cpython-310.pyc,, +sympy/liealgebras/cartan_matrix.py,sha256=yr2LoZi_Gxmu-EMKgFuPOPNMYPOsxucLAS6oRpSYi2U,524 +sympy/liealgebras/cartan_type.py,sha256=xLklg8Y5s40je6sXwmLmG9iyYi9YEk9KoxTSFz1GtdI,1790 +sympy/liealgebras/dynkin_diagram.py,sha256=ZzGuBGNOJ3lPDdJDs4n8hvGbz6wLhC5mwb8zFkDmyPw,535 +sympy/liealgebras/root_system.py,sha256=GwWc4iploE7ogS9LTOkkjsij1mbPMQxbV2_pvNriYbE,6727 +sympy/liealgebras/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/liealgebras/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/liealgebras/tests/__pycache__/test_cartan_matrix.cpython-310.pyc,, +sympy/liealgebras/tests/__pycache__/test_cartan_type.cpython-310.pyc,, +sympy/liealgebras/tests/__pycache__/test_dynkin_diagram.cpython-310.pyc,, +sympy/liealgebras/tests/__pycache__/test_root_system.cpython-310.pyc,, +sympy/liealgebras/tests/__pycache__/test_type_A.cpython-310.pyc,, +sympy/liealgebras/tests/__pycache__/test_type_B.cpython-310.pyc,, +sympy/liealgebras/tests/__pycache__/test_type_C.cpython-310.pyc,, +sympy/liealgebras/tests/__pycache__/test_type_D.cpython-310.pyc,, +sympy/liealgebras/tests/__pycache__/test_type_E.cpython-310.pyc,, +sympy/liealgebras/tests/__pycache__/test_type_F.cpython-310.pyc,, +sympy/liealgebras/tests/__pycache__/test_type_G.cpython-310.pyc,, +sympy/liealgebras/tests/__pycache__/test_weyl_group.cpython-310.pyc,, +sympy/liealgebras/tests/test_cartan_matrix.py,sha256=KCsakn0fHKHRbIUcrUkHBIKkudl3_ISUdHrfJy-UOd4,303 +sympy/liealgebras/tests/test_cartan_type.py,sha256=t5PvYYDXbNIFL3CV59Je7SBIAeLLf-W3mOINPUoHK6E,339 +sympy/liealgebras/tests/test_dynkin_diagram.py,sha256=DSixbnt_yd0zrhKzXW_XqkXWXYe1Dk2MmXN-Rjb1dGg,260 +sympy/liealgebras/tests/test_root_system.py,sha256=YmGBdUeJ4PkLSfAfRgTF7GW62RCEd5nH27FSX9UaG5Q,927 +sympy/liealgebras/tests/test_type_A.py,sha256=x7QmpjxsGmXol-IYVtN1lmIOmM3HLYwpX1tSG5h6FMM,657 +sympy/liealgebras/tests/test_type_B.py,sha256=Gw0GP24wP2rPn38Wwla9W7BwWH4JtCGpaprZb5W6JVY,642 +sympy/liealgebras/tests/test_type_C.py,sha256=ysSy-vzE9lNwzAunrmvnFkLBoJwF7W2On7QpqS6RI1s,927 +sympy/liealgebras/tests/test_type_D.py,sha256=qrO4oCjrjkp1uDvrNtbgANVyaOExqOLNtIpIxD1uH0U,764 +sympy/liealgebras/tests/test_type_E.py,sha256=suG6DaZ2R74ovnJrY6GGyiu9A6FjUkouRNUFPnEczqk,775 +sympy/liealgebras/tests/test_type_F.py,sha256=yUQJ7LzTemv4Cd1XW_dr3x7KEI07BahsWAyJfXLS1eA,1378 +sympy/liealgebras/tests/test_type_G.py,sha256=wVa6qcAHbdrc9dA63samexHL35cWWJS606pom-6mH2Q,548 +sympy/liealgebras/tests/test_weyl_group.py,sha256=HrzojRECbhNUsdLFQAXYnJEt8LfktOSJZuqVE45aRnc,1501 +sympy/liealgebras/type_a.py,sha256=l5SUJknj1xLgwRVMuOsVmwbcxY2V6PU59jBtssylKH4,4314 +sympy/liealgebras/type_b.py,sha256=50xdcrec1nFFtyUWOmP2Qm9ZW1zpbrgwbz_YPKp55Go,4563 +sympy/liealgebras/type_c.py,sha256=bXGqPiLN3x4NAsM-ZHKJPxFO6RY7lDZUckCarIODEi0,4439 +sympy/liealgebras/type_d.py,sha256=Rgh7KpI5FQnDai6KVfoz_TREYaKxqvINDXu6Zdu-7EQ,4694 +sympy/liealgebras/type_e.py,sha256=Uf-QzI-6bRJeI91stGHsiesknwBEVYIjZaiNP-2bIiY,9780 +sympy/liealgebras/type_f.py,sha256=boKDhOxRcAWDBHsEYk4j14vUvT0mO3UkRq6QzqoPOes,4417 +sympy/liealgebras/type_g.py,sha256=Ife98dGPtarGd-ii8hJbXdB0SMsct4okDkSX2wLN8XI,2965 +sympy/liealgebras/weyl_group.py,sha256=5YFA8qC4GWDM0WLNR_6VgpuNFZDfyDA7fBFjBcZaLgA,14557 +sympy/logic/__init__.py,sha256=RfoXrq9MESnXdL7PkwpYEfWeaxH6wBPHiE4zCgLKvk0,456 +sympy/logic/__pycache__/__init__.cpython-310.pyc,, +sympy/logic/__pycache__/boolalg.cpython-310.pyc,, +sympy/logic/__pycache__/inference.cpython-310.pyc,, +sympy/logic/algorithms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/logic/algorithms/__pycache__/__init__.cpython-310.pyc,, +sympy/logic/algorithms/__pycache__/dpll.cpython-310.pyc,, +sympy/logic/algorithms/__pycache__/dpll2.cpython-310.pyc,, +sympy/logic/algorithms/__pycache__/minisat22_wrapper.cpython-310.pyc,, +sympy/logic/algorithms/__pycache__/pycosat_wrapper.cpython-310.pyc,, +sympy/logic/algorithms/dpll.py,sha256=zqiZDm1oD5sNxFqm_0Hen6NjfILIDp5uRgEOad1vYXI,9188 +sympy/logic/algorithms/dpll2.py,sha256=UbBxJjiUaqBbQPaivtrv3ZhNNuHHdUsJ5Us2vy8QmxA,20317 +sympy/logic/algorithms/minisat22_wrapper.py,sha256=uINcvkIHGWYJb8u-Q0OgnSgaHfVUd9tYYFbBAVNiASo,1317 +sympy/logic/algorithms/pycosat_wrapper.py,sha256=0vNFTbu9-YhSfjwYTsZsP_Z4HM8WpL11-xujLBS1kYg,1207 +sympy/logic/boolalg.py,sha256=-t3WrVge-B7WmoUF25BfOxK15rsC0tIfigdcCcgvbdQ,114180 +sympy/logic/inference.py,sha256=18eETh6ObPCteJJgrrtrkCK031ymDQdvQbveaUymCcM,8542 +sympy/logic/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/logic/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/logic/tests/__pycache__/test_boolalg.cpython-310.pyc,, +sympy/logic/tests/__pycache__/test_dimacs.cpython-310.pyc,, +sympy/logic/tests/__pycache__/test_inference.cpython-310.pyc,, +sympy/logic/tests/test_boolalg.py,sha256=L6hUEjRIhn2Dh65BDXifDrgXHuvBoATT89-6dYZHzgo,48838 +sympy/logic/tests/test_dimacs.py,sha256=EK_mA_k9zBLcQLTOKTZVrGhnGuQNza5mwXDQD_f-X1c,3886 +sympy/logic/tests/test_inference.py,sha256=DOlgb4clEULjMBp0cG3ZdCrXN8vFdxJZmSDf-13bWSA,13246 +sympy/logic/utilities/__init__.py,sha256=WTn2vBgHcmhONRWI79PdMYNk8UxYDzsxRlZWuc-wtNI,55 +sympy/logic/utilities/__pycache__/__init__.cpython-310.pyc,, +sympy/logic/utilities/__pycache__/dimacs.cpython-310.pyc,, +sympy/logic/utilities/dimacs.py,sha256=aaHdXUOD8kZHWbTzuZc6c5xMM8O1oHbRxyOxPpVMMdQ,1663 +sympy/matrices/__init__.py,sha256=BUbgKPUXTwvrhDbQjjG6c3jFBwmQ0WfRiMQTTFnPL90,2611 +sympy/matrices/__pycache__/__init__.cpython-310.pyc,, +sympy/matrices/__pycache__/common.cpython-310.pyc,, +sympy/matrices/__pycache__/decompositions.cpython-310.pyc,, +sympy/matrices/__pycache__/dense.cpython-310.pyc,, +sympy/matrices/__pycache__/determinant.cpython-310.pyc,, +sympy/matrices/__pycache__/eigen.cpython-310.pyc,, +sympy/matrices/__pycache__/graph.cpython-310.pyc,, +sympy/matrices/__pycache__/immutable.cpython-310.pyc,, +sympy/matrices/__pycache__/inverse.cpython-310.pyc,, +sympy/matrices/__pycache__/matrices.cpython-310.pyc,, +sympy/matrices/__pycache__/normalforms.cpython-310.pyc,, +sympy/matrices/__pycache__/reductions.cpython-310.pyc,, +sympy/matrices/__pycache__/repmatrix.cpython-310.pyc,, +sympy/matrices/__pycache__/solvers.cpython-310.pyc,, +sympy/matrices/__pycache__/sparse.cpython-310.pyc,, +sympy/matrices/__pycache__/sparsetools.cpython-310.pyc,, +sympy/matrices/__pycache__/subspaces.cpython-310.pyc,, +sympy/matrices/__pycache__/utilities.cpython-310.pyc,, +sympy/matrices/benchmarks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/matrices/benchmarks/__pycache__/__init__.cpython-310.pyc,, +sympy/matrices/benchmarks/__pycache__/bench_matrix.cpython-310.pyc,, +sympy/matrices/benchmarks/bench_matrix.py,sha256=vGMlg-2il2cFeAWrf0NJ6pzPX3Yd3ZQMxFgQ4q5ILQE,306 +sympy/matrices/common.py,sha256=LnBG-5vXn6c8Oe9C-Q4ziQvNyJSu5l_4DirQ-VZ2rfM,93370 +sympy/matrices/decompositions.py,sha256=MYLr-Qt5wZTDBrnVmBAudOM5QYIgkXWtLDA0coLWk50,48074 +sympy/matrices/dense.py,sha256=cTAq0K3GnLBiNkCgZNVr9rLt8H3rrnyhHaeLc_YTBok,30375 +sympy/matrices/determinant.py,sha256=IxURxqbmux4jXwkIXMm0cxJ3oygY6InrqkVo4ZnD-nk,30118 +sympy/matrices/eigen.py,sha256=7vgLspYAIVmiFtVJ9wNiVLKrQSTGhqLtPR_wqdX0WRc,39786 +sympy/matrices/expressions/__init__.py,sha256=IMqXCSsPh0Vp_MC9HZTudA5DGM4WBq_yB-Bst0azyM8,1692 +sympy/matrices/expressions/__pycache__/__init__.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/_shape.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/adjoint.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/applyfunc.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/blockmatrix.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/companion.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/determinant.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/diagonal.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/dotproduct.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/factorizations.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/fourier.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/funcmatrix.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/hadamard.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/inverse.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/kronecker.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/matadd.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/matexpr.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/matmul.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/matpow.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/permutation.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/sets.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/slice.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/special.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/trace.cpython-310.pyc,, +sympy/matrices/expressions/__pycache__/transpose.cpython-310.pyc,, +sympy/matrices/expressions/_shape.py,sha256=fgKRp_3LrDvFYBYz2M0BqTbjAlKLtx6Gpy9g78wHpVQ,3058 +sympy/matrices/expressions/adjoint.py,sha256=CbkYP2Hi9JVb7WO5HiCE14fwOn16fT3Le5HfV30cpCQ,1572 +sympy/matrices/expressions/applyfunc.py,sha256=wFgcMOp6uakZ6wkkF7mB7GwM35GS5SGzXz1LCeJbemE,6749 +sympy/matrices/expressions/blockmatrix.py,sha256=eKQ4GlVm4_6i2bah7T95qtJdXWLJJ28yry27ajGGfIo,31809 +sympy/matrices/expressions/companion.py,sha256=lXUJRbjQR6e1mdHQdJwNIJXMW80XmKbOVqNvUXjB57U,1705 +sympy/matrices/expressions/determinant.py,sha256=wmtIB5q1_cJpnHSSsQT2MjE6wJdDV1RtZudGOzDJmG4,3173 +sympy/matrices/expressions/diagonal.py,sha256=NtIFAfpoI_jhElfkJ6WCxc4r9iWN8VBOR3LLxKEzJsE,6326 +sympy/matrices/expressions/dotproduct.py,sha256=sKdUhwVKTB3LEvd8xMwCDexNoQ1Dz43DCYsmm3UwFWw,1911 +sympy/matrices/expressions/factorizations.py,sha256=zFNjMBsJqhsIcDD8Me4W8-Q-TV89WptfG3Dd9yK_tPE,1456 +sympy/matrices/expressions/fourier.py,sha256=dvaftgB9jgkR_8ETyhzyVLtf1ZJu_wQC-ZbpTYMXZGE,2094 +sympy/matrices/expressions/funcmatrix.py,sha256=q6R75wLn0UdV4xJdVJUrNaofV1k1egXLLQdBeZcPtiY,3520 +sympy/matrices/expressions/hadamard.py,sha256=S-vY0RFuV7Xyf6kBwgQiGXJnci7j5gpxN8nazW1IGwE,13918 +sympy/matrices/expressions/inverse.py,sha256=ZJSzuTgKz01zmb3dnmFKn6AmR6gXd_5zEYzHkk8cF2o,2732 +sympy/matrices/expressions/kronecker.py,sha256=_JPrC-FruT4N2Sgl4hQdjThjFFfHsHGTLubvU4m3uvU,13398 +sympy/matrices/expressions/matadd.py,sha256=LwznSmZRJQt_sDeq_lcXsUXlSyrcE8J-cwgvi9saUDg,4771 +sympy/matrices/expressions/matexpr.py,sha256=1pswXMAOjYk3YwUhPxCoax2lIZ1rQgnskPdlE1gWhHY,27471 +sympy/matrices/expressions/matmul.py,sha256=bewNxpEnQ0WaVzHzpVgfF_5VHdBLroewZbBAxJTvHgE,15586 +sympy/matrices/expressions/matpow.py,sha256=gF0cscUBvOuAzsGbzN6VgkMPSgz_2_3wShl67B6YGo8,4916 +sympy/matrices/expressions/permutation.py,sha256=gGIht-JI1zWyZz7VPvm5S1Ae2i-P0WUAJl3euLRXWtM,8046 +sympy/matrices/expressions/sets.py,sha256=KxGHZ-4p4nALQBj2f1clG43lB4qYu6M2P0zpubiH-ik,2001 +sympy/matrices/expressions/slice.py,sha256=aNdY1Ey4VJR-UCvoORX2kh2DmA6QjOp-waENvWg8WVE,3355 +sympy/matrices/expressions/special.py,sha256=UH0sOc_XhRHaW5ERyVVHtNTlmfHYiUdRmYzXjcSbCzE,7495 +sympy/matrices/expressions/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/matrices/expressions/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_adjoint.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_applyfunc.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_blockmatrix.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_companion.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_derivatives.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_determinant.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_diagonal.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_dotproduct.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_factorizations.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_fourier.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_funcmatrix.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_hadamard.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_indexing.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_inverse.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_kronecker.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_matadd.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_matexpr.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_matmul.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_matpow.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_permutation.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_sets.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_slice.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_special.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_trace.cpython-310.pyc,, +sympy/matrices/expressions/tests/__pycache__/test_transpose.cpython-310.pyc,, +sympy/matrices/expressions/tests/test_adjoint.py,sha256=cxOc334yNSI9MazhG9HT8s1OCXjkDWr3Zj2JnyHS3Z4,1065 +sympy/matrices/expressions/tests/test_applyfunc.py,sha256=mxTJaoB4Ze50lk-2TgVopmrrbuQbEqUsZwc3K1H8w-Q,3522 +sympy/matrices/expressions/tests/test_blockmatrix.py,sha256=EHJWm2dniNmf1CfODQSPm_HCCV77Ia0FbeNigsYJXZY,15695 +sympy/matrices/expressions/tests/test_companion.py,sha256=Lam6r-cSOokjhSlJws55Kq-gL5_pHfeV_Xuvmn5PkRU,1657 +sympy/matrices/expressions/tests/test_derivatives.py,sha256=9mBeaAZDX7-JbYs6tMClNuGDygETVN_dCXSlHmyAhwg,15991 +sympy/matrices/expressions/tests/test_determinant.py,sha256=QutUKtr35GCZ4iS2H1WTzMwa0jAvL0prcS82Untgr5k,1989 +sympy/matrices/expressions/tests/test_diagonal.py,sha256=3L6Vs_Yr36a8dgIqAeIcNEf0xcVyeyGhANNu0dlIpwI,4516 +sympy/matrices/expressions/tests/test_dotproduct.py,sha256=Zkv2N6oRPm0-sN4PFwsVFrM5Y_qv4x2gWqQQQD86hBY,1171 +sympy/matrices/expressions/tests/test_factorizations.py,sha256=6UPA_UhCL5JPbaQCOatMnxhGnQ-aIHmb3lXqbwrSoIE,786 +sympy/matrices/expressions/tests/test_fourier.py,sha256=0eD69faoHXBcuQ7g2Q31fqs-gyR_Xfe-gv-7DXhJh_c,1638 +sympy/matrices/expressions/tests/test_funcmatrix.py,sha256=zmOEcXHCK2MziwVBJb7iq9Q-Lbl4bbCQ_RAk27c7qUU,2381 +sympy/matrices/expressions/tests/test_hadamard.py,sha256=WDelP7lQ9KqsalOOlWHaZq38nTijkRUMAXMcAvU42SM,4610 +sympy/matrices/expressions/tests/test_indexing.py,sha256=wwYQa7LNlzhBA5fU50gPyE8cqaJf0s3O70PUx4eNCEA,12038 +sympy/matrices/expressions/tests/test_inverse.py,sha256=33Ui_vXZBJR1gMirb8c5xHDnx2jpVjWoVpYmVuZQoJg,2060 +sympy/matrices/expressions/tests/test_kronecker.py,sha256=e5H6av3ioOn8jkjyDBrT3NEmCkyHbN6ZEHOlyB9OYLk,5366 +sympy/matrices/expressions/tests/test_matadd.py,sha256=DkK_RuIFA9H9HoWcegtPWRHfQNg17h5CfqUD26E8u8E,1862 +sympy/matrices/expressions/tests/test_matexpr.py,sha256=lBuqWCwSevU7JL66eoHWrxL5gIvaWmkminDoqFmpyKA,17409 +sympy/matrices/expressions/tests/test_matmul.py,sha256=MuMIzP-ouiuRuTU5PmBtU-Xk_0Btu4mym-C20M8lN58,5963 +sympy/matrices/expressions/tests/test_matpow.py,sha256=3tRbEmZi2gZTmkBm7mAWUDbX4jwEfC8tC4kYoOuzaUg,7304 +sympy/matrices/expressions/tests/test_permutation.py,sha256=93Cqjj2k3aoR3ayMJLdJUa5h1u87bRRxT3I8B4FQsvU,5607 +sympy/matrices/expressions/tests/test_sets.py,sha256=x60NRXGjxS_AE37jGFAOvZdKlWW5m4X0C3OzIukftAM,1410 +sympy/matrices/expressions/tests/test_slice.py,sha256=C7OGAQQTz0YZxZCa7g0m8_0Bqq8jaPRa22JHVSqK7tY,2027 +sympy/matrices/expressions/tests/test_special.py,sha256=Mhg71vnjjb4fm0jZgjDoWW8rAJMBeh8aDCM75gjEpKQ,6496 +sympy/matrices/expressions/tests/test_trace.py,sha256=fRlrw9CfdO3z3SI4TQb1fCUb_zVAndbtyOErEeCTCQ0,3383 +sympy/matrices/expressions/tests/test_transpose.py,sha256=P3wPPRywKnrAppX6gssgD66v0RIcolxqDkCaKGGPVcM,1987 +sympy/matrices/expressions/trace.py,sha256=Iqg3wgO7tTTVZGo1qbXKn99qTss-5znAW6-lLrhuIIs,5348 +sympy/matrices/expressions/transpose.py,sha256=SnfU_CE3_dBQkbi_SkPGqsE8eDgstYuplx7XDxKJIyA,2691 +sympy/matrices/graph.py,sha256=O73INKAbTpnzNdZ7y08ow9U2CmApdn7S9NEsA9LR-XQ,9076 +sympy/matrices/immutable.py,sha256=3NWY8oHiTGdWQR6AfZpg2fOtjRc1KH75yxkITNzCcPg,5425 +sympy/matrices/inverse.py,sha256=pGDQ3-iG9oTMEIuCwrFe0X5lxkvZSF-iMzod8zTv1OA,11409 +sympy/matrices/matrices.py,sha256=thx6Ks7DAts1FUB3l3cu4s3HRJ952mGNlXstLVvR4jM,75508 +sympy/matrices/normalforms.py,sha256=KiiKxxnYEaoA75UJjYFGqVLipgraNlG3Dlh9E2c1Q7k,3808 +sympy/matrices/reductions.py,sha256=GmXqmi3mgxi-jUiSx-B8xN0M7qLLovdDDTzjoMZvQR0,10781 +sympy/matrices/repmatrix.py,sha256=JIt55DuimIz7xN0WjdPzZhQmYbaqnDOT5xCRowPR2pY,21962 +sympy/matrices/solvers.py,sha256=IDDTmTY9FTZsbTwPC4oVG_0ZV8v6ey0JbhCFHulNm2E,22764 +sympy/matrices/sparse.py,sha256=KFRkfQ6iyLekYMc-0VJffNKzf7EeFvIk2zRsFoQwwcI,14675 +sympy/matrices/sparsetools.py,sha256=tzI541P8QW_v1eVJAXgOlo_KK1Xp6u1geawX_tdlBxY,9182 +sympy/matrices/subspaces.py,sha256=uLo4qnP0xvFcFo5hhf6g7pHSHiRbcQ1ATDKwGBxW7CE,3761 +sympy/matrices/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/matrices/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/matrices/tests/__pycache__/test_commonmatrix.cpython-310.pyc,, +sympy/matrices/tests/__pycache__/test_decompositions.cpython-310.pyc,, +sympy/matrices/tests/__pycache__/test_determinant.cpython-310.pyc,, +sympy/matrices/tests/__pycache__/test_eigen.cpython-310.pyc,, +sympy/matrices/tests/__pycache__/test_graph.cpython-310.pyc,, +sympy/matrices/tests/__pycache__/test_immutable.cpython-310.pyc,, +sympy/matrices/tests/__pycache__/test_interactions.cpython-310.pyc,, +sympy/matrices/tests/__pycache__/test_matrices.cpython-310.pyc,, +sympy/matrices/tests/__pycache__/test_normalforms.cpython-310.pyc,, +sympy/matrices/tests/__pycache__/test_reductions.cpython-310.pyc,, +sympy/matrices/tests/__pycache__/test_solvers.cpython-310.pyc,, +sympy/matrices/tests/__pycache__/test_sparse.cpython-310.pyc,, +sympy/matrices/tests/__pycache__/test_sparsetools.cpython-310.pyc,, +sympy/matrices/tests/__pycache__/test_subspaces.cpython-310.pyc,, +sympy/matrices/tests/test_commonmatrix.py,sha256=9xvYBhxFJm020OhVDKWIj-m1PGtkvHFwtV7iL67SdUI,38564 +sympy/matrices/tests/test_decompositions.py,sha256=SvjGIKZawYyotzbbwpwpcC7fV-nZRNlDwRhq1AL2AQ0,14417 +sympy/matrices/tests/test_determinant.py,sha256=RYmf2bLWtk8nuyIJuhRpSIFklsfVtAGa2gx2AvAi2TU,13350 +sympy/matrices/tests/test_eigen.py,sha256=guJ56Hd33ScYp2DPLMQ-mj6WtG7JbRB5pvJLv6SeP-0,22773 +sympy/matrices/tests/test_graph.py,sha256=ckfGDCg2M6gluv9XFnfURga8gxd2HTL7aX281s6wy6c,3213 +sympy/matrices/tests/test_immutable.py,sha256=qV1L1i8RWX3ihJx3J-M07s_thfXmuUA1wIRfQnUbqyA,4618 +sympy/matrices/tests/test_interactions.py,sha256=RKQsDDiwuEZxL7-bTJR_ue7DKGbCZYl7pvjjgE7EyEY,2066 +sympy/matrices/tests/test_matrices.py,sha256=WHL_ngSJgL_R4CBPACf4GPfand2bOGvVhjHcjJyFCY4,144201 +sympy/matrices/tests/test_normalforms.py,sha256=JQvFfp53MW8cJhxEkyNvsMmhhD7FVncAkjuGMXu5Fok,3009 +sympy/matrices/tests/test_reductions.py,sha256=xbB-_vbF9IYIzvkaOjsVeFfJHRk3buFRNdxKGZvuZXE,13951 +sympy/matrices/tests/test_solvers.py,sha256=hsbvtRyBhLzTxX62AYqDTn7bltGanT1NwYUecUPEViE,20386 +sympy/matrices/tests/test_sparse.py,sha256=GvXN6kBVldjqoR8WN8I_PjblKhRmyRWvVuLUgZEgugY,23281 +sympy/matrices/tests/test_sparsetools.py,sha256=pjQR6UaEMR92NolB_IGZ9Umk6FPZjvI0vk1Fd4H_C5I,4877 +sympy/matrices/tests/test_subspaces.py,sha256=vnuIyKbViZMa-AHCZ3PI9HbCL_t-LNI70gwbZvzRtzw,3839 +sympy/matrices/utilities.py,sha256=mMnNsDTxGKqiG0JATsM4W9b5jglhacy-vmRw2aZojgY,2117 +sympy/multipledispatch/__init__.py,sha256=aV2NC2cO_KmD6QFiwy4oC1D8fm3pFuPbaiTMeWmNWak,259 +sympy/multipledispatch/__pycache__/__init__.cpython-310.pyc,, +sympy/multipledispatch/__pycache__/conflict.cpython-310.pyc,, +sympy/multipledispatch/__pycache__/core.cpython-310.pyc,, +sympy/multipledispatch/__pycache__/dispatcher.cpython-310.pyc,, +sympy/multipledispatch/__pycache__/utils.cpython-310.pyc,, +sympy/multipledispatch/conflict.py,sha256=rR6tKn58MfhMMKZ4ZrhVduylXd9f5PjT2TpzM9LMB6o,2117 +sympy/multipledispatch/core.py,sha256=I4WOnmu1VtlaCnn2oD9R2-xckkYLRZPNFEWtCOTAYfM,2261 +sympy/multipledispatch/dispatcher.py,sha256=A2I4upt4qNollXGpwzrqg7M0oKHJhZx1BUMIBnjRIow,12226 +sympy/multipledispatch/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/multipledispatch/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/multipledispatch/tests/__pycache__/test_conflict.cpython-310.pyc,, +sympy/multipledispatch/tests/__pycache__/test_core.cpython-310.pyc,, +sympy/multipledispatch/tests/__pycache__/test_dispatcher.cpython-310.pyc,, +sympy/multipledispatch/tests/test_conflict.py,sha256=msNVSiikuPOqsEm_MMGmjsNbA2CAR0F1FZaHskzzo04,1786 +sympy/multipledispatch/tests/test_core.py,sha256=UfH_7cyvZ6PHjdH8vmLG49CG7E30W8uxm3FthuMc1Jk,4048 +sympy/multipledispatch/tests/test_dispatcher.py,sha256=saJPpGXLpLOuRfw-ekzZGzY-Rys0NsS5ke0n33i9j0U,6228 +sympy/multipledispatch/utils.py,sha256=39wB9i8jNhlLFZyCTFnioLx5N_CNWv4r5VZwKrxswIE,3097 +sympy/ntheory/__init__.py,sha256=MBs5Tdw5xAgNMlCdN8fSLiIswQudZibIbHjI9L5BEds,2746 +sympy/ntheory/__pycache__/__init__.cpython-310.pyc,, +sympy/ntheory/__pycache__/bbp_pi.cpython-310.pyc,, +sympy/ntheory/__pycache__/continued_fraction.cpython-310.pyc,, +sympy/ntheory/__pycache__/digits.cpython-310.pyc,, +sympy/ntheory/__pycache__/ecm.cpython-310.pyc,, +sympy/ntheory/__pycache__/egyptian_fraction.cpython-310.pyc,, +sympy/ntheory/__pycache__/elliptic_curve.cpython-310.pyc,, +sympy/ntheory/__pycache__/factor_.cpython-310.pyc,, +sympy/ntheory/__pycache__/generate.cpython-310.pyc,, +sympy/ntheory/__pycache__/modular.cpython-310.pyc,, +sympy/ntheory/__pycache__/multinomial.cpython-310.pyc,, +sympy/ntheory/__pycache__/partitions_.cpython-310.pyc,, +sympy/ntheory/__pycache__/primetest.cpython-310.pyc,, +sympy/ntheory/__pycache__/qs.cpython-310.pyc,, +sympy/ntheory/__pycache__/residue_ntheory.cpython-310.pyc,, +sympy/ntheory/bbp_pi.py,sha256=p4OLH6B7CFmpTQPM2DNvxWW3T-PYNha5EPAE649i_tA,5252 +sympy/ntheory/continued_fraction.py,sha256=-GA1fzvgK7h8Bad_1NN0majRhwIQEg2zZDPuKSHAVYA,10109 +sympy/ntheory/digits.py,sha256=xFzoMyAC36fLR5OvtTetoXUSvhNTbP3HKY_co8RUEr4,3688 +sympy/ntheory/ecm.py,sha256=3ot2F6V8TSsaFEZndxxDDyqnT0jQ67Xdq0e3cuea_UE,10618 +sympy/ntheory/egyptian_fraction.py,sha256=hW886hPWJtARqgZIrH1WjZFC0uvf9CHxMIn0X9MWZro,6923 +sympy/ntheory/elliptic_curve.py,sha256=zDRjICf4p3PPfdxKWrPeTcMbAMqPvrZmK2rk9JAbh60,11510 +sympy/ntheory/factor_.py,sha256=5Oqd9QvsW4MR_eH--wbpmoa502yhoLM4g-9gPh5eYKc,75815 +sympy/ntheory/generate.py,sha256=42BWhzsUNv2k3pqdzWyAHAPPydPIaxHkmTIV-8rVSAk,29411 +sympy/ntheory/modular.py,sha256=fA3_ovJcPqrwT2bPjmd4cSGPDyVG6HSM9oP07HP1R_s,7650 +sympy/ntheory/multinomial.py,sha256=rbm3STjgfRbNVbcPeH69qtWktthSCk0sC373NuDM6fU,5073 +sympy/ntheory/partitions_.py,sha256=mE-PQKxaEM20AJJiCgkfhuCAruPbrtnHq3Ad2WrBSM8,5975 +sympy/ntheory/primetest.py,sha256=2qI-5HR_CowK2iH07B4XE2anXxkhSDWw7PPcQkOy70g,20951 +sympy/ntheory/qs.py,sha256=QzIJFHjFG2ncIpoJ7CGMzJ6HudVqB2RNp2yBHBjkSz8,18474 +sympy/ntheory/residue_ntheory.py,sha256=qNJSoRFKAcAcRet5rv3nSF7p3BJJXk9ewJxIDdg1lSE,40653 +sympy/ntheory/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/ntheory/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/ntheory/tests/__pycache__/test_bbp_pi.cpython-310.pyc,, +sympy/ntheory/tests/__pycache__/test_continued_fraction.cpython-310.pyc,, +sympy/ntheory/tests/__pycache__/test_digits.cpython-310.pyc,, +sympy/ntheory/tests/__pycache__/test_ecm.cpython-310.pyc,, +sympy/ntheory/tests/__pycache__/test_egyptian_fraction.cpython-310.pyc,, +sympy/ntheory/tests/__pycache__/test_elliptic_curve.cpython-310.pyc,, +sympy/ntheory/tests/__pycache__/test_factor_.cpython-310.pyc,, +sympy/ntheory/tests/__pycache__/test_generate.cpython-310.pyc,, +sympy/ntheory/tests/__pycache__/test_modular.cpython-310.pyc,, +sympy/ntheory/tests/__pycache__/test_multinomial.cpython-310.pyc,, +sympy/ntheory/tests/__pycache__/test_partitions.cpython-310.pyc,, +sympy/ntheory/tests/__pycache__/test_primetest.cpython-310.pyc,, +sympy/ntheory/tests/__pycache__/test_qs.cpython-310.pyc,, +sympy/ntheory/tests/__pycache__/test_residue.cpython-310.pyc,, +sympy/ntheory/tests/test_bbp_pi.py,sha256=-RXXkqMUfVCYeO9HonldOOISDKDaUYCCe5CUgK18L3o,9433 +sympy/ntheory/tests/test_continued_fraction.py,sha256=gfQfLuLVFn-bmEPBcgnU-f0VibJiY8hAEl0FO4V3iVU,3052 +sympy/ntheory/tests/test_digits.py,sha256=jC8GCQVJelFcHMApf5TZU1KXP2oBp48lkkD0bM2TLCo,1182 +sympy/ntheory/tests/test_ecm.py,sha256=Hy9pYRZPuFm7yrGVRs2ob_w3YY3bMEENH_hkDh947UE,2303 +sympy/ntheory/tests/test_egyptian_fraction.py,sha256=tpHcwteuuQAahcPqvgBm4Mwq-efzcHOn8mldijynjlE,2378 +sympy/ntheory/tests/test_elliptic_curve.py,sha256=wc0EOsGo-qGpdevRq1o64htwTOT_YSUzUfyhJC-JVbg,624 +sympy/ntheory/tests/test_factor_.py,sha256=Z1RvrqLttbgp3ZhfJZtCZmUV7GehKGQDSUEEdF0CSSA,25024 +sympy/ntheory/tests/test_generate.py,sha256=ALKzLAcCPIMTr3JC6RJHuOYd6z0aFVaF5-e481icYe8,8069 +sympy/ntheory/tests/test_modular.py,sha256=g73sUXtYNxzbDcq5UnMWT8NodAU8unwRj_E-PpvJqDs,1425 +sympy/ntheory/tests/test_multinomial.py,sha256=8uuj6XlatNyIILOpjJap13CMZmDwrCyGKn9LiIUiLV0,2344 +sympy/ntheory/tests/test_partitions.py,sha256=AkmDpR0IFxo0ret91tRPYUqrgQfQ367okTt2Ee2Vm60,507 +sympy/ntheory/tests/test_primetest.py,sha256=1Pkoi-TNxvB0oT1J5_YXryabyiGgPeXigS_vo_4x_v8,7062 +sympy/ntheory/tests/test_qs.py,sha256=ZCWiWiUULzLDTCz6CsolmVAdvZMZrz3wFrZXd-GtHfM,4481 +sympy/ntheory/tests/test_residue.py,sha256=t3-yaWmZvfkQpjUDqOzgwnTFO0je7BkEU2QKpA-pttU,12884 +sympy/parsing/__init__.py,sha256=KHuyDeHY1ifpVxT4aTOhomazCBYVIrKWd28jqp6YNJ8,125 +sympy/parsing/__pycache__/__init__.cpython-310.pyc,, +sympy/parsing/__pycache__/ast_parser.cpython-310.pyc,, +sympy/parsing/__pycache__/mathematica.cpython-310.pyc,, +sympy/parsing/__pycache__/maxima.cpython-310.pyc,, +sympy/parsing/__pycache__/sym_expr.cpython-310.pyc,, +sympy/parsing/__pycache__/sympy_parser.cpython-310.pyc,, +sympy/parsing/ast_parser.py,sha256=PWuAoNPZ6-C8HCYYGCG9tMCgwuMzi_ebyIqFSJCqk6k,2724 +sympy/parsing/autolev/Autolev.g4,sha256=980mo25mLWrQFmhRIg-aqIalUuwktYYaBGTXZ5_XZwA,4195 +sympy/parsing/autolev/__init__.py,sha256=sp5hzv5siVW3xUmhkp0S0iaA0Cz-PVB0HO1zC04pxYs,3611 +sympy/parsing/autolev/__pycache__/__init__.cpython-310.pyc,, +sympy/parsing/autolev/__pycache__/_build_autolev_antlr.cpython-310.pyc,, +sympy/parsing/autolev/__pycache__/_listener_autolev_antlr.cpython-310.pyc,, +sympy/parsing/autolev/__pycache__/_parse_autolev_antlr.cpython-310.pyc,, +sympy/parsing/autolev/_antlr/__init__.py,sha256=MQ4ZacpTuP-NmruFXKdWLQatoeVJQ8SaBQ2DnYvtyE8,203 +sympy/parsing/autolev/_antlr/__pycache__/__init__.cpython-310.pyc,, +sympy/parsing/autolev/_antlr/__pycache__/autolevlexer.cpython-310.pyc,, +sympy/parsing/autolev/_antlr/__pycache__/autolevlistener.cpython-310.pyc,, +sympy/parsing/autolev/_antlr/__pycache__/autolevparser.cpython-310.pyc,, +sympy/parsing/autolev/_antlr/autolevlexer.py,sha256=K7HF_-5dUyAIv1_7GkhTmxqSCanEhCpzJG8fayAEB3Q,13609 +sympy/parsing/autolev/_antlr/autolevlistener.py,sha256=EDb3XkH9Y7CLzxGM-tY-nGqxMGfBHVkqKdVCPxABgRE,12821 +sympy/parsing/autolev/_antlr/autolevparser.py,sha256=BZYJ7IkurRmm44S50pYp_9JHCjT8fr1w5HeksAEPjtg,106291 +sympy/parsing/autolev/_build_autolev_antlr.py,sha256=XOR44PCPo234I_Z1QnneSArY8aPpp4xP4-dycMalQQw,2590 +sympy/parsing/autolev/_listener_autolev_antlr.py,sha256=P5XTo2UjkyDyx4d9kpmWIm6BoCXyOiED9s8Tr3w3Am4,104758 +sympy/parsing/autolev/_parse_autolev_antlr.py,sha256=b9hIaluJUd1V2XIAp1erak6U-c-CwKyDLH1UkYQuvKE,1736 +sympy/parsing/autolev/test-examples/README.txt,sha256=0C4m_nLROeV5J8nMfm3RYEfYgQJqmlHZaCpVD24boQY,528 +sympy/parsing/autolev/test-examples/__pycache__/ruletest1.cpython-310.pyc,, +sympy/parsing/autolev/test-examples/__pycache__/ruletest10.cpython-310.pyc,, +sympy/parsing/autolev/test-examples/__pycache__/ruletest11.cpython-310.pyc,, +sympy/parsing/autolev/test-examples/__pycache__/ruletest12.cpython-310.pyc,, +sympy/parsing/autolev/test-examples/__pycache__/ruletest2.cpython-310.pyc,, +sympy/parsing/autolev/test-examples/__pycache__/ruletest3.cpython-310.pyc,, +sympy/parsing/autolev/test-examples/__pycache__/ruletest4.cpython-310.pyc,, +sympy/parsing/autolev/test-examples/__pycache__/ruletest5.cpython-310.pyc,, +sympy/parsing/autolev/test-examples/__pycache__/ruletest6.cpython-310.pyc,, +sympy/parsing/autolev/test-examples/__pycache__/ruletest7.cpython-310.pyc,, +sympy/parsing/autolev/test-examples/__pycache__/ruletest8.cpython-310.pyc,, +sympy/parsing/autolev/test-examples/__pycache__/ruletest9.cpython-310.pyc,, +sympy/parsing/autolev/test-examples/pydy-example-repo/__pycache__/chaos_pendulum.cpython-310.pyc,, +sympy/parsing/autolev/test-examples/pydy-example-repo/__pycache__/double_pendulum.cpython-310.pyc,, +sympy/parsing/autolev/test-examples/pydy-example-repo/__pycache__/mass_spring_damper.cpython-310.pyc,, +sympy/parsing/autolev/test-examples/pydy-example-repo/__pycache__/non_min_pendulum.cpython-310.pyc,, +sympy/parsing/autolev/test-examples/pydy-example-repo/chaos_pendulum.al,sha256=HpTcX2wXzLqmgpp8fcSqNweKjxljk43iYK0wQmBbCDI,690 +sympy/parsing/autolev/test-examples/pydy-example-repo/chaos_pendulum.py,sha256=FSu4TP2BDTQjzYhMkcpRhXbb3kAD27XCyO_EoL55Ack,2274 +sympy/parsing/autolev/test-examples/pydy-example-repo/double_pendulum.al,sha256=wjeeRdCS3Es6ldX9Ug5Du1uaijUTyoXpfTqmhL0uYfk,427 +sympy/parsing/autolev/test-examples/pydy-example-repo/double_pendulum.py,sha256=uU9azTUGrY15BSDtw5T_V-7gmjyhHbXslzkmwBvFjGk,1583 +sympy/parsing/autolev/test-examples/pydy-example-repo/mass_spring_damper.al,sha256=Gf7OhgRlwqUEXq7rkfbf89yWA23u4uIUJ-buXTyOuXM,505 +sympy/parsing/autolev/test-examples/pydy-example-repo/mass_spring_damper.py,sha256=9ReCAqcUH5HYBgHmop9h5Zx54mfScWZN5L5F6rCHk4w,1366 +sympy/parsing/autolev/test-examples/pydy-example-repo/non_min_pendulum.al,sha256=p5v40h1nVFrWNqnB0K7GiNQT0b-MqwayYjZxXOY4M8M,362 +sympy/parsing/autolev/test-examples/pydy-example-repo/non_min_pendulum.py,sha256=DdxcWrm3HMQuyyY3Pk6sKHb4RXhQEM_EKY3HYZCP8ec,1503 +sympy/parsing/autolev/test-examples/ruletest1.al,sha256=mDJ02Q1Qm-ShVmGoyjzSfgDJHUOuDrsUg3YMnkpKdUw,176 +sympy/parsing/autolev/test-examples/ruletest1.py,sha256=eIKEFzEwkCFhPF0GTmf6SLuxXT384GqdCJnhiL2U0BQ,555 +sympy/parsing/autolev/test-examples/ruletest10.al,sha256=jKpV8BgX91iQsQDLFOJyaS396AyE5YQlUMxih5o9RK0,781 +sympy/parsing/autolev/test-examples/ruletest10.py,sha256=I1tsQcSAW6wqIguF-7lwlj9D4YZ8kCZqPqTKPUHR9oI,2726 +sympy/parsing/autolev/test-examples/ruletest11.al,sha256=j_q7giq2KIuXVRLWwNlwIlpbhNO6SqBMnLGLcxIkzwk,188 +sympy/parsing/autolev/test-examples/ruletest11.py,sha256=dYTRtXvMDXHiKzXHD2Sh0fcEukob3wr_GbSeqaZrrO8,475 +sympy/parsing/autolev/test-examples/ruletest12.al,sha256=drr2NLrK1ewn4FjMppXycpAUNbZEQ0IAMsdVx8nxk6I,185 +sympy/parsing/autolev/test-examples/ruletest12.py,sha256=ZG36s3PnkT0aKBM9Nx6H0sdJrtoLwaebU9386YSUql8,472 +sympy/parsing/autolev/test-examples/ruletest2.al,sha256=d-QjPpW0lzugaGBg8F6pDl_5sZHOR_EDJ8EvWLcz4FY,237 +sympy/parsing/autolev/test-examples/ruletest2.py,sha256=jrJfb0Jk2FP4GS5pDa0UB5ph0ijEVd1X8meKeZrTVng,820 +sympy/parsing/autolev/test-examples/ruletest3.al,sha256=1TAaOe8GI8-yBWJddfIxwnvScHNmOjSzSaQn0RS_v5k,308 +sympy/parsing/autolev/test-examples/ruletest3.py,sha256=O3K3IQo-HCjAIOSkfz3bDlst7dVUiRwhOZ0q_3jb5LU,1574 +sympy/parsing/autolev/test-examples/ruletest4.al,sha256=qPGlPbdDRrzTDUBeWydAIa7mbjs2o3uX938QAsWJ7Qk,302 +sympy/parsing/autolev/test-examples/ruletest4.py,sha256=WHod5yzKF4TNbEf4Yfxmx9WnimA7NOXqtTjZXR8FsP0,682 +sympy/parsing/autolev/test-examples/ruletest5.al,sha256=VuiKjiFmLK3uEdho0m3pk-n0qm4SNLoLPMRJqjMJ4GY,516 +sympy/parsing/autolev/test-examples/ruletest5.py,sha256=WvUtno1D3BrmFNPYYIBKR_gOA-PaHoxLlSTNDX67dcQ,1991 +sympy/parsing/autolev/test-examples/ruletest6.al,sha256=-HwgTmh_6X3wHjo3PQi7378t8YdizRJClc5Eb5DmjhE,703 +sympy/parsing/autolev/test-examples/ruletest6.py,sha256=vEO0jMOD-KIevAcVexmpvac0MGjN7O_dNipOBJJNzF0,1473 +sympy/parsing/autolev/test-examples/ruletest7.al,sha256=wR9S9rTzO9fyKL6Ofgwzw8XCFCV_p2hBpYotC8TvADI,773 +sympy/parsing/autolev/test-examples/ruletest7.py,sha256=_XvMrMe5r9RLopTrIqMGLhaYvHL1qjteWz9CKcotCL8,1696 +sympy/parsing/autolev/test-examples/ruletest8.al,sha256=P7Nu3Pq2R1mKcuFRc9dRO5jJ1_e5fwWdtqYG8NHVVds,682 +sympy/parsing/autolev/test-examples/ruletest8.py,sha256=8tgbwJ-ir0wiOCsgIFCAu4uD8SieYRrLoLzEfae5YQY,2690 +sympy/parsing/autolev/test-examples/ruletest9.al,sha256=txtZ5RH2p1FvAe6etwetSCH8rLktnpk5z0W72sCOdAA,755 +sympy/parsing/autolev/test-examples/ruletest9.py,sha256=GtqV-Wq2GGJzfblMscAz-KXCzs0P_4XqvA3FIdlPe04,1965 +sympy/parsing/c/__init__.py,sha256=J9CvkNRY-qy6CA06GZYuwTuxdnqas6oUP2g0qLztGro,65 +sympy/parsing/c/__pycache__/__init__.cpython-310.pyc,, +sympy/parsing/c/__pycache__/c_parser.cpython-310.pyc,, +sympy/parsing/c/c_parser.py,sha256=o7UohvD8V6feJr74sIbx2NNAyZOLFNJDHtiUPg_rUeg,39331 +sympy/parsing/fortran/__init__.py,sha256=KraiVw2qxIgYeMRTFjs1vkMi-hqqDkxUBv8Rc2gwkCI,73 +sympy/parsing/fortran/__pycache__/__init__.cpython-310.pyc,, +sympy/parsing/fortran/__pycache__/fortran_parser.cpython-310.pyc,, +sympy/parsing/fortran/fortran_parser.py,sha256=RpNQR3eNx5vgfzdt0nEZDCB56kF__SnYMaqWN3zla00,11483 +sympy/parsing/latex/LICENSE.txt,sha256=AHvDClj6QKmW53IEcSDeTq8x9REOT5w7X5P8374urKE,1075 +sympy/parsing/latex/LaTeX.g4,sha256=fG0ZUQPwYQOIbcyaPDAkGvcfGs3ZwwMB8ZnKW5yHUDY,5821 +sympy/parsing/latex/__init__.py,sha256=10TctFMpk3AolsniTJR5rQr19QXNqVTx-rl8ZFkHC4s,991 +sympy/parsing/latex/__pycache__/__init__.cpython-310.pyc,, +sympy/parsing/latex/__pycache__/_build_latex_antlr.cpython-310.pyc,, +sympy/parsing/latex/__pycache__/_parse_latex_antlr.cpython-310.pyc,, +sympy/parsing/latex/__pycache__/errors.cpython-310.pyc,, +sympy/parsing/latex/_antlr/__init__.py,sha256=TAb79senorEsoYLCLwUa8wg8AUCHzmmZ7tLdi0XGNaE,384 +sympy/parsing/latex/_antlr/__pycache__/__init__.cpython-310.pyc,, +sympy/parsing/latex/_antlr/__pycache__/latexlexer.cpython-310.pyc,, +sympy/parsing/latex/_antlr/__pycache__/latexparser.cpython-310.pyc,, +sympy/parsing/latex/_antlr/latexlexer.py,sha256=Y1hmY1VGL5FTSSlToTRQydPnyaLLNy1mDSWx76HaYwM,30502 +sympy/parsing/latex/_antlr/latexparser.py,sha256=ZvonpvTS3vLSOVpas88M3CfNnUhPUDsCCPPk4wBYUGE,123655 +sympy/parsing/latex/_build_latex_antlr.py,sha256=id_4pbcI4nAa0tHumN0lZX0Ubb-BaJ3czGwiQR_jZPE,2777 +sympy/parsing/latex/_parse_latex_antlr.py,sha256=3iUHktfORn60D5SBpRNjSSaxuKlmzEBI5-DilfkkRQ0,20525 +sympy/parsing/latex/errors.py,sha256=adSpvQyWjTLsbN_2KHJ4HuXpY7_U9noeWiG0lskYLgE,45 +sympy/parsing/mathematica.py,sha256=AX5q_9bDARtC0w3bFNmhNKGqe3X7NlprZEvMCbV_vMs,39282 +sympy/parsing/maxima.py,sha256=DhTnXRSAceijyA1OAm86c6TyW9-aeUVoZEELGu0oZtY,1835 +sympy/parsing/sym_expr.py,sha256=-hxarp961eyLtuwUhbg3D3qzy06HrEPZEYpGVcJzAv0,8895 +sympy/parsing/sympy_parser.py,sha256=QA9TRHZwqQ8kqfOPA4EeHfKz1dCqpBppRtVTE61IpO0,43814 +sympy/parsing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/parsing/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/parsing/tests/__pycache__/test_ast_parser.cpython-310.pyc,, +sympy/parsing/tests/__pycache__/test_autolev.cpython-310.pyc,, +sympy/parsing/tests/__pycache__/test_c_parser.cpython-310.pyc,, +sympy/parsing/tests/__pycache__/test_fortran_parser.cpython-310.pyc,, +sympy/parsing/tests/__pycache__/test_implicit_multiplication_application.cpython-310.pyc,, +sympy/parsing/tests/__pycache__/test_latex.cpython-310.pyc,, +sympy/parsing/tests/__pycache__/test_latex_deps.cpython-310.pyc,, +sympy/parsing/tests/__pycache__/test_mathematica.cpython-310.pyc,, +sympy/parsing/tests/__pycache__/test_maxima.cpython-310.pyc,, +sympy/parsing/tests/__pycache__/test_sym_expr.cpython-310.pyc,, +sympy/parsing/tests/__pycache__/test_sympy_parser.cpython-310.pyc,, +sympy/parsing/tests/test_ast_parser.py,sha256=lcT8w7mn6UEZ8T-xfA4TqG4Mt7JxY00oHhOW7JtHQfY,803 +sympy/parsing/tests/test_autolev.py,sha256=tQuUFa8YqVdsHPOcUhAwlMKB8Uk08HejDhDCda8lXs0,6647 +sympy/parsing/tests/test_c_parser.py,sha256=yIYdfnaHX9Z93-Cmf6x9C7eysQ-y3_lU-6CGRXN4WL8,154665 +sympy/parsing/tests/test_fortran_parser.py,sha256=SGbawrJ4a780TJAFVMONc7Y3Y8VYgVqsIHxVGaicbxE,11828 +sympy/parsing/tests/test_implicit_multiplication_application.py,sha256=nPzLKcAJJaoZgdLoq1_CXhiWKFBH--p4t6dq4I3sV9A,7448 +sympy/parsing/tests/test_latex.py,sha256=khNyIVANKnQFIE6hR3UdSqlzYdZWDtO0vs6TxhpWDUI,11503 +sympy/parsing/tests/test_latex_deps.py,sha256=oe5vm2eIKn05ZiCcXUaO8X6HCcRmN1qCuTsz6tB7Qrk,426 +sympy/parsing/tests/test_mathematica.py,sha256=ma9YM-Cti4hMhjZym5RMGaesxaWki6p29QROJ4oSs4E,13166 +sympy/parsing/tests/test_maxima.py,sha256=iIwnFm0lYD0-JcraUIymogqEMN3ji0c-0JeNFFGTEDs,1987 +sympy/parsing/tests/test_sym_expr.py,sha256=-wNR7GwvJHVmPSZxSuAuoX1_FJk83O0tcDi09qYY6Jk,5668 +sympy/parsing/tests/test_sympy_parser.py,sha256=5__CszZfy8DAl5JzfsLGsDECRjdT20a3p9cwYBXvAh8,12253 +sympy/physics/__init__.py,sha256=F_yvUMCuBq3HR-3Ai6W4oktBsXRg8KdutFLwT9FFJlY,220 +sympy/physics/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/__pycache__/hydrogen.cpython-310.pyc,, +sympy/physics/__pycache__/matrices.cpython-310.pyc,, +sympy/physics/__pycache__/paulialgebra.cpython-310.pyc,, +sympy/physics/__pycache__/pring.cpython-310.pyc,, +sympy/physics/__pycache__/qho_1d.cpython-310.pyc,, +sympy/physics/__pycache__/secondquant.cpython-310.pyc,, +sympy/physics/__pycache__/sho.cpython-310.pyc,, +sympy/physics/__pycache__/wigner.cpython-310.pyc,, +sympy/physics/continuum_mechanics/__init__.py,sha256=moVrcsEw_a8db69dtuwE-aquZ1TAJc7JxHukrYnJuyM,89 +sympy/physics/continuum_mechanics/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/continuum_mechanics/__pycache__/beam.cpython-310.pyc,, +sympy/physics/continuum_mechanics/__pycache__/truss.cpython-310.pyc,, +sympy/physics/continuum_mechanics/beam.py,sha256=i3BcVzCsC9AUPjyAcPd5Lfwcpb_9bz9V-cO6N2WlkLU,148566 +sympy/physics/continuum_mechanics/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/physics/continuum_mechanics/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/continuum_mechanics/tests/__pycache__/test_beam.cpython-310.pyc,, +sympy/physics/continuum_mechanics/tests/__pycache__/test_truss.cpython-310.pyc,, +sympy/physics/continuum_mechanics/tests/test_beam.py,sha256=IubYZzOkQ9dBcyR_rLA9FxUkFZ_x1BX16MKUvyJaOkE,26879 +sympy/physics/continuum_mechanics/tests/test_truss.py,sha256=dsjtXQoBXcFDacKc55DbZST1L69XGKN0TMtCBnHN5hY,3368 +sympy/physics/continuum_mechanics/truss.py,sha256=C9JPSDutXBS4QFmdqcsClFCtdN9tdGauPD8TYQ4_NF0,28496 +sympy/physics/control/__init__.py,sha256=Z5cPVgXd8BAdxX9iqyLLVyk2n2ry_jiMBHo6crMeLFA,1027 +sympy/physics/control/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/control/__pycache__/control_plots.cpython-310.pyc,, +sympy/physics/control/__pycache__/lti.cpython-310.pyc,, +sympy/physics/control/control_plots.py,sha256=Q25egDhUs-xrlh5oy4ZBlnOqF5pJtQ1SRo28r5nnudY,32222 +sympy/physics/control/lti.py,sha256=EquvSYF2ifqnFfYsnoJuAsRrZHQIm7f6LwmZGbmbW-M,114652 +sympy/physics/control/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/physics/control/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/control/tests/__pycache__/test_control_plots.cpython-310.pyc,, +sympy/physics/control/tests/__pycache__/test_lti.cpython-310.pyc,, +sympy/physics/control/tests/test_control_plots.py,sha256=EDTfKI08wacHtYFKf7HeBi43msqqAvMOhTWf-8RJu3k,15728 +sympy/physics/control/tests/test_lti.py,sha256=QPuNpHlSquTX14-r4YbhNfxh32x_D17jAxtO2aQn5GA,59908 +sympy/physics/hep/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/physics/hep/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/hep/__pycache__/gamma_matrices.cpython-310.pyc,, +sympy/physics/hep/gamma_matrices.py,sha256=WlSHLUtMU7NrgLyKEvTntMSYxMZq1r_6o2kqUEAdPaA,24253 +sympy/physics/hep/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/physics/hep/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/hep/tests/__pycache__/test_gamma_matrices.cpython-310.pyc,, +sympy/physics/hep/tests/test_gamma_matrices.py,sha256=iKqICj0bP7EK0sSuYFsPdPkDTbHGa6J_LMPZAzv1j4o,14722 +sympy/physics/hydrogen.py,sha256=R2wnNi1xB-WTQ8Z9aPUhX9Z8mQ8TdhCM1JAZIkyXgjw,7594 +sympy/physics/matrices.py,sha256=jHfbWkzL2myFt-39kodQo5wPubBxNZKXlljuSxZL4bE,3836 +sympy/physics/mechanics/__init__.py,sha256=57XHPOZF3y2-dLcrfwECEgjFthUYeQncmft3GZYKyOY,2033 +sympy/physics/mechanics/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/mechanics/__pycache__/body.cpython-310.pyc,, +sympy/physics/mechanics/__pycache__/functions.cpython-310.pyc,, +sympy/physics/mechanics/__pycache__/joint.cpython-310.pyc,, +sympy/physics/mechanics/__pycache__/jointsmethod.cpython-310.pyc,, +sympy/physics/mechanics/__pycache__/kane.cpython-310.pyc,, +sympy/physics/mechanics/__pycache__/lagrange.cpython-310.pyc,, +sympy/physics/mechanics/__pycache__/linearize.cpython-310.pyc,, +sympy/physics/mechanics/__pycache__/method.cpython-310.pyc,, +sympy/physics/mechanics/__pycache__/models.cpython-310.pyc,, +sympy/physics/mechanics/__pycache__/particle.cpython-310.pyc,, +sympy/physics/mechanics/__pycache__/rigidbody.cpython-310.pyc,, +sympy/physics/mechanics/__pycache__/system.cpython-310.pyc,, +sympy/physics/mechanics/body.py,sha256=eqQbmsPOZnad0aH326N_FfZZWtzs4IIvbugwfkLlHtQ,19088 +sympy/physics/mechanics/functions.py,sha256=GbhUZWZD0HqLGh03ojXfnATxM-oxM708AmFtCgOjJFE,25557 +sympy/physics/mechanics/joint.py,sha256=hTBI8wd7ylnRgR1hrW-Xg9pTiFHBNgA6j5MWfTJMzdU,82739 +sympy/physics/mechanics/jointsmethod.py,sha256=FmccW8429JLfg9-Gxc4oeekrPi2ig77gYZJ2x7qVzMA,8530 +sympy/physics/mechanics/kane.py,sha256=L-imRN4zBCtFXajjyQ4-2peMULqysCbVEUq69JpQbgA,30567 +sympy/physics/mechanics/lagrange.py,sha256=_BM2q2euBxiVj-5OVMOkuzu9D012MP5AC6LnOENwbX0,18338 +sympy/physics/mechanics/linearize.py,sha256=sEX52OQP-pJ_pIlw8oVv01oQPeHiPf0LCm1GMuIn1Yo,15615 +sympy/physics/mechanics/method.py,sha256=2vFRhA79ra4HR6AzVBHMr3oNncrcqgLLMRqdyif0DrI,660 +sympy/physics/mechanics/models.py,sha256=9q1g3I2xYpuTMi-v9geswEqxJWTP3RjcOquRfzMhHzM,6463 +sympy/physics/mechanics/particle.py,sha256=F-pPvcmfxdacZxSIwnaXJ-W9KslIEnCw7ljCLlxVk4Y,7577 +sympy/physics/mechanics/rigidbody.py,sha256=YTWj-awmWw-OZQQ6wn_HxrTnmSu0Hvhd1TJxRVU62LI,11192 +sympy/physics/mechanics/system.py,sha256=Un6ep47tygf1Vdp-8G2WS6uT-FCqOBRwrDUdonFd_vA,18671 +sympy/physics/mechanics/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/physics/mechanics/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/mechanics/tests/__pycache__/test_body.cpython-310.pyc,, +sympy/physics/mechanics/tests/__pycache__/test_functions.cpython-310.pyc,, +sympy/physics/mechanics/tests/__pycache__/test_joint.cpython-310.pyc,, +sympy/physics/mechanics/tests/__pycache__/test_jointsmethod.cpython-310.pyc,, +sympy/physics/mechanics/tests/__pycache__/test_kane.cpython-310.pyc,, +sympy/physics/mechanics/tests/__pycache__/test_kane2.cpython-310.pyc,, +sympy/physics/mechanics/tests/__pycache__/test_kane3.cpython-310.pyc,, +sympy/physics/mechanics/tests/__pycache__/test_kane4.cpython-310.pyc,, +sympy/physics/mechanics/tests/__pycache__/test_lagrange.cpython-310.pyc,, +sympy/physics/mechanics/tests/__pycache__/test_lagrange2.cpython-310.pyc,, +sympy/physics/mechanics/tests/__pycache__/test_linearize.cpython-310.pyc,, +sympy/physics/mechanics/tests/__pycache__/test_method.cpython-310.pyc,, +sympy/physics/mechanics/tests/__pycache__/test_models.cpython-310.pyc,, +sympy/physics/mechanics/tests/__pycache__/test_particle.cpython-310.pyc,, +sympy/physics/mechanics/tests/__pycache__/test_rigidbody.cpython-310.pyc,, +sympy/physics/mechanics/tests/__pycache__/test_system.cpython-310.pyc,, +sympy/physics/mechanics/tests/test_body.py,sha256=fV3dp94uFbE7ZHb7DkD0fJ1UgbSdc1NVVy0yRuYZfuk,11213 +sympy/physics/mechanics/tests/test_functions.py,sha256=W1k7uhYHs1Ayvtr4q8P_S8cUiwOuaz-UdE1svV4WpCQ,11033 +sympy/physics/mechanics/tests/test_joint.py,sha256=fordUBSC7clvKTuKCtb-KhrOGUonMF1w-91G-pawzKk,53035 +sympy/physics/mechanics/tests/test_jointsmethod.py,sha256=0soorl_p-tVwRx0jWreexWLXBk3v13ZnW9vJ0U6t6Pg,8935 +sympy/physics/mechanics/tests/test_kane.py,sha256=rFhtyVrr4Tifdwwgq-vedU8BneLPa_zVcUNWpHAiEvA,20599 +sympy/physics/mechanics/tests/test_kane2.py,sha256=3MweQ_qfbyc8WqcSvvj7iKQLRdMlki9S6uNyd8ZIDN0,19111 +sympy/physics/mechanics/tests/test_kane3.py,sha256=rc4BwlH3VGV21UH_s6I9y1CwHBwvdy3xvkEDS3lAJHQ,14432 +sympy/physics/mechanics/tests/test_kane4.py,sha256=a7CFmnz-MFbQbfop_tAhRUAHk7BJZEfa9PlcX2K8Y0Y,4722 +sympy/physics/mechanics/tests/test_lagrange.py,sha256=iuHomulBF8MafLeorKGaLHUEF8CvFhXcxEtN0hk1akM,10119 +sympy/physics/mechanics/tests/test_lagrange2.py,sha256=HCnDemnFD1r3DIT4oWnypcsZKvF1BA96_MMYHE7Q_xo,1413 +sympy/physics/mechanics/tests/test_linearize.py,sha256=G4XdGFp6lIUwNJ6qm77X24ZPKgGcyxYBuCv61WeROXM,11826 +sympy/physics/mechanics/tests/test_method.py,sha256=L7CnsvbQC-U7ijbSZdu7DEr03p88OLj4IPvFJ_3kCDo,154 +sympy/physics/mechanics/tests/test_models.py,sha256=X7lrxTIWuTP7GgpYyGVmOG48zG4UDWV99FACXFO5VMA,5091 +sympy/physics/mechanics/tests/test_particle.py,sha256=j66nmXM7R_TSxr2Z1xywQKD-al1z62I15ozPaywN1n0,2153 +sympy/physics/mechanics/tests/test_rigidbody.py,sha256=QvAAtofAqA4oQaYvxN1gK7QJf6TGrI3TqY5fHjbP200,5247 +sympy/physics/mechanics/tests/test_system.py,sha256=vRxvOH56wuWRTygmTcJJZAlB6Bw2Vlhcr9q6A526_WA,8713 +sympy/physics/optics/__init__.py,sha256=0UmqIt2-u8WwNkAqsnOVt9VlkB9K0CRIJYiQaltJ73w,1647 +sympy/physics/optics/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/optics/__pycache__/gaussopt.cpython-310.pyc,, +sympy/physics/optics/__pycache__/medium.cpython-310.pyc,, +sympy/physics/optics/__pycache__/polarization.cpython-310.pyc,, +sympy/physics/optics/__pycache__/utils.cpython-310.pyc,, +sympy/physics/optics/__pycache__/waves.cpython-310.pyc,, +sympy/physics/optics/gaussopt.py,sha256=xMoYUyPyh2ycyNj5gomy_0PkNKKHa9XRlE39mZUQaqI,20892 +sympy/physics/optics/medium.py,sha256=cys0tWGi1VCPWMTZuKadcN_bToz_bqKsDHSEVzuV3CE,7124 +sympy/physics/optics/polarization.py,sha256=mIrZiOVXetGtKkLxl8Llaf2Z9coWenf6JKrClh4W8yU,21434 +sympy/physics/optics/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/physics/optics/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/optics/tests/__pycache__/test_gaussopt.cpython-310.pyc,, +sympy/physics/optics/tests/__pycache__/test_medium.cpython-310.pyc,, +sympy/physics/optics/tests/__pycache__/test_polarization.cpython-310.pyc,, +sympy/physics/optics/tests/__pycache__/test_utils.cpython-310.pyc,, +sympy/physics/optics/tests/__pycache__/test_waves.cpython-310.pyc,, +sympy/physics/optics/tests/test_gaussopt.py,sha256=QMXJw_6mFCC3918b-pc_4b_zgO8Hsk7_SBvMupbEi5I,4222 +sympy/physics/optics/tests/test_medium.py,sha256=RxG7N3lzmCO_8hIoKyPnDKffmk8QFzA9yamu1_mr_dE,2194 +sympy/physics/optics/tests/test_polarization.py,sha256=81MzyA29HZckg_Ss-88-5o0g9augDqCr_LwcJIiXuA0,2605 +sympy/physics/optics/tests/test_utils.py,sha256=SjicjAptcZGwuX-ib_Lq7PlGONotvo2XJ4p3JA9iNVI,8553 +sympy/physics/optics/tests/test_waves.py,sha256=PeFfrl7MBkWBHdc796sDDYDuhGepat3DQk7PmyTXVnw,3397 +sympy/physics/optics/utils.py,sha256=qoSlzujMTHDxIZvBQPJ_cF2PxB-awyXVqCndriUd-PQ,22154 +sympy/physics/optics/waves.py,sha256=Iw-9gGksvWhPmQ_VepmI90ekKyzHdPlq6U41wdM4ikI,10042 +sympy/physics/paulialgebra.py,sha256=1r_qDBbVyl836qIXlVDdoF89Z9wedGvWIkHAbwQaK-4,6002 +sympy/physics/pring.py,sha256=SCMGGIcEhVoD7dwhY7_NWL1iKwo7OfgKdmm2Ok_9Xl0,2240 +sympy/physics/qho_1d.py,sha256=ZXemUsa_b0rLtPVTUkgAkZQ1Ecu2eIZxaiNSSXW0PDk,2005 +sympy/physics/quantum/__init__.py,sha256=RA2xbM7GhFq3dVNTna3odlTJYHqNerxjNeZ1kwigHiw,1705 +sympy/physics/quantum/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/anticommutator.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/boson.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/cartesian.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/cg.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/circuitplot.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/circuitutils.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/commutator.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/constants.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/dagger.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/density.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/fermion.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/gate.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/grover.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/hilbert.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/identitysearch.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/innerproduct.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/matrixcache.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/matrixutils.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/operator.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/operatorordering.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/operatorset.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/pauli.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/piab.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/qapply.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/qasm.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/qexpr.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/qft.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/qubit.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/represent.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/sho1d.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/shor.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/spin.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/state.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/tensorproduct.cpython-310.pyc,, +sympy/physics/quantum/__pycache__/trace.cpython-310.pyc,, +sympy/physics/quantum/anticommutator.py,sha256=TH0mPF3Dk9mL5fa2heuampDpwWFxxh3HCcg4g2uNQ_E,4446 +sympy/physics/quantum/boson.py,sha256=cEH8dcPXunognApc69Y6TSJRMZ63P20No6tB2xGHynQ,6313 +sympy/physics/quantum/cartesian.py,sha256=9R9VDYLV1Xe-GkA9TQbj8PVlBLaD0fF6KXfHJ1ze5as,9092 +sympy/physics/quantum/cg.py,sha256=hPkgraNAWHIC-b0Pr0IwiY_gfR9pthQC6IuNI89J4dI,23331 +sympy/physics/quantum/circuitplot.py,sha256=SacQMhPyDhizKmGRNEs1vtXph8lR6bMn5bVJI4rJiXg,11799 +sympy/physics/quantum/circuitutils.py,sha256=mrQNUDbwM3LV1NZ1EqVpXyOY2mOXCBVZW7cQTiCxUaM,13882 +sympy/physics/quantum/commutator.py,sha256=7IiNnFYxxi9EfElCFtMLEQccb6nB-jIeq4x3IlIqzKs,7521 +sympy/physics/quantum/constants.py,sha256=20VRATCkSprSnGFR5ejvMEYlWwEcv1B-dE3RPqPTQ9k,1420 +sympy/physics/quantum/dagger.py,sha256=KOeHXb52hvR1IbeNwlNU30KPiD9xv7S1a2dowkQqBLM,2428 +sympy/physics/quantum/density.py,sha256=vCH8c4Fu5lcrT0PsuBqEK7eWnyHtCRwVx4wSh3f07ME,9743 +sympy/physics/quantum/fermion.py,sha256=9umlSpm6pKoplH7hRRHbuwvkvdM98A9GGNZ6yeNJf_o,4506 +sympy/physics/quantum/gate.py,sha256=T_VkbtJEN0rbOB8wrlZFkI7NU1XJ2MGyEx9PX3GCV_4,42487 +sympy/physics/quantum/grover.py,sha256=Cu2EPTOWpfyxYMVOdGBZez8SBZ2i2QEUmHnTiPPSi-M,10454 +sympy/physics/quantum/hilbert.py,sha256=qrja92vF7BUeSyHOLKVX8-XKcPGT7QaQMWrqWXjRNus,19632 +sympy/physics/quantum/identitysearch.py,sha256=Zh_ji5J0YeAy2AezsQcHV9W2icWoaa3ZwTbfjCCQmJo,27607 +sympy/physics/quantum/innerproduct.py,sha256=K4tmyWYMlgzkTTXjs82PzEC8VU4jm2J6Qic4YmAM7SQ,4279 +sympy/physics/quantum/matrixcache.py,sha256=S6fPkkYmfX8ELBOc9EST-8XnQ1gtpSOBfd2KwLGKdYo,3587 +sympy/physics/quantum/matrixutils.py,sha256=D5ipMBRCh2NsxIy4F6ZLQAF4Y84-2rKKC-czCVZ22Ds,8213 +sympy/physics/quantum/operator.py,sha256=zxPohzuo4H_veqo_Lkws1mN5mKufKlK5JZrgpxQXABM,19311 +sympy/physics/quantum/operatorordering.py,sha256=smjToA0lj6he22d9R61EL2FSNXFz9oTIF8x5UOd4RNs,11597 +sympy/physics/quantum/operatorset.py,sha256=W8rYUrh167nkZcoXCTFscZ1ZvBT6WXkMfmKzRks3edE,9598 +sympy/physics/quantum/pauli.py,sha256=lzxWFHXqxKWRiYK99QCo9zuVG9eVXiB8vFya7TvrVxQ,17250 +sympy/physics/quantum/piab.py,sha256=Zjb2cRGniVDV6e35gjP4uEpI4w0C7YGQIEXReaq_z-E,1912 +sympy/physics/quantum/qapply.py,sha256=E6hH0w7pMHaXOixT3FWkcBJm56Yoi8B93wedgcH3XQY,7147 +sympy/physics/quantum/qasm.py,sha256=UWpcUIBgkK55SmEBZlpmz-1KGHZvW7dNeSVG8tHr44A,6288 +sympy/physics/quantum/qexpr.py,sha256=UD2gBfjYRnHcqKYk-Jhex8dOoxNProadx154vejvtB4,14005 +sympy/physics/quantum/qft.py,sha256=Iy6yd41lENuCeU5jLXY7O3E_Sc3SAHCN3X5bE0sQiiU,6352 +sympy/physics/quantum/qubit.py,sha256=OyVzGFycgwyn8ZvsCNYsuDmG801JurfKwlKxVDHIBCo,26007 +sympy/physics/quantum/represent.py,sha256=b_mEm3q-gZbIV5x5Vl6pzfyJytqlp_a98xpfse2AfgI,18707 +sympy/physics/quantum/sho1d.py,sha256=ZroR_FjxmjOmDcd0Fm04vWKTGCpvLaEu4NiuplKm708,20867 +sympy/physics/quantum/shor.py,sha256=nHT2m4msS5gyQLYPIo2X6XcF7y0pTRZYJUYxZG0YCUk,5504 +sympy/physics/quantum/spin.py,sha256=3h9uGC5vJcnu3qRzXnZr-nUNyHkC4AvIOB-rBmbliJ4,72948 +sympy/physics/quantum/state.py,sha256=ISVtxmQjQL28neAcvyLDD6QJtLAFPwotCBeArPmDuFc,30975 +sympy/physics/quantum/tensorproduct.py,sha256=uBpy2037T1bCxZsiFoIAzHQru2Yi2Om8PFDtdCq5Nas,14960 +sympy/physics/quantum/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/physics/quantum/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_anticommutator.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_boson.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_cartesian.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_cg.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_circuitplot.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_circuitutils.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_commutator.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_constants.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_dagger.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_density.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_fermion.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_gate.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_grover.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_hilbert.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_identitysearch.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_innerproduct.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_matrixutils.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_operator.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_operatorordering.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_operatorset.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_pauli.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_piab.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_printing.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_qapply.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_qasm.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_qexpr.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_qft.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_qubit.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_represent.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_sho1d.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_shor.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_spin.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_state.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_tensorproduct.cpython-310.pyc,, +sympy/physics/quantum/tests/__pycache__/test_trace.cpython-310.pyc,, +sympy/physics/quantum/tests/test_anticommutator.py,sha256=ckWHKwQFiAMWcDaYSa_26vi_GIsvs32_0O62I5lGsr8,1304 +sympy/physics/quantum/tests/test_boson.py,sha256=BZjdrZ-F1QhyhDqfK4Zc1VEFBJi1PeiPjMpfBcHekfo,1676 +sympy/physics/quantum/tests/test_cartesian.py,sha256=b8eBLwmL8ize-a30TMDkoWuDym02PvBjr7ayfLwaR_I,4112 +sympy/physics/quantum/tests/test_cg.py,sha256=pw14QQ6XBTkK35021E_nDqcvXdOi4bLiPlkddyE865s,8878 +sympy/physics/quantum/tests/test_circuitplot.py,sha256=c3v9wUzLHUH-eBVGj6_broVhHkioNwpaaApTDAJEflU,2096 +sympy/physics/quantum/tests/test_circuitutils.py,sha256=GrJAWRQVH_l8EIHrj1ve2jtxske72IriQ3lo94fqrVQ,13187 +sympy/physics/quantum/tests/test_commutator.py,sha256=keBstGDpNITFRr06uVFrka_Lje56g6oFoJQEpZXmnYw,2727 +sympy/physics/quantum/tests/test_constants.py,sha256=KBmYPIF49Sq34lbzbFCZRYWSyIdhnR3AK3q-VbU6grU,338 +sympy/physics/quantum/tests/test_dagger.py,sha256=PR19goU60RXL3aU3hU2CJ3VyrlGeP6x_531nI9mqvm8,2009 +sympy/physics/quantum/tests/test_density.py,sha256=EyxiEgyc0nDSweJwI0JUwta7gZ81TVHCl7YDEosTrvI,9718 +sympy/physics/quantum/tests/test_fermion.py,sha256=bFaOWjPHv5HNR10Jvk4i9muJ3MQIyznPWZMtDCtKrZM,1135 +sympy/physics/quantum/tests/test_gate.py,sha256=7oBX1HoWnrYtHjABRoqv_wQDB9B829E99fdcJzaqawM,12496 +sympy/physics/quantum/tests/test_grover.py,sha256=uze62AG6H4x2MYJJA-EY3NtkqwvrDIQ2kONuvIRQiZ4,3640 +sympy/physics/quantum/tests/test_hilbert.py,sha256=IGP6rc2-b3we9dRDbpRniFAhQwp_TYtMfFzxusAprx0,2643 +sympy/physics/quantum/tests/test_identitysearch.py,sha256=3YGrXCsFLhLtN5MRyT5ZF8ELrSdkvDKTv6xKM4i2ims,17745 +sympy/physics/quantum/tests/test_innerproduct.py,sha256=37tT8p6MhHjAYeoay1Zyv7gCs-DeZQi4VdwUH2IffDE,1483 +sympy/physics/quantum/tests/test_matrixutils.py,sha256=3wmKKRhfRuwdQWitWE2mJEHr-TUKn6ixNb_wPWs8wRw,4116 +sympy/physics/quantum/tests/test_operator.py,sha256=BZNYANH2w2xfOkqFA3oIS_Kl1KnwnDUroV7d9lQ3IdY,8164 +sympy/physics/quantum/tests/test_operatorordering.py,sha256=CNMvvTNGNSIXPGLaYjxAOFKk-2Tn4yp3L9w-hc1IMnE,1402 +sympy/physics/quantum/tests/test_operatorset.py,sha256=DNfBeYBa_58kSG7PM5Ilo6xnzek8lSiAGX01uMFRYqI,2628 +sympy/physics/quantum/tests/test_pauli.py,sha256=Bhsx_gj5cpYv4BhVJRQohxlKk_rcp4jHtSRlTP-m_xs,4940 +sympy/physics/quantum/tests/test_piab.py,sha256=8ndnzyIsjF4AOu_9k6Yqap_1XUDTbiGnv7onJdrZBWA,1086 +sympy/physics/quantum/tests/test_printing.py,sha256=wR45NMA2w242-qnAlMjyOPj2yvwDbCKuBDh_V2sekr8,30294 +sympy/physics/quantum/tests/test_qapply.py,sha256=uHw3Crt5Lv0t6TV9jxmNwPVbiWGzFMaLZ8TJZfB1-Mg,6022 +sympy/physics/quantum/tests/test_qasm.py,sha256=ZvMjiheWBceSmIM9LHOL5fiFUl6HsUo8puqdzywrhkc,2976 +sympy/physics/quantum/tests/test_qexpr.py,sha256=emcGEqQeCv-kVJxyfX66TZxahJ8pYznFLE1fyyzeZGc,1517 +sympy/physics/quantum/tests/test_qft.py,sha256=CQWIKZFSpkUe5X7AF27EqVwZ4l0Zqycl3bdYgVZj3Hs,1861 +sympy/physics/quantum/tests/test_qubit.py,sha256=LQNaOuvXc-glRifQBlsXattAQB-yKHvmNMw68_JoM_c,8957 +sympy/physics/quantum/tests/test_represent.py,sha256=rEc_cirIJvoU1xANuOTkMjJHdr6DluP4J9sWD2D8Xpc,5166 +sympy/physics/quantum/tests/test_sho1d.py,sha256=nc75ZE5XXtrc88OcfB5mAGh01Wpf3d4Rbsu8vLJPTC8,4684 +sympy/physics/quantum/tests/test_shor.py,sha256=3a3GCg6V5_mlJ2bltoXinGMGvlSxpq7GluapD_3SZaQ,666 +sympy/physics/quantum/tests/test_spin.py,sha256=LOIPNGWalfPLL7DNAaiLCp4J_G1mZpUYmTCNx3kjqgw,344807 +sympy/physics/quantum/tests/test_state.py,sha256=UjfOdwRzNXHK0AMhEaI431eMNjVUK7glqiGxOXJEC50,6741 +sympy/physics/quantum/tests/test_tensorproduct.py,sha256=UncgjQFeJX3BOdHy8UYbb_Lwit67CfNuwLaFYRmyKUI,4703 +sympy/physics/quantum/tests/test_trace.py,sha256=dbpTXcJArWRR_Hh5JTuy2GJIfgjVo6zS20o5mdVEGH4,3057 +sympy/physics/quantum/trace.py,sha256=2ZqN9IEsz3LKHTLV8ZDwTK0sM5PfwL0p2sYet0N7Gis,6397 +sympy/physics/secondquant.py,sha256=FvAm6mVUVVRxaYPzqn4qwhkZCvN8LA8xUFKjnkMpPdw,90400 +sympy/physics/sho.py,sha256=K8P9FAdZr6UfQKYZO9TlhDUqUd3YsMekXCsKy2HhaY0,2480 +sympy/physics/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/physics/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/tests/__pycache__/test_clebsch_gordan.cpython-310.pyc,, +sympy/physics/tests/__pycache__/test_hydrogen.cpython-310.pyc,, +sympy/physics/tests/__pycache__/test_paulialgebra.cpython-310.pyc,, +sympy/physics/tests/__pycache__/test_physics_matrices.cpython-310.pyc,, +sympy/physics/tests/__pycache__/test_pring.cpython-310.pyc,, +sympy/physics/tests/__pycache__/test_qho_1d.cpython-310.pyc,, +sympy/physics/tests/__pycache__/test_secondquant.cpython-310.pyc,, +sympy/physics/tests/__pycache__/test_sho.cpython-310.pyc,, +sympy/physics/tests/test_clebsch_gordan.py,sha256=HdmpjVHZ1JandoZrGwFb7YshkmEkcvt3jLLVxZ13UvA,8563 +sympy/physics/tests/test_hydrogen.py,sha256=kohRIR6JojE_GWYnlzLsMMgdhoKd8whazs0mq7cCTQc,4987 +sympy/physics/tests/test_paulialgebra.py,sha256=tyshEMsLNPR4iYzoAbPGZRZ-e_8t7GDP_xyjRyhepeQ,1477 +sympy/physics/tests/test_physics_matrices.py,sha256=Dha8iQRhzxLcl7TKSA6QP0pnEcBoqtj_Ob6tx01SMwI,2948 +sympy/physics/tests/test_pring.py,sha256=XScQQO9RhRrlqSII_ZyyOUpE-zs-7wphSFCZq2OuFnE,1261 +sympy/physics/tests/test_qho_1d.py,sha256=LD9WU-Y5lW7bVM7MyCkSGW9MU2FZhVjMB5Zk848_q1M,1775 +sympy/physics/tests/test_secondquant.py,sha256=VgG8NzcFmIkhFbKZpbjjzV4W5JOaJHGj9Ut8ugWM2UM,48450 +sympy/physics/tests/test_sho.py,sha256=aIs1f3eo6hb4ErRU8xrr_h_yhTmRx-fQgv9n27SfsLM,693 +sympy/physics/units/__init__.py,sha256=DVvWy9qNRm742NFGcBpybFY20ZK3BU7DWNbLMTXYiFo,12386 +sympy/physics/units/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/units/__pycache__/dimensions.cpython-310.pyc,, +sympy/physics/units/__pycache__/prefixes.cpython-310.pyc,, +sympy/physics/units/__pycache__/quantities.cpython-310.pyc,, +sympy/physics/units/__pycache__/unitsystem.cpython-310.pyc,, +sympy/physics/units/__pycache__/util.cpython-310.pyc,, +sympy/physics/units/definitions/__init__.py,sha256=F3RyZc1AjM2Ch5b27Tt-VYdZ1HAIWvhgtQQQTfMiN6w,7470 +sympy/physics/units/definitions/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/units/definitions/__pycache__/dimension_definitions.cpython-310.pyc,, +sympy/physics/units/definitions/__pycache__/unit_definitions.cpython-310.pyc,, +sympy/physics/units/definitions/dimension_definitions.py,sha256=5r_WDnyWFX0T8bTjDA6pnr5PqRKv5XGTm0LuJrZ6ffM,1745 +sympy/physics/units/definitions/unit_definitions.py,sha256=kldfMjhOFdJAbYgZiJPUFtyUVINovDf4XTTC0mkoiDU,14374 +sympy/physics/units/dimensions.py,sha256=B2jT7BEsyCSZmUxH6RYrP9gVGeXLn0nLhgMT9gFODW4,20911 +sympy/physics/units/prefixes.py,sha256=ENV04BUHeebXK2U8jf7ZQdYQ-dZUGm1K2m6BYwJYF2w,6224 +sympy/physics/units/quantities.py,sha256=r5E231CULmsSEM7Rh7zfcTPuR85_X0CwRCVU_nDsek0,4671 +sympy/physics/units/systems/__init__.py,sha256=jJuvdc15c83yl11IuvhyjijwOZ9m1JGgZOgKwKv2e2o,244 +sympy/physics/units/systems/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/units/systems/__pycache__/cgs.cpython-310.pyc,, +sympy/physics/units/systems/__pycache__/length_weight_time.cpython-310.pyc,, +sympy/physics/units/systems/__pycache__/mks.cpython-310.pyc,, +sympy/physics/units/systems/__pycache__/mksa.cpython-310.pyc,, +sympy/physics/units/systems/__pycache__/natural.cpython-310.pyc,, +sympy/physics/units/systems/__pycache__/si.cpython-310.pyc,, +sympy/physics/units/systems/cgs.py,sha256=gXbX8uuZo7lcYIENA-CpAnyS9WVQy-vRisxlQm-198A,3702 +sympy/physics/units/systems/length_weight_time.py,sha256=DXIDSWdhjfxGLA0ldOziWhwQjzTAs7-VQTNCHzDvCgY,7004 +sympy/physics/units/systems/mks.py,sha256=Z3eX9yWK9BdvEosCROK2qRKtKFYOjtQ50Jk6vFT7AQY,1546 +sympy/physics/units/systems/mksa.py,sha256=U8cSI-maIuLJRvpKLBuZA8V19LDRYVc2I40Rao-wvjk,2002 +sympy/physics/units/systems/natural.py,sha256=43Odvmtxdpbz8UcW_xoRE9ArJVVdF7dgdAN2ByDAXx4,909 +sympy/physics/units/systems/si.py,sha256=YBPUuovW3-JBDZYuStXXRaC8cfzE3En3K5MjNy5pLJk,14478 +sympy/physics/units/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/physics/units/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/units/tests/__pycache__/test_dimensions.cpython-310.pyc,, +sympy/physics/units/tests/__pycache__/test_dimensionsystem.cpython-310.pyc,, +sympy/physics/units/tests/__pycache__/test_prefixes.cpython-310.pyc,, +sympy/physics/units/tests/__pycache__/test_quantities.cpython-310.pyc,, +sympy/physics/units/tests/__pycache__/test_unit_system_cgs_gauss.cpython-310.pyc,, +sympy/physics/units/tests/__pycache__/test_unitsystem.cpython-310.pyc,, +sympy/physics/units/tests/__pycache__/test_util.cpython-310.pyc,, +sympy/physics/units/tests/test_dimensions.py,sha256=lzkgGfEXMHxB8Izv7nRTN2uOEPh65LXPYaG8Kr5H05o,6122 +sympy/physics/units/tests/test_dimensionsystem.py,sha256=s2_2RAJwOaPOTvyIiAO9SYap374ytZqWbatWkLCnbSU,2717 +sympy/physics/units/tests/test_prefixes.py,sha256=IFeF1tq9SkyqJLOLy5h42oMW7PDJ1QKtvyu0EbN3rxY,2198 +sympy/physics/units/tests/test_quantities.py,sha256=_OmQ1qBPud8-lVesvVNhQLrwRh9qp7rXMSGzqTtqCr0,20055 +sympy/physics/units/tests/test_unit_system_cgs_gauss.py,sha256=JepTWt8yGdtv5dQ2AKUKb9fxpuYqLWOp0oOmzov9vfY,3173 +sympy/physics/units/tests/test_unitsystem.py,sha256=1Xh78_8hbv-yP4ICWI_dUrOnk3cimlvP_VhO-EXOa7Q,3254 +sympy/physics/units/tests/test_util.py,sha256=f2pOxVLArai5EwRAriPh9rQdxIyhFpZ4v7WEB0CI-SI,8465 +sympy/physics/units/unitsystem.py,sha256=UXFcmQoI8Hl89v4ixEfh35g__o6AgQPzgvLJhCLIFtA,7618 +sympy/physics/units/util.py,sha256=dgMkwlaYWO2D1QwSpGKFfYluqzdN6TUp-aIgXo8-W1o,9602 +sympy/physics/vector/__init__.py,sha256=jZmrNB6ZfY7NOP8nx8GWcfI2Ixb2mv7lXuGHn63kyOw,985 +sympy/physics/vector/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/vector/__pycache__/dyadic.cpython-310.pyc,, +sympy/physics/vector/__pycache__/fieldfunctions.cpython-310.pyc,, +sympy/physics/vector/__pycache__/frame.cpython-310.pyc,, +sympy/physics/vector/__pycache__/functions.cpython-310.pyc,, +sympy/physics/vector/__pycache__/point.cpython-310.pyc,, +sympy/physics/vector/__pycache__/printing.cpython-310.pyc,, +sympy/physics/vector/__pycache__/vector.cpython-310.pyc,, +sympy/physics/vector/dyadic.py,sha256=qDsDiWZ8nTOVKKjST3MasskWUvrv8o8CZeLTXfJjp6Y,19538 +sympy/physics/vector/fieldfunctions.py,sha256=1tzyV2iH6-UIPJ6W4UhgOZHTGxAbnWhmdTxbz12Z528,8593 +sympy/physics/vector/frame.py,sha256=5wHaV4FIAC0XjvX5ziFmBwB2P2wKPk1Sipb6ao6STn0,52933 +sympy/physics/vector/functions.py,sha256=Fp3Fx0donNUPj9rkZ03xFC8HhUys4UvogK69ah2Sd3o,24583 +sympy/physics/vector/point.py,sha256=9hUKwsM_5npy9FuDSHe9eiOLQLfmZZE49rVxwEhPT2U,20446 +sympy/physics/vector/printing.py,sha256=iQmyZQib-9Oa7_suxwHplJ9HW198LPGmptDldwqRl20,11792 +sympy/physics/vector/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/physics/vector/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/physics/vector/tests/__pycache__/test_dyadic.cpython-310.pyc,, +sympy/physics/vector/tests/__pycache__/test_fieldfunctions.cpython-310.pyc,, +sympy/physics/vector/tests/__pycache__/test_frame.cpython-310.pyc,, +sympy/physics/vector/tests/__pycache__/test_functions.cpython-310.pyc,, +sympy/physics/vector/tests/__pycache__/test_output.cpython-310.pyc,, +sympy/physics/vector/tests/__pycache__/test_point.cpython-310.pyc,, +sympy/physics/vector/tests/__pycache__/test_printing.cpython-310.pyc,, +sympy/physics/vector/tests/__pycache__/test_vector.cpython-310.pyc,, +sympy/physics/vector/tests/test_dyadic.py,sha256=09VKP_uSaiJny5LxNlkSMwU_LdQhZ6yGqoD1GG4dc2U,4292 +sympy/physics/vector/tests/test_fieldfunctions.py,sha256=FUjh18QzB6dXSau9iHutb36o28faSa7T9sB0icpja-M,5825 +sympy/physics/vector/tests/test_frame.py,sha256=sk4atyErDljoa9Q4YDDWoubBOxfkSXR3mKTmYAO_2vE,26102 +sympy/physics/vector/tests/test_functions.py,sha256=5gR01x9HlqM_DViSlu7Yf1m5NQWI2oqBe1a3dRkBcIc,20763 +sympy/physics/vector/tests/test_output.py,sha256=TFqso2YUb5zw4oX6H206Wu0XTwJZFKPY92gd68ktMN4,2631 +sympy/physics/vector/tests/test_point.py,sha256=B6Yk7K-ouyN-VBXycDJV4sOYrPyFf8a_Q-Ytx7vq1mo,12257 +sympy/physics/vector/tests/test_printing.py,sha256=kptiX3xy_xPSyg8f4xZ2jJnorynPvfTenOBtntsYXaY,10433 +sympy/physics/vector/tests/test_vector.py,sha256=Jm6DeizQxKY-CD7722--Ko073bcN4jJJ-geRoNkofs4,9458 +sympy/physics/vector/vector.py,sha256=o9Ov2GD6-_4eZwqpNkaB1DvCioSXAVtR0HFoRneNEEc,27533 +sympy/physics/wigner.py,sha256=4jYcv62gfHJGlJfYcbn06BFmNIs5JCiEBNnxUbg2Oyo,37605 +sympy/plotting/__init__.py,sha256=hAdOjai8-laj79rLJ2HZbiW1okXlz0p1ck-CoeNU6m8,526 +sympy/plotting/__pycache__/__init__.cpython-310.pyc,, +sympy/plotting/__pycache__/experimental_lambdify.cpython-310.pyc,, +sympy/plotting/__pycache__/plot.cpython-310.pyc,, +sympy/plotting/__pycache__/plot_implicit.cpython-310.pyc,, +sympy/plotting/__pycache__/textplot.cpython-310.pyc,, +sympy/plotting/experimental_lambdify.py,sha256=wIvB02vdrI-nEJX3TqInsf0v8705JI5lcVgMJsJbtO0,22879 +sympy/plotting/intervalmath/__init__.py,sha256=fQV7sLZ9NHpZO5XGl2ZfqX56x-mdq-sYhtWEKLngHlU,479 +sympy/plotting/intervalmath/__pycache__/__init__.cpython-310.pyc,, +sympy/plotting/intervalmath/__pycache__/interval_arithmetic.cpython-310.pyc,, +sympy/plotting/intervalmath/__pycache__/interval_membership.cpython-310.pyc,, +sympy/plotting/intervalmath/__pycache__/lib_interval.cpython-310.pyc,, +sympy/plotting/intervalmath/interval_arithmetic.py,sha256=OibkI5I0i6_NpFd1HEl48d_R4PRWofUoOS4HYQBkVOc,15530 +sympy/plotting/intervalmath/interval_membership.py,sha256=1VpO1T7UjvPxcMySC5GhZl8-VM_DxIirSWC3ZGmxIAY,2385 +sympy/plotting/intervalmath/lib_interval.py,sha256=WY1qRtyub4MDJaZizw6cXQI5NMEIXBO9UEWPEI80aW8,14809 +sympy/plotting/intervalmath/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/plotting/intervalmath/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/plotting/intervalmath/tests/__pycache__/test_interval_functions.cpython-310.pyc,, +sympy/plotting/intervalmath/tests/__pycache__/test_interval_membership.cpython-310.pyc,, +sympy/plotting/intervalmath/tests/__pycache__/test_intervalmath.cpython-310.pyc,, +sympy/plotting/intervalmath/tests/test_interval_functions.py,sha256=gdIo5z54tIbG8hDaGd3I8rBDP67oetMZWWdM-uvt1ec,9862 +sympy/plotting/intervalmath/tests/test_interval_membership.py,sha256=D1KjcrLxAwOmDEUqA-8TCqkFWGtmeerR9KwmzS7tyjk,4216 +sympy/plotting/intervalmath/tests/test_intervalmath.py,sha256=ndBMczrs6xYMN5RGnyCL9yq7pNUxrXHTSU1mdUsp5tU,9034 +sympy/plotting/plot.py,sha256=eTKGJmFyTycCNb6CquLGutB9d92PdlllxW1Wn0W6Q-k,92139 +sympy/plotting/plot_implicit.py,sha256=2kRJ0YRrsDKad8Q34UXdy4lOVGKh6LvL6LokPVDZN8A,15683 +sympy/plotting/pygletplot/__init__.py,sha256=DM7GURQbdSfcddHz23MxOShatBFc26tP_sd3G8pGCQE,3732 +sympy/plotting/pygletplot/__pycache__/__init__.cpython-310.pyc,, +sympy/plotting/pygletplot/__pycache__/color_scheme.cpython-310.pyc,, +sympy/plotting/pygletplot/__pycache__/managed_window.cpython-310.pyc,, +sympy/plotting/pygletplot/__pycache__/plot.cpython-310.pyc,, +sympy/plotting/pygletplot/__pycache__/plot_axes.cpython-310.pyc,, +sympy/plotting/pygletplot/__pycache__/plot_camera.cpython-310.pyc,, +sympy/plotting/pygletplot/__pycache__/plot_controller.cpython-310.pyc,, +sympy/plotting/pygletplot/__pycache__/plot_curve.cpython-310.pyc,, +sympy/plotting/pygletplot/__pycache__/plot_interval.cpython-310.pyc,, +sympy/plotting/pygletplot/__pycache__/plot_mode.cpython-310.pyc,, +sympy/plotting/pygletplot/__pycache__/plot_mode_base.cpython-310.pyc,, +sympy/plotting/pygletplot/__pycache__/plot_modes.cpython-310.pyc,, +sympy/plotting/pygletplot/__pycache__/plot_object.cpython-310.pyc,, +sympy/plotting/pygletplot/__pycache__/plot_rotation.cpython-310.pyc,, +sympy/plotting/pygletplot/__pycache__/plot_surface.cpython-310.pyc,, +sympy/plotting/pygletplot/__pycache__/plot_window.cpython-310.pyc,, +sympy/plotting/pygletplot/__pycache__/util.cpython-310.pyc,, +sympy/plotting/pygletplot/color_scheme.py,sha256=NgPUamkldygfrIPj0LvC_1AzhscVtg18FSudElvFYB8,12522 +sympy/plotting/pygletplot/managed_window.py,sha256=N7AKtM7ELfIJLie6zvI-J6-OQRBnMZu6AL1USz7hFEk,3072 +sympy/plotting/pygletplot/plot.py,sha256=s-5AJB0KelHs9WGoFIVIdYrOoMXfdpnM5-G2cF8xzDQ,13352 +sympy/plotting/pygletplot/plot_axes.py,sha256=Q9YN8W0Hd1PeflHLvOvSZ-hxeLU4Kq3nUFLYDC0x0E8,8655 +sympy/plotting/pygletplot/plot_camera.py,sha256=yfkGg7TF3yPhhRUDhvPMT1uJgSboTwgAOtKOJdP7d8E,4001 +sympy/plotting/pygletplot/plot_controller.py,sha256=MroJJSPCbBDT8gGs_GdqpV_KHsllMNJpxx0MU3vKJV8,6941 +sympy/plotting/pygletplot/plot_curve.py,sha256=YwKA2lYC7IwCOQJaOVnww8AAG4P36cArgbC1iLV9OFI,2838 +sympy/plotting/pygletplot/plot_interval.py,sha256=doqr2wxnrED4MJDlkxQ07GFvaagX36HUb77ly_vIuKQ,5431 +sympy/plotting/pygletplot/plot_mode.py,sha256=Djq-ewVms_JoSriDpolDhhtttBJQdJO8BD4E0nyOWcQ,14156 +sympy/plotting/pygletplot/plot_mode_base.py,sha256=3z3WjeN7TTslHJevhr3X_7HRHPgUleYSngu6285lR6k,11502 +sympy/plotting/pygletplot/plot_modes.py,sha256=gKzJShz6OXa6EHKar8SuHWrELVznxg_s2d5IBQkkeYE,5352 +sympy/plotting/pygletplot/plot_object.py,sha256=qGtzcKup4It1CqZ2jxA7FnorCua4S9I-B_7I3SHBjcQ,330 +sympy/plotting/pygletplot/plot_rotation.py,sha256=K8MyudYRS2F-ku5blzkWg3q3goMDPUsXqzmHLDU2Uqc,1447 +sympy/plotting/pygletplot/plot_surface.py,sha256=C0q9tzDmxzC1IpWiNKY4llzcopx6dhotGOLpK1N9m3s,3803 +sympy/plotting/pygletplot/plot_window.py,sha256=5boC2Fkmk46-gWGqWzdTkPmTMNHHOpA0CnB9q946Hwc,4643 +sympy/plotting/pygletplot/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/plotting/pygletplot/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/plotting/pygletplot/tests/__pycache__/test_plotting.cpython-310.pyc,, +sympy/plotting/pygletplot/tests/test_plotting.py,sha256=NisjR-yuBRJfQvjcb20skTR3yid2U3MhKHW6sy8RE10,2720 +sympy/plotting/pygletplot/util.py,sha256=mzQQgDDbp04B03KyJrossLp8Yq72RJzjp-3ArfjbMH8,4621 +sympy/plotting/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/plotting/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/plotting/tests/__pycache__/test_experimental_lambdify.cpython-310.pyc,, +sympy/plotting/tests/__pycache__/test_plot.cpython-310.pyc,, +sympy/plotting/tests/__pycache__/test_plot_implicit.cpython-310.pyc,, +sympy/plotting/tests/__pycache__/test_textplot.cpython-310.pyc,, +sympy/plotting/tests/test_experimental_lambdify.py,sha256=EYshdXA5tAGWolaDX-nHAolp7xIJN4Oqb1Uc1C1IhJI,3127 +sympy/plotting/tests/test_plot.py,sha256=HWledOPr2xKq3XFGr458Lc5c0wgf2e0IFa4j63bfdH0,25204 +sympy/plotting/tests/test_plot_implicit.py,sha256=gXXMvVCIlp3HeN12Ej636RnhNEmV3i5WnDA48rjRPOg,5804 +sympy/plotting/tests/test_region_and.png,sha256=EV0Lm4HtQPk_6eIWtPY4TPcQk-O7tkpdZIuLmFjGRaA,6864 +sympy/plotting/tests/test_region_not.png,sha256=3O_9_nPW149FMULEcT5RqI2-k2H3nHELbfJADt2cO8k,7939 +sympy/plotting/tests/test_region_or.png,sha256=5Bug09vyog-Cu3mky7pbtFjew5bMvbpe0ZXWsgDKfy4,8809 +sympy/plotting/tests/test_region_xor.png,sha256=kucVWBA9A98OpcR4did5aLXUyoq4z0O4C3PM6dliBSw,10002 +sympy/plotting/tests/test_textplot.py,sha256=VurTGeMjUfBLpLdoMqzJK9gbcShNb7f1OrAcRNyrtag,12761 +sympy/plotting/textplot.py,sha256=M3TEzIDV6l6CpMpPZcAVrO-Y_pYbRRCsbuPMGAaQEXs,4921 +sympy/polys/__init__.py,sha256=2ZG4bdqNChU1niEsfBNC57G9B51TLYxiDy5WG5_2kMc,5545 +sympy/polys/__pycache__/__init__.cpython-310.pyc,, +sympy/polys/__pycache__/appellseqs.cpython-310.pyc,, +sympy/polys/__pycache__/compatibility.cpython-310.pyc,, +sympy/polys/__pycache__/constructor.cpython-310.pyc,, +sympy/polys/__pycache__/densearith.cpython-310.pyc,, +sympy/polys/__pycache__/densebasic.cpython-310.pyc,, +sympy/polys/__pycache__/densetools.cpython-310.pyc,, +sympy/polys/__pycache__/dispersion.cpython-310.pyc,, +sympy/polys/__pycache__/distributedmodules.cpython-310.pyc,, +sympy/polys/__pycache__/domainmatrix.cpython-310.pyc,, +sympy/polys/__pycache__/euclidtools.cpython-310.pyc,, +sympy/polys/__pycache__/factortools.cpython-310.pyc,, +sympy/polys/__pycache__/fglmtools.cpython-310.pyc,, +sympy/polys/__pycache__/fields.cpython-310.pyc,, +sympy/polys/__pycache__/galoistools.cpython-310.pyc,, +sympy/polys/__pycache__/groebnertools.cpython-310.pyc,, +sympy/polys/__pycache__/heuristicgcd.cpython-310.pyc,, +sympy/polys/__pycache__/modulargcd.cpython-310.pyc,, +sympy/polys/__pycache__/monomials.cpython-310.pyc,, +sympy/polys/__pycache__/multivariate_resultants.cpython-310.pyc,, +sympy/polys/__pycache__/orderings.cpython-310.pyc,, +sympy/polys/__pycache__/orthopolys.cpython-310.pyc,, +sympy/polys/__pycache__/partfrac.cpython-310.pyc,, +sympy/polys/__pycache__/polyclasses.cpython-310.pyc,, +sympy/polys/__pycache__/polyconfig.cpython-310.pyc,, +sympy/polys/__pycache__/polyerrors.cpython-310.pyc,, +sympy/polys/__pycache__/polyfuncs.cpython-310.pyc,, +sympy/polys/__pycache__/polymatrix.cpython-310.pyc,, +sympy/polys/__pycache__/polyoptions.cpython-310.pyc,, +sympy/polys/__pycache__/polyquinticconst.cpython-310.pyc,, +sympy/polys/__pycache__/polyroots.cpython-310.pyc,, +sympy/polys/__pycache__/polytools.cpython-310.pyc,, +sympy/polys/__pycache__/polyutils.cpython-310.pyc,, +sympy/polys/__pycache__/rationaltools.cpython-310.pyc,, +sympy/polys/__pycache__/ring_series.cpython-310.pyc,, +sympy/polys/__pycache__/rings.cpython-310.pyc,, +sympy/polys/__pycache__/rootisolation.cpython-310.pyc,, +sympy/polys/__pycache__/rootoftools.cpython-310.pyc,, +sympy/polys/__pycache__/solvers.cpython-310.pyc,, +sympy/polys/__pycache__/specialpolys.cpython-310.pyc,, +sympy/polys/__pycache__/sqfreetools.cpython-310.pyc,, +sympy/polys/__pycache__/subresultants_qq_zz.cpython-310.pyc,, +sympy/polys/agca/__init__.py,sha256=fahpWoG_0LgoqOXBnDBJS16Jj1fE1_VKG7edM3qZ2HE,130 +sympy/polys/agca/__pycache__/__init__.cpython-310.pyc,, +sympy/polys/agca/__pycache__/extensions.cpython-310.pyc,, +sympy/polys/agca/__pycache__/homomorphisms.cpython-310.pyc,, +sympy/polys/agca/__pycache__/ideals.cpython-310.pyc,, +sympy/polys/agca/__pycache__/modules.cpython-310.pyc,, +sympy/polys/agca/extensions.py,sha256=v3VmKWXQeyPuwNGyizfR6ZFb4GkRZ97xREHawuLWqpg,9168 +sympy/polys/agca/homomorphisms.py,sha256=gaMNV96pKUuYHZ8Bd7QOs27J1IbbJgkEjyWcTLe8GFI,21937 +sympy/polys/agca/ideals.py,sha256=8rh6iQt26zF0qKzHlfqGXKZzKuGY6Y5t9hBNVGG9v5M,10891 +sympy/polys/agca/modules.py,sha256=UZBnmvsQTHRkSVGdst6nksp9a07ZYD65eArjL91n3-Q,46946 +sympy/polys/agca/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/polys/agca/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/polys/agca/tests/__pycache__/test_extensions.cpython-310.pyc,, +sympy/polys/agca/tests/__pycache__/test_homomorphisms.cpython-310.pyc,, +sympy/polys/agca/tests/__pycache__/test_ideals.cpython-310.pyc,, +sympy/polys/agca/tests/__pycache__/test_modules.cpython-310.pyc,, +sympy/polys/agca/tests/test_extensions.py,sha256=i3IHQNXQByFMCvjjyd_hwwJSCiUj0z1rRwS9WFK2AFc,6455 +sympy/polys/agca/tests/test_homomorphisms.py,sha256=m0hFmcTzvZ8sZbbnWeENwzKyufpE9zWwZR-WCI4kdpU,4224 +sympy/polys/agca/tests/test_ideals.py,sha256=w76qXO-_HN6LQbV7l3h7gJZsM-DZ2io2X-kPWiHYRNw,3788 +sympy/polys/agca/tests/test_modules.py,sha256=HdfmcxdEVucEbtfmzVq8i_1wGojT5b5DE5VIfbTMx3k,13552 +sympy/polys/appellseqs.py,sha256=hWeDKsKnJuAuPN_5IU6m1okurAq9xMt3LQgMehcvBKQ,8305 +sympy/polys/benchmarks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/polys/benchmarks/__pycache__/__init__.cpython-310.pyc,, +sympy/polys/benchmarks/__pycache__/bench_galoispolys.cpython-310.pyc,, +sympy/polys/benchmarks/__pycache__/bench_groebnertools.cpython-310.pyc,, +sympy/polys/benchmarks/__pycache__/bench_solvers.cpython-310.pyc,, +sympy/polys/benchmarks/bench_galoispolys.py,sha256=8RtN9ZQga2oxscVPPkMGB29Dz8UbskMS2szYtqZ69u0,1502 +sympy/polys/benchmarks/bench_groebnertools.py,sha256=YqGDCzewRszCye_GnneDXMRNB38ORSpVu_Jn0ELIySo,803 +sympy/polys/benchmarks/bench_solvers.py,sha256=gLrZguh6pE0E4_vM2GeOS5bHnrcSUQXqD0Qz9tItfmo,446778 +sympy/polys/compatibility.py,sha256=OkpZiIrD2u_1YB7dE2NJmhpt1UZoBNoX2JBY3q1Uixo,57743 +sympy/polys/constructor.py,sha256=4hqADMZrcLOsnzVebcZxnn3LJ7HdPIHReq0Qalf91EY,11371 +sympy/polys/densearith.py,sha256=6lkYHNpTPp2qq8qKBNiK9V-xNqLg0MYcoi_ksKaNBcg,34108 +sympy/polys/densebasic.py,sha256=H9DimmE5zLuEpzyYvTWBViBJTe5bbLj-1RefaAy2XXk,35922 +sympy/polys/densetools.py,sha256=q75QA1e0rH9TpVbTGIwRgeisNFt-7HiRcdPUEdHYN2E,25902 +sympy/polys/dispersion.py,sha256=s6GIYnGA6U9jhGP7YXQQS8G3byG4-kPbr55BR6p-iz4,5740 +sympy/polys/distributedmodules.py,sha256=t8pLIgDQs_dMecGXwybVYoLavofEy2DXhFS8N5gj5SU,21827 +sympy/polys/domainmatrix.py,sha256=FmNqklNFQR1WrQYtP2r7jypw2IQadNKGP14EaUaxUqI,310 +sympy/polys/domains/__init__.py,sha256=T6qPNkU1EJ6D5BnvyJSXJv4zeJ5MUT5RLsovMkkXS9E,1872 +sympy/polys/domains/__pycache__/__init__.cpython-310.pyc,, +sympy/polys/domains/__pycache__/algebraicfield.cpython-310.pyc,, +sympy/polys/domains/__pycache__/characteristiczero.cpython-310.pyc,, +sympy/polys/domains/__pycache__/complexfield.cpython-310.pyc,, +sympy/polys/domains/__pycache__/compositedomain.cpython-310.pyc,, +sympy/polys/domains/__pycache__/domain.cpython-310.pyc,, +sympy/polys/domains/__pycache__/domainelement.cpython-310.pyc,, +sympy/polys/domains/__pycache__/expressiondomain.cpython-310.pyc,, +sympy/polys/domains/__pycache__/expressionrawdomain.cpython-310.pyc,, +sympy/polys/domains/__pycache__/field.cpython-310.pyc,, +sympy/polys/domains/__pycache__/finitefield.cpython-310.pyc,, +sympy/polys/domains/__pycache__/fractionfield.cpython-310.pyc,, +sympy/polys/domains/__pycache__/gaussiandomains.cpython-310.pyc,, +sympy/polys/domains/__pycache__/gmpyfinitefield.cpython-310.pyc,, +sympy/polys/domains/__pycache__/gmpyintegerring.cpython-310.pyc,, +sympy/polys/domains/__pycache__/gmpyrationalfield.cpython-310.pyc,, +sympy/polys/domains/__pycache__/groundtypes.cpython-310.pyc,, +sympy/polys/domains/__pycache__/integerring.cpython-310.pyc,, +sympy/polys/domains/__pycache__/modularinteger.cpython-310.pyc,, +sympy/polys/domains/__pycache__/mpelements.cpython-310.pyc,, +sympy/polys/domains/__pycache__/old_fractionfield.cpython-310.pyc,, +sympy/polys/domains/__pycache__/old_polynomialring.cpython-310.pyc,, +sympy/polys/domains/__pycache__/polynomialring.cpython-310.pyc,, +sympy/polys/domains/__pycache__/pythonfinitefield.cpython-310.pyc,, +sympy/polys/domains/__pycache__/pythonintegerring.cpython-310.pyc,, +sympy/polys/domains/__pycache__/pythonrational.cpython-310.pyc,, +sympy/polys/domains/__pycache__/pythonrationalfield.cpython-310.pyc,, +sympy/polys/domains/__pycache__/quotientring.cpython-310.pyc,, +sympy/polys/domains/__pycache__/rationalfield.cpython-310.pyc,, +sympy/polys/domains/__pycache__/realfield.cpython-310.pyc,, +sympy/polys/domains/__pycache__/ring.cpython-310.pyc,, +sympy/polys/domains/__pycache__/simpledomain.cpython-310.pyc,, +sympy/polys/domains/algebraicfield.py,sha256=hg2F7SBrc0I-uqRa90ehtHiF6bCo_AB98XDHRRcGFZw,21556 +sympy/polys/domains/characteristiczero.py,sha256=vHYRUXPrfJzDF8wrd1KSFqG8WzwfITP_eweA-SHPVYA,382 +sympy/polys/domains/complexfield.py,sha256=2GjeNMebTXxLHDkKYqbrP-hZqBXHoc_Uv7kk7xIyPcw,4620 +sympy/polys/domains/compositedomain.py,sha256=wgw_yKwC5gHYWxRHEbVDeHOKQycFkZH0ZxhVES0AR04,1042 +sympy/polys/domains/domain.py,sha256=KOj3-sDzLox86n3Av2Vl6nExWszyWXkJz0-lDpXDwJ4,38006 +sympy/polys/domains/domainelement.py,sha256=IrG-Mzv_VlCAmE-hmJVH_d77TrsfyaGGfJVmU8FFvlY,860 +sympy/polys/domains/expressiondomain.py,sha256=rk2Vky-C5sQiOtkWbtxh1s5_aOALGCREzq-R6qxVZ-I,6924 +sympy/polys/domains/expressionrawdomain.py,sha256=cXarD2jXi97FGNiqNiDqQlX0g764EW2M1PEbrveImnY,1448 +sympy/polys/domains/field.py,sha256=tyOjEqABaOXXkaBEL0qLqyG4g5Ktnd782B_6xTCfia8,2591 +sympy/polys/domains/finitefield.py,sha256=yFU8-FvoDxGQ9Yo-mKlOqnB-91ctpz_TT0zLRmx-iQI,6025 +sympy/polys/domains/fractionfield.py,sha256=pKR3dfOOXqBIwf3jvRnaqgA-t1YYWdubCuz3yNnxepU,5945 +sympy/polys/domains/gaussiandomains.py,sha256=qkbqSXzumxwQq7QGAyvNsgJZlzF5MbvN2O9nz2li-kQ,17975 +sympy/polys/domains/gmpyfinitefield.py,sha256=C_Nd9GubSMBJmIe5vs_C2IuBT8YGFL4xgK4oixNCOrk,444 +sympy/polys/domains/gmpyintegerring.py,sha256=U6Ph1_5Ez5bXN4JcF2Tsq1FUDEwYsGx0nUT-gZDvO5U,3017 +sympy/polys/domains/gmpyrationalfield.py,sha256=dZjrfcWaUA-BHUtutzLOWPlOSNLYzBqSFeukER6L_bA,3178 +sympy/polys/domains/groundtypes.py,sha256=bHPHdmpFRBWe86TNMSsE6m5grvE0bQWLWnRGRBBxMpQ,1615 +sympy/polys/domains/integerring.py,sha256=T2MvIiEI3OPFoOQ5Ep3HgZhNU1evP-Wxu0oDVG7oJa8,6085 +sympy/polys/domains/modularinteger.py,sha256=bAUskiiX1j-n9SLx79jUCPOuO9mDNbzUcuijRcI7Hg4,5094 +sympy/polys/domains/mpelements.py,sha256=MxymxwlGBA3Px2FFyzISEtAnkVoxeq-bJM1fk2jkEts,4616 +sympy/polys/domains/old_fractionfield.py,sha256=6qVb4Zzfq8ArxDyghXwW5Vvw4SattdIt0HUx4WcnD8U,6178 +sympy/polys/domains/old_polynomialring.py,sha256=_Rengtf5vN3w9GJAsDFcN3yKbWjYqkTbsPdxbtbplnE,14914 +sympy/polys/domains/polynomialring.py,sha256=kStXSAtq1b5Tk3vrEze7_E8UMn8bF91Goh7hVzhtax0,6153 +sympy/polys/domains/pythonfinitefield.py,sha256=RYwDRg1zVLLGtJvVXvWhwUZjC91g8pXTwAjuQoWezks,460 +sympy/polys/domains/pythonintegerring.py,sha256=qUBqWBtP_faY-m2tJA07JQyCTdh27tXVBDD7vsKNUn4,2929 +sympy/polys/domains/pythonrational.py,sha256=M3VUGODh3MLElePjYtjt9b02ReMThw-XXpuQTkohgNs,548 +sympy/polys/domains/pythonrationalfield.py,sha256=x8BPkGKj0WPuwJzN2py5l9aAjHaY4djv65c4tzUTr3Y,2295 +sympy/polys/domains/quotientring.py,sha256=LBUIIpN3y3QPS6pFYWwqpca5ShoWDyaZbZ6PwDm_SmA,5866 +sympy/polys/domains/rationalfield.py,sha256=-4rLYoh3IhsURx09OtLR3A29NLDi_RO-QzWO3RGoy8Q,4869 +sympy/polys/domains/realfield.py,sha256=Wt5_y7HTDe8u1qGalhNhTT7Rw3CQiVkmgduQ7jcpD9c,3782 +sympy/polys/domains/ring.py,sha256=p66U2X58acSHLHxOTU6aJZ0Umdcu1qiGIUDtV8iJCD0,3236 +sympy/polys/domains/simpledomain.py,sha256=_K-Zz8Opf505r3eHSrbPAlnGiGSjY_O4Cwa4OTeOSoY,369 +sympy/polys/domains/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/polys/domains/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/polys/domains/tests/__pycache__/test_domains.cpython-310.pyc,, +sympy/polys/domains/tests/__pycache__/test_polynomialring.cpython-310.pyc,, +sympy/polys/domains/tests/__pycache__/test_quotientring.cpython-310.pyc,, +sympy/polys/domains/tests/test_domains.py,sha256=1PsckHIBXMQFm-sgSDMjiUor2c-000iEZhqqPV9pfR4,43846 +sympy/polys/domains/tests/test_polynomialring.py,sha256=gW82jcxL2J5nKrA4iDCuk88K1bqpfAG7z32Y9191mKU,3312 +sympy/polys/domains/tests/test_quotientring.py,sha256=BYoq1CqI76RDSm0xQdp1v7Dv1n5sdcmes-b_y_AfW-0,1459 +sympy/polys/euclidtools.py,sha256=h8qC0ZsXf-ZKPLIMBaLV2aSCHDuXLQBczKZcU-J2BaE,41221 +sympy/polys/factortools.py,sha256=AghhwHVn_wJsEBBo-THmMIKT9zr-gBJlkLTctJrT_eY,38457 +sympy/polys/fglmtools.py,sha256=KYZuP4CxAN3KP6If3hM53HKM4S87rNU2HecwbYjWfOE,4302 +sympy/polys/fields.py,sha256=HEXUOH-bhYkTTXyev87LZPsyK3-aeqCmGRgErFiJzhA,21245 +sympy/polys/galoistools.py,sha256=cuwAArjtyoV4wfaQtX8fs4mz4ZXLuc6yKvHObyXgnw8,52133 +sympy/polys/groebnertools.py,sha256=NhK-XcFR9e4chDDJJ-diXb7XYuw9zcixFA_riomThPM,23342 +sympy/polys/heuristicgcd.py,sha256=rD3intgKCtAAMH3sqlgqbJL1XSq9QjfeG_MYzwCOek0,3732 +sympy/polys/matrices/__init__.py,sha256=ZaPJMi8l22d3F3rudS4NqzSt0xwxbs3uwnQwlhhR91o,397 +sympy/polys/matrices/__pycache__/__init__.cpython-310.pyc,, +sympy/polys/matrices/__pycache__/_typing.cpython-310.pyc,, +sympy/polys/matrices/__pycache__/ddm.cpython-310.pyc,, +sympy/polys/matrices/__pycache__/dense.cpython-310.pyc,, +sympy/polys/matrices/__pycache__/domainmatrix.cpython-310.pyc,, +sympy/polys/matrices/__pycache__/domainscalar.cpython-310.pyc,, +sympy/polys/matrices/__pycache__/eigen.cpython-310.pyc,, +sympy/polys/matrices/__pycache__/exceptions.cpython-310.pyc,, +sympy/polys/matrices/__pycache__/linsolve.cpython-310.pyc,, +sympy/polys/matrices/__pycache__/lll.cpython-310.pyc,, +sympy/polys/matrices/__pycache__/normalforms.cpython-310.pyc,, +sympy/polys/matrices/__pycache__/sdm.cpython-310.pyc,, +sympy/polys/matrices/_typing.py,sha256=ZMxO82uprk9lCq4ClHL-pg6_wOmmnLozg0sQhJrjbbk,319 +sympy/polys/matrices/ddm.py,sha256=a-NJkOmGtm0P8Y88e9frpxRwap-gGZluG07oDReeyTg,13586 +sympy/polys/matrices/dense.py,sha256=LcFY1OAEvIaXzdToD84VvU_DZmNwRSiZt3PA-6YCwMQ,8718 +sympy/polys/matrices/domainmatrix.py,sha256=KeXk7Q0vTweGAWZduZHo2u0RUl2g2EnPeCXgz-16vrQ,47889 +sympy/polys/matrices/domainscalar.py,sha256=zosOQfLeKsMpAv1sm-JHPneGmMTeELvAloNxKMkZ8Uo,3643 +sympy/polys/matrices/eigen.py,sha256=pvICWI8_r_usa0EFqlbz7I8ASzKMK2j2gn-65CmTSPU,2983 +sympy/polys/matrices/exceptions.py,sha256=ay3Lv21X3QqszysBN71xdr9KGQuC5kDBl90a2Sjx6pM,1351 +sympy/polys/matrices/linsolve.py,sha256=fuuS_NvFFw7vP7KEtkfursOtgJmnIWSv9PEZv56ovOE,7548 +sympy/polys/matrices/lll.py,sha256=8vWLPm3SaFDY5pAwawzb2paF29hmJBucVdxwqGEzcAk,3556 +sympy/polys/matrices/normalforms.py,sha256=SkrGcuvfi27Bb3UeU_HHtCU4HrPSZSz1Azh5p4TqZ68,13105 +sympy/polys/matrices/sdm.py,sha256=Y_GV0aMlJDDa452OA72EwxvwKQAA3NaZRGVRwqwbKTI,35571 +sympy/polys/matrices/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/polys/matrices/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/polys/matrices/tests/__pycache__/test_ddm.cpython-310.pyc,, +sympy/polys/matrices/tests/__pycache__/test_dense.cpython-310.pyc,, +sympy/polys/matrices/tests/__pycache__/test_domainmatrix.cpython-310.pyc,, +sympy/polys/matrices/tests/__pycache__/test_domainscalar.cpython-310.pyc,, +sympy/polys/matrices/tests/__pycache__/test_eigen.cpython-310.pyc,, +sympy/polys/matrices/tests/__pycache__/test_linsolve.cpython-310.pyc,, +sympy/polys/matrices/tests/__pycache__/test_lll.cpython-310.pyc,, +sympy/polys/matrices/tests/__pycache__/test_normalforms.cpython-310.pyc,, +sympy/polys/matrices/tests/__pycache__/test_sdm.cpython-310.pyc,, +sympy/polys/matrices/tests/test_ddm.py,sha256=3tFhjkA1alE827Qiw9mAPlWkSgV3Sesrqeh-NxHXsA4,16640 +sympy/polys/matrices/tests/test_dense.py,sha256=Ig_SJ86pogur9AEfcetO_L01fy1WFhe-E9g9ngVTlxs,9483 +sympy/polys/matrices/tests/test_domainmatrix.py,sha256=IjRa6uCfAu1hm6XrN1fUUaAA2GeVxi5IgVaf4vZc4Lk,32371 +sympy/polys/matrices/tests/test_domainscalar.py,sha256=9HQL95XlxyXHNDf_UBN9t1da_9syRNZGOb7IKkmjn-U,3624 +sympy/polys/matrices/tests/test_eigen.py,sha256=T1lYZeW-0NwDxDOG6ZJLr-OICfxY2wa0fVHV2V6EXSk,3200 +sympy/polys/matrices/tests/test_linsolve.py,sha256=G1LCDkB3BDUuDzQuUxn4jCjqUSbCwMX_lfkVXDLe-k0,3334 +sympy/polys/matrices/tests/test_lll.py,sha256=Zg7rNTlywHgrhr9OYpRj5yW6t2JPzJvwcclCvRNc7xw,6480 +sympy/polys/matrices/tests/test_normalforms.py,sha256=_4Cm3EJxHh3TEwF278uB7WQZweFWFsx3j0zc2AZFgDI,3036 +sympy/polys/matrices/tests/test_sdm.py,sha256=H0oNZkNmwpP8i6UpysnkD7yave0E3YU3Z8dKGobSbOA,14000 +sympy/polys/modulargcd.py,sha256=vE57ZJv1iJNKHcRbFJBgG6Jytudweq3wyDB90yxtFCc,58664 +sympy/polys/monomials.py,sha256=R2o7vpjdZdpp57u-PrKw1REk_Cr9uoNcum1a8DnDHZg,18925 +sympy/polys/multivariate_resultants.py,sha256=G9NCKrb5MBoUshiB_QD86w6MwQAxLwOmc-_HFO_ZXdE,15265 +sympy/polys/numberfields/__init__.py,sha256=ZfhC9MyfGfGUz_DT_rXasB-M_P2zUiZXOJUNh_Gtm8c,538 +sympy/polys/numberfields/__pycache__/__init__.cpython-310.pyc,, +sympy/polys/numberfields/__pycache__/basis.cpython-310.pyc,, +sympy/polys/numberfields/__pycache__/exceptions.cpython-310.pyc,, +sympy/polys/numberfields/__pycache__/galois_resolvents.cpython-310.pyc,, +sympy/polys/numberfields/__pycache__/galoisgroups.cpython-310.pyc,, +sympy/polys/numberfields/__pycache__/minpoly.cpython-310.pyc,, +sympy/polys/numberfields/__pycache__/modules.cpython-310.pyc,, +sympy/polys/numberfields/__pycache__/primes.cpython-310.pyc,, +sympy/polys/numberfields/__pycache__/resolvent_lookup.cpython-310.pyc,, +sympy/polys/numberfields/__pycache__/subfield.cpython-310.pyc,, +sympy/polys/numberfields/__pycache__/utilities.cpython-310.pyc,, +sympy/polys/numberfields/basis.py,sha256=IPA6cSwz-53ClQwo-wkmRzfx9pRX4iBhiggdLMVSgJ0,8261 +sympy/polys/numberfields/exceptions.py,sha256=IN36PiHvWvH5YOtWmU0EHSPiKhGryPezcOawdQmesMo,1668 +sympy/polys/numberfields/galois_resolvents.py,sha256=iGuCtXU5ZsoyHZVIbj7eh3ry_zhdAtUaV30Df7pT8WM,24858 +sympy/polys/numberfields/galoisgroups.py,sha256=_ORI7MYUyWhBuDsRL9W0olW5piJLkRNFsbRoJPPkryk,20665 +sympy/polys/numberfields/minpoly.py,sha256=uMMy3Ddui5_oNUBS55JNLF5xAZywfJzUjINmWRw3_EU,27716 +sympy/polys/numberfields/modules.py,sha256=pK69MtEb5BcrSWU9E9jtpVxGhEcR-5XB8_qatpskFVk,69117 +sympy/polys/numberfields/primes.py,sha256=9UHrJrIDPhAcNtqrDcqXIm9Z-Ch69W_gKGOBfDKduro,23967 +sympy/polys/numberfields/resolvent_lookup.py,sha256=qfLNKOz_WjtXwpVlfzy8EkD4gw12epx9npE9HsjyIdg,40411 +sympy/polys/numberfields/subfield.py,sha256=_s8u4a1y1L4HhoKEpoemSvNrXdW0Mh4YvrUOozq_lvc,16480 +sympy/polys/numberfields/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/polys/numberfields/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/polys/numberfields/tests/__pycache__/test_basis.cpython-310.pyc,, +sympy/polys/numberfields/tests/__pycache__/test_galoisgroups.cpython-310.pyc,, +sympy/polys/numberfields/tests/__pycache__/test_minpoly.cpython-310.pyc,, +sympy/polys/numberfields/tests/__pycache__/test_modules.cpython-310.pyc,, +sympy/polys/numberfields/tests/__pycache__/test_numbers.cpython-310.pyc,, +sympy/polys/numberfields/tests/__pycache__/test_primes.cpython-310.pyc,, +sympy/polys/numberfields/tests/__pycache__/test_subfield.cpython-310.pyc,, +sympy/polys/numberfields/tests/__pycache__/test_utilities.cpython-310.pyc,, +sympy/polys/numberfields/tests/test_basis.py,sha256=96BJ7e4oPDKXyvlRrUkiQxmHyjRGpOkAC7R3ln-jgNE,4580 +sympy/polys/numberfields/tests/test_galoisgroups.py,sha256=3LFuMbV92VBFlqqEqjh37oQvmG8cgZ0pFxDCXUoYRL4,5036 +sympy/polys/numberfields/tests/test_minpoly.py,sha256=IA0WH56vMXbSQpiml78jZes1M1XZSHDRARv5tM4VGTQ,22590 +sympy/polys/numberfields/tests/test_modules.py,sha256=GU4166j_hMlB22uWxxIjV_ON8RsyvpaN7Ly3eK8_m8Y,22926 +sympy/polys/numberfields/tests/test_numbers.py,sha256=M0vZIBnjPBHV4vFUnPBILaqiR_cgSuU50kFB-v7l1gA,5988 +sympy/polys/numberfields/tests/test_primes.py,sha256=JhcAkaQMgjkOSziQ2jZApJ8b8oviil5cUy0hfFqNmZg,9779 +sympy/polys/numberfields/tests/test_subfield.py,sha256=_aCbvukrahv-QyCwNT7EpTYC1u53yUlMhfGqV5GzW3Y,12215 +sympy/polys/numberfields/tests/test_utilities.py,sha256=T3YfFouXZNcBG2AfLEQ77Uqy-_TTufGTUsysmzUHNuA,3655 +sympy/polys/numberfields/utilities.py,sha256=aQBm_rgKxjHOCTktOYJ-aI5Cpb59IBvWJiyZCowcM-I,13081 +sympy/polys/orderings.py,sha256=IFieyj4LkFa7NDiGTZD3VwUY7mSN3GEjThKk0z5WJ1s,8500 +sympy/polys/orthopolys.py,sha256=Kjx3fSoLDpX-bXUlgkPQdOK_TutIidI0MHmJ-6cviKM,8526 +sympy/polys/partfrac.py,sha256=KzReYNMyYfgXUM-UFj67eQU7MQk6EsbfhVuf4_Tl_u0,14665 +sympy/polys/polyclasses.py,sha256=byf1JS2pYGCZXGvzaxnBC18r--jTf0OFqOjJxWy6z_U,54564 +sympy/polys/polyconfig.py,sha256=mgfFpp9SU159tA_PM2o04WZyzMoWfOtWZugRcHnP42c,1598 +sympy/polys/polyerrors.py,sha256=xByI-fqIHVYsYRm63NmHXlSSRCwSI9vZUoO-1Mf5Wlk,4744 +sympy/polys/polyfuncs.py,sha256=OEZpdYeHQADBJYqMw8JAyN4sw-jsJ6lzVH6m-CCoK8g,8547 +sympy/polys/polymatrix.py,sha256=83_9L66dbzVv0UfbPR3OTKtxZZ6sMaeOifMBPUDBeiM,9749 +sympy/polys/polyoptions.py,sha256=BqXFyhKVDoFRJlSSBb_jxOkWPzM2MpQ67BKiQR852A8,21721 +sympy/polys/polyquinticconst.py,sha256=mYLFWSBq3H3Y0I8cx76Z_xauLx1YeViC4xF6yWsSTPQ,96035 +sympy/polys/polyroots.py,sha256=etxwQFngxSLRgjRJ8AzPc28CCQm56xx9CRlp4MPwhl4,36995 +sympy/polys/polytools.py,sha256=H8xrnAGUu8Df_HStGD2wVpI-cKOhqEYlEECJ9ep3PHM,194263 +sympy/polys/polyutils.py,sha256=gGwRUZXAFv132f96uONc6Ybfh8xyyP9pAouNY6fX-uQ,16519 +sympy/polys/rationaltools.py,sha256=gkLu0YvsSJ2b04AOK7MV_rjp1m6exLkdqClOjrbBboo,2848 +sympy/polys/ring_series.py,sha256=qBKirsiZpM5x0ix4V5ntm7inynnahYCfVSgHZRCpccc,57766 +sympy/polys/rings.py,sha256=rparZxHTHV9j7Av3XUnAE2CSn1WglhXveO13IcuDljE,72970 +sympy/polys/rootisolation.py,sha256=vOvKe1Vi2uklmMB4qNy_EczSRzelMUqPB3o7qYdiWR0,64527 +sympy/polys/rootoftools.py,sha256=_rwgSXUkgg0bUsp949GiSz6ouoxuyysclg-fKGxRlYA,41040 +sympy/polys/solvers.py,sha256=CWrzPJNlosjhxScXzIHYZQwCjsLnkAgAeIgYrY92gbc,13519 +sympy/polys/specialpolys.py,sha256=B2vijl75zgUKUTY1HCqjB9BTDFf3FM8ugwkKGTB83XA,11038 +sympy/polys/sqfreetools.py,sha256=2Gdv9t9TNgdbnc-7XrpEhgYJfSvacHUyuE1aOWo9DXU,11464 +sympy/polys/subresultants_qq_zz.py,sha256=TDVS9-rEBXK88m4mAixuvPFMAXmn3MwKaSsGmq9oUCo,88261 +sympy/polys/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/polys/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_appellseqs.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_constructor.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_densearith.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_densebasic.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_densetools.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_dispersion.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_distributedmodules.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_euclidtools.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_factortools.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_fields.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_galoistools.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_groebnertools.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_heuristicgcd.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_injections.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_modulargcd.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_monomials.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_multivariate_resultants.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_orderings.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_orthopolys.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_partfrac.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_polyclasses.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_polyfuncs.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_polymatrix.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_polyoptions.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_polyroots.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_polytools.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_polyutils.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_pythonrational.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_rationaltools.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_ring_series.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_rings.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_rootisolation.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_rootoftools.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_solvers.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_specialpolys.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_sqfreetools.cpython-310.pyc,, +sympy/polys/tests/__pycache__/test_subresultants_qq_zz.cpython-310.pyc,, +sympy/polys/tests/test_appellseqs.py,sha256=YTERuRr30QtfxYR0erXvJG8D-INe9RaMFAF0ZM-H4Ks,3820 +sympy/polys/tests/test_constructor.py,sha256=U1LBjA881oG4A8oMXqZe0sZ42pmH7YpR_VSJjBNZz-w,6378 +sympy/polys/tests/test_densearith.py,sha256=1YBmEJTtPRWj4l39HMkFD6ffkU8h3pIs7lz-k_9XGYk,40428 +sympy/polys/tests/test_densebasic.py,sha256=vcoTscGRB1bef9UhclHcsKnBJp9baexjQ-enXq1-pKM,21477 +sympy/polys/tests/test_densetools.py,sha256=QM1Yt0hOHBnUTvdn14aFRUdfMQE9P2q1Hpzeud-n-ds,24572 +sympy/polys/tests/test_dispersion.py,sha256=8JfwjSNy7X74qJODMaVp1GSLprFiRDVt6XrYc_-omgQ,3183 +sympy/polys/tests/test_distributedmodules.py,sha256=dXmjhozX5Yzb7DsrtbdFTqAxi9Z1UZNJvGxj-vHM7cM,7639 +sympy/polys/tests/test_euclidtools.py,sha256=vEyj48eIjm6-KRQtThNfI4ic_VDNB6l7jMouxJAF9HE,19482 +sympy/polys/tests/test_factortools.py,sha256=MXOJfhjrLAu-UCyXg6YRMYAc7nkw6SAfkY66_RKG9Es,24560 +sympy/polys/tests/test_fields.py,sha256=vrdg27319R3Zro_idhQVxIeomN9P6mU3jHyX7HZKeMU,10245 +sympy/polys/tests/test_galoistools.py,sha256=btKRaqckjvyGOhCvIfwLtRDVG2Qiwo6CTnoPW8h4S9E,28130 +sympy/polys/tests/test_groebnertools.py,sha256=ZWHBcCCOVNwDxuJWg1WPo0krTHx1m1wTPi2cOYPsAT4,18584 +sympy/polys/tests/test_heuristicgcd.py,sha256=wsAKgOKuLYra14qMS8EUt_Pda_SoBfP90X2-Tv1WG7A,4031 +sympy/polys/tests/test_injections.py,sha256=EONGggBUNWaVSwi817CzLBYJgkTehFq8-m-Qdqes984,1286 +sympy/polys/tests/test_modulargcd.py,sha256=GE-24EnWOAQVYwgBb5PJzySX6EEJQs-q3HRFBWsXkTE,9042 +sympy/polys/tests/test_monomials.py,sha256=bY057IDFyVs864jcJ46ZITLv57xMKNfBVwBC-mnzJLA,10988 +sympy/polys/tests/test_multivariate_resultants.py,sha256=DJu8CcZ3xwx8njpjDeSOyhyxeqZYmhfb7dkSCU-ll7Y,9501 +sympy/polys/tests/test_orderings.py,sha256=bdsIsqJTFJCVyZNRMAGVDXVk79ldw9rmAGejS_lwKP0,4254 +sympy/polys/tests/test_orthopolys.py,sha256=UpJwPlmqZ3IZtWhaLcfhR5EyKj49_VpruRlI2dK_Awk,6379 +sympy/polys/tests/test_partfrac.py,sha256=78xlrvzvON2047j_DeQ0E8BBZg6Z1koJzksj5rQah9A,7096 +sympy/polys/tests/test_polyclasses.py,sha256=uUjLcfKrfW-EBB6N9ofESJgw4_QacKWN1fLa0etn6iY,13321 +sympy/polys/tests/test_polyfuncs.py,sha256=VbgCgCRE06dtSY9I9GSdPH9T52ETYYoxk4J3N1WBtd4,4520 +sympy/polys/tests/test_polymatrix.py,sha256=pl2VrN_d2XGOVHvvAnaNQzkdFTdQgjt9ePgo41soBRs,7353 +sympy/polys/tests/test_polyoptions.py,sha256=z9DUdt8K3lYkm4IyLH1Cv-TKe76HP-EyaRkZVsfWb6U,12416 +sympy/polys/tests/test_polyroots.py,sha256=LUh1A92dy93Ou2t2_650ujTqvC3DQK0qpl3QO7VZCrk,26809 +sympy/polys/tests/test_polytools.py,sha256=855XWTO3k68OALdT-PpsZ8ZfQepTsUEhDxU8dYyF1SE,126200 +sympy/polys/tests/test_polyutils.py,sha256=Qs3QQl0WYmTnkYE2ovTxdLeu6DYnWO_OoUmLwNDZzSw,11547 +sympy/polys/tests/test_pythonrational.py,sha256=vYMlOTuYvf-15P0nKTFm-uRrhUc-nCFEkqYFAPLxg08,4143 +sympy/polys/tests/test_rationaltools.py,sha256=wkvjzNP1IH-SdubNk5JJ7OWcY-zNF6z3t32kfp9Ncs0,2397 +sympy/polys/tests/test_ring_series.py,sha256=SCUiciL10XGGjxFuM6ulzA460XAUVRykW3HLb8RNsc0,24662 +sympy/polys/tests/test_rings.py,sha256=g3hl2fMJ6-X7-k9n3IBdOAtyqONbjYwTizlrFpWTR4M,45393 +sympy/polys/tests/test_rootisolation.py,sha256=x-n-T-Con-8phelNa05BPszkC_UCW1C0yAOwz658I60,32724 +sympy/polys/tests/test_rootoftools.py,sha256=psVf3YA1MMkeuVvn-IpmF_rc3AEhh8U4U09h6dEY9u0,21531 +sympy/polys/tests/test_solvers.py,sha256=LZwjEQKKpFdCr4hMaU0CoN650BqU-arsACJNOF7lOmk,13655 +sympy/polys/tests/test_specialpolys.py,sha256=vBEDCC82ccGvxsETR5xr3yQ70Ho_HUqv1Q970vWf44M,4995 +sympy/polys/tests/test_sqfreetools.py,sha256=QJdMLVvQOiPm8ZYr4OESV71d5Ag9QcK1dMUkYv3pY5o,4387 +sympy/polys/tests/test_subresultants_qq_zz.py,sha256=ro6-F0vJrR46syl5Q0zuXfXQzEREtlkWAeRV9xJE31Y,13138 +sympy/printing/__init__.py,sha256=ws2P2KshXpwfnij4zaU3lVzIFQOh7nSjLbrB50cVFcU,2264 +sympy/printing/__pycache__/__init__.cpython-310.pyc,, +sympy/printing/__pycache__/aesaracode.cpython-310.pyc,, +sympy/printing/__pycache__/c.cpython-310.pyc,, +sympy/printing/__pycache__/codeprinter.cpython-310.pyc,, +sympy/printing/__pycache__/conventions.cpython-310.pyc,, +sympy/printing/__pycache__/cxx.cpython-310.pyc,, +sympy/printing/__pycache__/defaults.cpython-310.pyc,, +sympy/printing/__pycache__/dot.cpython-310.pyc,, +sympy/printing/__pycache__/fortran.cpython-310.pyc,, +sympy/printing/__pycache__/glsl.cpython-310.pyc,, +sympy/printing/__pycache__/gtk.cpython-310.pyc,, +sympy/printing/__pycache__/jscode.cpython-310.pyc,, +sympy/printing/__pycache__/julia.cpython-310.pyc,, +sympy/printing/__pycache__/lambdarepr.cpython-310.pyc,, +sympy/printing/__pycache__/latex.cpython-310.pyc,, +sympy/printing/__pycache__/llvmjitcode.cpython-310.pyc,, +sympy/printing/__pycache__/maple.cpython-310.pyc,, +sympy/printing/__pycache__/mathematica.cpython-310.pyc,, +sympy/printing/__pycache__/mathml.cpython-310.pyc,, +sympy/printing/__pycache__/numpy.cpython-310.pyc,, +sympy/printing/__pycache__/octave.cpython-310.pyc,, +sympy/printing/__pycache__/precedence.cpython-310.pyc,, +sympy/printing/__pycache__/preview.cpython-310.pyc,, +sympy/printing/__pycache__/printer.cpython-310.pyc,, +sympy/printing/__pycache__/pycode.cpython-310.pyc,, +sympy/printing/__pycache__/python.cpython-310.pyc,, +sympy/printing/__pycache__/rcode.cpython-310.pyc,, +sympy/printing/__pycache__/repr.cpython-310.pyc,, +sympy/printing/__pycache__/rust.cpython-310.pyc,, +sympy/printing/__pycache__/smtlib.cpython-310.pyc,, +sympy/printing/__pycache__/str.cpython-310.pyc,, +sympy/printing/__pycache__/tableform.cpython-310.pyc,, +sympy/printing/__pycache__/tensorflow.cpython-310.pyc,, +sympy/printing/__pycache__/theanocode.cpython-310.pyc,, +sympy/printing/__pycache__/tree.cpython-310.pyc,, +sympy/printing/aesaracode.py,sha256=aVXDMh_YDRsDwPbZMt8X73jjv4DW8g15M1M4TdNlqXQ,18227 +sympy/printing/c.py,sha256=dQ2ucrIGZGgYB6hS4gLIzFKDEYpfABNbP54lS7H6AIQ,26942 +sympy/printing/codeprinter.py,sha256=RkV88Z-SSCGkWJXuc_7pe2zoB-hRheBtJDDPEyK5acQ,35350 +sympy/printing/conventions.py,sha256=k6YRWHfvbLHJp1uKgQX-ySiOXSsXH8QJxC9fymYmcSM,2580 +sympy/printing/cxx.py,sha256=CtkngKi4o_z5XMbmzpa1eC1uUR9SCbuOIli9Zsnh4Rc,5737 +sympy/printing/defaults.py,sha256=YitLfIRfFH8ltNd18Y6YtBgq5H2te0wFKlHuIO4cvo8,135 +sympy/printing/dot.py,sha256=W0J798ZxBdlJercffBGnNDTp7J2tMdIYQkE_KIiyi3s,8274 +sympy/printing/fortran.py,sha256=JeDXvo6dL0-yG2nk9oiTmgBiWJZrjeZURsMcrFuSayo,28568 +sympy/printing/glsl.py,sha256=fYURb8NYRAxmbMQleFs-X2IWQ7uk5xHkJVhgskrFsbU,20537 +sympy/printing/gtk.py,sha256=ptnwYxJr5ox3LG4TCDbRIgxsCikaVvEzWBaqIpITUXc,466 +sympy/printing/jscode.py,sha256=EkGUqMH3qBAbLVbSSuYi4ZQ89G4xUImDT2nTAf3nn9E,12131 +sympy/printing/julia.py,sha256=iJqOPrHhqJjAc6UnT_8R7A5NFcn6ImE3mOTLS7X0bUY,23553 +sympy/printing/lambdarepr.py,sha256=BCx4eSdG8MQ8ZSUV1lWEd3CzbZ4IiMid-TTxPoV6FHU,8305 +sympy/printing/latex.py,sha256=ImSA8Ri3-30szn-FgMC4xTkrjnq9qlGisUhZtUiTyYE,121722 +sympy/printing/llvmjitcode.py,sha256=wa32lF5254AOPnbV9F5OvQTd1HOk0rfN-HUekcN1HmI,17164 +sympy/printing/maple.py,sha256=yEGhEsE_WkG4M6PpRdURw-FbsG-eVLL8d2-d3CUpkHk,10588 +sympy/printing/mathematica.py,sha256=9R-wXu1SR7Rp5hDFHdrRA0CPpADI58qeGoSxbAMpYP0,12701 +sympy/printing/mathml.py,sha256=BZNSIr05Hf3i2qBeNq0rGGEtHsChD2p8lfqg6GpRU5M,75290 +sympy/printing/numpy.py,sha256=X-MKcpT1u6Z6qaFKs6N17TQnzZMaeSMeKpJEru6Mhvo,19776 +sympy/printing/octave.py,sha256=31BmnCU-CCqllApOBJp5EPQCRO7hjU7hvYTqYxerPYg,25621 +sympy/printing/precedence.py,sha256=dK6ueqV6OOXg0qY9L-goOgbQarqVRygIYK5FQGTBPR8,5268 +sympy/printing/pretty/__init__.py,sha256=pJTe-DO4ctTlnjg1UvqyoeBY50B5znFjcGvivXRhM2U,344 +sympy/printing/pretty/__pycache__/__init__.cpython-310.pyc,, +sympy/printing/pretty/__pycache__/pretty.cpython-310.pyc,, +sympy/printing/pretty/__pycache__/pretty_symbology.cpython-310.pyc,, +sympy/printing/pretty/__pycache__/stringpict.cpython-310.pyc,, +sympy/printing/pretty/pretty.py,sha256=Yom39Yqxqb7mO0FxSRqsOmxSUvrwCaORdE4e_78YGIk,105281 +sympy/printing/pretty/pretty_symbology.py,sha256=nfBI-cLYLBP9VuZxb7DSWtFIg3vgDphNfV-uBtFDMIE,20208 +sympy/printing/pretty/stringpict.py,sha256=NuWPIg1wLFMu39Cxf09pgVKix_oY7zAWrPOBWVd_5Jc,19097 +sympy/printing/pretty/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/printing/pretty/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/printing/pretty/tests/__pycache__/test_pretty.cpython-310.pyc,, +sympy/printing/pretty/tests/test_pretty.py,sha256=IC7BOUZ01_-WrqBvn3nEAL89UezKzucS8dNDAvDzAHY,184797 +sympy/printing/preview.py,sha256=FwN0_q52iU6idLNZNXo002gPNpVw_9xrxLifFnK_ssw,14104 +sympy/printing/printer.py,sha256=0-hGTS9IPEqqP3s2sW7cZWyBe6opGa1FzyIRhND6FkA,14479 +sympy/printing/pycode.py,sha256=L6SbgH4ulnqTKVvAUtaKCATX4XYLNK-rs2UAgVe-1Rw,24290 +sympy/printing/python.py,sha256=sJcUWJYaWX41EZVkhUmZqpLA2ITcYU65Qd1UKZXMdFo,3367 +sympy/printing/rcode.py,sha256=mgWYYacqkLiBblV60CRH1G6FC9FkZ0LOfAYs1NgxOHA,14282 +sympy/printing/repr.py,sha256=p9G_EeK2WkI__6LFEtWyL1KFHJLL1KTFUJsp7N5n6vk,11649 +sympy/printing/rust.py,sha256=OD9xYBoTk-yRhhtbCaxyceg1lsnCaUclp_NWW4uaNYY,21377 +sympy/printing/smtlib.py,sha256=sJ0-_Ns2vH45b5oEXIPJtIOG9lvCEqHlJRQzQoiVC44,19445 +sympy/printing/str.py,sha256=OEX6W7wBj1aJIiq39qFxstyWJxkAp08RzOLolXObeIM,33260 +sympy/printing/tableform.py,sha256=-1d1cwmnprJKPXpViTbQxpwy3wT7K8KjPD5HCyjbDGk,11799 +sympy/printing/tensorflow.py,sha256=KHdJMHMBOaJkHO8_uBfYRHeBW2VIziv_YYqIV30D-dA,7906 +sympy/printing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/printing/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_aesaracode.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_c.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_codeprinter.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_conventions.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_cupy.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_cxx.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_dot.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_fortran.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_glsl.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_gtk.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_jax.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_jscode.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_julia.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_lambdarepr.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_latex.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_llvmjit.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_maple.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_mathematica.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_mathml.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_numpy.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_octave.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_precedence.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_preview.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_pycode.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_python.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_rcode.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_repr.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_rust.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_smtlib.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_str.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_tableform.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_tensorflow.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_theanocode.cpython-310.pyc,, +sympy/printing/tests/__pycache__/test_tree.cpython-310.pyc,, +sympy/printing/tests/test_aesaracode.py,sha256=s0pu_J7hfDJ4HttXP6cFM6fSUU1rHgga1SeAIdbNbAo,21016 +sympy/printing/tests/test_c.py,sha256=OrK5CxLbppwiOX2L-Whh9h7GC9XXueNkWhhF5ODaCnA,30804 +sympy/printing/tests/test_codeprinter.py,sha256=Bdh1RcusYzR7lTQ8s3Sik7zw_INivUcW2AS4dA0OCtg,1410 +sympy/printing/tests/test_conventions.py,sha256=yqPpU3F0WcbxImPBBAHd3YEZpkFGfcq_TLK4WN_gtP4,5257 +sympy/printing/tests/test_cupy.py,sha256=-hO52M1RJSQe0qSVSl6B1LudZIgaBMme0Nkd6dQGr6g,1858 +sympy/printing/tests/test_cxx.py,sha256=900VUfUpS55zfllYGQcpjdC4Wmcg4T8TV94Mr430NZc,2490 +sympy/printing/tests/test_dot.py,sha256=TSAtgGIgK_JbY-RMbQgUvnAI87SJqeJOqzcLjAobhKM,4648 +sympy/printing/tests/test_fortran.py,sha256=8L2zwZX8_QuNwcx24swcQUTvXYTO-5i-YrPL1hTRUVI,35518 +sympy/printing/tests/test_glsl.py,sha256=cfog9fp_EOFm_piJwqUcSvAIJ78bRwkFjecwr3ocCak,28421 +sympy/printing/tests/test_gtk.py,sha256=94gp1xRlPrFiALQGuqHnmh9xKrMxR52RQVkN0MXbUdA,500 +sympy/printing/tests/test_jax.py,sha256=B5GVZV9UxKeOmb4lzJHDkQXRbWQiLLD7w7Ze3sDrWHQ,10536 +sympy/printing/tests/test_jscode.py,sha256=ObahZne9lQbBiXyJZLohjQGdHsG2CnWCFOB8KbFOAqQ,11369 +sympy/printing/tests/test_julia.py,sha256=U7R9zOckGWy99f5StDFE9lMXkcEmMkGHzYj1UM1xzgc,13875 +sympy/printing/tests/test_lambdarepr.py,sha256=YU_lAQpiNHKJpBjZmgXr-unzOwS6Ss-u8sS2D_u-Mq0,6947 +sympy/printing/tests/test_latex.py,sha256=m8UBxuluF0fEYoLSOMM79VtwhEzkqIiouu6vsaZ1G4c,135670 +sympy/printing/tests/test_llvmjit.py,sha256=EGPeRisM60_TIVgnk7PTLSm5F-Aod_88zLjHPZwfyZ8,5344 +sympy/printing/tests/test_maple.py,sha256=te2l-yWWfklFHnaw-F2ik8q2dqES2cxrnE1voJxMGL0,13135 +sympy/printing/tests/test_mathematica.py,sha256=vijg7xfoelywL-ZhNuXFfDjM1FgaW_4liTBx1wzpkWk,10954 +sympy/printing/tests/test_mathml.py,sha256=x4IckrMxOlSzt6CxGFpHdN2l6OXl7zrcxIHwn-KxeS8,96209 +sympy/printing/tests/test_numpy.py,sha256=7fGncgPzvUbSjtltsu-kwiCFPv9tJlv2zPLRFo3ZkNw,10360 +sympy/printing/tests/test_octave.py,sha256=xIFRIXtTHcuU6ZhBW8Ht_KjUPewJoCEQ0b5GVVRyP7g,18728 +sympy/printing/tests/test_precedence.py,sha256=CS4L-WbI2ZuWLgbGATtF41--h0iGkfuE6dK5DYYiC5g,2787 +sympy/printing/tests/test_preview.py,sha256=dSVxiGqdNR6gbF40V4J2tGhQ-T4RDvSyGypHvYcPDYM,988 +sympy/printing/tests/test_pycode.py,sha256=nFeQHGQ9l-R2X_Q1snMFZP4KQ0M35V48P_j9kdahW4Q,15894 +sympy/printing/tests/test_python.py,sha256=HN7JkzQcKSnB6718i7kaEJZ5pYMqu56z1mSmHQGzY4k,8128 +sympy/printing/tests/test_rcode.py,sha256=PqYfr3akhhBcmswU3QLSFNyrmNTc92irTn0Wf_2jdv4,13779 +sympy/printing/tests/test_repr.py,sha256=sj3bAdBShn0itw2yYsAuDOuRPfKQSKJy2R8cPlLdDnY,12689 +sympy/printing/tests/test_rust.py,sha256=eZTYJ3zN5LEt8tl5KhADg1HwcrofhSQswagP_zcxoMw,11504 +sympy/printing/tests/test_smtlib.py,sha256=b4Ou4bTp8E_fFzlg6vQRpWowhxR-9SB88qA_yShXjhk,20934 +sympy/printing/tests/test_str.py,sha256=m-fw28ThIk0AcCz2_0HKgUNIwe9m3YGndcb4bJ28Leo,42262 +sympy/printing/tests/test_tableform.py,sha256=Ff5l1QL2HxN32WS_TdFhUAVqzop8YoWY3Uz1TThvVIM,5692 +sympy/printing/tests/test_tensorflow.py,sha256=p-Jx4Umby9k5t5umhus-0hkuTJN7C5kEbJL_l2KdyJA,15643 +sympy/printing/tests/test_theanocode.py,sha256=E36Fj72HxMK0e1pKTkoTpv9wI4UvwHdVufo-JA6dYq0,21394 +sympy/printing/tests/test_tree.py,sha256=_8PGAhWMQ_A0f2DQLdDeMrpxY19889P5Ih9H41RZn8s,6080 +sympy/printing/theanocode.py,sha256=3RxlOR4bRjMHOta6kvBk_ZuxKM3LZvPO8WYuxrtd38g,19028 +sympy/printing/tree.py,sha256=GxEF1WIflPNShlOrZc8AZch2I6GxDlbpImHqX61_P5o,3872 +sympy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/release.py,sha256=iyi5eR6SKGqbP1Fp0_6p-darg5riTqiLfREzuz7g8UE,21 +sympy/sandbox/__init__.py,sha256=IaEVOYHaZ97OHEuto1UGthFuO35c0uvAZFZU23YyEaU,189 +sympy/sandbox/__pycache__/__init__.cpython-310.pyc,, +sympy/sandbox/__pycache__/indexed_integrals.cpython-310.pyc,, +sympy/sandbox/indexed_integrals.py,sha256=svh4xDIa8nGpDeH4TeRb49gG8miMvXpCzEarbor58EE,2141 +sympy/sandbox/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/sandbox/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/sandbox/tests/__pycache__/test_indexed_integrals.cpython-310.pyc,, +sympy/sandbox/tests/test_indexed_integrals.py,sha256=UK2E2wg9EMwda4Vwpzyj3rmXs6ni33HqcbyaqAww6ww,1179 +sympy/series/__init__.py,sha256=DYG9oisjzYeS55dIUpQpbAFcoDz7Q81fZJw36PRGu14,766 +sympy/series/__pycache__/__init__.cpython-310.pyc,, +sympy/series/__pycache__/acceleration.cpython-310.pyc,, +sympy/series/__pycache__/approximants.cpython-310.pyc,, +sympy/series/__pycache__/aseries.cpython-310.pyc,, +sympy/series/__pycache__/formal.cpython-310.pyc,, +sympy/series/__pycache__/fourier.cpython-310.pyc,, +sympy/series/__pycache__/gruntz.cpython-310.pyc,, +sympy/series/__pycache__/kauers.cpython-310.pyc,, +sympy/series/__pycache__/limits.cpython-310.pyc,, +sympy/series/__pycache__/limitseq.cpython-310.pyc,, +sympy/series/__pycache__/order.cpython-310.pyc,, +sympy/series/__pycache__/residues.cpython-310.pyc,, +sympy/series/__pycache__/sequences.cpython-310.pyc,, +sympy/series/__pycache__/series.cpython-310.pyc,, +sympy/series/__pycache__/series_class.cpython-310.pyc,, +sympy/series/acceleration.py,sha256=9VTCOEOgIyOvcwjY5ZT_c4kWE-f_bL79iz_T3WGis94,3357 +sympy/series/approximants.py,sha256=tE-hHuoW62QJHDA3WhRlXaTkokCAODs1vXgjirhOYiQ,3181 +sympy/series/aseries.py,sha256=cHVGRQaza4ayqI6ji6OHNkdQEMV7Bko4f4vug2buEQY,255 +sympy/series/benchmarks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/series/benchmarks/__pycache__/__init__.cpython-310.pyc,, +sympy/series/benchmarks/__pycache__/bench_limit.cpython-310.pyc,, +sympy/series/benchmarks/__pycache__/bench_order.cpython-310.pyc,, +sympy/series/benchmarks/bench_limit.py,sha256=2PtdeeJtD6qyEvt9HFNvyTnMM8phFZRjscgnb4fHndU,173 +sympy/series/benchmarks/bench_order.py,sha256=iC8sQJ0lLlTgiXltAyLzSCQ-3490cf-c6NFiIU44JSk,207 +sympy/series/formal.py,sha256=CtRziTUItAd8G9z__jJ9s7dRIHAOdeHajdPmNB3HRgY,51772 +sympy/series/fourier.py,sha256=dzVo4VZ8OkD9YSbBEYQudpcHcEdVMG7LfnIRTMd4Lzg,22885 +sympy/series/gruntz.py,sha256=Iex_MRKqixBX7cehe-Wro-4fNreoXBsFIjcoUvsijG8,24544 +sympy/series/kauers.py,sha256=PzD0MATMNjLjPi9GW5GQGL6Uqc2UT-uPwnzhi7TkJH8,1720 +sympy/series/limits.py,sha256=D_lAe-Y0V1n5W3JztWs34tUasTTFgNqQi4MuPZc5oJk,12820 +sympy/series/limitseq.py,sha256=WM1Lh3RXhSZM1gQaJrhWnUtYEgJunLujIEw1gmtVhYw,7752 +sympy/series/order.py,sha256=bKvLPG0QwPl3a7Qw-SMQEjkpyaTxxye7pvC27-jvt80,19255 +sympy/series/residues.py,sha256=k46s_fFfIHdJZqfst-B_-X1R-SAWs_rR9MQH7a9JLtg,2213 +sympy/series/sequences.py,sha256=S2_GtHiPY9q2BpzbVgJsD4pBf_e4yWveEwluX9rSHF4,35589 +sympy/series/series.py,sha256=crSkQK1wA6FQAKI1islG6rpAzvWlz1gZZPx2Awp43Qg,1861 +sympy/series/series_class.py,sha256=033NJ5Re8AS4eq-chmfct3-Lz2vBqdFqXtnrbxswTx0,2918 +sympy/series/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/series/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/series/tests/__pycache__/test_approximants.cpython-310.pyc,, +sympy/series/tests/__pycache__/test_aseries.cpython-310.pyc,, +sympy/series/tests/__pycache__/test_demidovich.cpython-310.pyc,, +sympy/series/tests/__pycache__/test_formal.cpython-310.pyc,, +sympy/series/tests/__pycache__/test_fourier.cpython-310.pyc,, +sympy/series/tests/__pycache__/test_gruntz.cpython-310.pyc,, +sympy/series/tests/__pycache__/test_kauers.cpython-310.pyc,, +sympy/series/tests/__pycache__/test_limits.cpython-310.pyc,, +sympy/series/tests/__pycache__/test_limitseq.cpython-310.pyc,, +sympy/series/tests/__pycache__/test_lseries.cpython-310.pyc,, +sympy/series/tests/__pycache__/test_nseries.cpython-310.pyc,, +sympy/series/tests/__pycache__/test_order.cpython-310.pyc,, +sympy/series/tests/__pycache__/test_residues.cpython-310.pyc,, +sympy/series/tests/__pycache__/test_sequences.cpython-310.pyc,, +sympy/series/tests/__pycache__/test_series.cpython-310.pyc,, +sympy/series/tests/test_approximants.py,sha256=KViHMW1dPXn7xaPYhtTQ9L_WtLLkoIic6yfFnwZ8Q70,1012 +sympy/series/tests/test_aseries.py,sha256=LblW4hBDVhigX9YvNc_HFvMm8nJMSTAT9PcUK3p-9HU,2371 +sympy/series/tests/test_demidovich.py,sha256=JGYacqJMEqHS6oT2AYs9d7iutIEb32PkJs9EJqOHxcQ,4947 +sympy/series/tests/test_formal.py,sha256=k2rqySJg6WnPSwcDyQBG7041bJxXdiYZt-KSs_IAso0,22495 +sympy/series/tests/test_fourier.py,sha256=Dknk64RWGNO8kXmpy2RRIbT8b-0CjL_35QcBugReW38,5891 +sympy/series/tests/test_gruntz.py,sha256=CRRAlU0JLygDL7pHnxfILSDAQ6UbJfaKZrClAdGB1iE,16060 +sympy/series/tests/test_kauers.py,sha256=Z85FhfXOOVki0HNGeK5BEBZOpkuB6SnKK3FqfK1-aLQ,1102 +sympy/series/tests/test_limits.py,sha256=yMw_5X2GLXybVHHMnQ0H0Nx8sXWPYK9EH8boSZBOYwo,44263 +sympy/series/tests/test_limitseq.py,sha256=QjEF99sYEDqfY7ULz1qjQTo6e0lIRUCflEOBgiDYRVA,5691 +sympy/series/tests/test_lseries.py,sha256=GlQvlBlD9wh02PPBP6zU83wmhurvGUFTuCRp44B4uI4,1875 +sympy/series/tests/test_nseries.py,sha256=uzhzYswSOe9Gh_nWKeO69tvGPMLd-9tqk4HBYX8JIm4,18284 +sympy/series/tests/test_order.py,sha256=BGB1j0vmSMS8lGwSVmBOc9apI1NM82quFwF2Hhr2bDE,16500 +sympy/series/tests/test_residues.py,sha256=pT9xzPqtmfKGSbLLAxgDVZLTSy3TOxyfq3thTJs2VLw,3178 +sympy/series/tests/test_sequences.py,sha256=Oyq32yQZnGNQDS2uJ3by3bZ-y4G9c9BFfdQTcVuW2RM,11161 +sympy/series/tests/test_series.py,sha256=rsSCpDWpZQGMo0RfrkCS5XOl--wVFmIyZcaYUoaFXdc,15478 +sympy/sets/__init__.py,sha256=3vjCm4v2esbpsVPY0ROwTXMETxns_66bG4FCIFZ96oM,1026 +sympy/sets/__pycache__/__init__.cpython-310.pyc,, +sympy/sets/__pycache__/conditionset.cpython-310.pyc,, +sympy/sets/__pycache__/contains.cpython-310.pyc,, +sympy/sets/__pycache__/fancysets.cpython-310.pyc,, +sympy/sets/__pycache__/ordinals.cpython-310.pyc,, +sympy/sets/__pycache__/powerset.cpython-310.pyc,, +sympy/sets/__pycache__/setexpr.cpython-310.pyc,, +sympy/sets/__pycache__/sets.cpython-310.pyc,, +sympy/sets/conditionset.py,sha256=mBxxVHIFt9UfddAyvwfd-uVsM5fisNUSvBdNWH5QN_A,7825 +sympy/sets/contains.py,sha256=1jXxAFsl2ivXlT9SsGOM7s1uvS2UKEuWzNYA_bTtS6U,1234 +sympy/sets/fancysets.py,sha256=kVDkGbp316dFdR5GMWLtreltBFot8G39XM_xLvG1TkU,48118 +sympy/sets/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/sets/handlers/__pycache__/__init__.cpython-310.pyc,, +sympy/sets/handlers/__pycache__/add.cpython-310.pyc,, +sympy/sets/handlers/__pycache__/comparison.cpython-310.pyc,, +sympy/sets/handlers/__pycache__/functions.cpython-310.pyc,, +sympy/sets/handlers/__pycache__/intersection.cpython-310.pyc,, +sympy/sets/handlers/__pycache__/issubset.cpython-310.pyc,, +sympy/sets/handlers/__pycache__/mul.cpython-310.pyc,, +sympy/sets/handlers/__pycache__/power.cpython-310.pyc,, +sympy/sets/handlers/__pycache__/union.cpython-310.pyc,, +sympy/sets/handlers/add.py,sha256=_ucFvxuDv9wsmKxGkCDUERtYk3I_tQxjZjY3ZkroWs0,1863 +sympy/sets/handlers/comparison.py,sha256=WfT_vLrOkvPqRg2mf7gziVs_6cLg0kOTEFv-Nb1zIvo,1601 +sympy/sets/handlers/functions.py,sha256=jYSFqFNH6mXbKFPgvIAIGY8BhbLPo1dAvcNg4MxmCaI,8381 +sympy/sets/handlers/intersection.py,sha256=rIdRTqFQzbsa0NGepzWmfoKhAd87aEqxONdOgujR_0A,16633 +sympy/sets/handlers/issubset.py,sha256=azka_5eOaUro3r3v72PmET0oY8-aaoJkzVEK7kuqXCA,4739 +sympy/sets/handlers/mul.py,sha256=XFbkOw4PDQumaOEUlHeQLvjhIom0f3iniSYv_Kau-xw,1842 +sympy/sets/handlers/power.py,sha256=84N3dIus7r09XV7PF_RiEpFRw1y5tOGD34WKzSM9F-4,3186 +sympy/sets/handlers/union.py,sha256=lrAdydqExnALUjM0dnoM-7JAZqtbgLb46Y2GGmFtQdw,4225 +sympy/sets/ordinals.py,sha256=GSyaBq7BHJC3pvgoCDoUKZQ0IE2VXyHtx6_g5OS64W4,7641 +sympy/sets/powerset.py,sha256=vIGnSYKngEPEt6V-6beDOXAOY9ugDLJ8fXOx5H9JJck,2913 +sympy/sets/setexpr.py,sha256=jMOQigDscLTrFPXvHqo1ODVRG9BqC4yn38Ej4m6WPa0,3019 +sympy/sets/sets.py,sha256=Ma1U85BlQq_VwQZzu5aVVrqK9h0f7iwsltfOleqRnUE,79027 +sympy/sets/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/sets/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/sets/tests/__pycache__/test_conditionset.cpython-310.pyc,, +sympy/sets/tests/__pycache__/test_contains.cpython-310.pyc,, +sympy/sets/tests/__pycache__/test_fancysets.cpython-310.pyc,, +sympy/sets/tests/__pycache__/test_ordinals.cpython-310.pyc,, +sympy/sets/tests/__pycache__/test_powerset.cpython-310.pyc,, +sympy/sets/tests/__pycache__/test_setexpr.cpython-310.pyc,, +sympy/sets/tests/__pycache__/test_sets.cpython-310.pyc,, +sympy/sets/tests/test_conditionset.py,sha256=4FdbXxobY286r5UtrCbcQPqaFIycsdlbtNO2vJmzsEI,11352 +sympy/sets/tests/test_contains.py,sha256=SYiiiedUpAevS0I2gBQ8JEWrhRBmGsvOAxjGLPRe_gg,1559 +sympy/sets/tests/test_fancysets.py,sha256=GsRbQGZK_KAGp9aIBs6TLWlLzDNJvzkrzjzdUFMhRb8,51685 +sympy/sets/tests/test_ordinals.py,sha256=L4DYc6ByQMDwJGFzJC3YhfSrVk5auW7pf4QYpJ5xY7w,2637 +sympy/sets/tests/test_powerset.py,sha256=nFvDGlhAf0wG-pZnPkgJjfwDHrTwdro3MYIinwyxn94,4805 +sympy/sets/tests/test_setexpr.py,sha256=E--SjYVzrmau0EbD8g4NTqp6aLD8qHzIuI7sAfuWxpY,14797 +sympy/sets/tests/test_sets.py,sha256=9Upkysel9pewUn77Rowv0Ct8jKduZgW2lutpGKBnQj4,66659 +sympy/simplify/__init__.py,sha256=MH1vkwHq0J5tNm7ss8V6v-mjrDGUXwfOsariIwfi38c,1274 +sympy/simplify/__pycache__/__init__.cpython-310.pyc,, +sympy/simplify/__pycache__/combsimp.cpython-310.pyc,, +sympy/simplify/__pycache__/cse_main.cpython-310.pyc,, +sympy/simplify/__pycache__/cse_opts.cpython-310.pyc,, +sympy/simplify/__pycache__/epathtools.cpython-310.pyc,, +sympy/simplify/__pycache__/fu.cpython-310.pyc,, +sympy/simplify/__pycache__/gammasimp.cpython-310.pyc,, +sympy/simplify/__pycache__/hyperexpand.cpython-310.pyc,, +sympy/simplify/__pycache__/hyperexpand_doc.cpython-310.pyc,, +sympy/simplify/__pycache__/powsimp.cpython-310.pyc,, +sympy/simplify/__pycache__/radsimp.cpython-310.pyc,, +sympy/simplify/__pycache__/ratsimp.cpython-310.pyc,, +sympy/simplify/__pycache__/simplify.cpython-310.pyc,, +sympy/simplify/__pycache__/sqrtdenest.cpython-310.pyc,, +sympy/simplify/__pycache__/traversaltools.cpython-310.pyc,, +sympy/simplify/__pycache__/trigsimp.cpython-310.pyc,, +sympy/simplify/combsimp.py,sha256=XZOyP8qxowsXNbrtdUiinUFTUau4DZvivmd--Cw8Jnk,3605 +sympy/simplify/cse_main.py,sha256=4TJ15SSMyLa1rBp3FswVpkSmUDsu3uMxBkaUlyU9xZM,31349 +sympy/simplify/cse_opts.py,sha256=ZTCaOdOrgtifWxQmFzyngrLq9uwzByBdiSS5mE-DDoE,1618 +sympy/simplify/epathtools.py,sha256=YEeS5amYseT1nC4bHqyyemrjAE1qlhWz0ISXJk5I8Xo,10173 +sympy/simplify/fu.py,sha256=fgEyS5xWwvEUDWDkA7nco9k96NDxmjf3AHrP6Yc1zsg,61835 +sympy/simplify/gammasimp.py,sha256=n-TDIl7W_8RPSvpRTk8XiRSvYDBpzh55xxxWBpdXrfI,18609 +sympy/simplify/hyperexpand.py,sha256=TCqQwNyLflSgkGbuhVAohoXcMr1Dc9OgdXzeROC78Go,84437 +sympy/simplify/hyperexpand_doc.py,sha256=E8AD0mj8ULtelDSUkmJKJY7kYm5fVfCL4QH_DX65qEw,521 +sympy/simplify/powsimp.py,sha256=ThrrYTEIwQnd1cOfw-_p6ydRb1e2-7K5CU7dJpXTx-Y,26577 +sympy/simplify/radsimp.py,sha256=rE5fKX7Rf744zH_ybaTdytGNDPmGtEnd8oD9btuM_cU,41028 +sympy/simplify/ratsimp.py,sha256=s8K5jmxvPoYw8DVIpW0-h-brHlWi3a3Xj7DQoKJUjl8,7686 +sympy/simplify/simplify.py,sha256=VNAkKbQc_Mr4wxKTNfhOP4US4FccKMNI07Avj4axcQc,72902 +sympy/simplify/sqrtdenest.py,sha256=Ee1_NGJmWMG2fn2906PpyC79W-dZQdsSLNjkiT4gi1Q,21635 +sympy/simplify/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/simplify/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/simplify/tests/__pycache__/test_combsimp.cpython-310.pyc,, +sympy/simplify/tests/__pycache__/test_cse.cpython-310.pyc,, +sympy/simplify/tests/__pycache__/test_epathtools.cpython-310.pyc,, +sympy/simplify/tests/__pycache__/test_fu.cpython-310.pyc,, +sympy/simplify/tests/__pycache__/test_function.cpython-310.pyc,, +sympy/simplify/tests/__pycache__/test_gammasimp.cpython-310.pyc,, +sympy/simplify/tests/__pycache__/test_hyperexpand.cpython-310.pyc,, +sympy/simplify/tests/__pycache__/test_powsimp.cpython-310.pyc,, +sympy/simplify/tests/__pycache__/test_radsimp.cpython-310.pyc,, +sympy/simplify/tests/__pycache__/test_ratsimp.cpython-310.pyc,, +sympy/simplify/tests/__pycache__/test_rewrite.cpython-310.pyc,, +sympy/simplify/tests/__pycache__/test_simplify.cpython-310.pyc,, +sympy/simplify/tests/__pycache__/test_sqrtdenest.cpython-310.pyc,, +sympy/simplify/tests/__pycache__/test_trigsimp.cpython-310.pyc,, +sympy/simplify/tests/test_combsimp.py,sha256=O95WSxCvo2fDQs-UlarAcSf0_8M3PuTR76lhREDoNA8,2958 +sympy/simplify/tests/test_cse.py,sha256=pXDjx2yrL1YlT0ddzUJnZn3a1zD-Ch6I1C4TPtK9Nlk,25299 +sympy/simplify/tests/test_epathtools.py,sha256=ugsQlfuK6POiixdeit63QovsVAlG5JyCaPlPp0j35LE,3525 +sympy/simplify/tests/test_fu.py,sha256=Xqv8OyB_z3GrDUa9YdxyY98vq_XrwiMKzwMpqKx8XFQ,18651 +sympy/simplify/tests/test_function.py,sha256=gzdcSFObuDzVFJDdAgmERtZJvG38WNSmclPAdG8OaPQ,2199 +sympy/simplify/tests/test_gammasimp.py,sha256=32cPRmtG-_Mz9g02lmmn-PWDD3J_Ku6sxLxIUU7WqxE,5320 +sympy/simplify/tests/test_hyperexpand.py,sha256=tkrRq3zeOjXlH88kGiPgPHC3TTr5Y4BboC3bqDssKJc,40851 +sympy/simplify/tests/test_powsimp.py,sha256=CG5H_xSbtwZakjLzL-EEg-T9j2GOUylCU5YgLsbHm2A,14313 +sympy/simplify/tests/test_radsimp.py,sha256=7GjCVKP_nyS8s36Oxwmw6TiPRY0fG3aZP9Rd3oSksTY,18789 +sympy/simplify/tests/test_ratsimp.py,sha256=uRq7AGI957LeLOmYIXMqKkstQylK09xMYJRUflT8a-s,2210 +sympy/simplify/tests/test_rewrite.py,sha256=LZj4V6a95GJj1o3NlKRoHMk7sWGPASFlw24nsm4z43k,1127 +sympy/simplify/tests/test_simplify.py,sha256=7t9yEQCj53nrir-lItM0BSKZPgueDpul3H-Bsp-Bcu8,41565 +sympy/simplify/tests/test_sqrtdenest.py,sha256=4zRtDQVGpKRRBYSAnEF5pSM0AR_fAMumONu2Ocb3tqg,7470 +sympy/simplify/tests/test_trigsimp.py,sha256=vG5PDTDNOuFypT7H9DSMjIollPqkKdNhWv5FBj6vFnE,19949 +sympy/simplify/traversaltools.py,sha256=pn_t9Yrk_SL1X0vl-zVR6yZaxkY25D4MwTBv4ywnD1Y,409 +sympy/simplify/trigsimp.py,sha256=CasB3mOMniKbNiBDJU-SjyIFxNCKIWkgFLEsbOYlRSA,46856 +sympy/solvers/__init__.py,sha256=cqnpjbmL0YQNal_aQ-AFeCNkU1eHCpC17uaJ-Jo8COQ,2210 +sympy/solvers/__pycache__/__init__.cpython-310.pyc,, +sympy/solvers/__pycache__/bivariate.cpython-310.pyc,, +sympy/solvers/__pycache__/decompogen.cpython-310.pyc,, +sympy/solvers/__pycache__/deutils.cpython-310.pyc,, +sympy/solvers/__pycache__/inequalities.cpython-310.pyc,, +sympy/solvers/__pycache__/pde.cpython-310.pyc,, +sympy/solvers/__pycache__/polysys.cpython-310.pyc,, +sympy/solvers/__pycache__/recurr.cpython-310.pyc,, +sympy/solvers/__pycache__/solvers.cpython-310.pyc,, +sympy/solvers/__pycache__/solveset.cpython-310.pyc,, +sympy/solvers/benchmarks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/solvers/benchmarks/__pycache__/__init__.cpython-310.pyc,, +sympy/solvers/benchmarks/__pycache__/bench_solvers.cpython-310.pyc,, +sympy/solvers/benchmarks/bench_solvers.py,sha256=ZVK2TIW0XjWRDBex054ymmVlSBQw-RIBhEL1wS2ZAmU,288 +sympy/solvers/bivariate.py,sha256=yrlo0AoY_MtXHP1j0qKV4UgAhSXBBpvHHRnDJuCFsC8,17869 +sympy/solvers/decompogen.py,sha256=dWQla7hp7A4RqI2a0qRNQLWNPEuur68lD3dVTyktdBU,3757 +sympy/solvers/deutils.py,sha256=6dCIoZqX8mFz77SpT1DOM_I5yvdwU1tUMnTbA2vjYME,10309 +sympy/solvers/diophantine/__init__.py,sha256=I1p3uj3kFQv20cbsZ34K5rNCx1_pDS7JwHUCFstpBgs,128 +sympy/solvers/diophantine/__pycache__/__init__.cpython-310.pyc,, +sympy/solvers/diophantine/__pycache__/diophantine.cpython-310.pyc,, +sympy/solvers/diophantine/diophantine.py,sha256=oU1NhMmD2Eyzl_H5mMZw90-rxxU4A4MnwvrDswukk-8,120229 +sympy/solvers/diophantine/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/solvers/diophantine/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/solvers/diophantine/tests/__pycache__/test_diophantine.cpython-310.pyc,, +sympy/solvers/diophantine/tests/test_diophantine.py,sha256=mB79JLU5qe-9EM33USi8LmNLJjKrNuZ8TpPxaBz7gVw,42265 +sympy/solvers/inequalities.py,sha256=2IZlzDBYx8lWmW_7PVnIpTw6_FuYFsJLKvYna3nurA4,33098 +sympy/solvers/ode/__init__.py,sha256=I7RKwCcaoerflUm5i3ZDJgBIOnkhBjb83BCHcVcFqfM,468 +sympy/solvers/ode/__pycache__/__init__.cpython-310.pyc,, +sympy/solvers/ode/__pycache__/hypergeometric.cpython-310.pyc,, +sympy/solvers/ode/__pycache__/lie_group.cpython-310.pyc,, +sympy/solvers/ode/__pycache__/nonhomogeneous.cpython-310.pyc,, +sympy/solvers/ode/__pycache__/ode.cpython-310.pyc,, +sympy/solvers/ode/__pycache__/riccati.cpython-310.pyc,, +sympy/solvers/ode/__pycache__/single.cpython-310.pyc,, +sympy/solvers/ode/__pycache__/subscheck.cpython-310.pyc,, +sympy/solvers/ode/__pycache__/systems.cpython-310.pyc,, +sympy/solvers/ode/hypergeometric.py,sha256=kizvLgjzX1VUZ1n84uT6tlOs_8NfQBW1JZVo0fJLkdM,10048 +sympy/solvers/ode/lie_group.py,sha256=tGCy_KAMuKa4gb4JR084Qy0VKu9qU1BoYBgreDX5D9Q,39242 +sympy/solvers/ode/nonhomogeneous.py,sha256=SyQVXK3BB1gEZlcK1q5LueWvpyo-U600tdnpV_87QbE,18231 +sympy/solvers/ode/ode.py,sha256=Zt6XrqtQTEPa5a7lj-r0HJ8tZoS-lJNgt8J_3kHrqyg,145088 +sympy/solvers/ode/riccati.py,sha256=Ma2sEij9Ns3onj35F7PMOLAXsFG4NAcPjP-Qp5Spt4s,30748 +sympy/solvers/ode/single.py,sha256=UtDMHdaKSYKCOfanLiwG3tAzqov5eG51fV_5dGq_agI,109468 +sympy/solvers/ode/subscheck.py,sha256=CIPca_qTxL9z5oaD2e2NrgME0eVQgF9PabZndcVqHZM,16130 +sympy/solvers/ode/systems.py,sha256=jjhV_7GdP-kpqM8Kk3xlR1Dss5rvWCC839wguTnFLhI,71526 +sympy/solvers/ode/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/solvers/ode/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/solvers/ode/tests/__pycache__/test_lie_group.cpython-310.pyc,, +sympy/solvers/ode/tests/__pycache__/test_ode.cpython-310.pyc,, +sympy/solvers/ode/tests/__pycache__/test_riccati.cpython-310.pyc,, +sympy/solvers/ode/tests/__pycache__/test_single.cpython-310.pyc,, +sympy/solvers/ode/tests/__pycache__/test_subscheck.cpython-310.pyc,, +sympy/solvers/ode/tests/__pycache__/test_systems.cpython-310.pyc,, +sympy/solvers/ode/tests/test_lie_group.py,sha256=vg1yy_-a5x1Xm2IcVkEi5cD2uA5wE5gjqpfBwkV1vZc,5319 +sympy/solvers/ode/tests/test_ode.py,sha256=WsDeiS1cxO4NCDNJa99NMAqysPsOrKTQ0c6aY_u2vjc,48311 +sympy/solvers/ode/tests/test_riccati.py,sha256=-2C79UTh6WGwT8GjQ_YwdzlBrQU45f-NT7y0s1vdo8c,29352 +sympy/solvers/ode/tests/test_single.py,sha256=RV6Dl3MjY1dOQwNZk7hveZUzz8Gft6plRuIr7FmG58c,99983 +sympy/solvers/ode/tests/test_subscheck.py,sha256=Gzwc9h9n6zlNOhJ8Qh6fQDeB8ghaRmgv3ktBAfPJx-U,12468 +sympy/solvers/ode/tests/test_systems.py,sha256=Lkq84sR3pSw75d_pTAkm2_0gY45pCTKWmKmrO2zbov8,129359 +sympy/solvers/pde.py,sha256=FRFnEbD7ZJOcy8-q1LZ5NvYRt4Fu4Avf5Xe6Xk6pWoo,35659 +sympy/solvers/polysys.py,sha256=SQw-W8d5VHBfF81EYVFbcSSVUrsIHG9a9YzbkUaKIqc,13202 +sympy/solvers/recurr.py,sha256=DyssZuOyemoC6J1cWq635O7zkg1WLHrR7KGoM-gNy0g,25389 +sympy/solvers/solvers.py,sha256=bVtrpSn5jmko1ik6_JXD2rYW5ZRNKnboT0OiBDRbFRw,136170 +sympy/solvers/solveset.py,sha256=KySAjWzQfiEnVpXRHSCGh8Gq2ObJWOZf7OMmssZR5qU,141021 +sympy/solvers/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/solvers/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/solvers/tests/__pycache__/test_constantsimp.cpython-310.pyc,, +sympy/solvers/tests/__pycache__/test_decompogen.cpython-310.pyc,, +sympy/solvers/tests/__pycache__/test_inequalities.cpython-310.pyc,, +sympy/solvers/tests/__pycache__/test_numeric.cpython-310.pyc,, +sympy/solvers/tests/__pycache__/test_pde.cpython-310.pyc,, +sympy/solvers/tests/__pycache__/test_polysys.cpython-310.pyc,, +sympy/solvers/tests/__pycache__/test_recurr.cpython-310.pyc,, +sympy/solvers/tests/__pycache__/test_solvers.cpython-310.pyc,, +sympy/solvers/tests/__pycache__/test_solveset.cpython-310.pyc,, +sympy/solvers/tests/test_constantsimp.py,sha256=9Feugsg9jD2BwQiG4EFpb9fORyst6JdBmZqq2GaOgH8,8707 +sympy/solvers/tests/test_decompogen.py,sha256=7GUsDQQZtYbZIK0p0UxsOuNEJxEt4IHeOSsem_k-k0U,2943 +sympy/solvers/tests/test_inequalities.py,sha256=MuSP5v1kFL7eH_CSqOPhl6xDd1GuwRBWcZQSCwBy6Bg,20688 +sympy/solvers/tests/test_numeric.py,sha256=EeqGECpAsHoaXulCsOEJ6zAFn5i8iDy52Uo67awFAII,4738 +sympy/solvers/tests/test_pde.py,sha256=UGP3uWjF8pKQgfPifmdfvS5URVmzSg6m2NkS7LGzmio,9257 +sympy/solvers/tests/test_polysys.py,sha256=P1Jk79CAYB85L-O3KRJKpsqvwVJgqqJ_u44NigGWsaA,6873 +sympy/solvers/tests/test_recurr.py,sha256=-OeghSg16GFN70y_RUXC6CF6VU_b7NXaKDbejtRSocg,11418 +sympy/solvers/tests/test_solvers.py,sha256=hbJtihDVJQfRngUOBSz4OtV8HIkojkg528UNGtVAmr8,104484 +sympy/solvers/tests/test_solveset.py,sha256=YXl1lfZ1xnYrk_Dt4DY1gZuY9a0A5V462TPgqNfIPXk,134515 +sympy/stats/__init__.py,sha256=aNs_difmTw7e2GIfLGaPLpS-mXlttrrB3TVFPDSdGwU,8471 +sympy/stats/__pycache__/__init__.cpython-310.pyc,, +sympy/stats/__pycache__/compound_rv.cpython-310.pyc,, +sympy/stats/__pycache__/crv.cpython-310.pyc,, +sympy/stats/__pycache__/crv_types.cpython-310.pyc,, +sympy/stats/__pycache__/drv.cpython-310.pyc,, +sympy/stats/__pycache__/drv_types.cpython-310.pyc,, +sympy/stats/__pycache__/error_prop.cpython-310.pyc,, +sympy/stats/__pycache__/frv.cpython-310.pyc,, +sympy/stats/__pycache__/frv_types.cpython-310.pyc,, +sympy/stats/__pycache__/joint_rv.cpython-310.pyc,, +sympy/stats/__pycache__/joint_rv_types.cpython-310.pyc,, +sympy/stats/__pycache__/matrix_distributions.cpython-310.pyc,, +sympy/stats/__pycache__/random_matrix.cpython-310.pyc,, +sympy/stats/__pycache__/random_matrix_models.cpython-310.pyc,, +sympy/stats/__pycache__/rv.cpython-310.pyc,, +sympy/stats/__pycache__/rv_interface.cpython-310.pyc,, +sympy/stats/__pycache__/stochastic_process.cpython-310.pyc,, +sympy/stats/__pycache__/stochastic_process_types.cpython-310.pyc,, +sympy/stats/__pycache__/symbolic_multivariate_probability.cpython-310.pyc,, +sympy/stats/__pycache__/symbolic_probability.cpython-310.pyc,, +sympy/stats/compound_rv.py,sha256=SO1KXJ0aHGbD5y9QA8o6qOHbio3ua8wyO2Rsh0Hnw48,7965 +sympy/stats/crv.py,sha256=VK7jvYiQH523ar6QvLzV_k67u0ghcCrrWlBgt3cMdaw,20979 +sympy/stats/crv_types.py,sha256=TDANQNWz_fcSq7RzyMzxEKeidlHEmzdhunmxnuGlZNk,120259 +sympy/stats/drv.py,sha256=ewxYnUlCyvaF5ceMpziiz4e6FAgknzP5cC1ZVvQ_YLE,11995 +sympy/stats/drv_types.py,sha256=q7MjAtpLjO2nFxnQOKfw_Ipf2-gYzlavbqrEcUjMQlw,19288 +sympy/stats/error_prop.py,sha256=a-H6GZEidsiP_4-iNw7nSD99AMyN6DNHsSl0IUZGIAs,3315 +sympy/stats/frv.py,sha256=C4FHAVuckxdVnXGlmT957At5xdOLVYvH76KgL44TR38,16876 +sympy/stats/frv_types.py,sha256=MP1byJwusjZKRmzsy0fMBRkzScurG2-q58puaF6TF0U,23224 +sympy/stats/joint_rv.py,sha256=DcixlO2Ml4gnwMmZk2VTegiHVq88DkLdQlOTQ57SQtc,15963 +sympy/stats/joint_rv_types.py,sha256=Yx_TL9Xx862SZo8MofErvVh-fptL9UTzalDUbnW26Lg,30633 +sympy/stats/matrix_distributions.py,sha256=3OricwEMM_NU8b2lJxoiSTml7kvqrNQ6IUIn9Xy_DsY,21953 +sympy/stats/random_matrix.py,sha256=NmzLC5JMDWI2TvH8tY6go8lYyHmqcZ-B7sSIO7z7oAk,1028 +sympy/stats/random_matrix_models.py,sha256=7i5XAUYxt-ekmP5KDMaytUlmCvxglEspoWbswSf82tE,15328 +sympy/stats/rv.py,sha256=r8G52PBmkfrVJtHUWEw1dPiBSrwTYagRdyzAweftjqk,54464 +sympy/stats/rv_interface.py,sha256=8KeUP2YG_1g4OYPrwSdZyq4R0mOO52qqBX-D225WbUg,13939 +sympy/stats/sampling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/stats/sampling/__pycache__/__init__.cpython-310.pyc,, +sympy/stats/sampling/__pycache__/sample_numpy.cpython-310.pyc,, +sympy/stats/sampling/__pycache__/sample_pymc.cpython-310.pyc,, +sympy/stats/sampling/__pycache__/sample_scipy.cpython-310.pyc,, +sympy/stats/sampling/sample_numpy.py,sha256=B4ZC7ZBrSD6ICQT468rOy-xrOgQDuecsHa0zJesAeYE,4229 +sympy/stats/sampling/sample_pymc.py,sha256=9g-n04aXSFc6F7FJ5zTYtHHL6W8-26g1nrgtamJc3Hw,2995 +sympy/stats/sampling/sample_scipy.py,sha256=ysqpDy8bp1RMH0g5FFgMmp2SQuXGFkcSH7JDZEpiZ8w,6329 +sympy/stats/sampling/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/stats/sampling/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/stats/sampling/tests/__pycache__/test_sample_continuous_rv.cpython-310.pyc,, +sympy/stats/sampling/tests/__pycache__/test_sample_discrete_rv.cpython-310.pyc,, +sympy/stats/sampling/tests/__pycache__/test_sample_finite_rv.cpython-310.pyc,, +sympy/stats/sampling/tests/test_sample_continuous_rv.py,sha256=Gh8hFN1hFFsthEv9wP2ZdgghQfaEnE8n7HlmyXXhN1E,5708 +sympy/stats/sampling/tests/test_sample_discrete_rv.py,sha256=jd2qnr4ABqpFcJrGcUpnTsN1z1d1prVvwUkG965oFeA,3319 +sympy/stats/sampling/tests/test_sample_finite_rv.py,sha256=dWwrFePw8eX2rBheAXi1AVxr_gqBD63VZKfW81hNoQc,3061 +sympy/stats/stochastic_process.py,sha256=pDz0rbKXTiaNmMmmz70dP3F_KWL_XhoCKFHYBNt1QeU,2312 +sympy/stats/stochastic_process_types.py,sha256=S2y3qCs7AO1EkQltN_OYkB4PsamQqcIjcPu_181wFqY,88608 +sympy/stats/symbolic_multivariate_probability.py,sha256=4wwyTYywD3TQ43Isv5KDtg-7jCyF-SW5xR5JeeqEfFM,10446 +sympy/stats/symbolic_probability.py,sha256=m0-p5hTGU2Ey7uBQrB7LSPgTvS0C8Fr-SA9d2BAX6Mk,23019 +sympy/stats/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/stats/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/stats/tests/__pycache__/test_compound_rv.cpython-310.pyc,, +sympy/stats/tests/__pycache__/test_continuous_rv.cpython-310.pyc,, +sympy/stats/tests/__pycache__/test_discrete_rv.cpython-310.pyc,, +sympy/stats/tests/__pycache__/test_error_prop.cpython-310.pyc,, +sympy/stats/tests/__pycache__/test_finite_rv.cpython-310.pyc,, +sympy/stats/tests/__pycache__/test_joint_rv.cpython-310.pyc,, +sympy/stats/tests/__pycache__/test_matrix_distributions.cpython-310.pyc,, +sympy/stats/tests/__pycache__/test_mix.cpython-310.pyc,, +sympy/stats/tests/__pycache__/test_random_matrix.cpython-310.pyc,, +sympy/stats/tests/__pycache__/test_rv.cpython-310.pyc,, +sympy/stats/tests/__pycache__/test_stochastic_process.cpython-310.pyc,, +sympy/stats/tests/__pycache__/test_symbolic_multivariate.cpython-310.pyc,, +sympy/stats/tests/__pycache__/test_symbolic_probability.cpython-310.pyc,, +sympy/stats/tests/test_compound_rv.py,sha256=2927chbHTThA34Ki-ji319QT7ajQ1ueC640Mga-18ZA,6263 +sympy/stats/tests/test_continuous_rv.py,sha256=j3SFC2-4a6X2JObL3JU8znQkRXOGxz2a9XPlGPoBku0,55665 +sympy/stats/tests/test_discrete_rv.py,sha256=kr3MjfI02cPvQrQISwmsIDEEh2gpMnzZsjMd5TOhAl0,10676 +sympy/stats/tests/test_error_prop.py,sha256=xKAkw3F5XJ72xiDREI7PkyReWNVW_89CD_mjOY_diDY,1933 +sympy/stats/tests/test_finite_rv.py,sha256=JHYgY4snFF5t9qcnQfKaN5zaGsO7_SuNR7Tq234W4No,20413 +sympy/stats/tests/test_joint_rv.py,sha256=W28rCRYczv5Jax7k-bj7OveT-y-AP4q-kRR0-LNaWX0,18653 +sympy/stats/tests/test_matrix_distributions.py,sha256=9daJUiSGaLq34TeZfB-xPqC8xz6vECGrm0DdBZaQPyY,8857 +sympy/stats/tests/test_mix.py,sha256=Cplnw06Ki96Y_4fx6Bu7lUXjxoIfX7tNJasm9SOz5wQ,3991 +sympy/stats/tests/test_random_matrix.py,sha256=CiD1hV25MGHwTfHGaoaehGD3iJ4lqNYi-ZiwReO6CVk,5842 +sympy/stats/tests/test_rv.py,sha256=Bp7UwffIMO7oc8UnFV11yYGcXUjSa0NhsuOgQaNRMt8,12959 +sympy/stats/tests/test_stochastic_process.py,sha256=ufbFxlJ6El6YH7JDztMlrOjXKzrOvEyLGK30j1_lNjw,39335 +sympy/stats/tests/test_symbolic_multivariate.py,sha256=0qXWQUjBU6N5yiNO09B3QB8RfAiLBSCJ0R5n0Eo2-lQ,5576 +sympy/stats/tests/test_symbolic_probability.py,sha256=k5trScMiwSgl9dzJt30BV-t0KuYcyD-s9HtT2-hVhQ0,9398 +sympy/strategies/__init__.py,sha256=XaTAPqDoi6527juvR8LLN1mv6ZcslDrGloTTBMjJzxA,1402 +sympy/strategies/__pycache__/__init__.cpython-310.pyc,, +sympy/strategies/__pycache__/core.cpython-310.pyc,, +sympy/strategies/__pycache__/rl.cpython-310.pyc,, +sympy/strategies/__pycache__/tools.cpython-310.pyc,, +sympy/strategies/__pycache__/traverse.cpython-310.pyc,, +sympy/strategies/__pycache__/tree.cpython-310.pyc,, +sympy/strategies/__pycache__/util.cpython-310.pyc,, +sympy/strategies/branch/__init__.py,sha256=xxbMwR2LzLcQWsH9ss8ddE99VHFJTY-cYiR6xhO3tj0,356 +sympy/strategies/branch/__pycache__/__init__.cpython-310.pyc,, +sympy/strategies/branch/__pycache__/core.cpython-310.pyc,, +sympy/strategies/branch/__pycache__/tools.cpython-310.pyc,, +sympy/strategies/branch/__pycache__/traverse.cpython-310.pyc,, +sympy/strategies/branch/core.py,sha256=QiXSa7uhvmUBTLyUwBQHrYkWlOceKh5p4kVD90VnCKM,2759 +sympy/strategies/branch/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/strategies/branch/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/strategies/branch/tests/__pycache__/test_core.cpython-310.pyc,, +sympy/strategies/branch/tests/__pycache__/test_tools.cpython-310.pyc,, +sympy/strategies/branch/tests/__pycache__/test_traverse.cpython-310.pyc,, +sympy/strategies/branch/tests/test_core.py,sha256=23KQWJxC_2T1arwMAkt9pY1ZtG59avlxTZcVTn81UPI,2246 +sympy/strategies/branch/tests/test_tools.py,sha256=4BDkqVqrTlsivQ0PldQr6PjVZsAikc39tSxGAQA3ir8,942 +sympy/strategies/branch/tests/test_traverse.py,sha256=6rikMnZdamSzww1sSiM-aQwqa4lQrpM-DpOU9XCbiOQ,1322 +sympy/strategies/branch/tools.py,sha256=tvv3IjmQGNYbo-slCbbDf_rylZd537wvLcpdBtT-bbY,357 +sympy/strategies/branch/traverse.py,sha256=7iBViQdNpKu-AHoFED7_C9KBSyYcQBfLGopEJQbNtvk,799 +sympy/strategies/core.py,sha256=nsH6LZgyc_aslv4Na5XvJMEizC6uSzscRlVW91k1pu4,3956 +sympy/strategies/rl.py,sha256=I2puD2khbCmO3e9_ngUnclLgk1c-xBHeUf-bZu5haLM,4403 +sympy/strategies/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/strategies/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/strategies/tests/__pycache__/test_core.cpython-310.pyc,, +sympy/strategies/tests/__pycache__/test_rl.cpython-310.pyc,, +sympy/strategies/tests/__pycache__/test_tools.cpython-310.pyc,, +sympy/strategies/tests/__pycache__/test_traverse.cpython-310.pyc,, +sympy/strategies/tests/__pycache__/test_tree.cpython-310.pyc,, +sympy/strategies/tests/test_core.py,sha256=42XHlv1hN1S1QPEf2r9pddZ2EQL6o4FEPQvfo-UmXcw,2152 +sympy/strategies/tests/test_rl.py,sha256=wm0L6pdvddBgRcwhpiSk-nCgyzVGickfnOCkmHWS0j4,1949 +sympy/strategies/tests/test_tools.py,sha256=UdMojFIn3f1b2x2iRGv1Wfnwdso-Kl57GTyjCU_DjzQ,875 +sympy/strategies/tests/test_traverse.py,sha256=jWuZhYEt-F18_rxEMhn6OgGQ1GNs-dM_GFZ2F5nHs2I,2082 +sympy/strategies/tests/test_tree.py,sha256=9NL948rt6i9tYU6CQz9VNxE6l1begQs-MxP2euzE3Sc,2400 +sympy/strategies/tools.py,sha256=ERASzEP2SP-EcJ8p-4XyREYB15q3t81x1cyamJ-M880,1368 +sympy/strategies/traverse.py,sha256=DhPnBJ5Rw_xzhGiBtSciTyV-H2zhlxgjYVjrNH-gLyk,1183 +sympy/strategies/tree.py,sha256=ggnP9l3NIpJsssBMVKr4-yM_m8uCkrkm191ZC6MfZjc,3770 +sympy/strategies/util.py,sha256=2fbR813IY4IYco5mBoGJLu5z88OhXmwuIxgOO9IvZO4,361 +sympy/tensor/__init__.py,sha256=VMNXCRSayigQT6a3cvf5M_M-wdV-KSil_JbAmHcuUQc,870 +sympy/tensor/__pycache__/__init__.cpython-310.pyc,, +sympy/tensor/__pycache__/functions.cpython-310.pyc,, +sympy/tensor/__pycache__/index_methods.cpython-310.pyc,, +sympy/tensor/__pycache__/indexed.cpython-310.pyc,, +sympy/tensor/__pycache__/tensor.cpython-310.pyc,, +sympy/tensor/__pycache__/toperators.cpython-310.pyc,, +sympy/tensor/array/__init__.py,sha256=lTT1EwV5tb3WAvmmS_mIjhCSWSLiB0NNPW4n9_3fu0k,8244 +sympy/tensor/array/__pycache__/__init__.cpython-310.pyc,, +sympy/tensor/array/__pycache__/array_comprehension.cpython-310.pyc,, +sympy/tensor/array/__pycache__/array_derivatives.cpython-310.pyc,, +sympy/tensor/array/__pycache__/arrayop.cpython-310.pyc,, +sympy/tensor/array/__pycache__/dense_ndim_array.cpython-310.pyc,, +sympy/tensor/array/__pycache__/mutable_ndim_array.cpython-310.pyc,, +sympy/tensor/array/__pycache__/ndim_array.cpython-310.pyc,, +sympy/tensor/array/__pycache__/sparse_ndim_array.cpython-310.pyc,, +sympy/tensor/array/array_comprehension.py,sha256=01PTIbkAGaq0CDcaI_2KsaMnYm1nxQ8sFAiHHcc__gw,12262 +sympy/tensor/array/array_derivatives.py,sha256=BWQC43h2WieqJgaCqhLV39BXN22Gb6zcy_BXerdVixA,4811 +sympy/tensor/array/arrayop.py,sha256=UYKdKQZgDsXtDopymWS8QM7FZcxR1O0D_cbt-Kjx7yM,18395 +sympy/tensor/array/dense_ndim_array.py,sha256=Ie8qVMJyp2Tsq7aVhmZpPX8X-KTlF9uaxkQfTzCZ9z8,6433 +sympy/tensor/array/expressions/__init__.py,sha256=OUMJjZY7HtWJL0ygqkdWC8LdCqibJZhHCfYeXu-eB4E,7045 +sympy/tensor/array/expressions/__pycache__/__init__.cpython-310.pyc,, +sympy/tensor/array/expressions/__pycache__/array_expressions.cpython-310.pyc,, +sympy/tensor/array/expressions/__pycache__/arrayexpr_derivatives.cpython-310.pyc,, +sympy/tensor/array/expressions/__pycache__/conv_array_to_indexed.cpython-310.pyc,, +sympy/tensor/array/expressions/__pycache__/conv_array_to_matrix.cpython-310.pyc,, +sympy/tensor/array/expressions/__pycache__/conv_indexed_to_array.cpython-310.pyc,, +sympy/tensor/array/expressions/__pycache__/conv_matrix_to_array.cpython-310.pyc,, +sympy/tensor/array/expressions/__pycache__/from_array_to_indexed.cpython-310.pyc,, +sympy/tensor/array/expressions/__pycache__/from_array_to_matrix.cpython-310.pyc,, +sympy/tensor/array/expressions/__pycache__/from_indexed_to_array.cpython-310.pyc,, +sympy/tensor/array/expressions/__pycache__/from_matrix_to_array.cpython-310.pyc,, +sympy/tensor/array/expressions/__pycache__/utils.cpython-310.pyc,, +sympy/tensor/array/expressions/array_expressions.py,sha256=Gc0ADM3i-6sFoQTsgRHs7dRpmdH0XYVj8z9iS80vEoQ,77022 +sympy/tensor/array/expressions/arrayexpr_derivatives.py,sha256=W9-bY2LL83lLSNHXItzqjOgvf-HIDbUXPoVw8uOymcg,6249 +sympy/tensor/array/expressions/conv_array_to_indexed.py,sha256=BIwlQr7RKC8bZN3mR8ICC5TYOC9uasYcV0Zc1VNKmiE,445 +sympy/tensor/array/expressions/conv_array_to_matrix.py,sha256=85YZBTZI4o9dJtKDJXXug_lJVLG8dT_22AT7l7DKoyE,416 +sympy/tensor/array/expressions/conv_indexed_to_array.py,sha256=EyW52TplBxIx25mUDvI_5Tzc8LD6Mnp6XNW9wIw9pH4,254 +sympy/tensor/array/expressions/conv_matrix_to_array.py,sha256=XYyqt0NsQSrgNpEkr8xTGeUhR7ZYeNljVFfVEF1K7vA,250 +sympy/tensor/array/expressions/from_array_to_indexed.py,sha256=3YIcsAzWVWQRJYQS90uPvSl2dM7ZqLV_qt7E9-uYU28,3936 +sympy/tensor/array/expressions/from_array_to_matrix.py,sha256=OHkMM_yOLP6C1aAIZB-lPbz4AYS9i2shhFXGFBi9_Lc,41355 +sympy/tensor/array/expressions/from_indexed_to_array.py,sha256=RUcKemmrwuK5RFRr19YSPVMCOkZfLAWlbbB56u8Wi0g,11187 +sympy/tensor/array/expressions/from_matrix_to_array.py,sha256=yIY1RupF9-FVV3jZLsqWxZ1ckoE1-HkQyM8cQIm4_Gs,3929 +sympy/tensor/array/expressions/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/tensor/array/expressions/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/tensor/array/expressions/tests/__pycache__/test_array_expressions.cpython-310.pyc,, +sympy/tensor/array/expressions/tests/__pycache__/test_arrayexpr_derivatives.cpython-310.pyc,, +sympy/tensor/array/expressions/tests/__pycache__/test_as_explicit.cpython-310.pyc,, +sympy/tensor/array/expressions/tests/__pycache__/test_convert_array_to_indexed.cpython-310.pyc,, +sympy/tensor/array/expressions/tests/__pycache__/test_convert_array_to_matrix.cpython-310.pyc,, +sympy/tensor/array/expressions/tests/__pycache__/test_convert_indexed_to_array.cpython-310.pyc,, +sympy/tensor/array/expressions/tests/__pycache__/test_convert_matrix_to_array.cpython-310.pyc,, +sympy/tensor/array/expressions/tests/__pycache__/test_deprecated_conv_modules.cpython-310.pyc,, +sympy/tensor/array/expressions/tests/test_array_expressions.py,sha256=QUAdxQ9TvBpDEAZoJpLSWwbqjmuflPe3xBRP30lFZr0,31262 +sympy/tensor/array/expressions/tests/test_arrayexpr_derivatives.py,sha256=lpC4ly6MJLDRBcVt3GcP3H6ke9bI-o3VULw0xyF5QbY,2470 +sympy/tensor/array/expressions/tests/test_as_explicit.py,sha256=nOjFKXCqYNu2O7Szc1TD1x1bsUchPRAG3nGlNGEd1Yg,2568 +sympy/tensor/array/expressions/tests/test_convert_array_to_indexed.py,sha256=6yNxGXH6BX5607FTjMkwR2t9wNVlEhV8JMSh4UIWux8,2500 +sympy/tensor/array/expressions/tests/test_convert_array_to_matrix.py,sha256=2vkSep9CPKYrQQS0u8Ayn_sc7yek1zwzjjCWK5cfYe8,29311 +sympy/tensor/array/expressions/tests/test_convert_indexed_to_array.py,sha256=RVEG_qUsXiBH9gHtWp2-9pMC4J2aLc4iUdzBFM0QyTw,8615 +sympy/tensor/array/expressions/tests/test_convert_matrix_to_array.py,sha256=G2g5E0l-FABwYyQowbKKvLcEI8NViJXaYLW3eUEcvjw,4595 +sympy/tensor/array/expressions/tests/test_deprecated_conv_modules.py,sha256=DG8IoUtxCy2acWjUHUUKu4bRsTxXbeFLFjKMLA2GdLY,1216 +sympy/tensor/array/expressions/utils.py,sha256=Rn58boHHUEoBZFtinDpruLWFBkNBwgkVQ4c9m7Nym1o,3939 +sympy/tensor/array/mutable_ndim_array.py,sha256=M0PTt8IOIcVXqQPWe2N50sm4Eq2bodRXV4Vkd08crXk,277 +sympy/tensor/array/ndim_array.py,sha256=_UYVi2vd1zI0asXN7B53e0mp2plgVT5xvB71A_L63Ao,19060 +sympy/tensor/array/sparse_ndim_array.py,sha256=4nD_Hg-JdC_1mYQTohmKFfL5M1Ugdq0fpnDUILkTtq8,6387 +sympy/tensor/array/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/tensor/array/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/tensor/array/tests/__pycache__/test_array_comprehension.cpython-310.pyc,, +sympy/tensor/array/tests/__pycache__/test_array_derivatives.cpython-310.pyc,, +sympy/tensor/array/tests/__pycache__/test_arrayop.cpython-310.pyc,, +sympy/tensor/array/tests/__pycache__/test_immutable_ndim_array.cpython-310.pyc,, +sympy/tensor/array/tests/__pycache__/test_mutable_ndim_array.cpython-310.pyc,, +sympy/tensor/array/tests/__pycache__/test_ndim_array.cpython-310.pyc,, +sympy/tensor/array/tests/__pycache__/test_ndim_array_conversions.cpython-310.pyc,, +sympy/tensor/array/tests/test_array_comprehension.py,sha256=32n8ZKV4_5DeJ0F7fM_Xo0i0mx6m9w3uWUI2a6OXhzY,4750 +sympy/tensor/array/tests/test_array_derivatives.py,sha256=3O2nD4_d1TFP75qcGJ8XD4DwfPblFzKhY6fAgNQ9KJ0,1609 +sympy/tensor/array/tests/test_arrayop.py,sha256=WahGcUnArsAo9eaMqGT7_AjKons0WgFzLOWTtNvnSEI,25844 +sympy/tensor/array/tests/test_immutable_ndim_array.py,sha256=9ji_14szn-qoL6DQ5muzIFNaXefT7n55PFigXoFwk50,15823 +sympy/tensor/array/tests/test_mutable_ndim_array.py,sha256=rFFa0o0AJYgPNnpqijl91Vb9EW2kgHGQc6cu9f1fIvY,13070 +sympy/tensor/array/tests/test_ndim_array.py,sha256=KH-9LAME3ldVIu5n7Vd_Xr36dN4frCdiF9qZdBWETu0,2232 +sympy/tensor/array/tests/test_ndim_array_conversions.py,sha256=CUGDCbCcslACy3Ngq-zoig9JnO4yHTw3IPcKy0FnRpw,648 +sympy/tensor/functions.py,sha256=3jkzxjMvHHsWchz-0wvuOSFvkNqnoG5knknPCEsZ1bk,4166 +sympy/tensor/index_methods.py,sha256=dcX9kNKLHi_XXkFHBPS-fcM-PaeYKkX80jmzxC0siiQ,15434 +sympy/tensor/indexed.py,sha256=dLic-2CMpPXItLsJCjIUrRDEio-mH2Dcu3H0NgRo3Do,24660 +sympy/tensor/tensor.py,sha256=MEUQJM7NA40rzlZTV1D5PBR_SdIf7K3bVT2ixzqkYKw,165096 +sympy/tensor/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/tensor/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/tensor/tests/__pycache__/test_functions.cpython-310.pyc,, +sympy/tensor/tests/__pycache__/test_index_methods.cpython-310.pyc,, +sympy/tensor/tests/__pycache__/test_indexed.cpython-310.pyc,, +sympy/tensor/tests/__pycache__/test_printing.cpython-310.pyc,, +sympy/tensor/tests/__pycache__/test_tensor.cpython-310.pyc,, +sympy/tensor/tests/__pycache__/test_tensor_element.cpython-310.pyc,, +sympy/tensor/tests/__pycache__/test_tensor_operators.cpython-310.pyc,, +sympy/tensor/tests/test_functions.py,sha256=rBBHjJIUA2oR83UgEJ_GIASDWfTZXDzOllmcO90XYDU,1552 +sympy/tensor/tests/test_index_methods.py,sha256=Pu951z4yYYMOXBKcNteH63hTAxmNX8702nSQH_pciFE,7112 +sympy/tensor/tests/test_indexed.py,sha256=pCvqmScU0oQxx44qm9T3MkKIXKgVFRDkSHLDhSNqOIY,16157 +sympy/tensor/tests/test_printing.py,sha256=sUx_rChNTWFKPNwVl296QXO-d4-yemDJnkEHFislsmc,424 +sympy/tensor/tests/test_tensor.py,sha256=JybH2AAbEGNob44I6vl7uiiy_VpmR4O4gKCZOfwDPWE,75044 +sympy/tensor/tests/test_tensor_element.py,sha256=1dF96FtqUGaJzethw23vJIj3H5KdxsU1Xyd4DU54EB4,908 +sympy/tensor/tests/test_tensor_operators.py,sha256=sOwu-U28098Lg0iV_9RfYxvJ8wAd5Rk6_vAivWdkc9Q,17945 +sympy/tensor/toperators.py,sha256=fniTUpdYz0OvtNnFgrHINedX86FxVcxfKj9l_l1p9Rw,8840 +sympy/testing/__init__.py,sha256=YhdM87Kfsci8340HmKrXVmA4y0z_VeUN5QQbwAOvEbg,139 +sympy/testing/__pycache__/__init__.cpython-310.pyc,, +sympy/testing/__pycache__/matrices.cpython-310.pyc,, +sympy/testing/__pycache__/pytest.cpython-310.pyc,, +sympy/testing/__pycache__/quality_unicode.cpython-310.pyc,, +sympy/testing/__pycache__/randtest.cpython-310.pyc,, +sympy/testing/__pycache__/runtests.cpython-310.pyc,, +sympy/testing/__pycache__/tmpfiles.cpython-310.pyc,, +sympy/testing/matrices.py,sha256=VWBPdjIUYNHE7fdbYcmQwQTYcIWpOP9tFn9A0rGCBmE,216 +sympy/testing/pytest.py,sha256=VsbyFXAwDHWc69AxJZBml7U_Mun6kS5NutziSH6l-RE,13142 +sympy/testing/quality_unicode.py,sha256=aJma-KtrKgusUL1jz5IADz7q6vc70rsfbT9NtxJDeV4,3318 +sympy/testing/randtest.py,sha256=IKDFAm8b72Z1OkT7vpgnZjaW5LsSU_wf6g35sCkq9I0,562 +sympy/testing/runtests.py,sha256=QbirfrvKseYmrM2kLjHHhNGNgO6DsHJS1ncuH5PnPT4,88921 +sympy/testing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/testing/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/testing/tests/__pycache__/diagnose_imports.cpython-310.pyc,, +sympy/testing/tests/__pycache__/test_code_quality.cpython-310.pyc,, +sympy/testing/tests/__pycache__/test_deprecated.cpython-310.pyc,, +sympy/testing/tests/__pycache__/test_module_imports.cpython-310.pyc,, +sympy/testing/tests/__pycache__/test_pytest.cpython-310.pyc,, +sympy/testing/tests/diagnose_imports.py,sha256=ZtSLMYNT1-RUvPlCUpYzj97aE3NafvGgp0UzRXOPd0Q,9694 +sympy/testing/tests/test_code_quality.py,sha256=JTVznHG1HKBmy3Or4_gFjBlAi0L1BJ2wjgZLUu5zBa0,19237 +sympy/testing/tests/test_deprecated.py,sha256=wQZHs4wDNuK4flaKKLsJW6XRMtrVjMv_5rUP3WspgPA,183 +sympy/testing/tests/test_module_imports.py,sha256=5w6F6JW6K7lgpbB4X9Tj0Vw8AcNVlfaSuvbwKXJKD6c,1459 +sympy/testing/tests/test_pytest.py,sha256=iKO10Tvua1Xem6a22IWH4SDrpFfr-bM-rXx039Ua7YA,6778 +sympy/testing/tmpfiles.py,sha256=bF8ktKC9lDhS65gahB9hOewsZ378UkhLgq3QHiqWYXU,1042 +sympy/this.py,sha256=XfOkN5EIM2RuDxSm_q6k_R_WtkIoSy6PXWKp3aAXvoc,550 +sympy/unify/__init__.py,sha256=Upa9h7SSr9W1PXo0WkNESsGsMZ85rcWkeruBtkAi3Fg,293 +sympy/unify/__pycache__/__init__.cpython-310.pyc,, +sympy/unify/__pycache__/core.cpython-310.pyc,, +sympy/unify/__pycache__/rewrite.cpython-310.pyc,, +sympy/unify/__pycache__/usympy.cpython-310.pyc,, +sympy/unify/core.py,sha256=-BCNPPMdfZuhhIWqyn9pYJoO8yFPGDX78Hn2551ABuE,7037 +sympy/unify/rewrite.py,sha256=Emr8Uoum3gxKpMDqFHJIjx3xChArUIN6XIy6NPfCS8I,1798 +sympy/unify/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/unify/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/unify/tests/__pycache__/test_rewrite.cpython-310.pyc,, +sympy/unify/tests/__pycache__/test_sympy.cpython-310.pyc,, +sympy/unify/tests/__pycache__/test_unify.cpython-310.pyc,, +sympy/unify/tests/test_rewrite.py,sha256=BgA8zmdz9Nw-Xbu4-w3UABeWypqLvmy9VzL744EmYtE,2002 +sympy/unify/tests/test_sympy.py,sha256=UCItZJNAx9dG5F7O27pyXUF1-e6aOwkZ-cVdB6SZFZc,5922 +sympy/unify/tests/test_unify.py,sha256=4TlgchV6NWuBekJx9RGlMjx3-UwonzgIYXDytb7sBRU,3029 +sympy/unify/usympy.py,sha256=6Kxx96FXSdqXimLseVK_FkYwy2vqWhNnxMVPMRShvy4,3964 +sympy/utilities/__init__.py,sha256=nbQhzII8dw5zd4hQJ2SUyriK5dOrqf-bbjy10XKQXPw,840 +sympy/utilities/__pycache__/__init__.cpython-310.pyc,, +sympy/utilities/__pycache__/autowrap.cpython-310.pyc,, +sympy/utilities/__pycache__/codegen.cpython-310.pyc,, +sympy/utilities/__pycache__/decorator.cpython-310.pyc,, +sympy/utilities/__pycache__/enumerative.cpython-310.pyc,, +sympy/utilities/__pycache__/exceptions.cpython-310.pyc,, +sympy/utilities/__pycache__/iterables.cpython-310.pyc,, +sympy/utilities/__pycache__/lambdify.cpython-310.pyc,, +sympy/utilities/__pycache__/magic.cpython-310.pyc,, +sympy/utilities/__pycache__/matchpy_connector.cpython-310.pyc,, +sympy/utilities/__pycache__/memoization.cpython-310.pyc,, +sympy/utilities/__pycache__/misc.cpython-310.pyc,, +sympy/utilities/__pycache__/pkgdata.cpython-310.pyc,, +sympy/utilities/__pycache__/pytest.cpython-310.pyc,, +sympy/utilities/__pycache__/randtest.cpython-310.pyc,, +sympy/utilities/__pycache__/runtests.cpython-310.pyc,, +sympy/utilities/__pycache__/source.cpython-310.pyc,, +sympy/utilities/__pycache__/timeutils.cpython-310.pyc,, +sympy/utilities/__pycache__/tmpfiles.cpython-310.pyc,, +sympy/utilities/_compilation/__init__.py,sha256=uYUDPbwrMTbGEMVuago32EN_ix8fsi5M0SvcLOtwMOk,751 +sympy/utilities/_compilation/__pycache__/__init__.cpython-310.pyc,, +sympy/utilities/_compilation/__pycache__/availability.cpython-310.pyc,, +sympy/utilities/_compilation/__pycache__/compilation.cpython-310.pyc,, +sympy/utilities/_compilation/__pycache__/runners.cpython-310.pyc,, +sympy/utilities/_compilation/__pycache__/util.cpython-310.pyc,, +sympy/utilities/_compilation/availability.py,sha256=ybxp3mboH5772JHTWKBN1D-cs6QxATQiaL4zJVV4RE0,2884 +sympy/utilities/_compilation/compilation.py,sha256=t6UrVUHDrk7im_mYXx8s7ZkyUEkllhx38u7AAk5Z1P8,21675 +sympy/utilities/_compilation/runners.py,sha256=mb8_rvyx68qekMx8yZZyBH5G7bX94QG6W3lJ17rBmGU,8974 +sympy/utilities/_compilation/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/utilities/_compilation/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/utilities/_compilation/tests/__pycache__/test_compilation.cpython-310.pyc,, +sympy/utilities/_compilation/tests/test_compilation.py,sha256=MORW8RsdmQTgFpYR7PLRQ35gxFYup3ejQu0byiIxmig,1735 +sympy/utilities/_compilation/util.py,sha256=3ZVUy732fHXFm6oK2EE13M-tztpG5G5vy4FcJ-V3SwY,7928 +sympy/utilities/autowrap.py,sha256=MNoV81PCxJvlk9_aG87jUpWkGhn03WCCk0SPG54nRoc,41123 +sympy/utilities/codegen.py,sha256=WbFTgzQPlCf-0O-gk8X-r9pxMnz4j8roObFsCThVl4Q,81495 +sympy/utilities/decorator.py,sha256=RTwHzeF1N9WMe6apBkYM2vaJcDoP683Ze548S3T_NN8,10925 +sympy/utilities/enumerative.py,sha256=pYpty2YDgvF5LBrmiAVyiqpiqhfFeYTfQfS7sTQMNks,43621 +sympy/utilities/exceptions.py,sha256=g9fgLCjrkuYk-ImX_V42ve2XIayK01mWmlXKOIVmW_8,10571 +sympy/utilities/iterables.py,sha256=VpGyggsMbqd2CL2TRSX1Iozp1G4VMIPNS7FMME-hPAw,90920 +sympy/utilities/lambdify.py,sha256=2DLVtqwhws_PAPVzxS5nh7YVfICAdGKxYGVNQ9p9mrg,55149 +sympy/utilities/magic.py,sha256=ofrwi1-xwMWb4VCQOEIwe4J1QAwxOscigDq26uSn3iY,400 +sympy/utilities/matchpy_connector.py,sha256=045re8zEDdr70Ey39OWRq0xnM6OsKBISiu9SB4nJ90g,10068 +sympy/utilities/mathml/__init__.py,sha256=3AG_eTJ4I7071riTqesIi1A3bykCeIUES2CTEYxfrPI,2299 +sympy/utilities/mathml/__pycache__/__init__.cpython-310.pyc,, +sympy/utilities/mathml/data/mmlctop.xsl,sha256=fi3CTNyg-mSscOGYBXLJv8veE_ItR_YTFMJ4jmjp6aE,114444 +sympy/utilities/mathml/data/mmltex.xsl,sha256=haX7emZOfD6_nbn5BjK93F-C85mSS8KogAbIBsW1aBA,137304 +sympy/utilities/mathml/data/simple_mmlctop.xsl,sha256=lhL-HXG_FfsJZhjeHbD7Ou8RnUaStI0-5VFcggsogjA,114432 +sympy/utilities/memoization.py,sha256=ZGOUUmwJCNRhHVZjTF4j65WjQ6VUoCeC1E8DkjryU00,1429 +sympy/utilities/misc.py,sha256=7N6LNt5N9eR2AK-_jmdOXXKhyhbW4kLRY8O5wYw3VgI,16007 +sympy/utilities/pkgdata.py,sha256=jt-hKL0xhxnDJDI9C2IXtH_QgYYtfq9fX9kJ3E7iang,1788 +sympy/utilities/pytest.py,sha256=F9TGNtoNvQUdlt5HYU084ITNmc7__7MBCSLLulBlM_Y,435 +sympy/utilities/randtest.py,sha256=aYUX_mgmQyfRdMjEOWaHM506CZ6WUK0eFuew0vFTwRs,430 +sympy/utilities/runtests.py,sha256=hYnDNiFNnDjQcXG04_3lzPFbUz6i0AUZ2rZ_RECVoDo,446 +sympy/utilities/source.py,sha256=ShIXRNtplSEfZNi5VDYD3yi6305eRz4TmchEOEvcicw,1127 +sympy/utilities/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/utilities/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/utilities/tests/__pycache__/test_autowrap.cpython-310.pyc,, +sympy/utilities/tests/__pycache__/test_codegen.cpython-310.pyc,, +sympy/utilities/tests/__pycache__/test_codegen_julia.cpython-310.pyc,, +sympy/utilities/tests/__pycache__/test_codegen_octave.cpython-310.pyc,, +sympy/utilities/tests/__pycache__/test_codegen_rust.cpython-310.pyc,, +sympy/utilities/tests/__pycache__/test_decorator.cpython-310.pyc,, +sympy/utilities/tests/__pycache__/test_deprecated.cpython-310.pyc,, +sympy/utilities/tests/__pycache__/test_enumerative.cpython-310.pyc,, +sympy/utilities/tests/__pycache__/test_exceptions.cpython-310.pyc,, +sympy/utilities/tests/__pycache__/test_iterables.cpython-310.pyc,, +sympy/utilities/tests/__pycache__/test_lambdify.cpython-310.pyc,, +sympy/utilities/tests/__pycache__/test_matchpy_connector.cpython-310.pyc,, +sympy/utilities/tests/__pycache__/test_mathml.cpython-310.pyc,, +sympy/utilities/tests/__pycache__/test_misc.cpython-310.pyc,, +sympy/utilities/tests/__pycache__/test_pickling.cpython-310.pyc,, +sympy/utilities/tests/__pycache__/test_source.cpython-310.pyc,, +sympy/utilities/tests/__pycache__/test_timeutils.cpython-310.pyc,, +sympy/utilities/tests/__pycache__/test_wester.cpython-310.pyc,, +sympy/utilities/tests/__pycache__/test_xxe.cpython-310.pyc,, +sympy/utilities/tests/test_autowrap.py,sha256=NW20YQiJgEofZ0xr4Ggocix4fAsBmnyankmbxPf54Fk,14603 +sympy/utilities/tests/test_codegen.py,sha256=PLuSicBhnspClTiSeKCJgKd1NyU0qBkDRvQMrwm_gLc,55496 +sympy/utilities/tests/test_codegen_julia.py,sha256=kb3soJ1L7lTfZkYJKytfY_aKoHt6fkNjWhYblebzThw,18543 +sympy/utilities/tests/test_codegen_octave.py,sha256=_yd9uGKHZzwUFpderSa9E2cYqt8JMcEtBuN6U7_7bJ0,17833 +sympy/utilities/tests/test_codegen_rust.py,sha256=wJh6YmDfq8haGjJDniDaVUsDIKEj3rT_OB4r6uLI77Y,12323 +sympy/utilities/tests/test_decorator.py,sha256=VYUvzUrVI7I7MK0YZxLLEmEu4pV5dqaB1CLEJ8Ocav4,3705 +sympy/utilities/tests/test_deprecated.py,sha256=LRrZ2UxuXnK6Jwxl8vT0EdLT-q-7jLkTC69U9JjuYYU,489 +sympy/utilities/tests/test_enumerative.py,sha256=aUw6nbSzBp8h_pk35YZ_uzRncRoLYStblodeiDRFk6I,6089 +sympy/utilities/tests/test_exceptions.py,sha256=OKRa2yuHMtnVcnisu-xcaedi2RKsH9QrgU9exgoOK30,716 +sympy/utilities/tests/test_iterables.py,sha256=fPlgquV8GaZEIAjCwxE5DnXjGJUQlt6PGR7yj-gBLJ8,34905 +sympy/utilities/tests/test_lambdify.py,sha256=COnloXr7-MetPh-YonB1h6sEy5UkzBYWTdNuEGuduew,59594 +sympy/utilities/tests/test_matchpy_connector.py,sha256=dUfDfIdofKYufww29jV8mVQmglU1AnG2uEyREpNY7V0,4506 +sympy/utilities/tests/test_mathml.py,sha256=-6z1MRYEH4eYQi2_wt8zmdjwtt5Cn483zqsvD-o_r70,836 +sympy/utilities/tests/test_misc.py,sha256=TxjUNCosyCR5w1iJ6o77yKB4WBLyirVhOaALGYdkN9k,4726 +sympy/utilities/tests/test_pickling.py,sha256=JxsZSIVrXrscDwZ0Bvx4DkyLSEIyXUzoO96qrOx-5tU,23301 +sympy/utilities/tests/test_source.py,sha256=ObjrJxZFVhLgXjVmFHUy7bti9UPPgOh5Cptw8lHW9mM,289 +sympy/utilities/tests/test_timeutils.py,sha256=sCRC6BCSho1e9n4clke3QXHx4a3qYLru-bddS_sEmFA,337 +sympy/utilities/tests/test_wester.py,sha256=6_o3Dm4fT3R-TZEinuel2VFdZth0BOgPTPFYSEIcDX0,94546 +sympy/utilities/tests/test_xxe.py,sha256=xk1j0Dd96wsGYKRNDzXTW0hTQejGCfiZcEhYcYiqojg,66 +sympy/utilities/timeutils.py,sha256=DUtQYONkJnWjU2FvAbvxuRMkGmXpLMeaiOcH7R9Os9o,1968 +sympy/utilities/tmpfiles.py,sha256=yOjbs90sEtVc00YZyveyblT8zkwj4o70_RmuEKdKq_s,445 +sympy/vector/__init__.py,sha256=8a4cSQ1sJ5uirdMoHnV7SWXU3zJPKt_0ojona8C-p1Y,1909 +sympy/vector/__pycache__/__init__.cpython-310.pyc,, +sympy/vector/__pycache__/basisdependent.cpython-310.pyc,, +sympy/vector/__pycache__/coordsysrect.cpython-310.pyc,, +sympy/vector/__pycache__/deloperator.cpython-310.pyc,, +sympy/vector/__pycache__/dyadic.cpython-310.pyc,, +sympy/vector/__pycache__/functions.cpython-310.pyc,, +sympy/vector/__pycache__/implicitregion.cpython-310.pyc,, +sympy/vector/__pycache__/integrals.cpython-310.pyc,, +sympy/vector/__pycache__/operators.cpython-310.pyc,, +sympy/vector/__pycache__/orienters.cpython-310.pyc,, +sympy/vector/__pycache__/parametricregion.cpython-310.pyc,, +sympy/vector/__pycache__/point.cpython-310.pyc,, +sympy/vector/__pycache__/scalar.cpython-310.pyc,, +sympy/vector/__pycache__/vector.cpython-310.pyc,, +sympy/vector/basisdependent.py,sha256=BTTlFGRnZIvpvK_WEK4Tk_WZXEXYGosx9fWTuMO4M0o,11553 +sympy/vector/coordsysrect.py,sha256=1JV4GBgG99JKIWo2snYMMgIJCdob3XcwYqq9s8d6fA8,36859 +sympy/vector/deloperator.py,sha256=4BJNjmI342HkVRmeQkqauqvibKsf2HOuzknQTfQMkpg,3191 +sympy/vector/dyadic.py,sha256=IOyrgONyGDHPtG0RINcMgetAVMSOmYI5a99s-OwXBTA,8571 +sympy/vector/functions.py,sha256=auLfE1Su2kLtkRvlB_7Wol8O0_sqei1hojun3pkDRYI,15552 +sympy/vector/implicitregion.py,sha256=WrCIFuh_KZ6iEA7FZzYanZoUQuJ4gNBP3NeNKMxC0l0,16155 +sympy/vector/integrals.py,sha256=x8DrvKXPznE05JgnZ7I3IWLWrvFl9SEghGaFmHrBaE4,6837 +sympy/vector/operators.py,sha256=mI6d0eIxVcoDeH5PrhtPTzhxX_RXByX_4hjXeBTeq88,9521 +sympy/vector/orienters.py,sha256=EtWNWfOvAuy_wipam9SA7_muKSrsP-43UPRCCz56sb0,11798 +sympy/vector/parametricregion.py,sha256=3YyY0fkFNelR6ldi8XYRWpkFEvqY5-rFg_vT3NFute0,5932 +sympy/vector/point.py,sha256=ozYlInnlsmIpKBEr5Ui331T1lnAB5zS2_pHYh9k_eMs,4516 +sympy/vector/scalar.py,sha256=Z2f2wiK7BS73ctYTyNvn3gB74mXZuENpScLi_M1SpYg,1962 +sympy/vector/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +sympy/vector/tests/__pycache__/__init__.cpython-310.pyc,, +sympy/vector/tests/__pycache__/test_coordsysrect.cpython-310.pyc,, +sympy/vector/tests/__pycache__/test_dyadic.cpython-310.pyc,, +sympy/vector/tests/__pycache__/test_field_functions.cpython-310.pyc,, +sympy/vector/tests/__pycache__/test_functions.cpython-310.pyc,, +sympy/vector/tests/__pycache__/test_implicitregion.cpython-310.pyc,, +sympy/vector/tests/__pycache__/test_integrals.cpython-310.pyc,, +sympy/vector/tests/__pycache__/test_operators.cpython-310.pyc,, +sympy/vector/tests/__pycache__/test_parametricregion.cpython-310.pyc,, +sympy/vector/tests/__pycache__/test_printing.cpython-310.pyc,, +sympy/vector/tests/__pycache__/test_vector.cpython-310.pyc,, +sympy/vector/tests/test_coordsysrect.py,sha256=q9n9OIG_CpD4KQN20dzwRZIXoMv7VSgp8fHmVnkZfr0,19595 +sympy/vector/tests/test_dyadic.py,sha256=f1R-BL_63VBbc0XgEX_LYzV_3OupYd4hp5RzRk6dAbI,4949 +sympy/vector/tests/test_field_functions.py,sha256=v9l8Ex8K2MsPGxqAPhpEgu6WAo6wS6qvdWLKQMxgE4A,14094 +sympy/vector/tests/test_functions.py,sha256=Bs2sekdDJyw_wrUpG7vZQGH0y0S4C4AbxGSpeU_8C2s,8050 +sympy/vector/tests/test_implicitregion.py,sha256=wVilD5H-MhHiW58QT6P5U7uT79JdKHm9D7JgZoi6BE4,4028 +sympy/vector/tests/test_integrals.py,sha256=BVRhrr_JeAsCKv_E-kA2jaXB8ZXTfj7nkNgT5o-XOJc,5093 +sympy/vector/tests/test_operators.py,sha256=KexUWvc_Nwp2HWrEbhxiO7MeaFxYlckrp__Tkwg-wmU,1613 +sympy/vector/tests/test_parametricregion.py,sha256=OfKapF9A_g9X6JxgYc0UfxIhwXzRERzaj-EijQCJONw,4009 +sympy/vector/tests/test_printing.py,sha256=3BeW55iQ4qXdfDTFqptE2ufJPJIBOzdfIYVx84n_EwA,7708 +sympy/vector/tests/test_vector.py,sha256=Mo88Jgmy3CuSQz25WSH34EnZSs_JBY7E-OKPO2SjhPc,7861 +sympy/vector/vector.py,sha256=pikmeLwkdW_6ed-Xo_U0_a2Om5TGSlfE4PijkRsJllc,17911 diff --git a/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/WHEEL b/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..1f37c02f2eb2e26b306202feaccb31e522b8b169 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.40.0) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/entry_points.txt b/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..42a12f960335556fcee728e5754c346447d4e89c --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/entry_points.txt @@ -0,0 +1,2 @@ +[console_scripts] +isympy = isympy:main diff --git a/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/top_level.txt b/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..0aa85c253508b68bb075f556be3c3f76dc4467ad --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/sympy-1.12.dist-info/top_level.txt @@ -0,0 +1,2 @@ +isympy +sympy diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/__init__.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..471549419627d3fb2a05bbb01ebddb34a740c523 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/__init__.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/__main__.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/__main__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ea3757e55a225ae9979c28117c847e79aeeec965 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/__main__.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_dist_ver.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_dist_ver.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7b4c14009ccebb9acae8cd23daef6b5b2e77a4e6 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_dist_ver.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_main.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_main.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a68b18c499136e9b3f08885093b5b7e9c2767018 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_main.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_monitor.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_monitor.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..581ad587879380b665f1253da3665354db1fdc1b Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_monitor.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_tqdm.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_tqdm.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..01738ef2172e5f523c78164be9284030eb10a91e Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_tqdm.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_tqdm_gui.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_tqdm_gui.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7eb71385149b4ad3d801ac441456f2f51ef0f1d9 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_tqdm_gui.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_tqdm_notebook.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_tqdm_notebook.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..efc187cffa71fcf560aab00c03b59667a27d330a Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_tqdm_notebook.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_tqdm_pandas.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_tqdm_pandas.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6728788810ed5d8001fb2ccd696917c9a2772a64 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_tqdm_pandas.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_utils.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1afa9e86b6c9b9f384a077444f465f3f90f0a01b Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/_utils.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/asyncio.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/asyncio.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e210f134b6423c196b0b320f042ce7bc34ede571 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/asyncio.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/auto.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/auto.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..01801b722eb4d26abbd9b1622de2b97289c806d5 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/auto.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/autonotebook.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/autonotebook.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8186bee34297727cf3a65c7409c710fde89087da Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/autonotebook.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/cli.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/cli.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..197abc3c3057334d74beeaea3394f2c7dd64d2cd Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/cli.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/dask.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/dask.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b73873530f9115a1ad5cc751c494c6cf1b3d39a9 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/dask.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/gui.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/gui.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4bb08e7d4597996915184ded11a68903cd261947 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/gui.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/keras.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/keras.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5853280fed184c79851220262c4e7a8b22ea2aad Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/keras.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/notebook.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/notebook.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4141c708d9ffad5f9ec5afb66934cb65031c36a1 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/notebook.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/rich.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/rich.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a120dbda72ff5d20d9da34148d315710436b8ccb Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/rich.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/std.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/std.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..38d04518b16d7bf83d17c8e389e0f7254ac93109 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/std.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/tk.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/tk.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1b974b0319789316fc997ee082268eb429ac0ca8 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/tk.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/utils.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5ba4fa47893647321348ed6038d4066d75ca3901 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/utils.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/version.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/version.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..91e1142d1001faccc175f8bc01bdc5c19c9bde31 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/__pycache__/version.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/_main.py b/env-llmeval/lib/python3.10/site-packages/tqdm/_main.py new file mode 100644 index 0000000000000000000000000000000000000000..04fdeeff17b5cc84b210f445b54b87d5b99e3748 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/tqdm/_main.py @@ -0,0 +1,9 @@ +from warnings import warn + +from .cli import * # NOQA +from .cli import __all__ # NOQA +from .std import TqdmDeprecationWarning + +warn("This function will be removed in tqdm==5.0.0\n" + "Please use `tqdm.cli.*` instead of `tqdm._main.*`", + TqdmDeprecationWarning, stacklevel=2) diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/_monitor.py b/env-llmeval/lib/python3.10/site-packages/tqdm/_monitor.py new file mode 100644 index 0000000000000000000000000000000000000000..f71aa56817ca77eba5df4a2dd11cb0c4a9a7ea1c --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/tqdm/_monitor.py @@ -0,0 +1,95 @@ +import atexit +from threading import Event, Thread, current_thread +from time import time +from warnings import warn + +__all__ = ["TMonitor", "TqdmSynchronisationWarning"] + + +class TqdmSynchronisationWarning(RuntimeWarning): + """tqdm multi-thread/-process errors which may cause incorrect nesting + but otherwise no adverse effects""" + pass + + +class TMonitor(Thread): + """ + Monitoring thread for tqdm bars. + Monitors if tqdm bars are taking too much time to display + and readjusts miniters automatically if necessary. + + Parameters + ---------- + tqdm_cls : class + tqdm class to use (can be core tqdm or a submodule). + sleep_interval : float + Time to sleep between monitoring checks. + """ + _test = {} # internal vars for unit testing + + def __init__(self, tqdm_cls, sleep_interval): + Thread.__init__(self) + self.daemon = True # kill thread when main killed (KeyboardInterrupt) + self.woken = 0 # last time woken up, to sync with monitor + self.tqdm_cls = tqdm_cls + self.sleep_interval = sleep_interval + self._time = self._test.get("time", time) + self.was_killed = self._test.get("Event", Event)() + atexit.register(self.exit) + self.start() + + def exit(self): + self.was_killed.set() + if self is not current_thread(): + self.join() + return self.report() + + def get_instances(self): + # returns a copy of started `tqdm_cls` instances + return [i for i in self.tqdm_cls._instances.copy() + # Avoid race by checking that the instance started + if hasattr(i, 'start_t')] + + def run(self): + cur_t = self._time() + while True: + # After processing and before sleeping, notify that we woke + # Need to be done just before sleeping + self.woken = cur_t + # Sleep some time... + self.was_killed.wait(self.sleep_interval) + # Quit if killed + if self.was_killed.is_set(): + return + # Then monitor! + # Acquire lock (to access _instances) + with self.tqdm_cls.get_lock(): + cur_t = self._time() + # Check tqdm instances are waiting too long to print + instances = self.get_instances() + for instance in instances: + # Check event in loop to reduce blocking time on exit + if self.was_killed.is_set(): + return + # Only if mininterval > 1 (else iterations are just slow) + # and last refresh exceeded maxinterval + if ( + instance.miniters > 1 + and (cur_t - instance.last_print_t) >= instance.maxinterval + ): + # force bypassing miniters on next iteration + # (dynamic_miniters adjusts mininterval automatically) + instance.miniters = 1 + # Refresh now! (works only for manual tqdm) + instance.refresh(nolock=True) + # Remove accidental long-lived strong reference + del instance + if instances != self.get_instances(): # pragma: nocover + warn("Set changed size during iteration" + + " (see https://github.com/tqdm/tqdm/issues/481)", + TqdmSynchronisationWarning, stacklevel=2) + # Remove accidental long-lived strong references + del instances + + def report(self): + return not self.was_killed.is_set() diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/_tqdm_pandas.py b/env-llmeval/lib/python3.10/site-packages/tqdm/_tqdm_pandas.py new file mode 100644 index 0000000000000000000000000000000000000000..c4fe6efdc603579e7f8acfa27ac10dccdf3e94ce --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/tqdm/_tqdm_pandas.py @@ -0,0 +1,24 @@ +import sys + +__author__ = "github.com/casperdcl" +__all__ = ['tqdm_pandas'] + + +def tqdm_pandas(tclass, **tqdm_kwargs): + """ + Registers the given `tqdm` instance with + `pandas.core.groupby.DataFrameGroupBy.progress_apply`. + """ + from tqdm import TqdmDeprecationWarning + + if isinstance(tclass, type) or (getattr(tclass, '__name__', '').startswith( + 'tqdm_')): # delayed adapter case + TqdmDeprecationWarning( + "Please use `tqdm.pandas(...)` instead of `tqdm_pandas(tqdm, ...)`.", + fp_write=getattr(tqdm_kwargs.get('file', None), 'write', sys.stderr.write)) + tclass.pandas(**tqdm_kwargs) + else: + TqdmDeprecationWarning( + "Please use `tqdm.pandas(...)` instead of `tqdm_pandas(tqdm(...))`.", + fp_write=getattr(tclass.fp, 'write', sys.stderr.write)) + type(tclass).pandas(deprecated_t=tclass) diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/asyncio.py b/env-llmeval/lib/python3.10/site-packages/tqdm/asyncio.py new file mode 100644 index 0000000000000000000000000000000000000000..ddc89b8539a4628bc527976dc3f07f813950d44f --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/tqdm/asyncio.py @@ -0,0 +1,93 @@ +""" +Asynchronous progressbar decorator for iterators. +Includes a default `range` iterator printing to `stderr`. + +Usage: +>>> from tqdm.asyncio import trange, tqdm +>>> async for i in trange(10): +... ... +""" +import asyncio +from sys import version_info + +from .std import tqdm as std_tqdm + +__author__ = {"github.com/": ["casperdcl"]} +__all__ = ['tqdm_asyncio', 'tarange', 'tqdm', 'trange'] + + +class tqdm_asyncio(std_tqdm): + """ + Asynchronous-friendly version of tqdm. + """ + def __init__(self, iterable=None, *args, **kwargs): + super(tqdm_asyncio, self).__init__(iterable, *args, **kwargs) + self.iterable_awaitable = False + if iterable is not None: + if hasattr(iterable, "__anext__"): + self.iterable_next = iterable.__anext__ + self.iterable_awaitable = True + elif hasattr(iterable, "__next__"): + self.iterable_next = iterable.__next__ + else: + self.iterable_iterator = iter(iterable) + self.iterable_next = self.iterable_iterator.__next__ + + def __aiter__(self): + return self + + async def __anext__(self): + try: + if self.iterable_awaitable: + res = await self.iterable_next() + else: + res = self.iterable_next() + self.update() + return res + except StopIteration: + self.close() + raise StopAsyncIteration + except BaseException: + self.close() + raise + + def send(self, *args, **kwargs): + return self.iterable.send(*args, **kwargs) + + @classmethod + def as_completed(cls, fs, *, loop=None, timeout=None, total=None, **tqdm_kwargs): + """ + Wrapper for `asyncio.as_completed`. + """ + if total is None: + total = len(fs) + kwargs = {} + if version_info[:2] < (3, 10): + kwargs['loop'] = loop + yield from cls(asyncio.as_completed(fs, timeout=timeout, **kwargs), + total=total, **tqdm_kwargs) + + @classmethod + async def gather(cls, *fs, loop=None, timeout=None, total=None, **tqdm_kwargs): + """ + Wrapper for `asyncio.gather`. + """ + async def wrap_awaitable(i, f): + return i, await f + + ifs = [wrap_awaitable(i, f) for i, f in enumerate(fs)] + res = [await f for f in cls.as_completed(ifs, loop=loop, timeout=timeout, + total=total, **tqdm_kwargs)] + return [i for _, i in sorted(res)] + + +def tarange(*args, **kwargs): + """ + A shortcut for `tqdm.asyncio.tqdm(range(*args), **kwargs)`. + """ + return tqdm_asyncio(range(*args), **kwargs) + + +# Aliases +tqdm = tqdm_asyncio +trange = tarange diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/auto.py b/env-llmeval/lib/python3.10/site-packages/tqdm/auto.py new file mode 100644 index 0000000000000000000000000000000000000000..206c4409d5269594bdbab3a092ef6e09e7c01947 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/tqdm/auto.py @@ -0,0 +1,40 @@ +""" +Enables multiple commonly used features. + +Method resolution order: + +- `tqdm.autonotebook` without import warnings +- `tqdm.asyncio` +- `tqdm.std` base class + +Usage: +>>> from tqdm.auto import trange, tqdm +>>> for i in trange(10): +... ... +""" +import warnings + +from .std import TqdmExperimentalWarning + +with warnings.catch_warnings(): + warnings.simplefilter("ignore", category=TqdmExperimentalWarning) + from .autonotebook import tqdm as notebook_tqdm + +from .asyncio import tqdm as asyncio_tqdm +from .std import tqdm as std_tqdm + +if notebook_tqdm != std_tqdm: + class tqdm(notebook_tqdm, asyncio_tqdm): # pylint: disable=inconsistent-mro + pass +else: + tqdm = asyncio_tqdm + + +def trange(*args, **kwargs): + """ + A shortcut for `tqdm.auto.tqdm(range(*args), **kwargs)`. + """ + return tqdm(range(*args), **kwargs) + + +__all__ = ["tqdm", "trange"] diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/cli.py b/env-llmeval/lib/python3.10/site-packages/tqdm/cli.py new file mode 100644 index 0000000000000000000000000000000000000000..1223d4977a737a249203bba6579f87558fb3e7b7 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/tqdm/cli.py @@ -0,0 +1,311 @@ +""" +Module version for monitoring CLI pipes (`... | python -m tqdm | ...`). +""" +import logging +import re +import sys +from ast import literal_eval as numeric + +from .std import TqdmKeyError, TqdmTypeError, tqdm +from .version import __version__ + +__all__ = ["main"] +log = logging.getLogger(__name__) + + +def cast(val, typ): + log.debug((val, typ)) + if " or " in typ: + for t in typ.split(" or "): + try: + return cast(val, t) + except TqdmTypeError: + pass + raise TqdmTypeError(val + ' : ' + typ) + + # sys.stderr.write('\ndebug | `val:type`: `' + val + ':' + typ + '`.\n') + if typ == 'bool': + if (val == 'True') or (val == ''): + return True + elif val == 'False': + return False + else: + raise TqdmTypeError(val + ' : ' + typ) + try: + return eval(typ + '("' + val + '")') + except Exception: + if typ == 'chr': + return chr(ord(eval('"' + val + '"'))).encode() + else: + raise TqdmTypeError(val + ' : ' + typ) + + +def posix_pipe(fin, fout, delim=b'\\n', buf_size=256, + callback=lambda float: None, callback_len=True): + """ + Params + ------ + fin : binary file with `read(buf_size : int)` method + fout : binary file with `write` (and optionally `flush`) methods. + callback : function(float), e.g.: `tqdm.update` + callback_len : If (default: True) do `callback(len(buffer))`. + Otherwise, do `callback(data) for data in buffer.split(delim)`. + """ + fp_write = fout.write + + if not delim: + while True: + tmp = fin.read(buf_size) + + # flush at EOF + if not tmp: + getattr(fout, 'flush', lambda: None)() + return + + fp_write(tmp) + callback(len(tmp)) + # return + + buf = b'' + len_delim = len(delim) + # n = 0 + while True: + tmp = fin.read(buf_size) + + # flush at EOF + if not tmp: + if buf: + fp_write(buf) + if callback_len: + # n += 1 + buf.count(delim) + callback(1 + buf.count(delim)) + else: + for i in buf.split(delim): + callback(i) + getattr(fout, 'flush', lambda: None)() + return # n + + while True: + i = tmp.find(delim) + if i < 0: + buf += tmp + break + fp_write(buf + tmp[:i + len(delim)]) + # n += 1 + callback(1 if callback_len else (buf + tmp[:i])) + buf = b'' + tmp = tmp[i + len_delim:] + + +# ((opt, type), ... ) +RE_OPTS = re.compile(r'\n {4}(\S+)\s{2,}:\s*([^,]+)') +# better split method assuming no positional args +RE_SHLEX = re.compile(r'\s*(? : \2', d) + split = RE_OPTS.split(d) + opt_types_desc = zip(split[1::3], split[2::3], split[3::3]) + d = ''.join(('\n --{0} : {2}{3}' if otd[1] == 'bool' else + '\n --{0}=<{1}> : {2}{3}').format( + otd[0].replace('_', '-'), otd[0], *otd[1:]) + for otd in opt_types_desc if otd[0] not in UNSUPPORTED_OPTS) + + help_short = "Usage:\n tqdm [--help | options]\n" + d = help_short + """ +Options: + -h, --help Print this help and exit. + -v, --version Print version and exit. +""" + d.strip('\n') + '\n' + + # opts = docopt(d, version=__version__) + if any(v in argv for v in ('-v', '--version')): + sys.stdout.write(__version__ + '\n') + sys.exit(0) + elif any(v in argv for v in ('-h', '--help')): + sys.stdout.write(d + '\n') + sys.exit(0) + elif argv and argv[0][:2] != '--': + sys.stderr.write(f"Error:Unknown argument:{argv[0]}\n{help_short}") + + argv = RE_SHLEX.split(' '.join(["tqdm"] + argv)) + opts = dict(zip(argv[1::3], argv[3::3])) + + log.debug(opts) + opts.pop('log', True) + + tqdm_args = {'file': fp} + try: + for (o, v) in opts.items(): + o = o.replace('-', '_') + try: + tqdm_args[o] = cast(v, opt_types[o]) + except KeyError as e: + raise TqdmKeyError(str(e)) + log.debug('args:' + str(tqdm_args)) + + delim_per_char = tqdm_args.pop('bytes', False) + update = tqdm_args.pop('update', False) + update_to = tqdm_args.pop('update_to', False) + if sum((delim_per_char, update, update_to)) > 1: + raise TqdmKeyError("Can only have one of --bytes --update --update_to") + except Exception: + fp.write("\nError:\n" + help_short) + stdin, stdout_write = sys.stdin, sys.stdout.write + for i in stdin: + stdout_write(i) + raise + else: + buf_size = tqdm_args.pop('buf_size', 256) + delim = tqdm_args.pop('delim', b'\\n') + tee = tqdm_args.pop('tee', False) + manpath = tqdm_args.pop('manpath', None) + comppath = tqdm_args.pop('comppath', None) + if tqdm_args.pop('null', False): + class stdout(object): + @staticmethod + def write(_): + pass + else: + stdout = sys.stdout + stdout = getattr(stdout, 'buffer', stdout) + stdin = getattr(sys.stdin, 'buffer', sys.stdin) + if manpath or comppath: + from importlib import resources + from os import path + from shutil import copyfile + + def cp(name, dst): + """copy resource `name` to `dst`""" + if hasattr(resources, 'files'): + copyfile(str(resources.files('tqdm') / name), dst) + else: # py<3.9 + with resources.path('tqdm', name) as src: + copyfile(str(src), dst) + log.info("written:%s", dst) + if manpath is not None: + cp('tqdm.1', path.join(manpath, 'tqdm.1')) + if comppath is not None: + cp('completion.sh', path.join(comppath, 'tqdm_completion.sh')) + sys.exit(0) + if tee: + stdout_write = stdout.write + fp_write = getattr(fp, 'buffer', fp).write + + class stdout(object): # pylint: disable=function-redefined + @staticmethod + def write(x): + with tqdm.external_write_mode(file=fp): + fp_write(x) + stdout_write(x) + if delim_per_char: + tqdm_args.setdefault('unit', 'B') + tqdm_args.setdefault('unit_scale', True) + tqdm_args.setdefault('unit_divisor', 1024) + log.debug(tqdm_args) + with tqdm(**tqdm_args) as t: + posix_pipe(stdin, stdout, '', buf_size, t.update) + elif delim == b'\\n': + log.debug(tqdm_args) + write = stdout.write + if update or update_to: + with tqdm(**tqdm_args) as t: + if update: + def callback(i): + t.update(numeric(i.decode())) + else: # update_to + def callback(i): + t.update(numeric(i.decode()) - t.n) + for i in stdin: + write(i) + callback(i) + else: + for i in tqdm(stdin, **tqdm_args): + write(i) + else: + log.debug(tqdm_args) + with tqdm(**tqdm_args) as t: + callback_len = False + if update: + def callback(i): + t.update(numeric(i.decode())) + elif update_to: + def callback(i): + t.update(numeric(i.decode()) - t.n) + else: + callback = t.update + callback_len = True + posix_pipe(stdin, stdout, delim, buf_size, callback, callback_len) diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/completion.sh b/env-llmeval/lib/python3.10/site-packages/tqdm/completion.sh new file mode 100644 index 0000000000000000000000000000000000000000..9f61c7f14bb8c1f6099b9eb75dce28ece6a7ae96 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/tqdm/completion.sh @@ -0,0 +1,19 @@ +#!/usr/bin/env bash +_tqdm(){ + local cur prv + cur="${COMP_WORDS[COMP_CWORD]}" + prv="${COMP_WORDS[COMP_CWORD - 1]}" + + case ${prv} in + --bar_format|--buf_size|--colour|--comppath|--delay|--delim|--desc|--initial|--lock_args|--manpath|--maxinterval|--mininterval|--miniters|--ncols|--nrows|--position|--postfix|--smoothing|--total|--unit|--unit_divisor) + # await user input + ;; + "--log") + COMPREPLY=($(compgen -W 'CRITICAL FATAL ERROR WARN WARNING INFO DEBUG NOTSET' -- ${cur})) + ;; + *) + COMPREPLY=($(compgen -W '--ascii --bar_format --buf_size --bytes --colour --comppath --delay --delim --desc --disable --dynamic_ncols --help --initial --leave --lock_args --log --manpath --maxinterval --mininterval --miniters --ncols --nrows --null --position --postfix --smoothing --tee --total --unit --unit_divisor --unit_scale --update --update_to --version --write_bytes -h -v' -- ${cur})) + ;; + esac +} +complete -F _tqdm tqdm diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__init__.py b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7338c960a44c4d0c3a56c370ce3b398b255cd0cb --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__init__.py @@ -0,0 +1,92 @@ +""" +Thin wrappers around common functions. + +Subpackages contain potentially unstable extensions. +""" +from warnings import warn + +from ..auto import tqdm as tqdm_auto +from ..std import TqdmDeprecationWarning, tqdm +from ..utils import ObjectWrapper + +__author__ = {"github.com/": ["casperdcl"]} +__all__ = ['tenumerate', 'tzip', 'tmap'] + + +class DummyTqdmFile(ObjectWrapper): + """Dummy file-like that will write to tqdm""" + + def __init__(self, wrapped): + super(DummyTqdmFile, self).__init__(wrapped) + self._buf = [] + + def write(self, x, nolock=False): + nl = b"\n" if isinstance(x, bytes) else "\n" + pre, sep, post = x.rpartition(nl) + if sep: + blank = type(nl)() + tqdm.write(blank.join(self._buf + [pre, sep]), + end=blank, file=self._wrapped, nolock=nolock) + self._buf = [post] + else: + self._buf.append(x) + + def __del__(self): + if self._buf: + blank = type(self._buf[0])() + try: + tqdm.write(blank.join(self._buf), end=blank, file=self._wrapped) + except (OSError, ValueError): + pass + + +def builtin_iterable(func): + """Returns `func`""" + warn("This function has no effect, and will be removed in tqdm==5.0.0", + TqdmDeprecationWarning, stacklevel=2) + return func + + +def tenumerate(iterable, start=0, total=None, tqdm_class=tqdm_auto, **tqdm_kwargs): + """ + Equivalent of `numpy.ndenumerate` or builtin `enumerate`. + + Parameters + ---------- + tqdm_class : [default: tqdm.auto.tqdm]. + """ + try: + import numpy as np + except ImportError: + pass + else: + if isinstance(iterable, np.ndarray): + return tqdm_class(np.ndenumerate(iterable), total=total or iterable.size, + **tqdm_kwargs) + return enumerate(tqdm_class(iterable, total=total, **tqdm_kwargs), start) + + +def tzip(iter1, *iter2plus, **tqdm_kwargs): + """ + Equivalent of builtin `zip`. + + Parameters + ---------- + tqdm_class : [default: tqdm.auto.tqdm]. + """ + kwargs = tqdm_kwargs.copy() + tqdm_class = kwargs.pop("tqdm_class", tqdm_auto) + for i in zip(tqdm_class(iter1, **kwargs), *iter2plus): + yield i + + +def tmap(function, *sequences, **tqdm_kwargs): + """ + Equivalent of builtin `map`. + + Parameters + ---------- + tqdm_class : [default: tqdm.auto.tqdm]. + """ + for i in tzip(*sequences, **tqdm_kwargs): + yield function(*i) diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/__init__.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b00e64c3e87c8de0a11837670db6055bcbd862e4 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/__init__.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/bells.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/bells.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..63cd7894774983b84fcd3cc1a53903ae93239b17 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/bells.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/concurrent.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/concurrent.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3a0aa751a083f6d662ea0e879bf231b072a82c60 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/concurrent.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/discord.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/discord.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a2ce9b252a4d3befbb1e821de5373cf204b5628f Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/discord.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/itertools.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/itertools.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bfae22c8205788463e1ada67cbf61234e4fe87ed Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/itertools.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/logging.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/logging.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5aa18741b006714c16fb56b8f6ad8d235091602a Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/logging.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/slack.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/slack.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..34419600d977c999d927ce8a38febf0ff3d4389d Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/slack.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/telegram.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/telegram.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e9d8e7f78081726ba6f9c769418fb6f0e73557ba Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/telegram.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/utils_worker.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/utils_worker.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a6a56882777fbb1398856e03bb6d096e08982f67 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/__pycache__/utils_worker.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/bells.py b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/bells.py new file mode 100644 index 0000000000000000000000000000000000000000..5b8f4b9ecd894f1edfaa08d9fe730b8d7c8b93e0 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/bells.py @@ -0,0 +1,26 @@ +""" +Even more features than `tqdm.auto` (all the bells & whistles): + +- `tqdm.auto` +- `tqdm.tqdm.pandas` +- `tqdm.contrib.telegram` + + uses `${TQDM_TELEGRAM_TOKEN}` and `${TQDM_TELEGRAM_CHAT_ID}` +- `tqdm.contrib.discord` + + uses `${TQDM_DISCORD_TOKEN}` and `${TQDM_DISCORD_CHANNEL_ID}` +""" +__all__ = ['tqdm', 'trange'] +import warnings +from os import getenv + +if getenv("TQDM_SLACK_TOKEN") and getenv("TQDM_SLACK_CHANNEL"): + from .slack import tqdm, trange +elif getenv("TQDM_TELEGRAM_TOKEN") and getenv("TQDM_TELEGRAM_CHAT_ID"): + from .telegram import tqdm, trange +elif getenv("TQDM_DISCORD_TOKEN") and getenv("TQDM_DISCORD_CHANNEL_ID"): + from .discord import tqdm, trange +else: + from ..auto import tqdm, trange + +with warnings.catch_warnings(): + warnings.simplefilter("ignore", category=FutureWarning) + tqdm.pandas() diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/concurrent.py b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/concurrent.py new file mode 100644 index 0000000000000000000000000000000000000000..cd81d622a1309df179042159a56cef4f8c309224 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/concurrent.py @@ -0,0 +1,105 @@ +""" +Thin wrappers around `concurrent.futures`. +""" +from contextlib import contextmanager +from operator import length_hint +from os import cpu_count + +from ..auto import tqdm as tqdm_auto +from ..std import TqdmWarning + +__author__ = {"github.com/": ["casperdcl"]} +__all__ = ['thread_map', 'process_map'] + + +@contextmanager +def ensure_lock(tqdm_class, lock_name=""): + """get (create if necessary) and then restore `tqdm_class`'s lock""" + old_lock = getattr(tqdm_class, '_lock', None) # don't create a new lock + lock = old_lock or tqdm_class.get_lock() # maybe create a new lock + lock = getattr(lock, lock_name, lock) # maybe subtype + tqdm_class.set_lock(lock) + yield lock + if old_lock is None: + del tqdm_class._lock + else: + tqdm_class.set_lock(old_lock) + + +def _executor_map(PoolExecutor, fn, *iterables, **tqdm_kwargs): + """ + Implementation of `thread_map` and `process_map`. + + Parameters + ---------- + tqdm_class : [default: tqdm.auto.tqdm]. + max_workers : [default: min(32, cpu_count() + 4)]. + chunksize : [default: 1]. + lock_name : [default: "":str]. + """ + kwargs = tqdm_kwargs.copy() + if "total" not in kwargs: + kwargs["total"] = length_hint(iterables[0]) + tqdm_class = kwargs.pop("tqdm_class", tqdm_auto) + max_workers = kwargs.pop("max_workers", min(32, cpu_count() + 4)) + chunksize = kwargs.pop("chunksize", 1) + lock_name = kwargs.pop("lock_name", "") + with ensure_lock(tqdm_class, lock_name=lock_name) as lk: + # share lock in case workers are already using `tqdm` + with PoolExecutor(max_workers=max_workers, initializer=tqdm_class.set_lock, + initargs=(lk,)) as ex: + return list(tqdm_class(ex.map(fn, *iterables, chunksize=chunksize), **kwargs)) + + +def thread_map(fn, *iterables, **tqdm_kwargs): + """ + Equivalent of `list(map(fn, *iterables))` + driven by `concurrent.futures.ThreadPoolExecutor`. + + Parameters + ---------- + tqdm_class : optional + `tqdm` class to use for bars [default: tqdm.auto.tqdm]. + max_workers : int, optional + Maximum number of workers to spawn; passed to + `concurrent.futures.ThreadPoolExecutor.__init__`. + [default: max(32, cpu_count() + 4)]. + """ + from concurrent.futures import ThreadPoolExecutor + return _executor_map(ThreadPoolExecutor, fn, *iterables, **tqdm_kwargs) + + +def process_map(fn, *iterables, **tqdm_kwargs): + """ + Equivalent of `list(map(fn, *iterables))` + driven by `concurrent.futures.ProcessPoolExecutor`. + + Parameters + ---------- + tqdm_class : optional + `tqdm` class to use for bars [default: tqdm.auto.tqdm]. + max_workers : int, optional + Maximum number of workers to spawn; passed to + `concurrent.futures.ProcessPoolExecutor.__init__`. + [default: min(32, cpu_count() + 4)]. + chunksize : int, optional + Size of chunks sent to worker processes; passed to + `concurrent.futures.ProcessPoolExecutor.map`. [default: 1]. + lock_name : str, optional + Member of `tqdm_class.get_lock()` to use [default: mp_lock]. + """ + from concurrent.futures import ProcessPoolExecutor + if iterables and "chunksize" not in tqdm_kwargs: + # default `chunksize=1` has poor performance for large iterables + # (most time spent dispatching items to workers). + longest_iterable_len = max(map(length_hint, iterables)) + if longest_iterable_len > 1000: + from warnings import warn + warn("Iterable length %d > 1000 but `chunksize` is not set." + " This may seriously degrade multiprocess performance." + " Set `chunksize=1` or more." % longest_iterable_len, + TqdmWarning, stacklevel=2) + if "lock_name" not in tqdm_kwargs: + tqdm_kwargs = tqdm_kwargs.copy() + tqdm_kwargs["lock_name"] = "mp_lock" + return _executor_map(ProcessPoolExecutor, fn, *iterables, **tqdm_kwargs) diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/discord.py b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/discord.py new file mode 100644 index 0000000000000000000000000000000000000000..1e413082895f1de0b5a9dc510d4f0746455c1fc5 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/discord.py @@ -0,0 +1,119 @@ +""" +Sends updates to a Discord bot. + +Usage: +>>> from tqdm.contrib.discord import tqdm, trange +>>> for i in trange(10, token='{token}', channel_id='{channel_id}'): +... ... + +![screenshot](https://tqdm.github.io/img/screenshot-discord.png) +""" +import logging +from os import getenv + +try: + from disco.client import Client, ClientConfig +except ImportError: + raise ImportError("Please `pip install disco-py`") + +from ..auto import tqdm as tqdm_auto +from .utils_worker import MonoWorker + +__author__ = {"github.com/": ["casperdcl"]} +__all__ = ['DiscordIO', 'tqdm_discord', 'tdrange', 'tqdm', 'trange'] + + +class DiscordIO(MonoWorker): + """Non-blocking file-like IO using a Discord Bot.""" + def __init__(self, token, channel_id): + """Creates a new message in the given `channel_id`.""" + super(DiscordIO, self).__init__() + config = ClientConfig() + config.token = token + client = Client(config) + self.text = self.__class__.__name__ + try: + self.message = client.api.channels_messages_create(channel_id, self.text) + except Exception as e: + tqdm_auto.write(str(e)) + self.message = None + + def write(self, s): + """Replaces internal `message`'s text with `s`.""" + if not s: + s = "..." + s = s.replace('\r', '').strip() + if s == self.text: + return # skip duplicate message + message = self.message + if message is None: + return + self.text = s + try: + future = self.submit(message.edit, '`' + s + '`') + except Exception as e: + tqdm_auto.write(str(e)) + else: + return future + + +class tqdm_discord(tqdm_auto): + """ + Standard `tqdm.auto.tqdm` but also sends updates to a Discord Bot. + May take a few seconds to create (`__init__`). + + - create a discord bot (not public, no requirement of OAuth2 code + grant, only send message permissions) & invite it to a channel: + + - copy the bot `{token}` & `{channel_id}` and paste below + + >>> from tqdm.contrib.discord import tqdm, trange + >>> for i in tqdm(iterable, token='{token}', channel_id='{channel_id}'): + ... ... + """ + def __init__(self, *args, **kwargs): + """ + Parameters + ---------- + token : str, required. Discord token + [default: ${TQDM_DISCORD_TOKEN}]. + channel_id : int, required. Discord channel ID + [default: ${TQDM_DISCORD_CHANNEL_ID}]. + mininterval : float, optional. + Minimum of [default: 1.5] to avoid rate limit. + + See `tqdm.auto.tqdm.__init__` for other parameters. + """ + if not kwargs.get('disable'): + kwargs = kwargs.copy() + logging.getLogger("HTTPClient").setLevel(logging.WARNING) + self.dio = DiscordIO( + kwargs.pop('token', getenv("TQDM_DISCORD_TOKEN")), + kwargs.pop('channel_id', getenv("TQDM_DISCORD_CHANNEL_ID"))) + kwargs['mininterval'] = max(1.5, kwargs.get('mininterval', 1.5)) + super(tqdm_discord, self).__init__(*args, **kwargs) + + def display(self, **kwargs): + super(tqdm_discord, self).display(**kwargs) + fmt = self.format_dict + if fmt.get('bar_format', None): + fmt['bar_format'] = fmt['bar_format'].replace( + '', '{bar:10u}').replace('{bar}', '{bar:10u}') + else: + fmt['bar_format'] = '{l_bar}{bar:10u}{r_bar}' + self.dio.write(self.format_meter(**fmt)) + + def clear(self, *args, **kwargs): + super(tqdm_discord, self).clear(*args, **kwargs) + if not self.disable: + self.dio.write("") + + +def tdrange(*args, **kwargs): + """Shortcut for `tqdm.contrib.discord.tqdm(range(*args), **kwargs)`.""" + return tqdm_discord(range(*args), **kwargs) + + +# Aliases +tqdm = tqdm_discord +trange = tdrange diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/itertools.py b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/itertools.py new file mode 100644 index 0000000000000000000000000000000000000000..e67651a41a6b8760d9b928ea48239e4611d70315 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/itertools.py @@ -0,0 +1,35 @@ +""" +Thin wrappers around `itertools`. +""" +import itertools + +from ..auto import tqdm as tqdm_auto + +__author__ = {"github.com/": ["casperdcl"]} +__all__ = ['product'] + + +def product(*iterables, **tqdm_kwargs): + """ + Equivalent of `itertools.product`. + + Parameters + ---------- + tqdm_class : [default: tqdm.auto.tqdm]. + """ + kwargs = tqdm_kwargs.copy() + tqdm_class = kwargs.pop("tqdm_class", tqdm_auto) + try: + lens = list(map(len, iterables)) + except TypeError: + total = None + else: + total = 1 + for i in lens: + total *= i + kwargs.setdefault("total", total) + with tqdm_class(**kwargs) as t: + it = itertools.product(*iterables) + for i in it: + yield i + t.update() diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/logging.py b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/logging.py new file mode 100644 index 0000000000000000000000000000000000000000..b8eaec53f16c0e63f174aef4d2a4da49ebdf0b30 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/logging.py @@ -0,0 +1,126 @@ +""" +Helper functionality for interoperability with stdlib `logging`. +""" +import logging +import sys +from contextlib import contextmanager + +try: + from typing import Iterator, List, Optional, Type # noqa: F401 +except ImportError: + pass + +from ..std import tqdm as std_tqdm + + +class _TqdmLoggingHandler(logging.StreamHandler): + def __init__( + self, + tqdm_class=std_tqdm # type: Type[std_tqdm] + ): + super(_TqdmLoggingHandler, self).__init__() + self.tqdm_class = tqdm_class + + def emit(self, record): + try: + msg = self.format(record) + self.tqdm_class.write(msg, file=self.stream) + self.flush() + except (KeyboardInterrupt, SystemExit): + raise + except: # noqa pylint: disable=bare-except + self.handleError(record) + + +def _is_console_logging_handler(handler): + return (isinstance(handler, logging.StreamHandler) + and handler.stream in {sys.stdout, sys.stderr}) + + +def _get_first_found_console_logging_handler(handlers): + for handler in handlers: + if _is_console_logging_handler(handler): + return handler + + +@contextmanager +def logging_redirect_tqdm( + loggers=None, # type: Optional[List[logging.Logger]], + tqdm_class=std_tqdm # type: Type[std_tqdm] +): + # type: (...) -> Iterator[None] + """ + Context manager redirecting console logging to `tqdm.write()`, leaving + other logging handlers (e.g. log files) unaffected. + + Parameters + ---------- + loggers : list, optional + Which handlers to redirect (default: [logging.root]). + tqdm_class : optional + + Example + ------- + ```python + import logging + from tqdm import trange + from tqdm.contrib.logging import logging_redirect_tqdm + + LOG = logging.getLogger(__name__) + + if __name__ == '__main__': + logging.basicConfig(level=logging.INFO) + with logging_redirect_tqdm(): + for i in trange(9): + if i == 4: + LOG.info("console logging redirected to `tqdm.write()`") + # logging restored + ``` + """ + if loggers is None: + loggers = [logging.root] + original_handlers_list = [logger.handlers for logger in loggers] + try: + for logger in loggers: + tqdm_handler = _TqdmLoggingHandler(tqdm_class) + orig_handler = _get_first_found_console_logging_handler(logger.handlers) + if orig_handler is not None: + tqdm_handler.setFormatter(orig_handler.formatter) + tqdm_handler.stream = orig_handler.stream + logger.handlers = [ + handler for handler in logger.handlers + if not _is_console_logging_handler(handler)] + [tqdm_handler] + yield + finally: + for logger, original_handlers in zip(loggers, original_handlers_list): + logger.handlers = original_handlers + + +@contextmanager +def tqdm_logging_redirect( + *args, + # loggers=None, # type: Optional[List[logging.Logger]] + # tqdm=None, # type: Optional[Type[tqdm.tqdm]] + **kwargs +): + # type: (...) -> Iterator[None] + """ + Convenience shortcut for: + ```python + with tqdm_class(*args, **tqdm_kwargs) as pbar: + with logging_redirect_tqdm(loggers=loggers, tqdm_class=tqdm_class): + yield pbar + ``` + + Parameters + ---------- + tqdm_class : optional, (default: tqdm.std.tqdm). + loggers : optional, list. + **tqdm_kwargs : passed to `tqdm_class`. + """ + tqdm_kwargs = kwargs.copy() + loggers = tqdm_kwargs.pop('loggers', None) + tqdm_class = tqdm_kwargs.pop('tqdm_class', std_tqdm) + with tqdm_class(*args, **tqdm_kwargs) as pbar: + with logging_redirect_tqdm(loggers=loggers, tqdm_class=tqdm_class): + yield pbar diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/slack.py b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/slack.py new file mode 100644 index 0000000000000000000000000000000000000000..d4c850ca403c2337d50bdc0acaad6ba7d9c39666 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/slack.py @@ -0,0 +1,120 @@ +""" +Sends updates to a Slack app. + +Usage: +>>> from tqdm.contrib.slack import tqdm, trange +>>> for i in trange(10, token='{token}', channel='{channel}'): +... ... + +![screenshot](https://tqdm.github.io/img/screenshot-slack.png) +""" +import logging +from os import getenv + +try: + from slack_sdk import WebClient +except ImportError: + raise ImportError("Please `pip install slack-sdk`") + +from ..auto import tqdm as tqdm_auto +from .utils_worker import MonoWorker + +__author__ = {"github.com/": ["0x2b3bfa0", "casperdcl"]} +__all__ = ['SlackIO', 'tqdm_slack', 'tsrange', 'tqdm', 'trange'] + + +class SlackIO(MonoWorker): + """Non-blocking file-like IO using a Slack app.""" + def __init__(self, token, channel): + """Creates a new message in the given `channel`.""" + super(SlackIO, self).__init__() + self.client = WebClient(token=token) + self.text = self.__class__.__name__ + try: + self.message = self.client.chat_postMessage(channel=channel, text=self.text) + except Exception as e: + tqdm_auto.write(str(e)) + self.message = None + + def write(self, s): + """Replaces internal `message`'s text with `s`.""" + if not s: + s = "..." + s = s.replace('\r', '').strip() + if s == self.text: + return # skip duplicate message + message = self.message + if message is None: + return + self.text = s + try: + future = self.submit(self.client.chat_update, channel=message['channel'], + ts=message['ts'], text='`' + s + '`') + except Exception as e: + tqdm_auto.write(str(e)) + else: + return future + + +class tqdm_slack(tqdm_auto): + """ + Standard `tqdm.auto.tqdm` but also sends updates to a Slack app. + May take a few seconds to create (`__init__`). + + - create a Slack app with the `chat:write` scope & invite it to a + channel: + - copy the bot `{token}` & `{channel}` and paste below + >>> from tqdm.contrib.slack import tqdm, trange + >>> for i in tqdm(iterable, token='{token}', channel='{channel}'): + ... ... + """ + def __init__(self, *args, **kwargs): + """ + Parameters + ---------- + token : str, required. Slack token + [default: ${TQDM_SLACK_TOKEN}]. + channel : int, required. Slack channel + [default: ${TQDM_SLACK_CHANNEL}]. + mininterval : float, optional. + Minimum of [default: 1.5] to avoid rate limit. + + See `tqdm.auto.tqdm.__init__` for other parameters. + """ + if not kwargs.get('disable'): + kwargs = kwargs.copy() + logging.getLogger("HTTPClient").setLevel(logging.WARNING) + self.sio = SlackIO( + kwargs.pop('token', getenv("TQDM_SLACK_TOKEN")), + kwargs.pop('channel', getenv("TQDM_SLACK_CHANNEL"))) + kwargs['mininterval'] = max(1.5, kwargs.get('mininterval', 1.5)) + super(tqdm_slack, self).__init__(*args, **kwargs) + + def display(self, **kwargs): + super(tqdm_slack, self).display(**kwargs) + fmt = self.format_dict + if fmt.get('bar_format', None): + fmt['bar_format'] = fmt['bar_format'].replace( + '', '`{bar:10}`').replace('{bar}', '`{bar:10u}`') + else: + fmt['bar_format'] = '{l_bar}`{bar:10}`{r_bar}' + if fmt['ascii'] is False: + fmt['ascii'] = [":black_square:", ":small_blue_diamond:", ":large_blue_diamond:", + ":large_blue_square:"] + fmt['ncols'] = 336 + self.sio.write(self.format_meter(**fmt)) + + def clear(self, *args, **kwargs): + super(tqdm_slack, self).clear(*args, **kwargs) + if not self.disable: + self.sio.write("") + + +def tsrange(*args, **kwargs): + """Shortcut for `tqdm.contrib.slack.tqdm(range(*args), **kwargs)`.""" + return tqdm_slack(range(*args), **kwargs) + + +# Aliases +tqdm = tqdm_slack +trange = tsrange diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/telegram.py b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/telegram.py new file mode 100644 index 0000000000000000000000000000000000000000..cbeadf20f1e83e8fde9d79cd4fa2d36a77ecdb5a --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/telegram.py @@ -0,0 +1,153 @@ +""" +Sends updates to a Telegram bot. + +Usage: +>>> from tqdm.contrib.telegram import tqdm, trange +>>> for i in trange(10, token='{token}', chat_id='{chat_id}'): +... ... + +![screenshot](https://tqdm.github.io/img/screenshot-telegram.gif) +""" +from os import getenv +from warnings import warn + +from requests import Session + +from ..auto import tqdm as tqdm_auto +from ..std import TqdmWarning +from .utils_worker import MonoWorker + +__author__ = {"github.com/": ["casperdcl"]} +__all__ = ['TelegramIO', 'tqdm_telegram', 'ttgrange', 'tqdm', 'trange'] + + +class TelegramIO(MonoWorker): + """Non-blocking file-like IO using a Telegram Bot.""" + API = 'https://api.telegram.org/bot' + + def __init__(self, token, chat_id): + """Creates a new message in the given `chat_id`.""" + super(TelegramIO, self).__init__() + self.token = token + self.chat_id = chat_id + self.session = Session() + self.text = self.__class__.__name__ + self.message_id + + @property + def message_id(self): + if hasattr(self, '_message_id'): + return self._message_id + try: + res = self.session.post( + self.API + '%s/sendMessage' % self.token, + data={'text': '`' + self.text + '`', 'chat_id': self.chat_id, + 'parse_mode': 'MarkdownV2'}).json() + except Exception as e: + tqdm_auto.write(str(e)) + else: + if res.get('error_code') == 429: + warn("Creation rate limit: try increasing `mininterval`.", + TqdmWarning, stacklevel=2) + else: + self._message_id = res['result']['message_id'] + return self._message_id + + def write(self, s): + """Replaces internal `message_id`'s text with `s`.""" + if not s: + s = "..." + s = s.replace('\r', '').strip() + if s == self.text: + return # avoid duplicate message Bot error + message_id = self.message_id + if message_id is None: + return + self.text = s + try: + future = self.submit( + self.session.post, self.API + '%s/editMessageText' % self.token, + data={'text': '`' + s + '`', 'chat_id': self.chat_id, + 'message_id': message_id, 'parse_mode': 'MarkdownV2'}) + except Exception as e: + tqdm_auto.write(str(e)) + else: + return future + + def delete(self): + """Deletes internal `message_id`.""" + try: + future = self.submit( + self.session.post, self.API + '%s/deleteMessage' % self.token, + data={'chat_id': self.chat_id, 'message_id': self.message_id}) + except Exception as e: + tqdm_auto.write(str(e)) + else: + return future + + +class tqdm_telegram(tqdm_auto): + """ + Standard `tqdm.auto.tqdm` but also sends updates to a Telegram Bot. + May take a few seconds to create (`__init__`). + + - create a bot + - copy its `{token}` + - add the bot to a chat and send it a message such as `/start` + - go to to find out + the `{chat_id}` + - paste the `{token}` & `{chat_id}` below + + >>> from tqdm.contrib.telegram import tqdm, trange + >>> for i in tqdm(iterable, token='{token}', chat_id='{chat_id}'): + ... ... + """ + def __init__(self, *args, **kwargs): + """ + Parameters + ---------- + token : str, required. Telegram token + [default: ${TQDM_TELEGRAM_TOKEN}]. + chat_id : str, required. Telegram chat ID + [default: ${TQDM_TELEGRAM_CHAT_ID}]. + + See `tqdm.auto.tqdm.__init__` for other parameters. + """ + if not kwargs.get('disable'): + kwargs = kwargs.copy() + self.tgio = TelegramIO( + kwargs.pop('token', getenv('TQDM_TELEGRAM_TOKEN')), + kwargs.pop('chat_id', getenv('TQDM_TELEGRAM_CHAT_ID'))) + super(tqdm_telegram, self).__init__(*args, **kwargs) + + def display(self, **kwargs): + super(tqdm_telegram, self).display(**kwargs) + fmt = self.format_dict + if fmt.get('bar_format', None): + fmt['bar_format'] = fmt['bar_format'].replace( + '', '{bar:10u}').replace('{bar}', '{bar:10u}') + else: + fmt['bar_format'] = '{l_bar}{bar:10u}{r_bar}' + self.tgio.write(self.format_meter(**fmt)) + + def clear(self, *args, **kwargs): + super(tqdm_telegram, self).clear(*args, **kwargs) + if not self.disable: + self.tgio.write("") + + def close(self): + if self.disable: + return + super(tqdm_telegram, self).close() + if not (self.leave or (self.leave is None and self.pos == 0)): + self.tgio.delete() + + +def ttgrange(*args, **kwargs): + """Shortcut for `tqdm.contrib.telegram.tqdm(range(*args), **kwargs)`.""" + return tqdm_telegram(range(*args), **kwargs) + + +# Aliases +tqdm = tqdm_telegram +trange = ttgrange diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/utils_worker.py b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/utils_worker.py new file mode 100644 index 0000000000000000000000000000000000000000..2a03a2a8930001e37938836196e0d15b649b07a8 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/tqdm/contrib/utils_worker.py @@ -0,0 +1,38 @@ +""" +IO/concurrency helpers for `tqdm.contrib`. +""" +from collections import deque +from concurrent.futures import ThreadPoolExecutor + +from ..auto import tqdm as tqdm_auto + +__author__ = {"github.com/": ["casperdcl"]} +__all__ = ['MonoWorker'] + + +class MonoWorker(object): + """ + Supports one running task and one waiting task. + The waiting task is the most recent submitted (others are discarded). + """ + def __init__(self): + self.pool = ThreadPoolExecutor(max_workers=1) + self.futures = deque([], 2) + + def submit(self, func, *args, **kwargs): + """`func(*args, **kwargs)` may replace currently waiting task.""" + futures = self.futures + if len(futures) == futures.maxlen: + running = futures.popleft() + if not running.done(): + if len(futures): # clear waiting + waiting = futures.pop() + waiting.cancel() + futures.appendleft(running) # re-insert running + try: + waiting = self.pool.submit(func, *args, **kwargs) + except Exception as e: + tqdm_auto.write(str(e)) + else: + futures.append(waiting) + return waiting diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/dask.py b/env-llmeval/lib/python3.10/site-packages/tqdm/dask.py new file mode 100644 index 0000000000000000000000000000000000000000..af9926a2797b9a49220fc5b2228e1ae18c447f37 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/tqdm/dask.py @@ -0,0 +1,44 @@ +from functools import partial + +from dask.callbacks import Callback + +from .auto import tqdm as tqdm_auto + +__author__ = {"github.com/": ["casperdcl"]} +__all__ = ['TqdmCallback'] + + +class TqdmCallback(Callback): + """Dask callback for task progress.""" + def __init__(self, start=None, pretask=None, tqdm_class=tqdm_auto, + **tqdm_kwargs): + """ + Parameters + ---------- + tqdm_class : optional + `tqdm` class to use for bars [default: `tqdm.auto.tqdm`]. + tqdm_kwargs : optional + Any other arguments used for all bars. + """ + super(TqdmCallback, self).__init__(start=start, pretask=pretask) + if tqdm_kwargs: + tqdm_class = partial(tqdm_class, **tqdm_kwargs) + self.tqdm_class = tqdm_class + + def _start_state(self, _, state): + self.pbar = self.tqdm_class(total=sum( + len(state[k]) for k in ['ready', 'waiting', 'running', 'finished'])) + + def _posttask(self, *_, **__): + self.pbar.update() + + def _finish(self, *_, **__): + self.pbar.close() + + def display(self): + """Displays in the current cell in Notebooks.""" + container = getattr(self.bar, 'container', None) + if container is None: + return + from .notebook import display + display(container) diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/std.py b/env-llmeval/lib/python3.10/site-packages/tqdm/std.py new file mode 100644 index 0000000000000000000000000000000000000000..e58fdca9188b2091e33cf0e16cf7483b868a5cd0 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/tqdm/std.py @@ -0,0 +1,1524 @@ +""" +Customisable progressbar decorator for iterators. +Includes a default `range` iterator printing to `stderr`. + +Usage: +>>> from tqdm import trange, tqdm +>>> for i in trange(10): +... ... +""" +import sys +from collections import OrderedDict, defaultdict +from contextlib import contextmanager +from datetime import datetime, timedelta, timezone +from numbers import Number +from time import time +from warnings import warn +from weakref import WeakSet + +from ._monitor import TMonitor +from .utils import ( + CallbackIOWrapper, Comparable, DisableOnWriteError, FormatReplace, SimpleTextIOWrapper, + _is_ascii, _screen_shape_wrapper, _supports_unicode, _term_move_up, disp_len, disp_trim, + envwrap) + +__author__ = "https://github.com/tqdm/tqdm#contributions" +__all__ = ['tqdm', 'trange', + 'TqdmTypeError', 'TqdmKeyError', 'TqdmWarning', + 'TqdmExperimentalWarning', 'TqdmDeprecationWarning', + 'TqdmMonitorWarning'] + + +class TqdmTypeError(TypeError): + pass + + +class TqdmKeyError(KeyError): + pass + + +class TqdmWarning(Warning): + """base class for all tqdm warnings. + + Used for non-external-code-breaking errors, such as garbled printing. + """ + def __init__(self, msg, fp_write=None, *a, **k): + if fp_write is not None: + fp_write("\n" + self.__class__.__name__ + ": " + str(msg).rstrip() + '\n') + else: + super(TqdmWarning, self).__init__(msg, *a, **k) + + +class TqdmExperimentalWarning(TqdmWarning, FutureWarning): + """beta feature, unstable API and behaviour""" + pass + + +class TqdmDeprecationWarning(TqdmWarning, DeprecationWarning): + # not suppressed if raised + pass + + +class TqdmMonitorWarning(TqdmWarning, RuntimeWarning): + """tqdm monitor errors which do not affect external functionality""" + pass + + +def TRLock(*args, **kwargs): + """threading RLock""" + try: + from threading import RLock + return RLock(*args, **kwargs) + except (ImportError, OSError): # pragma: no cover + pass + + +class TqdmDefaultWriteLock(object): + """ + Provide a default write lock for thread and multiprocessing safety. + Works only on platforms supporting `fork` (so Windows is excluded). + You must initialise a `tqdm` or `TqdmDefaultWriteLock` instance + before forking in order for the write lock to work. + On Windows, you need to supply the lock from the parent to the children as + an argument to joblib or the parallelism lib you use. + """ + # global thread lock so no setup required for multithreading. + # NB: Do not create multiprocessing lock as it sets the multiprocessing + # context, disallowing `spawn()`/`forkserver()` + th_lock = TRLock() + + def __init__(self): + # Create global parallelism locks to avoid racing issues with parallel + # bars works only if fork available (Linux/MacOSX, but not Windows) + cls = type(self) + root_lock = cls.th_lock + if root_lock is not None: + root_lock.acquire() + cls.create_mp_lock() + self.locks = [lk for lk in [cls.mp_lock, cls.th_lock] if lk is not None] + if root_lock is not None: + root_lock.release() + + def acquire(self, *a, **k): + for lock in self.locks: + lock.acquire(*a, **k) + + def release(self): + for lock in self.locks[::-1]: # Release in inverse order of acquisition + lock.release() + + def __enter__(self): + self.acquire() + + def __exit__(self, *exc): + self.release() + + @classmethod + def create_mp_lock(cls): + if not hasattr(cls, 'mp_lock'): + try: + from multiprocessing import RLock + cls.mp_lock = RLock() + except (ImportError, OSError): # pragma: no cover + cls.mp_lock = None + + @classmethod + def create_th_lock(cls): + assert hasattr(cls, 'th_lock') + warn("create_th_lock not needed anymore", TqdmDeprecationWarning, stacklevel=2) + + +class Bar(object): + """ + `str.format`-able bar with format specifiers: `[width][type]` + + - `width` + + unspecified (default): use `self.default_len` + + `int >= 0`: overrides `self.default_len` + + `int < 0`: subtract from `self.default_len` + - `type` + + `a`: ascii (`charset=self.ASCII` override) + + `u`: unicode (`charset=self.UTF` override) + + `b`: blank (`charset=" "` override) + """ + ASCII = " 123456789#" + UTF = u" " + u''.join(map(chr, range(0x258F, 0x2587, -1))) + BLANK = " " + COLOUR_RESET = '\x1b[0m' + COLOUR_RGB = '\x1b[38;2;%d;%d;%dm' + COLOURS = {'BLACK': '\x1b[30m', 'RED': '\x1b[31m', 'GREEN': '\x1b[32m', + 'YELLOW': '\x1b[33m', 'BLUE': '\x1b[34m', 'MAGENTA': '\x1b[35m', + 'CYAN': '\x1b[36m', 'WHITE': '\x1b[37m'} + + def __init__(self, frac, default_len=10, charset=UTF, colour=None): + if not 0 <= frac <= 1: + warn("clamping frac to range [0, 1]", TqdmWarning, stacklevel=2) + frac = max(0, min(1, frac)) + assert default_len > 0 + self.frac = frac + self.default_len = default_len + self.charset = charset + self.colour = colour + + @property + def colour(self): + return self._colour + + @colour.setter + def colour(self, value): + if not value: + self._colour = None + return + try: + if value.upper() in self.COLOURS: + self._colour = self.COLOURS[value.upper()] + elif value[0] == '#' and len(value) == 7: + self._colour = self.COLOUR_RGB % tuple( + int(i, 16) for i in (value[1:3], value[3:5], value[5:7])) + else: + raise KeyError + except (KeyError, AttributeError): + warn("Unknown colour (%s); valid choices: [hex (#00ff00), %s]" % ( + value, ", ".join(self.COLOURS)), + TqdmWarning, stacklevel=2) + self._colour = None + + def __format__(self, format_spec): + if format_spec: + _type = format_spec[-1].lower() + try: + charset = {'a': self.ASCII, 'u': self.UTF, 'b': self.BLANK}[_type] + except KeyError: + charset = self.charset + else: + format_spec = format_spec[:-1] + if format_spec: + N_BARS = int(format_spec) + if N_BARS < 0: + N_BARS += self.default_len + else: + N_BARS = self.default_len + else: + charset = self.charset + N_BARS = self.default_len + + nsyms = len(charset) - 1 + bar_length, frac_bar_length = divmod(int(self.frac * N_BARS * nsyms), nsyms) + + res = charset[-1] * bar_length + if bar_length < N_BARS: # whitespace padding + res = res + charset[frac_bar_length] + charset[0] * (N_BARS - bar_length - 1) + return self.colour + res + self.COLOUR_RESET if self.colour else res + + +class EMA(object): + """ + Exponential moving average: smoothing to give progressively lower + weights to older values. + + Parameters + ---------- + smoothing : float, optional + Smoothing factor in range [0, 1], [default: 0.3]. + Increase to give more weight to recent values. + Ranges from 0 (yields old value) to 1 (yields new value). + """ + def __init__(self, smoothing=0.3): + self.alpha = smoothing + self.last = 0 + self.calls = 0 + + def __call__(self, x=None): + """ + Parameters + ---------- + x : float + New value to include in EMA. + """ + beta = 1 - self.alpha + if x is not None: + self.last = self.alpha * x + beta * self.last + self.calls += 1 + return self.last / (1 - beta ** self.calls) if self.calls else self.last + + +class tqdm(Comparable): + """ + Decorate an iterable object, returning an iterator which acts exactly + like the original iterable, but prints a dynamically updating + progressbar every time a value is requested. + + Parameters + ---------- + iterable : iterable, optional + Iterable to decorate with a progressbar. + Leave blank to manually manage the updates. + desc : str, optional + Prefix for the progressbar. + total : int or float, optional + The number of expected iterations. If unspecified, + len(iterable) is used if possible. If float("inf") or as a last + resort, only basic progress statistics are displayed + (no ETA, no progressbar). + If `gui` is True and this parameter needs subsequent updating, + specify an initial arbitrary large positive number, + e.g. 9e9. + leave : bool, optional + If [default: True], keeps all traces of the progressbar + upon termination of iteration. + If `None`, will leave only if `position` is `0`. + file : `io.TextIOWrapper` or `io.StringIO`, optional + Specifies where to output the progress messages + (default: sys.stderr). Uses `file.write(str)` and `file.flush()` + methods. For encoding, see `write_bytes`. + ncols : int, optional + The width of the entire output message. If specified, + dynamically resizes the progressbar to stay within this bound. + If unspecified, attempts to use environment width. The + fallback is a meter width of 10 and no limit for the counter and + statistics. If 0, will not print any meter (only stats). + mininterval : float, optional + Minimum progress display update interval [default: 0.1] seconds. + maxinterval : float, optional + Maximum progress display update interval [default: 10] seconds. + Automatically adjusts `miniters` to correspond to `mininterval` + after long display update lag. Only works if `dynamic_miniters` + or monitor thread is enabled. + miniters : int or float, optional + Minimum progress display update interval, in iterations. + If 0 and `dynamic_miniters`, will automatically adjust to equal + `mininterval` (more CPU efficient, good for tight loops). + If > 0, will skip display of specified number of iterations. + Tweak this and `mininterval` to get very efficient loops. + If your progress is erratic with both fast and slow iterations + (network, skipping items, etc) you should set miniters=1. + ascii : bool or str, optional + If unspecified or False, use unicode (smooth blocks) to fill + the meter. The fallback is to use ASCII characters " 123456789#". + disable : bool, optional + Whether to disable the entire progressbar wrapper + [default: False]. If set to None, disable on non-TTY. + unit : str, optional + String that will be used to define the unit of each iteration + [default: it]. + unit_scale : bool or int or float, optional + If 1 or True, the number of iterations will be reduced/scaled + automatically and a metric prefix following the + International System of Units standard will be added + (kilo, mega, etc.) [default: False]. If any other non-zero + number, will scale `total` and `n`. + dynamic_ncols : bool, optional + If set, constantly alters `ncols` and `nrows` to the + environment (allowing for window resizes) [default: False]. + smoothing : float, optional + Exponential moving average smoothing factor for speed estimates + (ignored in GUI mode). Ranges from 0 (average speed) to 1 + (current/instantaneous speed) [default: 0.3]. + bar_format : str, optional + Specify a custom bar string formatting. May impact performance. + [default: '{l_bar}{bar}{r_bar}'], where + l_bar='{desc}: {percentage:3.0f}%|' and + r_bar='| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, ' + '{rate_fmt}{postfix}]' + Possible vars: l_bar, bar, r_bar, n, n_fmt, total, total_fmt, + percentage, elapsed, elapsed_s, ncols, nrows, desc, unit, + rate, rate_fmt, rate_noinv, rate_noinv_fmt, + rate_inv, rate_inv_fmt, postfix, unit_divisor, + remaining, remaining_s, eta. + Note that a trailing ": " is automatically removed after {desc} + if the latter is empty. + initial : int or float, optional + The initial counter value. Useful when restarting a progress + bar [default: 0]. If using float, consider specifying `{n:.3f}` + or similar in `bar_format`, or specifying `unit_scale`. + position : int, optional + Specify the line offset to print this bar (starting from 0) + Automatic if unspecified. + Useful to manage multiple bars at once (eg, from threads). + postfix : dict or *, optional + Specify additional stats to display at the end of the bar. + Calls `set_postfix(**postfix)` if possible (dict). + unit_divisor : float, optional + [default: 1000], ignored unless `unit_scale` is True. + write_bytes : bool, optional + Whether to write bytes. If (default: False) will write unicode. + lock_args : tuple, optional + Passed to `refresh` for intermediate output + (initialisation, iterating, and updating). + nrows : int, optional + The screen height. If specified, hides nested bars outside this + bound. If unspecified, attempts to use environment height. + The fallback is 20. + colour : str, optional + Bar colour (e.g. 'green', '#00ff00'). + delay : float, optional + Don't display until [default: 0] seconds have elapsed. + gui : bool, optional + WARNING: internal parameter - do not use. + Use tqdm.gui.tqdm(...) instead. If set, will attempt to use + matplotlib animations for a graphical output [default: False]. + + Returns + ------- + out : decorated iterator. + """ + + monitor_interval = 10 # set to 0 to disable the thread + monitor = None + _instances = WeakSet() + + @staticmethod + def format_sizeof(num, suffix='', divisor=1000): + """ + Formats a number (greater than unity) with SI Order of Magnitude + prefixes. + + Parameters + ---------- + num : float + Number ( >= 1) to format. + suffix : str, optional + Post-postfix [default: '']. + divisor : float, optional + Divisor between prefixes [default: 1000]. + + Returns + ------- + out : str + Number with Order of Magnitude SI unit postfix. + """ + for unit in ['', 'k', 'M', 'G', 'T', 'P', 'E', 'Z']: + if abs(num) < 999.5: + if abs(num) < 99.95: + if abs(num) < 9.995: + return f'{num:1.2f}{unit}{suffix}' + return f'{num:2.1f}{unit}{suffix}' + return f'{num:3.0f}{unit}{suffix}' + num /= divisor + return f'{num:3.1f}Y{suffix}' + + @staticmethod + def format_interval(t): + """ + Formats a number of seconds as a clock time, [H:]MM:SS + + Parameters + ---------- + t : int + Number of seconds. + + Returns + ------- + out : str + [H:]MM:SS + """ + mins, s = divmod(int(t), 60) + h, m = divmod(mins, 60) + return f'{h:d}:{m:02d}:{s:02d}' if h else f'{m:02d}:{s:02d}' + + @staticmethod + def format_num(n): + """ + Intelligent scientific notation (.3g). + + Parameters + ---------- + n : int or float or Numeric + A Number. + + Returns + ------- + out : str + Formatted number. + """ + f = f'{n:.3g}'.replace('e+0', 'e+').replace('e-0', 'e-') + n = str(n) + return f if len(f) < len(n) else n + + @staticmethod + def status_printer(file): + """ + Manage the printing and in-place updating of a line of characters. + Note that if the string is longer than a line, then in-place + updating may not work (it will print a new line at each refresh). + """ + fp = file + fp_flush = getattr(fp, 'flush', lambda: None) # pragma: no cover + if fp in (sys.stderr, sys.stdout): + getattr(sys.stderr, 'flush', lambda: None)() + getattr(sys.stdout, 'flush', lambda: None)() + + def fp_write(s): + fp.write(str(s)) + fp_flush() + + last_len = [0] + + def print_status(s): + len_s = disp_len(s) + fp_write('\r' + s + (' ' * max(last_len[0] - len_s, 0))) + last_len[0] = len_s + + return print_status + + @staticmethod + def format_meter(n, total, elapsed, ncols=None, prefix='', ascii=False, unit='it', + unit_scale=False, rate=None, bar_format=None, postfix=None, + unit_divisor=1000, initial=0, colour=None, **extra_kwargs): + """ + Return a string-based progress bar given some parameters + + Parameters + ---------- + n : int or float + Number of finished iterations. + total : int or float + The expected total number of iterations. If meaningless (None), + only basic progress statistics are displayed (no ETA). + elapsed : float + Number of seconds passed since start. + ncols : int, optional + The width of the entire output message. If specified, + dynamically resizes `{bar}` to stay within this bound + [default: None]. If `0`, will not print any bar (only stats). + The fallback is `{bar:10}`. + prefix : str, optional + Prefix message (included in total width) [default: '']. + Use as {desc} in bar_format string. + ascii : bool, optional or str, optional + If not set, use unicode (smooth blocks) to fill the meter + [default: False]. The fallback is to use ASCII characters + " 123456789#". + unit : str, optional + The iteration unit [default: 'it']. + unit_scale : bool or int or float, optional + If 1 or True, the number of iterations will be printed with an + appropriate SI metric prefix (k = 10^3, M = 10^6, etc.) + [default: False]. If any other non-zero number, will scale + `total` and `n`. + rate : float, optional + Manual override for iteration rate. + If [default: None], uses n/elapsed. + bar_format : str, optional + Specify a custom bar string formatting. May impact performance. + [default: '{l_bar}{bar}{r_bar}'], where + l_bar='{desc}: {percentage:3.0f}%|' and + r_bar='| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, ' + '{rate_fmt}{postfix}]' + Possible vars: l_bar, bar, r_bar, n, n_fmt, total, total_fmt, + percentage, elapsed, elapsed_s, ncols, nrows, desc, unit, + rate, rate_fmt, rate_noinv, rate_noinv_fmt, + rate_inv, rate_inv_fmt, postfix, unit_divisor, + remaining, remaining_s, eta. + Note that a trailing ": " is automatically removed after {desc} + if the latter is empty. + postfix : *, optional + Similar to `prefix`, but placed at the end + (e.g. for additional stats). + Note: postfix is usually a string (not a dict) for this method, + and will if possible be set to postfix = ', ' + postfix. + However other types are supported (#382). + unit_divisor : float, optional + [default: 1000], ignored unless `unit_scale` is True. + initial : int or float, optional + The initial counter value [default: 0]. + colour : str, optional + Bar colour (e.g. 'green', '#00ff00'). + + Returns + ------- + out : Formatted meter and stats, ready to display. + """ + + # sanity check: total + if total and n >= (total + 0.5): # allow float imprecision (#849) + total = None + + # apply custom scale if necessary + if unit_scale and unit_scale not in (True, 1): + if total: + total *= unit_scale + n *= unit_scale + if rate: + rate *= unit_scale # by default rate = self.avg_dn / self.avg_dt + unit_scale = False + + elapsed_str = tqdm.format_interval(elapsed) + + # if unspecified, attempt to use rate = average speed + # (we allow manual override since predicting time is an arcane art) + if rate is None and elapsed: + rate = (n - initial) / elapsed + inv_rate = 1 / rate if rate else None + format_sizeof = tqdm.format_sizeof + rate_noinv_fmt = ((format_sizeof(rate) if unit_scale else f'{rate:5.2f}') + if rate else '?') + unit + '/s' + rate_inv_fmt = ( + (format_sizeof(inv_rate) if unit_scale else f'{inv_rate:5.2f}') + if inv_rate else '?') + 's/' + unit + rate_fmt = rate_inv_fmt if inv_rate and inv_rate > 1 else rate_noinv_fmt + + if unit_scale: + n_fmt = format_sizeof(n, divisor=unit_divisor) + total_fmt = format_sizeof(total, divisor=unit_divisor) if total is not None else '?' + else: + n_fmt = str(n) + total_fmt = str(total) if total is not None else '?' + + try: + postfix = ', ' + postfix if postfix else '' + except TypeError: + pass + + remaining = (total - n) / rate if rate and total else 0 + remaining_str = tqdm.format_interval(remaining) if rate else '?' + try: + eta_dt = (datetime.now() + timedelta(seconds=remaining) + if rate and total else datetime.fromtimestamp(0, timezone.utc)) + except OverflowError: + eta_dt = datetime.max + + # format the stats displayed to the left and right sides of the bar + if prefix: + # old prefix setup work around + bool_prefix_colon_already = (prefix[-2:] == ": ") + l_bar = prefix if bool_prefix_colon_already else prefix + ": " + else: + l_bar = '' + + r_bar = f'| {n_fmt}/{total_fmt} [{elapsed_str}<{remaining_str}, {rate_fmt}{postfix}]' + + # Custom bar formatting + # Populate a dict with all available progress indicators + format_dict = { + # slight extension of self.format_dict + 'n': n, 'n_fmt': n_fmt, 'total': total, 'total_fmt': total_fmt, + 'elapsed': elapsed_str, 'elapsed_s': elapsed, + 'ncols': ncols, 'desc': prefix or '', 'unit': unit, + 'rate': inv_rate if inv_rate and inv_rate > 1 else rate, + 'rate_fmt': rate_fmt, 'rate_noinv': rate, + 'rate_noinv_fmt': rate_noinv_fmt, 'rate_inv': inv_rate, + 'rate_inv_fmt': rate_inv_fmt, + 'postfix': postfix, 'unit_divisor': unit_divisor, + 'colour': colour, + # plus more useful definitions + 'remaining': remaining_str, 'remaining_s': remaining, + 'l_bar': l_bar, 'r_bar': r_bar, 'eta': eta_dt, + **extra_kwargs} + + # total is known: we can predict some stats + if total: + # fractional and percentage progress + frac = n / total + percentage = frac * 100 + + l_bar += f'{percentage:3.0f}%|' + + if ncols == 0: + return l_bar[:-1] + r_bar[1:] + + format_dict.update(l_bar=l_bar) + if bar_format: + format_dict.update(percentage=percentage) + + # auto-remove colon for empty `{desc}` + if not prefix: + bar_format = bar_format.replace("{desc}: ", '') + else: + bar_format = "{l_bar}{bar}{r_bar}" + + full_bar = FormatReplace() + nobar = bar_format.format(bar=full_bar, **format_dict) + if not full_bar.format_called: + return nobar # no `{bar}`; nothing else to do + + # Formatting progress bar space available for bar's display + full_bar = Bar(frac, + max(1, ncols - disp_len(nobar)) if ncols else 10, + charset=Bar.ASCII if ascii is True else ascii or Bar.UTF, + colour=colour) + if not _is_ascii(full_bar.charset) and _is_ascii(bar_format): + bar_format = str(bar_format) + res = bar_format.format(bar=full_bar, **format_dict) + return disp_trim(res, ncols) if ncols else res + + elif bar_format: + # user-specified bar_format but no total + l_bar += '|' + format_dict.update(l_bar=l_bar, percentage=0) + full_bar = FormatReplace() + nobar = bar_format.format(bar=full_bar, **format_dict) + if not full_bar.format_called: + return nobar + full_bar = Bar(0, + max(1, ncols - disp_len(nobar)) if ncols else 10, + charset=Bar.BLANK, colour=colour) + res = bar_format.format(bar=full_bar, **format_dict) + return disp_trim(res, ncols) if ncols else res + else: + # no total: no progressbar, ETA, just progress stats + return (f'{(prefix + ": ") if prefix else ""}' + f'{n_fmt}{unit} [{elapsed_str}, {rate_fmt}{postfix}]') + + def __new__(cls, *_, **__): + instance = object.__new__(cls) + with cls.get_lock(): # also constructs lock if non-existent + cls._instances.add(instance) + # create monitoring thread + if cls.monitor_interval and (cls.monitor is None + or not cls.monitor.report()): + try: + cls.monitor = TMonitor(cls, cls.monitor_interval) + except Exception as e: # pragma: nocover + warn("tqdm:disabling monitor support" + " (monitor_interval = 0) due to:\n" + str(e), + TqdmMonitorWarning, stacklevel=2) + cls.monitor_interval = 0 + return instance + + @classmethod + def _get_free_pos(cls, instance=None): + """Skips specified instance.""" + positions = {abs(inst.pos) for inst in cls._instances + if inst is not instance and hasattr(inst, "pos")} + return min(set(range(len(positions) + 1)).difference(positions)) + + @classmethod + def _decr_instances(cls, instance): + """ + Remove from list and reposition another unfixed bar + to fill the new gap. + + This means that by default (where all nested bars are unfixed), + order is not maintained but screen flicker/blank space is minimised. + (tqdm<=4.44.1 moved ALL subsequent unfixed bars up.) + """ + with cls._lock: + try: + cls._instances.remove(instance) + except KeyError: + # if not instance.gui: # pragma: no cover + # raise + pass # py2: maybe magically removed already + # else: + if not instance.gui: + last = (instance.nrows or 20) - 1 + # find unfixed (`pos >= 0`) overflow (`pos >= nrows - 1`) + instances = list(filter( + lambda i: hasattr(i, "pos") and last <= i.pos, + cls._instances)) + # set first found to current `pos` + if instances: + inst = min(instances, key=lambda i: i.pos) + inst.clear(nolock=True) + inst.pos = abs(instance.pos) + + @classmethod + def write(cls, s, file=None, end="\n", nolock=False): + """Print a message via tqdm (without overlap with bars).""" + fp = file if file is not None else sys.stdout + with cls.external_write_mode(file=file, nolock=nolock): + # Write the message + fp.write(s) + fp.write(end) + + @classmethod + @contextmanager + def external_write_mode(cls, file=None, nolock=False): + """ + Disable tqdm within context and refresh tqdm when exits. + Useful when writing to standard output stream + """ + fp = file if file is not None else sys.stdout + + try: + if not nolock: + cls.get_lock().acquire() + # Clear all bars + inst_cleared = [] + for inst in getattr(cls, '_instances', []): + # Clear instance if in the target output file + # or if write output + tqdm output are both either + # sys.stdout or sys.stderr (because both are mixed in terminal) + if hasattr(inst, "start_t") and (inst.fp == fp or all( + f in (sys.stdout, sys.stderr) for f in (fp, inst.fp))): + inst.clear(nolock=True) + inst_cleared.append(inst) + yield + # Force refresh display of bars we cleared + for inst in inst_cleared: + inst.refresh(nolock=True) + finally: + if not nolock: + cls._lock.release() + + @classmethod + def set_lock(cls, lock): + """Set the global lock.""" + cls._lock = lock + + @classmethod + def get_lock(cls): + """Get the global lock. Construct it if it does not exist.""" + if not hasattr(cls, '_lock'): + cls._lock = TqdmDefaultWriteLock() + return cls._lock + + @classmethod + def pandas(cls, **tqdm_kwargs): + """ + Registers the current `tqdm` class with + pandas.core. + ( frame.DataFrame + | series.Series + | groupby.(generic.)DataFrameGroupBy + | groupby.(generic.)SeriesGroupBy + ).progress_apply + + A new instance will be created every time `progress_apply` is called, + and each instance will automatically `close()` upon completion. + + Parameters + ---------- + tqdm_kwargs : arguments for the tqdm instance + + Examples + -------- + >>> import pandas as pd + >>> import numpy as np + >>> from tqdm import tqdm + >>> from tqdm.gui import tqdm as tqdm_gui + >>> + >>> df = pd.DataFrame(np.random.randint(0, 100, (100000, 6))) + >>> tqdm.pandas(ncols=50) # can use tqdm_gui, optional kwargs, etc + >>> # Now you can use `progress_apply` instead of `apply` + >>> df.groupby(0).progress_apply(lambda x: x**2) + + References + ---------- + + """ + from warnings import catch_warnings, simplefilter + + from pandas.core.frame import DataFrame + from pandas.core.series import Series + try: + with catch_warnings(): + simplefilter("ignore", category=FutureWarning) + from pandas import Panel + except ImportError: # pandas>=1.2.0 + Panel = None + Rolling, Expanding = None, None + try: # pandas>=1.0.0 + from pandas.core.window.rolling import _Rolling_and_Expanding + except ImportError: + try: # pandas>=0.18.0 + from pandas.core.window import _Rolling_and_Expanding + except ImportError: # pandas>=1.2.0 + try: # pandas>=1.2.0 + from pandas.core.window.expanding import Expanding + from pandas.core.window.rolling import Rolling + _Rolling_and_Expanding = Rolling, Expanding + except ImportError: # pragma: no cover + _Rolling_and_Expanding = None + try: # pandas>=0.25.0 + from pandas.core.groupby.generic import SeriesGroupBy # , NDFrameGroupBy + from pandas.core.groupby.generic import DataFrameGroupBy + except ImportError: # pragma: no cover + try: # pandas>=0.23.0 + from pandas.core.groupby.groupby import DataFrameGroupBy, SeriesGroupBy + except ImportError: + from pandas.core.groupby import DataFrameGroupBy, SeriesGroupBy + try: # pandas>=0.23.0 + from pandas.core.groupby.groupby import GroupBy + except ImportError: # pragma: no cover + from pandas.core.groupby import GroupBy + + try: # pandas>=0.23.0 + from pandas.core.groupby.groupby import PanelGroupBy + except ImportError: + try: + from pandas.core.groupby import PanelGroupBy + except ImportError: # pandas>=0.25.0 + PanelGroupBy = None + + tqdm_kwargs = tqdm_kwargs.copy() + deprecated_t = [tqdm_kwargs.pop('deprecated_t', None)] + + def inner_generator(df_function='apply'): + def inner(df, func, *args, **kwargs): + """ + Parameters + ---------- + df : (DataFrame|Series)[GroupBy] + Data (may be grouped). + func : function + To be applied on the (grouped) data. + **kwargs : optional + Transmitted to `df.apply()`. + """ + + # Precompute total iterations + total = tqdm_kwargs.pop("total", getattr(df, 'ngroups', None)) + if total is None: # not grouped + if df_function == 'applymap': + total = df.size + elif isinstance(df, Series): + total = len(df) + elif (_Rolling_and_Expanding is None or + not isinstance(df, _Rolling_and_Expanding)): + # DataFrame or Panel + axis = kwargs.get('axis', 0) + if axis == 'index': + axis = 0 + elif axis == 'columns': + axis = 1 + # when axis=0, total is shape[axis1] + total = df.size // df.shape[axis] + + # Init bar + if deprecated_t[0] is not None: + t = deprecated_t[0] + deprecated_t[0] = None + else: + t = cls(total=total, **tqdm_kwargs) + + if len(args) > 0: + # *args intentionally not supported (see #244, #299) + TqdmDeprecationWarning( + "Except func, normal arguments are intentionally" + + " not supported by" + + " `(DataFrame|Series|GroupBy).progress_apply`." + + " Use keyword arguments instead.", + fp_write=getattr(t.fp, 'write', sys.stderr.write)) + + try: # pandas>=1.3.0 + from pandas.core.common import is_builtin_func + except ImportError: + is_builtin_func = df._is_builtin_func + try: + func = is_builtin_func(func) + except TypeError: + pass + + # Define bar updating wrapper + def wrapper(*args, **kwargs): + # update tbar correctly + # it seems `pandas apply` calls `func` twice + # on the first column/row to decide whether it can + # take a fast or slow code path; so stop when t.total==t.n + t.update(n=1 if not t.total or t.n < t.total else 0) + return func(*args, **kwargs) + + # Apply the provided function (in **kwargs) + # on the df using our wrapper (which provides bar updating) + try: + return getattr(df, df_function)(wrapper, **kwargs) + finally: + t.close() + + return inner + + # Monkeypatch pandas to provide easy methods + # Enable custom tqdm progress in pandas! + Series.progress_apply = inner_generator() + SeriesGroupBy.progress_apply = inner_generator() + Series.progress_map = inner_generator('map') + SeriesGroupBy.progress_map = inner_generator('map') + + DataFrame.progress_apply = inner_generator() + DataFrameGroupBy.progress_apply = inner_generator() + DataFrame.progress_applymap = inner_generator('applymap') + DataFrame.progress_map = inner_generator('map') + DataFrameGroupBy.progress_map = inner_generator('map') + + if Panel is not None: + Panel.progress_apply = inner_generator() + if PanelGroupBy is not None: + PanelGroupBy.progress_apply = inner_generator() + + GroupBy.progress_apply = inner_generator() + GroupBy.progress_aggregate = inner_generator('aggregate') + GroupBy.progress_transform = inner_generator('transform') + + if Rolling is not None and Expanding is not None: + Rolling.progress_apply = inner_generator() + Expanding.progress_apply = inner_generator() + elif _Rolling_and_Expanding is not None: + _Rolling_and_Expanding.progress_apply = inner_generator() + + # override defaults via env vars + @envwrap("TQDM_", is_method=True, types={'total': float, 'ncols': int, 'miniters': float, + 'position': int, 'nrows': int}) + def __init__(self, iterable=None, desc=None, total=None, leave=True, file=None, + ncols=None, mininterval=0.1, maxinterval=10.0, miniters=None, + ascii=None, disable=False, unit='it', unit_scale=False, + dynamic_ncols=False, smoothing=0.3, bar_format=None, initial=0, + position=None, postfix=None, unit_divisor=1000, write_bytes=False, + lock_args=None, nrows=None, colour=None, delay=0.0, gui=False, + **kwargs): + """see tqdm.tqdm for arguments""" + if file is None: + file = sys.stderr + + if write_bytes: + # Despite coercing unicode into bytes, py2 sys.std* streams + # should have bytes written to them. + file = SimpleTextIOWrapper( + file, encoding=getattr(file, 'encoding', None) or 'utf-8') + + file = DisableOnWriteError(file, tqdm_instance=self) + + if disable is None and hasattr(file, "isatty") and not file.isatty(): + disable = True + + if total is None and iterable is not None: + try: + total = len(iterable) + except (TypeError, AttributeError): + total = None + if total == float("inf"): + # Infinite iterations, behave same as unknown + total = None + + if disable: + self.iterable = iterable + self.disable = disable + with self._lock: + self.pos = self._get_free_pos(self) + self._instances.remove(self) + self.n = initial + self.total = total + self.leave = leave + return + + if kwargs: + self.disable = True + with self._lock: + self.pos = self._get_free_pos(self) + self._instances.remove(self) + raise ( + TqdmDeprecationWarning( + "`nested` is deprecated and automated.\n" + "Use `position` instead for manual control.\n", + fp_write=getattr(file, 'write', sys.stderr.write)) + if "nested" in kwargs else + TqdmKeyError("Unknown argument(s): " + str(kwargs))) + + # Preprocess the arguments + if ( + (ncols is None or nrows is None) and (file in (sys.stderr, sys.stdout)) + ) or dynamic_ncols: # pragma: no cover + if dynamic_ncols: + dynamic_ncols = _screen_shape_wrapper() + if dynamic_ncols: + ncols, nrows = dynamic_ncols(file) + else: + _dynamic_ncols = _screen_shape_wrapper() + if _dynamic_ncols: + _ncols, _nrows = _dynamic_ncols(file) + if ncols is None: + ncols = _ncols + if nrows is None: + nrows = _nrows + + if miniters is None: + miniters = 0 + dynamic_miniters = True + else: + dynamic_miniters = False + + if mininterval is None: + mininterval = 0 + + if maxinterval is None: + maxinterval = 0 + + if ascii is None: + ascii = not _supports_unicode(file) + + if bar_format and ascii is not True and not _is_ascii(ascii): + # Convert bar format into unicode since terminal uses unicode + bar_format = str(bar_format) + + if smoothing is None: + smoothing = 0 + + # Store the arguments + self.iterable = iterable + self.desc = desc or '' + self.total = total + self.leave = leave + self.fp = file + self.ncols = ncols + self.nrows = nrows + self.mininterval = mininterval + self.maxinterval = maxinterval + self.miniters = miniters + self.dynamic_miniters = dynamic_miniters + self.ascii = ascii + self.disable = disable + self.unit = unit + self.unit_scale = unit_scale + self.unit_divisor = unit_divisor + self.initial = initial + self.lock_args = lock_args + self.delay = delay + self.gui = gui + self.dynamic_ncols = dynamic_ncols + self.smoothing = smoothing + self._ema_dn = EMA(smoothing) + self._ema_dt = EMA(smoothing) + self._ema_miniters = EMA(smoothing) + self.bar_format = bar_format + self.postfix = None + self.colour = colour + self._time = time + if postfix: + try: + self.set_postfix(refresh=False, **postfix) + except TypeError: + self.postfix = postfix + + # Init the iterations counters + self.last_print_n = initial + self.n = initial + + # if nested, at initial sp() call we replace '\r' by '\n' to + # not overwrite the outer progress bar + with self._lock: + # mark fixed positions as negative + self.pos = self._get_free_pos(self) if position is None else -position + + if not gui: + # Initialize the screen printer + self.sp = self.status_printer(self.fp) + if delay <= 0: + self.refresh(lock_args=self.lock_args) + + # Init the time counter + self.last_print_t = self._time() + # NB: Avoid race conditions by setting start_t at the very end of init + self.start_t = self.last_print_t + + def __bool__(self): + if self.total is not None: + return self.total > 0 + if self.iterable is None: + raise TypeError('bool() undefined when iterable == total == None') + return bool(self.iterable) + + def __len__(self): + return ( + self.total if self.iterable is None + else self.iterable.shape[0] if hasattr(self.iterable, "shape") + else len(self.iterable) if hasattr(self.iterable, "__len__") + else self.iterable.__length_hint__() if hasattr(self.iterable, "__length_hint__") + else getattr(self, "total", None)) + + def __reversed__(self): + try: + orig = self.iterable + except AttributeError: + raise TypeError("'tqdm' object is not reversible") + else: + self.iterable = reversed(self.iterable) + return self.__iter__() + finally: + self.iterable = orig + + def __contains__(self, item): + contains = getattr(self.iterable, '__contains__', None) + return contains(item) if contains is not None else item in self.__iter__() + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + try: + self.close() + except AttributeError: + # maybe eager thread cleanup upon external error + if (exc_type, exc_value, traceback) == (None, None, None): + raise + warn("AttributeError ignored", TqdmWarning, stacklevel=2) + + def __del__(self): + self.close() + + def __str__(self): + return self.format_meter(**self.format_dict) + + @property + def _comparable(self): + return abs(getattr(self, "pos", 1 << 31)) + + def __hash__(self): + return id(self) + + def __iter__(self): + """Backward-compatibility to use: for x in tqdm(iterable)""" + + # Inlining instance variables as locals (speed optimisation) + iterable = self.iterable + + # If the bar is disabled, then just walk the iterable + # (note: keep this check outside the loop for performance) + if self.disable: + for obj in iterable: + yield obj + return + + mininterval = self.mininterval + last_print_t = self.last_print_t + last_print_n = self.last_print_n + min_start_t = self.start_t + self.delay + n = self.n + time = self._time + + try: + for obj in iterable: + yield obj + # Update and possibly print the progressbar. + # Note: does not call self.update(1) for speed optimisation. + n += 1 + + if n - last_print_n >= self.miniters: + cur_t = time() + dt = cur_t - last_print_t + if dt >= mininterval and cur_t >= min_start_t: + self.update(n - last_print_n) + last_print_n = self.last_print_n + last_print_t = self.last_print_t + finally: + self.n = n + self.close() + + def update(self, n=1): + """ + Manually update the progress bar, useful for streams + such as reading files. + E.g.: + >>> t = tqdm(total=filesize) # Initialise + >>> for current_buffer in stream: + ... ... + ... t.update(len(current_buffer)) + >>> t.close() + The last line is highly recommended, but possibly not necessary if + `t.update()` will be called in such a way that `filesize` will be + exactly reached and printed. + + Parameters + ---------- + n : int or float, optional + Increment to add to the internal counter of iterations + [default: 1]. If using float, consider specifying `{n:.3f}` + or similar in `bar_format`, or specifying `unit_scale`. + + Returns + ------- + out : bool or None + True if a `display()` was triggered. + """ + if self.disable: + return + + if n < 0: + self.last_print_n += n # for auto-refresh logic to work + self.n += n + + # check counter first to reduce calls to time() + if self.n - self.last_print_n >= self.miniters: + cur_t = self._time() + dt = cur_t - self.last_print_t + if dt >= self.mininterval and cur_t >= self.start_t + self.delay: + cur_t = self._time() + dn = self.n - self.last_print_n # >= n + if self.smoothing and dt and dn: + # EMA (not just overall average) + self._ema_dn(dn) + self._ema_dt(dt) + self.refresh(lock_args=self.lock_args) + if self.dynamic_miniters: + # If no `miniters` was specified, adjust automatically to the + # maximum iteration rate seen so far between two prints. + # e.g.: After running `tqdm.update(5)`, subsequent + # calls to `tqdm.update()` will only cause an update after + # at least 5 more iterations. + if self.maxinterval and dt >= self.maxinterval: + self.miniters = dn * (self.mininterval or self.maxinterval) / dt + elif self.smoothing: + # EMA miniters update + self.miniters = self._ema_miniters( + dn * (self.mininterval / dt if self.mininterval and dt + else 1)) + else: + # max iters between two prints + self.miniters = max(self.miniters, dn) + + # Store old values for next call + self.last_print_n = self.n + self.last_print_t = cur_t + return True + + def close(self): + """Cleanup and (if leave=False) close the progressbar.""" + if self.disable: + return + + # Prevent multiple closures + self.disable = True + + # decrement instance pos and remove from internal set + pos = abs(self.pos) + self._decr_instances(self) + + if self.last_print_t < self.start_t + self.delay: + # haven't ever displayed; nothing to clear + return + + # GUI mode + if getattr(self, 'sp', None) is None: + return + + # annoyingly, _supports_unicode isn't good enough + def fp_write(s): + self.fp.write(str(s)) + + try: + fp_write('') + except ValueError as e: + if 'closed' in str(e): + return + raise # pragma: no cover + + leave = pos == 0 if self.leave is None else self.leave + + with self._lock: + if leave: + # stats for overall rate (no weighted average) + self._ema_dt = lambda: None + self.display(pos=0) + fp_write('\n') + else: + # clear previous display + if self.display(msg='', pos=pos) and not pos: + fp_write('\r') + + def clear(self, nolock=False): + """Clear current bar display.""" + if self.disable: + return + + if not nolock: + self._lock.acquire() + pos = abs(self.pos) + if pos < (self.nrows or 20): + self.moveto(pos) + self.sp('') + self.fp.write('\r') # place cursor back at the beginning of line + self.moveto(-pos) + if not nolock: + self._lock.release() + + def refresh(self, nolock=False, lock_args=None): + """ + Force refresh the display of this bar. + + Parameters + ---------- + nolock : bool, optional + If `True`, does not lock. + If [default: `False`]: calls `acquire()` on internal lock. + lock_args : tuple, optional + Passed to internal lock's `acquire()`. + If specified, will only `display()` if `acquire()` returns `True`. + """ + if self.disable: + return + + if not nolock: + if lock_args: + if not self._lock.acquire(*lock_args): + return False + else: + self._lock.acquire() + self.display() + if not nolock: + self._lock.release() + return True + + def unpause(self): + """Restart tqdm timer from last print time.""" + if self.disable: + return + cur_t = self._time() + self.start_t += cur_t - self.last_print_t + self.last_print_t = cur_t + + def reset(self, total=None): + """ + Resets to 0 iterations for repeated use. + + Consider combining with `leave=True`. + + Parameters + ---------- + total : int or float, optional. Total to use for the new bar. + """ + self.n = 0 + if total is not None: + self.total = total + if self.disable: + return + self.last_print_n = 0 + self.last_print_t = self.start_t = self._time() + self._ema_dn = EMA(self.smoothing) + self._ema_dt = EMA(self.smoothing) + self._ema_miniters = EMA(self.smoothing) + self.refresh() + + def set_description(self, desc=None, refresh=True): + """ + Set/modify description of the progress bar. + + Parameters + ---------- + desc : str, optional + refresh : bool, optional + Forces refresh [default: True]. + """ + self.desc = desc + ': ' if desc else '' + if refresh: + self.refresh() + + def set_description_str(self, desc=None, refresh=True): + """Set/modify description without ': ' appended.""" + self.desc = desc or '' + if refresh: + self.refresh() + + def set_postfix(self, ordered_dict=None, refresh=True, **kwargs): + """ + Set/modify postfix (additional stats) + with automatic formatting based on datatype. + + Parameters + ---------- + ordered_dict : dict or OrderedDict, optional + refresh : bool, optional + Forces refresh [default: True]. + kwargs : dict, optional + """ + # Sort in alphabetical order to be more deterministic + postfix = OrderedDict([] if ordered_dict is None else ordered_dict) + for key in sorted(kwargs.keys()): + postfix[key] = kwargs[key] + # Preprocess stats according to datatype + for key in postfix.keys(): + # Number: limit the length of the string + if isinstance(postfix[key], Number): + postfix[key] = self.format_num(postfix[key]) + # Else for any other type, try to get the string conversion + elif not isinstance(postfix[key], str): + postfix[key] = str(postfix[key]) + # Else if it's a string, don't need to preprocess anything + # Stitch together to get the final postfix + self.postfix = ', '.join(key + '=' + postfix[key].strip() + for key in postfix.keys()) + if refresh: + self.refresh() + + def set_postfix_str(self, s='', refresh=True): + """ + Postfix without dictionary expansion, similar to prefix handling. + """ + self.postfix = str(s) + if refresh: + self.refresh() + + def moveto(self, n): + # TODO: private method + self.fp.write('\n' * n + _term_move_up() * -n) + getattr(self.fp, 'flush', lambda: None)() + + @property + def format_dict(self): + """Public API for read-only member access.""" + if self.disable and not hasattr(self, 'unit'): + return defaultdict(lambda: None, { + 'n': self.n, 'total': self.total, 'elapsed': 0, 'unit': 'it'}) + if self.dynamic_ncols: + self.ncols, self.nrows = self.dynamic_ncols(self.fp) + return { + 'n': self.n, 'total': self.total, + 'elapsed': self._time() - self.start_t if hasattr(self, 'start_t') else 0, + 'ncols': self.ncols, 'nrows': self.nrows, 'prefix': self.desc, + 'ascii': self.ascii, 'unit': self.unit, 'unit_scale': self.unit_scale, + 'rate': self._ema_dn() / self._ema_dt() if self._ema_dt() else None, + 'bar_format': self.bar_format, 'postfix': self.postfix, + 'unit_divisor': self.unit_divisor, 'initial': self.initial, + 'colour': self.colour} + + def display(self, msg=None, pos=None): + """ + Use `self.sp` to display `msg` in the specified `pos`. + + Consider overloading this function when inheriting to use e.g.: + `self.some_frontend(**self.format_dict)` instead of `self.sp`. + + Parameters + ---------- + msg : str, optional. What to display (default: `repr(self)`). + pos : int, optional. Position to `moveto` + (default: `abs(self.pos)`). + """ + if pos is None: + pos = abs(self.pos) + + nrows = self.nrows or 20 + if pos >= nrows - 1: + if pos >= nrows: + return False + if msg or msg is None: # override at `nrows - 1` + msg = " ... (more hidden) ..." + + if not hasattr(self, "sp"): + raise TqdmDeprecationWarning( + "Please use `tqdm.gui.tqdm(...)`" + " instead of `tqdm(..., gui=True)`\n", + fp_write=getattr(self.fp, 'write', sys.stderr.write)) + + if pos: + self.moveto(pos) + self.sp(self.__str__() if msg is None else msg) + if pos: + self.moveto(-pos) + return True + + @classmethod + @contextmanager + def wrapattr(cls, stream, method, total=None, bytes=True, **tqdm_kwargs): + """ + stream : file-like object. + method : str, "read" or "write". The result of `read()` and + the first argument of `write()` should have a `len()`. + + >>> with tqdm.wrapattr(file_obj, "read", total=file_obj.size) as fobj: + ... while True: + ... chunk = fobj.read(chunk_size) + ... if not chunk: + ... break + """ + with cls(total=total, **tqdm_kwargs) as t: + if bytes: + t.unit = "B" + t.unit_scale = True + t.unit_divisor = 1024 + yield CallbackIOWrapper(t.update, stream, method) + + +def trange(*args, **kwargs): + """Shortcut for tqdm(range(*args), **kwargs).""" + return tqdm(range(*args), **kwargs) diff --git a/env-llmeval/lib/python3.10/site-packages/tqdm/tk.py b/env-llmeval/lib/python3.10/site-packages/tqdm/tk.py new file mode 100644 index 0000000000000000000000000000000000000000..dfebf5c741c936d992c4ac37300562966480c7dc --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/tqdm/tk.py @@ -0,0 +1,196 @@ +""" +Tkinter GUI progressbar decorator for iterators. + +Usage: +>>> from tqdm.tk import trange, tqdm +>>> for i in trange(10): +... ... +""" +import re +import sys +import tkinter +import tkinter.ttk as ttk +from warnings import warn + +from .std import TqdmExperimentalWarning, TqdmWarning +from .std import tqdm as std_tqdm + +__author__ = {"github.com/": ["richardsheridan", "casperdcl"]} +__all__ = ['tqdm_tk', 'ttkrange', 'tqdm', 'trange'] + + +class tqdm_tk(std_tqdm): # pragma: no cover + """ + Experimental Tkinter GUI version of tqdm! + + Note: Window interactivity suffers if `tqdm_tk` is not running within + a Tkinter mainloop and values are generated infrequently. In this case, + consider calling `tqdm_tk.refresh()` frequently in the Tk thread. + """ + + # TODO: @classmethod: write()? + + def __init__(self, *args, **kwargs): + """ + This class accepts the following parameters *in addition* to + the parameters accepted by `tqdm`. + + Parameters + ---------- + grab : bool, optional + Grab the input across all windows of the process. + tk_parent : `tkinter.Wm`, optional + Parent Tk window. + cancel_callback : Callable, optional + Create a cancel button and set `cancel_callback` to be called + when the cancel or window close button is clicked. + """ + kwargs = kwargs.copy() + kwargs['gui'] = True + # convert disable = None to False + kwargs['disable'] = bool(kwargs.get('disable', False)) + self._warn_leave = 'leave' in kwargs + grab = kwargs.pop('grab', False) + tk_parent = kwargs.pop('tk_parent', None) + self._cancel_callback = kwargs.pop('cancel_callback', None) + super(tqdm_tk, self).__init__(*args, **kwargs) + + if self.disable: + return + + if tk_parent is None: # Discover parent widget + try: + tk_parent = tkinter._default_root + except AttributeError: + raise AttributeError( + "`tk_parent` required when using `tkinter.NoDefaultRoot()`") + if tk_parent is None: # use new default root window as display + self._tk_window = tkinter.Tk() + else: # some other windows already exist + self._tk_window = tkinter.Toplevel() + else: + self._tk_window = tkinter.Toplevel(tk_parent) + + warn("GUI is experimental/alpha", TqdmExperimentalWarning, stacklevel=2) + self._tk_dispatching = self._tk_dispatching_helper() + + self._tk_window.protocol("WM_DELETE_WINDOW", self.cancel) + self._tk_window.wm_title(self.desc) + self._tk_window.wm_attributes("-topmost", 1) + self._tk_window.after(0, lambda: self._tk_window.wm_attributes("-topmost", 0)) + self._tk_n_var = tkinter.DoubleVar(self._tk_window, value=0) + self._tk_text_var = tkinter.StringVar(self._tk_window) + pbar_frame = ttk.Frame(self._tk_window, padding=5) + pbar_frame.pack() + _tk_label = ttk.Label(pbar_frame, textvariable=self._tk_text_var, + wraplength=600, anchor="center", justify="center") + _tk_label.pack() + self._tk_pbar = ttk.Progressbar( + pbar_frame, variable=self._tk_n_var, length=450) + if self.total is not None: + self._tk_pbar.configure(maximum=self.total) + else: + self._tk_pbar.configure(mode="indeterminate") + self._tk_pbar.pack() + if self._cancel_callback is not None: + _tk_button = ttk.Button(pbar_frame, text="Cancel", command=self.cancel) + _tk_button.pack() + if grab: + self._tk_window.grab_set() + + def close(self): + if self.disable: + return + + self.disable = True + + with self.get_lock(): + self._instances.remove(self) + + def _close(): + self._tk_window.after('idle', self._tk_window.destroy) + if not self._tk_dispatching: + self._tk_window.update() + + self._tk_window.protocol("WM_DELETE_WINDOW", _close) + + # if leave is set but we are self-dispatching, the left window is + # totally unresponsive unless the user manually dispatches + if not self.leave: + _close() + elif not self._tk_dispatching: + if self._warn_leave: + warn("leave flag ignored if not in tkinter mainloop", + TqdmWarning, stacklevel=2) + _close() + + def clear(self, *_, **__): + pass + + def display(self, *_, **__): + self._tk_n_var.set(self.n) + d = self.format_dict + # remove {bar} + d['bar_format'] = (d['bar_format'] or "{l_bar}{r_bar}").replace( + "{bar}", "") + msg = self.format_meter(**d) + if '' in msg: + msg = "".join(re.split(r'\|?\|?', msg, maxsplit=1)) + self._tk_text_var.set(msg) + if not self._tk_dispatching: + self._tk_window.update() + + def set_description(self, desc=None, refresh=True): + self.set_description_str(desc, refresh) + + def set_description_str(self, desc=None, refresh=True): + self.desc = desc + if not self.disable: + self._tk_window.wm_title(desc) + if refresh and not self._tk_dispatching: + self._tk_window.update() + + def cancel(self): + """ + `cancel_callback()` followed by `close()` + when close/cancel buttons clicked. + """ + if self._cancel_callback is not None: + self._cancel_callback() + self.close() + + def reset(self, total=None): + """ + Resets to 0 iterations for repeated use. + + Parameters + ---------- + total : int or float, optional. Total to use for the new bar. + """ + if hasattr(self, '_tk_pbar'): + if total is None: + self._tk_pbar.configure(maximum=100, mode="indeterminate") + else: + self._tk_pbar.configure(maximum=total, mode="determinate") + super(tqdm_tk, self).reset(total=total) + + @staticmethod + def _tk_dispatching_helper(): + """determine if Tkinter mainloop is dispatching events""" + codes = {tkinter.mainloop.__code__, tkinter.Misc.mainloop.__code__} + for frame in sys._current_frames().values(): + while frame: + if frame.f_code in codes: + return True + frame = frame.f_back + return False + + +def ttkrange(*args, **kwargs): + """Shortcut for `tqdm.tk.tqdm(range(*args), **kwargs)`.""" + return tqdm_tk(range(*args), **kwargs) + + +# Aliases +tqdm = tqdm_tk +trange = ttkrange