Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/Jinja2-3.1.3.dist-info/INSTALLER

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

env-llmeval/lib/python3.10/site-packages/Jinja2-3.1.3.dist-info/LICENSE.rst

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

env-llmeval/lib/python3.10/site-packages/Jinja2-3.1.3.dist-info/METADATA

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

env-llmeval/lib/python3.10/site-packages/Jinja2-3.1.3.dist-info/RECORD

@@ -0,0 +1,58 @@
+Jinja2-3.1.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+Jinja2-3.1.3.dist-info/LICENSE.rst,sha256=O0nc7kEF6ze6wQ-vG-JgQI_oXSUrjp3y4JefweCUQ3s,1475
+Jinja2-3.1.3.dist-info/METADATA,sha256=0cLNbRCI91jytc7Bzv3XAQfZzFDF2gxkJuH46eF5vew,3301
+Jinja2-3.1.3.dist-info/RECORD,,
+Jinja2-3.1.3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+Jinja2-3.1.3.dist-info/entry_points.txt,sha256=zRd62fbqIyfUpsRtU7EVIFyiu1tPwfgO7EvPErnxgTE,59
+Jinja2-3.1.3.dist-info/top_level.txt,sha256=PkeVWtLb3-CqjWi1fO29OCbj55EhX_chhKrCdrVe_zs,7
+jinja2/__init__.py,sha256=NTBwMwsECrdHmxeXF7seusHLzrh6Ldn1A9qhS5cDuf0,1927
+jinja2/__pycache__/__init__.cpython-310.pyc,,
+jinja2/__pycache__/_identifier.cpython-310.pyc,,
+jinja2/__pycache__/async_utils.cpython-310.pyc,,
+jinja2/__pycache__/bccache.cpython-310.pyc,,
+jinja2/__pycache__/compiler.cpython-310.pyc,,
+jinja2/__pycache__/constants.cpython-310.pyc,,
+jinja2/__pycache__/debug.cpython-310.pyc,,
+jinja2/__pycache__/defaults.cpython-310.pyc,,
+jinja2/__pycache__/environment.cpython-310.pyc,,
+jinja2/__pycache__/exceptions.cpython-310.pyc,,
+jinja2/__pycache__/ext.cpython-310.pyc,,
+jinja2/__pycache__/filters.cpython-310.pyc,,
+jinja2/__pycache__/idtracking.cpython-310.pyc,,
+jinja2/__pycache__/lexer.cpython-310.pyc,,
+jinja2/__pycache__/loaders.cpython-310.pyc,,
+jinja2/__pycache__/meta.cpython-310.pyc,,
+jinja2/__pycache__/nativetypes.cpython-310.pyc,,
+jinja2/__pycache__/nodes.cpython-310.pyc,,
+jinja2/__pycache__/optimizer.cpython-310.pyc,,
+jinja2/__pycache__/parser.cpython-310.pyc,,
+jinja2/__pycache__/runtime.cpython-310.pyc,,
+jinja2/__pycache__/sandbox.cpython-310.pyc,,
+jinja2/__pycache__/tests.cpython-310.pyc,,
+jinja2/__pycache__/utils.cpython-310.pyc,,
+jinja2/__pycache__/visitor.cpython-310.pyc,,
+jinja2/_identifier.py,sha256=_zYctNKzRqlk_murTNlzrju1FFJL7Va_Ijqqd7ii2lU,1958
+jinja2/async_utils.py,sha256=dFcmh6lMNfbh7eLKrBio8JqAKLHdZbpCuurFN4OERtY,2447
+jinja2/bccache.py,sha256=mhz5xtLxCcHRAa56azOhphIAe19u1we0ojifNMClDio,14061
+jinja2/compiler.py,sha256=PJzYdRLStlEOqmnQs1YxlizPrJoj3jTZuUleREn6AIQ,72199
+jinja2/constants.py,sha256=GMoFydBF_kdpaRKPoM5cl5MviquVRLVyZtfp5-16jg0,1433
+jinja2/debug.py,sha256=iWJ432RadxJNnaMOPrjIDInz50UEgni3_HKuFXi2vuQ,6299
+jinja2/defaults.py,sha256=boBcSw78h-lp20YbaXSJsqkAI2uN_mD_TtCydpeq5wU,1267
+jinja2/environment.py,sha256=0qldX3VQKZcm6lgn7zHz94oRFow7YPYERiqkquomNjU,61253
+jinja2/exceptions.py,sha256=ioHeHrWwCWNaXX1inHmHVblvc4haO7AXsjCp3GfWvx0,5071
+jinja2/ext.py,sha256=5fnMpllaXkfm2P_93RIvi-OnK7Tk8mCW8Du-GcD12Hc,31844
+jinja2/filters.py,sha256=vYjKb2zaPShvYtn_LpSmqfS8SScbrA_KOanNibsMDIE,53862
+jinja2/idtracking.py,sha256=GfNmadir4oDALVxzn3DL9YInhJDr69ebXeA2ygfuCGA,10704
+jinja2/lexer.py,sha256=DW2nX9zk-6MWp65YR2bqqj0xqCvLtD-u9NWT8AnFRxQ,29726
+jinja2/loaders.py,sha256=ayAwxfrA1SAffQta0nwSDm3TDT4KYiIGN_D9Z45B310,23085
+jinja2/meta.py,sha256=GNPEvifmSaU3CMxlbheBOZjeZ277HThOPUTf1RkppKQ,4396
+jinja2/nativetypes.py,sha256=7GIGALVJgdyL80oZJdQUaUfwSt5q2lSSZbXt0dNf_M4,4210
+jinja2/nodes.py,sha256=i34GPRAZexXMT6bwuf5SEyvdmS-bRCy9KMjwN5O6pjk,34550
+jinja2/optimizer.py,sha256=tHkMwXxfZkbfA1KmLcqmBMSaz7RLIvvItrJcPoXTyD8,1650
+jinja2/parser.py,sha256=Y199wPL-G67gJoi5G_5sHuu9uEP1PJkjjLEW_xTH8-k,39736
+jinja2/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jinja2/runtime.py,sha256=_6LkKIWFJjQdqlrgA3K39zBFQ-7Orm3wGDm96RwxQoE,33406
+jinja2/sandbox.py,sha256=Y0xZeXQnH6EX5VjaV2YixESxoepnRbW_3UeQosaBU3M,14584
+jinja2/tests.py,sha256=Am5Z6Lmfr2XaH_npIfJJ8MdXtWsbLjMULZJulTAj30E,5905
+jinja2/utils.py,sha256=IMwRIcN1SsTw2-jdQtlH2KzNABsXZBW_-tnFXafQBvY,23933
+jinja2/visitor.py,sha256=MH14C6yq24G_KVtWzjwaI7Wg14PCJIYlWW1kpkxYak0,3568

env-llmeval/lib/python3.10/site-packages/Jinja2-3.1.3.dist-info/WHEEL

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

env-llmeval/lib/python3.10/site-packages/Jinja2-3.1.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[babel.extractors]
+jinja2 = jinja2.ext:babel_extract[i18n]

env-llmeval/lib/python3.10/site-packages/Jinja2-3.1.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+jinja2

env-llmeval/lib/python3.10/site-packages/absl/testing/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

env-llmeval/lib/python3.10/site-packages/absl/testing/_bazelize_command.py

@@ -0,0 +1,68 @@
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Internal helper for running tests on Windows Bazel."""
+
+import os
+
+from absl import flags
+
+FLAGS = flags.FLAGS
+
+
+def get_executable_path(py_binary_name):
+  """Returns the executable path of a py_binary.
+
+  This returns the executable path of a py_binary that is in another Bazel
+  target's data dependencies.
+
+  On Linux/macOS, the path and __file__ has the same root directory.
+  On Windows, bazel builds an .exe file and we need to use the MANIFEST file
+  the location the actual binary.
+
+  Args:
+    py_binary_name: string, the name of a py_binary that is in another Bazel
+        target's data dependencies.
+
+  Raises:
+    RuntimeError: Raised when it cannot locate the executable path.
+  """
+
+  if os.name == 'nt':
+    py_binary_name += '.exe'
+    manifest_file = os.path.join(FLAGS.test_srcdir, 'MANIFEST')
+    workspace_name = os.environ['TEST_WORKSPACE']
+    manifest_entry = '{}/{}'.format(workspace_name, py_binary_name)
+    with open(manifest_file, 'r') as manifest_fd:
+      for line in manifest_fd:
+        tokens = line.strip().split(' ')
+        if len(tokens) != 2:
+          continue
+        if manifest_entry == tokens[0]:
+          return tokens[1]
+    raise RuntimeError(
+        'Cannot locate executable path for {}, MANIFEST file: {}.'.format(
+            py_binary_name, manifest_file))
+  else:
+    # NOTE: __file__ may be .py or .pyc, depending on how the module was
+    # loaded and executed.
+    path = __file__
+
+    # Use the package name to find the root directory: every dot is
+    # a directory, plus one for ourselves.
+    for _ in range(__name__.count('.') + 1):
+      path = os.path.dirname(path)
+
+    root_directory = path
+    return os.path.join(root_directory, py_binary_name)

env-llmeval/lib/python3.10/site-packages/absl/testing/flagsaver.py

@@ -0,0 +1,386 @@
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Decorator and context manager for saving and restoring flag values.
+
+There are many ways to save and restore.  Always use the most convenient method
+for a given use case.
+
+Here are examples of each method.  They all call ``do_stuff()`` while
+``FLAGS.someflag`` is temporarily set to ``'foo'``::
+
+    from absl.testing import flagsaver
+
+    # Use a decorator which can optionally override flags via arguments.
+    @flagsaver.flagsaver(someflag='foo')
+    def some_func():
+      do_stuff()
+
+    # Use a decorator which can optionally override flags with flagholders.
+    @flagsaver.flagsaver((module.FOO_FLAG, 'foo'), (other_mod.BAR_FLAG, 23))
+    def some_func():
+      do_stuff()
+
+    # Use a decorator which does not override flags itself.
+    @flagsaver.flagsaver
+    def some_func():
+      FLAGS.someflag = 'foo'
+      do_stuff()
+
+    # Use a context manager which can optionally override flags via arguments.
+    with flagsaver.flagsaver(someflag='foo'):
+      do_stuff()
+
+    # Save and restore the flag values yourself.
+    saved_flag_values = flagsaver.save_flag_values()
+    try:
+      FLAGS.someflag = 'foo'
+      do_stuff()
+    finally:
+      flagsaver.restore_flag_values(saved_flag_values)
+
+    # Use the parsing version to emulate users providing the flags.
+    # Note that all flags must be provided as strings (unparsed).
+    @flagsaver.as_parsed(some_int_flag='123')
+    def some_func():
+      # Because the flag was parsed it is considered "present".
+      assert FLAGS.some_int_flag.present
+      do_stuff()
+
+    # flagsaver.as_parsed() can also be used as a context manager just like
+    # flagsaver.flagsaver()
+    with flagsaver.as_parsed(some_int_flag='123'):
+      do_stuff()
+
+    # The flagsaver.as_parsed() interface also supports FlagHolder objects.
+    @flagsaver.as_parsed((module.FOO_FLAG, 'foo'), (other_mod.BAR_FLAG, '23'))
+    def some_func():
+      do_stuff()
+
+    # Using as_parsed with a multi_X flag requires a sequence of strings.
+    @flagsaver.as_parsed(some_multi_int_flag=['123', '456'])
+    def some_func():
+      assert FLAGS.some_multi_int_flag.present
+      do_stuff()
+
+    # If a flag name includes non-identifier characters it can be specified like
+    # so:
+    @flagsaver.as_parsed(**{'i-like-dashes': 'true'})
+    def some_func():
+      do_stuff()
+
+We save and restore a shallow copy of each Flag object's ``__dict__`` attribute.
+This preserves all attributes of the flag, such as whether or not it was
+overridden from its default value.
+
+WARNING: Currently a flag that is saved and then deleted cannot be restored.  An
+exception will be raised.  However if you *add* a flag after saving flag values,
+and then restore flag values, the added flag will be deleted with no errors.
+"""
+
+import collections
+import functools
+import inspect
+from typing import overload, Any, Callable, Mapping, Tuple, TypeVar, Type, Sequence, Union
+
+from absl import flags
+
+FLAGS = flags.FLAGS
+
+
+# The type of pre/post wrapped functions.
+_CallableT = TypeVar('_CallableT', bound=Callable)
+
+
+@overload
+def flagsaver(*args: Tuple[flags.FlagHolder, Any],
+              **kwargs: Any) -> '_FlagOverrider':
+  ...
+
+
+@overload
+def flagsaver(func: _CallableT) -> _CallableT:
+  ...
+
+
+def flagsaver(*args, **kwargs):
+  """The main flagsaver interface. See module doc for usage."""
+  return _construct_overrider(_FlagOverrider, *args, **kwargs)
+
+
+@overload
+def as_parsed(*args: Tuple[flags.FlagHolder, Union[str, Sequence[str]]],
+              **kwargs: Union[str, Sequence[str]]) -> '_ParsingFlagOverrider':
+  ...
+
+
+@overload
+def as_parsed(func: _CallableT) -> _CallableT:
+  ...
+
+
+def as_parsed(*args, **kwargs):
+  """Overrides flags by parsing strings, saves flag state similar to flagsaver.
+
+  This function can be used as either a decorator or context manager similar to
+  flagsaver.flagsaver(). However, where flagsaver.flagsaver() directly sets the
+  flags to new values, this function will parse the provided arguments as if
+  they were provided on the command line. Among other things, this will cause
+  `FLAGS['flag_name'].present == True`.
+
+  A note on unparsed input: For many flag types, the unparsed version will be
+  a single string. However for multi_x (multi_string, multi_integer, multi_enum)
+  the unparsed version will be a Sequence of strings.
+
+  Args:
+    *args: Tuples of FlagHolders and their unparsed value.
+    **kwargs: The keyword args are flag names, and the values are unparsed
+      values.
+
+  Returns:
+    _ParsingFlagOverrider that serves as a context manager or decorator. Will
+    save previous flag state and parse new flags, then on cleanup it will
+    restore the previous flag state.
+  """
+  return _construct_overrider(_ParsingFlagOverrider, *args, **kwargs)
+
+
+# NOTE: the order of these overload declarations matters. The type checker will
+# pick the first match which could be incorrect.
+@overload
+def _construct_overrider(
+    flag_overrider_cls: Type['_ParsingFlagOverrider'],
+    *args: Tuple[flags.FlagHolder, Union[str, Sequence[str]]],
+    **kwargs: Union[str, Sequence[str]]) -> '_ParsingFlagOverrider':
+  ...
+
+
+@overload
+def _construct_overrider(flag_overrider_cls: Type['_FlagOverrider'],
+                         *args: Tuple[flags.FlagHolder, Any],
+                         **kwargs: Any) -> '_FlagOverrider':
+  ...
+
+
+@overload
+def _construct_overrider(flag_overrider_cls: Type['_FlagOverrider'],
+                         func: _CallableT) -> _CallableT:
+  ...
+
+
+def _construct_overrider(flag_overrider_cls, *args, **kwargs):
+  """Handles the args/kwargs returning an instance of flag_overrider_cls.
+
+  If flag_overrider_cls is _FlagOverrider then values should be native python
+  types matching the python types. Otherwise if flag_overrider_cls is
+  _ParsingFlagOverrider the values should be strings or sequences of strings.
+
+  Args:
+    flag_overrider_cls: The class that will do the overriding.
+    *args: Tuples of FlagHolder and the new flag value.
+    **kwargs: Keword args mapping flag name to new flag value.
+
+  Returns:
+    A _FlagOverrider to be used as a decorator or context manager.
+  """
+  if not args:
+    return flag_overrider_cls(**kwargs)
+  # args can be [func] if used as `@flagsaver` instead of `@flagsaver(...)`
+  if len(args) == 1 and callable(args[0]):
+    if kwargs:
+      raise ValueError(
+          "It's invalid to specify both positional and keyword parameters.")
+    func = args[0]
+    if inspect.isclass(func):
+      raise TypeError('@flagsaver.flagsaver cannot be applied to a class.')
+    return _wrap(flag_overrider_cls, func, {})
+  # args can be a list of (FlagHolder, value) pairs.
+  # In which case they augment any specified kwargs.
+  for arg in args:
+    if not isinstance(arg, tuple) or len(arg) != 2:
+      raise ValueError('Expected (FlagHolder, value) pair, found %r' % (arg,))
+    holder, value = arg
+    if not isinstance(holder, flags.FlagHolder):
+      raise ValueError('Expected (FlagHolder, value) pair, found %r' % (arg,))
+    if holder.name in kwargs:
+      raise ValueError('Cannot set --%s multiple times' % holder.name)
+    kwargs[holder.name] = value
+  return flag_overrider_cls(**kwargs)
+
+
+def save_flag_values(
+    flag_values: flags.FlagValues = FLAGS) -> Mapping[str, Mapping[str, Any]]:
+  """Returns copy of flag values as a dict.
+
+  Args:
+    flag_values: FlagValues, the FlagValues instance with which the flag will be
+      saved. This should almost never need to be overridden.
+
+  Returns:
+    Dictionary mapping keys to values. Keys are flag names, values are
+    corresponding ``__dict__`` members. E.g. ``{'key': value_dict, ...}``.
+  """
+  return {name: _copy_flag_dict(flag_values[name]) for name in flag_values}
+
+
+def restore_flag_values(saved_flag_values: Mapping[str, Mapping[str, Any]],
+                        flag_values: flags.FlagValues = FLAGS):
+  """Restores flag values based on the dictionary of flag values.
+
+  Args:
+    saved_flag_values: {'flag_name': value_dict, ...}
+    flag_values: FlagValues, the FlagValues instance from which the flag will be
+      restored. This should almost never need to be overridden.
+  """
+  new_flag_names = list(flag_values)
+  for name in new_flag_names:
+    saved = saved_flag_values.get(name)
+    if saved is None:
+      # If __dict__ was not saved delete "new" flag.
+      delattr(flag_values, name)
+    else:
+      if flag_values[name].value != saved['_value']:
+        flag_values[name].value = saved['_value']  # Ensure C++ value is set.
+      flag_values[name].__dict__ = saved
+
+
+@overload
+def _wrap(flag_overrider_cls: Type['_FlagOverrider'], func: _CallableT,
+          overrides: Mapping[str, Any]) -> _CallableT:
+  ...
+
+
+@overload
+def _wrap(flag_overrider_cls: Type['_ParsingFlagOverrider'], func: _CallableT,
+          overrides: Mapping[str, Union[str, Sequence[str]]]) -> _CallableT:
+  ...
+
+
+def _wrap(flag_overrider_cls, func, overrides):
+  """Creates a wrapper function that saves/restores flag values.
+
+  Args:
+    flag_overrider_cls: The class that will be used as a context manager.
+    func: This will be called between saving flags and restoring flags.
+    overrides: Flag names mapped to their values. These flags will be set after
+      saving the original flag state. The type of the values depends on if
+      _FlagOverrider or _ParsingFlagOverrider was specified.
+
+  Returns:
+    A wrapped version of func.
+  """
+
+  @functools.wraps(func)
+  def _flagsaver_wrapper(*args, **kwargs):
+    """Wrapper function that saves and restores flags."""
+    with flag_overrider_cls(**overrides):
+      return func(*args, **kwargs)
+
+  return _flagsaver_wrapper
+
+
+class _FlagOverrider(object):
+  """Overrides flags for the duration of the decorated function call.
+
+  It also restores all original values of flags after decorated method
+  completes.
+  """
+
+  def __init__(self, **overrides: Any):
+    self._overrides = overrides
+    self._saved_flag_values = None
+
+  def __call__(self, func: _CallableT) -> _CallableT:
+    if inspect.isclass(func):
+      raise TypeError('flagsaver cannot be applied to a class.')
+    return _wrap(self.__class__, func, self._overrides)
+
+  def __enter__(self):
+    self._saved_flag_values = save_flag_values(FLAGS)
+    try:
+      FLAGS._set_attributes(**self._overrides)
+    except:
+      # It may fail because of flag validators.
+      restore_flag_values(self._saved_flag_values, FLAGS)
+      raise
+
+  def __exit__(self, exc_type, exc_value, traceback):
+    restore_flag_values(self._saved_flag_values, FLAGS)
+
+
+class _ParsingFlagOverrider(_FlagOverrider):
+  """Context manager for overriding flags.
+
+  Simulates command line parsing.
+
+  This is simlar to _FlagOverrider except that all **overrides should be
+  strings or sequences of strings, and when context is entered this class calls
+  .parse(value)
+
+  This results in the flags having .present set properly.
+  """
+
+  def __init__(self, **overrides: Union[str, Sequence[str]]):
+    for flag_name, new_value in overrides.items():
+      if isinstance(new_value, str):
+        continue
+      if (isinstance(new_value, collections.abc.Sequence) and
+          all(isinstance(single_value, str) for single_value in new_value)):
+        continue
+      raise TypeError(
+          f'flagsaver.as_parsed() cannot parse {flag_name}. Expected a single '
+          f'string or sequence of strings but {type(new_value)} was provided.')
+    super().__init__(**overrides)
+
+  def __enter__(self):
+    self._saved_flag_values = save_flag_values(FLAGS)
+    try:
+      for flag_name, unparsed_value in self._overrides.items():
+        # LINT.IfChange(flag_override_parsing)
+        FLAGS[flag_name].parse(unparsed_value)
+        FLAGS[flag_name].using_default_value = False
+        # LINT.ThenChange()
+
+      # Perform the validation on all modified flags. This is something that
+      # FLAGS._set_attributes() does for you in _FlagOverrider.
+      for flag_name in self._overrides:
+        FLAGS._assert_validators(FLAGS[flag_name].validators)
+
+    except KeyError as e:
+      # If a flag doesn't exist, an UnrecognizedFlagError is more specific.
+      restore_flag_values(self._saved_flag_values, FLAGS)
+      raise flags.UnrecognizedFlagError('Unknown command line flag.') from e
+
+    except:
+      # It may fail because of flag validators or general parsing issues.
+      restore_flag_values(self._saved_flag_values, FLAGS)
+      raise
+
+
+def _copy_flag_dict(flag: flags.Flag) -> Mapping[str, Any]:
+  """Returns a copy of the flag object's ``__dict__``.
+
+  It's mostly a shallow copy of the ``__dict__``, except it also does a shallow
+  copy of the validator list.
+
+  Args:
+    flag: flags.Flag, the flag to copy.
+
+  Returns:
+    A copy of the flag object's ``__dict__``.
+  """
+  copy = flag.__dict__.copy()
+  copy['_value'] = flag.value  # Ensure correct restore for C++ flags.
+  copy['validators'] = list(flag.validators)
+  return copy

env-llmeval/lib/python3.10/site-packages/absl/testing/parameterized.py

@@ -0,0 +1,724 @@
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Adds support for parameterized tests to Python's unittest TestCase class.
+
+A parameterized test is a method in a test case that is invoked with different
+argument tuples.
+
+A simple example::
+
+    class AdditionExample(parameterized.TestCase):
+      @parameterized.parameters(
+        (1, 2, 3),
+        (4, 5, 9),
+        (1, 1, 3))
+      def testAddition(self, op1, op2, result):
+        self.assertEqual(result, op1 + op2)
+
+Each invocation is a separate test case and properly isolated just
+like a normal test method, with its own setUp/tearDown cycle. In the
+example above, there are three separate testcases, one of which will
+fail due to an assertion error (1 + 1 != 3).
+
+Parameters for individual test cases can be tuples (with positional parameters)
+or dictionaries (with named parameters)::
+
+    class AdditionExample(parameterized.TestCase):
+      @parameterized.parameters(
+        {'op1': 1, 'op2': 2, 'result': 3},
+        {'op1': 4, 'op2': 5, 'result': 9},
+      )
+      def testAddition(self, op1, op2, result):
+        self.assertEqual(result, op1 + op2)
+
+If a parameterized test fails, the error message will show the
+original test name and the parameters for that test.
+
+The id method of the test, used internally by the unittest framework, is also
+modified to show the arguments (but note that the name reported by `id()`
+doesn't match the actual test name, see below). To make sure that test names
+stay the same across several invocations, object representations like::
+
+    >>> class Foo(object):
+    ...  pass
+    >>> repr(Foo())
+    '<__main__.Foo object at 0x23d8610>'
+
+are turned into ``__main__.Foo``. When selecting a subset of test cases to run
+on the command-line, the test cases contain an index suffix for each argument
+in the order they were passed to :func:`parameters` (eg. testAddition0,
+testAddition1, etc.) This naming scheme is subject to change; for more reliable
+and stable names, especially in test logs, use :func:`named_parameters` instead.
+
+Tests using :func:`named_parameters` are similar to :func:`parameters`, except
+only tuples or dicts of args are supported. For tuples, the first parameter arg
+has to be a string (or an object that returns an apt name when converted via
+``str()``). For dicts, a value for the key ``testcase_name`` must be present and
+must be a string (or an object that returns an apt name when converted via
+``str()``)::
+
+    class NamedExample(parameterized.TestCase):
+      @parameterized.named_parameters(
+        ('Normal', 'aa', 'aaa', True),
+        ('EmptyPrefix', '', 'abc', True),
+        ('BothEmpty', '', '', True))
+      def testStartsWith(self, prefix, string, result):
+        self.assertEqual(result, string.startswith(prefix))
+
+    class NamedExample(parameterized.TestCase):
+      @parameterized.named_parameters(
+        {'testcase_name': 'Normal',
+          'result': True, 'string': 'aaa', 'prefix': 'aa'},
+        {'testcase_name': 'EmptyPrefix',
+          'result': True, 'string': 'abc', 'prefix': ''},
+        {'testcase_name': 'BothEmpty',
+          'result': True, 'string': '', 'prefix': ''})
+      def testStartsWith(self, prefix, string, result):
+        self.assertEqual(result, string.startswith(prefix))
+
+Named tests also have the benefit that they can be run individually
+from the command line::
+
+    $ testmodule.py NamedExample.testStartsWithNormal
+    .
+    --------------------------------------------------------------------
+    Ran 1 test in 0.000s
+
+    OK
+
+Parameterized Classes
+=====================
+
+If invocation arguments are shared across test methods in a single
+TestCase class, instead of decorating all test methods
+individually, the class itself can be decorated::
+
+    @parameterized.parameters(
+      (1, 2, 3),
+      (4, 5, 9))
+    class ArithmeticTest(parameterized.TestCase):
+      def testAdd(self, arg1, arg2, result):
+        self.assertEqual(arg1 + arg2, result)
+
+      def testSubtract(self, arg1, arg2, result):
+        self.assertEqual(result - arg1, arg2)
+
+Inputs from Iterables
+=====================
+
+If parameters should be shared across several test cases, or are dynamically
+created from other sources, a single non-tuple iterable can be passed into
+the decorator. This iterable will be used to obtain the test cases::
+
+    class AdditionExample(parameterized.TestCase):
+      @parameterized.parameters(
+        c.op1, c.op2, c.result for c in testcases
+      )
+      def testAddition(self, op1, op2, result):
+        self.assertEqual(result, op1 + op2)
+
+
+Single-Argument Test Methods
+============================
+
+If a test method takes only one argument, the single arguments must not be
+wrapped into a tuple::
+
+    class NegativeNumberExample(parameterized.TestCase):
+      @parameterized.parameters(
+        -1, -3, -4, -5
+      )
+      def testIsNegative(self, arg):
+        self.assertTrue(IsNegative(arg))
+
+
+List/tuple as a Single Argument
+===============================
+
+If a test method takes a single argument of a list/tuple, it must be wrapped
+inside a tuple::
+
+    class ZeroSumExample(parameterized.TestCase):
+      @parameterized.parameters(
+        ([-1, 0, 1], ),
+        ([-2, 0, 2], ),
+      )
+      def testSumIsZero(self, arg):
+        self.assertEqual(0, sum(arg))
+
+
+Cartesian product of Parameter Values as Parameterized Test Cases
+=================================================================
+
+If required to test method over a cartesian product of parameters,
+`parameterized.product` may be used to facilitate generation of parameters
+test combinations::
+
+    class TestModuloExample(parameterized.TestCase):
+      @parameterized.product(
+          num=[0, 20, 80],
+          modulo=[2, 4],
+          expected=[0]
+      )
+      def testModuloResult(self, num, modulo, expected):
+        self.assertEqual(expected, num % modulo)
+
+This results in 6 test cases being created - one for each combination of the
+parameters. It is also possible to supply sequences of keyword argument dicts
+as elements of the cartesian product::
+
+    @parameterized.product(
+        (dict(num=5, modulo=3, expected=2),
+         dict(num=7, modulo=4, expected=3)),
+        dtype=(int, float)
+    )
+    def testModuloResult(self, num, modulo, expected, dtype):
+      self.assertEqual(expected, dtype(num) % modulo)
+
+This results in 4 test cases being created - for each of the two sets of test
+data (supplied as kwarg dicts) and for each of the two data types (supplied as
+a named parameter). Multiple keyword argument dicts may be supplied if required.
+
+Async Support
+=============
+
+If a test needs to call async functions, it can inherit from both
+parameterized.TestCase and another TestCase that supports async calls, such
+as [asynctest](https://github.com/Martiusweb/asynctest)::
+
+  import asynctest
+
+  class AsyncExample(parameterized.TestCase, asynctest.TestCase):
+    @parameterized.parameters(
+      ('a', 1),
+      ('b', 2),
+    )
+    async def testSomeAsyncFunction(self, arg, expected):
+      actual = await someAsyncFunction(arg)
+      self.assertEqual(actual, expected)
+"""
+
+from collections import abc
+import functools
+import inspect
+import itertools
+import re
+import types
+import unittest
+import warnings
+
+from absl.testing import absltest
+
+
+_ADDR_RE = re.compile(r'\<([a-zA-Z0-9_\-\.]+) object at 0x[a-fA-F0-9]+\>')
+_NAMED = object()
+_ARGUMENT_REPR = object()
+_NAMED_DICT_KEY = 'testcase_name'
+
+
+class NoTestsError(Exception):
+  """Raised when parameterized decorators do not generate any tests."""
+
+
+class DuplicateTestNameError(Exception):
+  """Raised when a parameterized test has the same test name multiple times."""
+
+  def __init__(self, test_class_name, new_test_name, original_test_name):
+    super(DuplicateTestNameError, self).__init__(
+        'Duplicate parameterized test name in {}: generated test name {!r} '
+        '(generated from {!r}) already exists. Consider using '
+        'named_parameters() to give your tests unique names and/or renaming '
+        'the conflicting test method.'.format(
+            test_class_name, new_test_name, original_test_name))
+
+
+def _clean_repr(obj):
+  return _ADDR_RE.sub(r'<\1>', repr(obj))
+
+
+def _non_string_or_bytes_iterable(obj):
+  return (isinstance(obj, abc.Iterable) and not isinstance(obj, str) and
+          not isinstance(obj, bytes))
+
+
+def _format_parameter_list(testcase_params):
+  if isinstance(testcase_params, abc.Mapping):
+    return ', '.join('%s=%s' % (argname, _clean_repr(value))
+                     for argname, value in testcase_params.items())
+  elif _non_string_or_bytes_iterable(testcase_params):
+    return ', '.join(map(_clean_repr, testcase_params))
+  else:
+    return _format_parameter_list((testcase_params,))
+
+
+def _async_wrapped(func):
+  @functools.wraps(func)
+  async def wrapper(*args, **kwargs):
+    return await func(*args, **kwargs)
+  return wrapper
+
+
+class _ParameterizedTestIter(object):
+  """Callable and iterable class for producing new test cases."""
+
+  def __init__(self, test_method, testcases, naming_type, original_name=None):
+    """Returns concrete test functions for a test and a list of parameters.
+
+    The naming_type is used to determine the name of the concrete
+    functions as reported by the unittest framework. If naming_type is
+    _FIRST_ARG, the testcases must be tuples, and the first element must
+    have a string representation that is a valid Python identifier.
+
+    Args:
+      test_method: The decorated test method.
+      testcases: (list of tuple/dict) A list of parameter tuples/dicts for
+          individual test invocations.
+      naming_type: The test naming type, either _NAMED or _ARGUMENT_REPR.
+      original_name: The original test method name. When decorated on a test
+          method, None is passed to __init__ and test_method.__name__ is used.
+          Note test_method.__name__ might be different than the original defined
+          test method because of the use of other decorators. A more accurate
+          value is set by TestGeneratorMetaclass.__new__ later.
+    """
+    self._test_method = test_method
+    self.testcases = testcases
+    self._naming_type = naming_type
+    if original_name is None:
+      original_name = test_method.__name__
+    self._original_name = original_name
+    self.__name__ = _ParameterizedTestIter.__name__
+
+  def __call__(self, *args, **kwargs):
+    raise RuntimeError('You appear to be running a parameterized test case '
+                       'without having inherited from parameterized.'
+                       'TestCase. This is bad because none of '
+                       'your test cases are actually being run. You may also '
+                       'be using another decorator before the parameterized '
+                       'one, in which case you should reverse the order.')
+
+  def __iter__(self):
+    test_method = self._test_method
+    naming_type = self._naming_type
+
+    def make_bound_param_test(testcase_params):
+      @functools.wraps(test_method)
+      def bound_param_test(self):
+        if isinstance(testcase_params, abc.Mapping):
+          return test_method(self, **testcase_params)
+        elif _non_string_or_bytes_iterable(testcase_params):
+          return test_method(self, *testcase_params)
+        else:
+          return test_method(self, testcase_params)
+
+      if naming_type is _NAMED:
+        # Signal the metaclass that the name of the test function is unique
+        # and descriptive.
+        bound_param_test.__x_use_name__ = True
+
+        testcase_name = None
+        if isinstance(testcase_params, abc.Mapping):
+          if _NAMED_DICT_KEY not in testcase_params:
+            raise RuntimeError(
+                'Dict for named tests must contain key "%s"' % _NAMED_DICT_KEY)
+          # Create a new dict to avoid modifying the supplied testcase_params.
+          testcase_name = testcase_params[_NAMED_DICT_KEY]
+          testcase_params = {
+              k: v for k, v in testcase_params.items() if k != _NAMED_DICT_KEY
+          }
+        elif _non_string_or_bytes_iterable(testcase_params):
+          if not isinstance(testcase_params[0], str):
+            raise RuntimeError(
+                'The first element of named test parameters is the test name '
+                'suffix and must be a string')
+          testcase_name = testcase_params[0]
+          testcase_params = testcase_params[1:]
+        else:
+          raise RuntimeError(
+              'Named tests must be passed a dict or non-string iterable.')
+
+        test_method_name = self._original_name
+        # Support PEP-8 underscore style for test naming if used.
+        if (test_method_name.startswith('test_')
+            and testcase_name
+            and not testcase_name.startswith('_')):
+          test_method_name += '_'
+
+        bound_param_test.__name__ = test_method_name + str(testcase_name)
+      elif naming_type is _ARGUMENT_REPR:
+        # If it's a generator, convert it to a tuple and treat them as
+        # parameters.
+        if isinstance(testcase_params, types.GeneratorType):
+          testcase_params = tuple(testcase_params)
+        # The metaclass creates a unique, but non-descriptive method name for
+        # _ARGUMENT_REPR tests using an indexed suffix.
+        # To keep test names descriptive, only the original method name is used.
+        # To make sure test names are unique, we add a unique descriptive suffix
+        # __x_params_repr__ for every test.
+        params_repr = '(%s)' % (_format_parameter_list(testcase_params),)
+        bound_param_test.__x_params_repr__ = params_repr
+      else:
+        raise RuntimeError('%s is not a valid naming type.' % (naming_type,))
+
+      bound_param_test.__doc__ = '%s(%s)' % (
+          bound_param_test.__name__, _format_parameter_list(testcase_params))
+      if test_method.__doc__:
+        bound_param_test.__doc__ += '\n%s' % (test_method.__doc__,)
+      if inspect.iscoroutinefunction(test_method):
+        return _async_wrapped(bound_param_test)
+      return bound_param_test
+
+    return (make_bound_param_test(c) for c in self.testcases)
+
+
+def _modify_class(class_object, testcases, naming_type):
+  assert not getattr(class_object, '_test_params_reprs', None), (
+      'Cannot add parameters to %s. Either it already has parameterized '
+      'methods, or its super class is also a parameterized class.' % (
+          class_object,))
+  # NOTE: _test_params_repr is private to parameterized.TestCase and it's
+  # metaclass; do not use it outside of those classes.
+  class_object._test_params_reprs = test_params_reprs = {}
+  for name, obj in class_object.__dict__.copy().items():
+    if (name.startswith(unittest.TestLoader.testMethodPrefix)
+        and isinstance(obj, types.FunctionType)):
+      delattr(class_object, name)
+      methods = {}
+      _update_class_dict_for_param_test_case(
+          class_object.__name__, methods, test_params_reprs, name,
+          _ParameterizedTestIter(obj, testcases, naming_type, name))
+      for meth_name, meth in methods.items():
+        setattr(class_object, meth_name, meth)
+
+
+def _parameter_decorator(naming_type, testcases):
+  """Implementation of the parameterization decorators.
+
+  Args:
+    naming_type: The naming type.
+    testcases: Testcase parameters.
+
+  Raises:
+    NoTestsError: Raised when the decorator generates no tests.
+
+  Returns:
+    A function for modifying the decorated object.
+  """
+  def _apply(obj):
+    if isinstance(obj, type):
+      _modify_class(obj, testcases, naming_type)
+      return obj
+    else:
+      return _ParameterizedTestIter(obj, testcases, naming_type)
+
+  if (len(testcases) == 1 and
+      not isinstance(testcases[0], tuple) and
+      not isinstance(testcases[0], abc.Mapping)):
+    # Support using a single non-tuple parameter as a list of test cases.
+    # Note that the single non-tuple parameter can't be Mapping either, which
+    # means a single dict parameter case.
+    assert _non_string_or_bytes_iterable(testcases[0]), (
+        'Single parameter argument must be a non-string non-Mapping iterable')
+    testcases = testcases[0]
+
+  if not isinstance(testcases, abc.Sequence):
+    testcases = list(testcases)
+  if not testcases:
+    raise NoTestsError(
+        'parameterized test decorators did not generate any tests. '
+        'Make sure you specify non-empty parameters, '
+        'and do not reuse generators more than once.')
+
+  return _apply
+
+
+def parameters(*testcases):
+  """A decorator for creating parameterized tests.
+
+  See the module docstring for a usage example.
+
+  Args:
+    *testcases: Parameters for the decorated method, either a single
+        iterable, or a list of tuples/dicts/objects (for tests with only one
+        argument).
+
+  Raises:
+    NoTestsError: Raised when the decorator generates no tests.
+
+  Returns:
+     A test generator to be handled by TestGeneratorMetaclass.
+  """
+  return _parameter_decorator(_ARGUMENT_REPR, testcases)
+
+
+def named_parameters(*testcases):
+  """A decorator for creating parameterized tests.
+
+  See the module docstring for a usage example. For every parameter tuple
+  passed, the first element of the tuple should be a string and will be appended
+  to the name of the test method. Each parameter dict passed must have a value
+  for the key "testcase_name", the string representation of that value will be
+  appended to the name of the test method.
+
+  Args:
+    *testcases: Parameters for the decorated method, either a single iterable,
+        or a list of tuples or dicts.
+
+  Raises:
+    NoTestsError: Raised when the decorator generates no tests.
+
+  Returns:
+     A test generator to be handled by TestGeneratorMetaclass.
+  """
+  return _parameter_decorator(_NAMED, testcases)
+
+
+def product(*kwargs_seqs, **testgrid):
+  """A decorator for running tests over cartesian product of parameters values.
+
+  See the module docstring for a usage example. The test will be run for every
+  possible combination of the parameters.
+
+  Args:
+    *kwargs_seqs: Each positional parameter is a sequence of keyword arg dicts;
+      every test case generated will include exactly one kwargs dict from each
+      positional parameter; these will then be merged to form an overall list
+      of arguments for the test case.
+    **testgrid: A mapping of parameter names and their possible values. Possible
+      values should given as either a list or a tuple.
+
+  Raises:
+    NoTestsError: Raised when the decorator generates no tests.
+
+  Returns:
+     A test generator to be handled by TestGeneratorMetaclass.
+  """
+
+  for name, values in testgrid.items():
+    assert isinstance(values, (list, tuple)), (
+        'Values of {} must be given as list or tuple, found {}'.format(
+            name, type(values)))
+
+  prior_arg_names = set()
+  for kwargs_seq in kwargs_seqs:
+    assert ((isinstance(kwargs_seq, (list, tuple))) and
+            all(isinstance(kwargs, dict) for kwargs in kwargs_seq)), (
+                'Positional parameters must be a sequence of keyword arg'
+                'dicts, found {}'
+                .format(kwargs_seq))
+    if kwargs_seq:
+      arg_names = set(kwargs_seq[0])
+      assert all(set(kwargs) == arg_names for kwargs in kwargs_seq), (
+          'Keyword argument dicts within a single parameter must all have the '
+          'same keys, found {}'.format(kwargs_seq))
+      assert not (arg_names & prior_arg_names), (
+          'Keyword argument dict sequences must all have distinct argument '
+          'names, found duplicate(s) {}'
+          .format(sorted(arg_names & prior_arg_names)))
+      prior_arg_names |= arg_names
+
+  assert not (prior_arg_names & set(testgrid)), (
+      'Arguments supplied in kwargs dicts in positional parameters must not '
+      'overlap with arguments supplied as named parameters; found duplicate '
+      'argument(s) {}'.format(sorted(prior_arg_names & set(testgrid))))
+
+  # Convert testgrid into a sequence of sequences of kwargs dicts and combine
+  # with the positional parameters.
+  # So foo=[1,2], bar=[3,4] --> [[{foo: 1}, {foo: 2}], [{bar: 3, bar: 4}]]
+  testgrid = (tuple({k: v} for v in vs) for k, vs in testgrid.items())
+  testgrid = tuple(kwargs_seqs) + tuple(testgrid)
+
+  # Create all possible combinations of parameters as a cartesian product
+  # of parameter values.
+  testcases = [
+      dict(itertools.chain.from_iterable(case.items()
+                                         for case in cases))
+      for cases in itertools.product(*testgrid)
+  ]
+  return _parameter_decorator(_ARGUMENT_REPR, testcases)
+
+
+class TestGeneratorMetaclass(type):
+  """Metaclass for adding tests generated by parameterized decorators."""
+
+  def __new__(cls, class_name, bases, dct):
+    # NOTE: _test_params_repr is private to parameterized.TestCase and it's
+    # metaclass; do not use it outside of those classes.
+    test_params_reprs = dct.setdefault('_test_params_reprs', {})
+    for name, obj in dct.copy().items():
+      if (name.startswith(unittest.TestLoader.testMethodPrefix) and
+          _non_string_or_bytes_iterable(obj)):
+        # NOTE: `obj` might not be a _ParameterizedTestIter in two cases:
+        # 1. a class-level iterable named test* that isn't a test, such as
+        #    a list of something. Such attributes get deleted from the class.
+        #
+        # 2. If a decorator is applied to the parameterized test, e.g.
+        #    @morestuff
+        #    @parameterized.parameters(...)
+        #    def test_foo(...): ...
+        #
+        #   This is OK so long as the underlying parameterized function state
+        #   is forwarded (e.g. using functool.wraps() and **without**
+        #   accessing explicitly accessing the internal attributes.
+        if isinstance(obj, _ParameterizedTestIter):
+          # Update the original test method name so it's more accurate.
+          # The mismatch might happen when another decorator is used inside
+          # the parameterized decrators, and the inner decorator doesn't
+          # preserve its __name__.
+          obj._original_name = name
+        iterator = iter(obj)
+        dct.pop(name)
+        _update_class_dict_for_param_test_case(
+            class_name, dct, test_params_reprs, name, iterator)
+    # If the base class is a subclass of parameterized.TestCase, inherit its
+    # _test_params_reprs too.
+    for base in bases:
+      # Check if the base has _test_params_reprs first, then check if it's a
+      # subclass of parameterized.TestCase. Otherwise when this is called for
+      # the parameterized.TestCase definition itself, this raises because
+      # itself is not defined yet. This works as long as absltest.TestCase does
+      # not define _test_params_reprs.
+      base_test_params_reprs = getattr(base, '_test_params_reprs', None)
+      if base_test_params_reprs and issubclass(base, TestCase):
+        for test_method, test_method_id in base_test_params_reprs.items():
+          # test_method may both exists in base and this class.
+          # This class's method overrides base class's.
+          # That's why it should only inherit it if it does not exist.
+          test_params_reprs.setdefault(test_method, test_method_id)
+
+    return type.__new__(cls, class_name, bases, dct)
+
+
+def _update_class_dict_for_param_test_case(
+    test_class_name, dct, test_params_reprs, name, iterator):
+  """Adds individual test cases to a dictionary.
+
+  Args:
+    test_class_name: The name of the class tests are added to.
+    dct: The target dictionary.
+    test_params_reprs: The dictionary for mapping names to test IDs.
+    name: The original name of the test case.
+    iterator: The iterator generating the individual test cases.
+
+  Raises:
+    DuplicateTestNameError: Raised when a test name occurs multiple times.
+    RuntimeError: If non-parameterized functions are generated.
+  """
+  for idx, func in enumerate(iterator):
+    assert callable(func), 'Test generators must yield callables, got %r' % (
+        func,)
+    if not (getattr(func, '__x_use_name__', None) or
+            getattr(func, '__x_params_repr__', None)):
+      raise RuntimeError(
+          '{}.{} generated a test function without using the parameterized '
+          'decorators. Only tests generated using the decorators are '
+          'supported.'.format(test_class_name, name))
+
+    if getattr(func, '__x_use_name__', False):
+      original_name = func.__name__
+      new_name = original_name
+    else:
+      original_name = name
+      new_name = '%s%d' % (original_name, idx)
+
+    if new_name in dct:
+      raise DuplicateTestNameError(test_class_name, new_name, original_name)
+
+    dct[new_name] = func
+    test_params_reprs[new_name] = getattr(func, '__x_params_repr__', '')
+
+
+class TestCase(absltest.TestCase, metaclass=TestGeneratorMetaclass):
+  """Base class for test cases using the parameters decorator."""
+
+  # visibility: private; do not call outside this class.
+  def _get_params_repr(self):
+    return self._test_params_reprs.get(self._testMethodName, '')
+
+  def __str__(self):
+    params_repr = self._get_params_repr()
+    if params_repr:
+      params_repr = ' ' + params_repr
+    return '{}{} ({})'.format(
+        self._testMethodName, params_repr,
+        unittest.util.strclass(self.__class__))
+
+  def id(self):
+    """Returns the descriptive ID of the test.
+
+    This is used internally by the unittesting framework to get a name
+    for the test to be used in reports.
+
+    Returns:
+      The test id.
+    """
+    base = super(TestCase, self).id()
+    params_repr = self._get_params_repr()
+    if params_repr:
+      # We include the params in the id so that, when reported in the
+      # test.xml file, the value is more informative than just "test_foo0".
+      # Use a space to separate them so that it's copy/paste friendly and
+      # easy to identify the actual test id.
+      return '{} {}'.format(base, params_repr)
+    else:
+      return base
+
+
+# This function is kept CamelCase because it's used as a class's base class.
+def CoopTestCase(other_base_class):  # pylint: disable=invalid-name
+  """Returns a new base class with a cooperative metaclass base.
+
+  This enables the TestCase to be used in combination
+  with other base classes that have custom metaclasses, such as
+  ``mox.MoxTestBase``.
+
+  Only works with metaclasses that do not override ``type.__new__``.
+
+  Example::
+
+      from absl.testing import parameterized
+
+      class ExampleTest(parameterized.CoopTestCase(OtherTestCase)):
+        ...
+
+  Args:
+    other_base_class: (class) A test case base class.
+
+  Returns:
+    A new class object.
+  """
+  # If the other base class has a metaclass of 'type' then trying to combine
+  # the metaclasses will result in an MRO error. So simply combine them and
+  # return.
+  if type(other_base_class) == type:  # pylint: disable=unidiomatic-typecheck
+    warnings.warn(
+        'CoopTestCase is only necessary when combining with a class that uses'
+        ' a metaclass. Use multiple inheritance like this instead: class'
+        f' ExampleTest(paramaterized.TestCase, {other_base_class.__name__}):',
+        stacklevel=2,
+    )
+
+    class CoopTestCaseBase(other_base_class, TestCase):
+      pass
+
+    return CoopTestCaseBase
+  else:
+
+    class CoopMetaclass(type(other_base_class), TestGeneratorMetaclass):  # pylint: disable=unused-variable
+      pass
+
+    class CoopTestCaseBase(other_base_class, TestCase, metaclass=CoopMetaclass):
+      pass
+
+    return CoopTestCaseBase

env-llmeval/lib/python3.10/site-packages/absl/testing/xml_reporter.py

@@ -0,0 +1,563 @@
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""A Python test reporter that generates test reports in JUnit XML format."""
+
+import datetime
+import re
+import sys
+import threading
+import time
+import traceback
+import unittest
+from xml.sax import saxutils
+from absl.testing import _pretty_print_reporter
+
+
+# See http://www.w3.org/TR/REC-xml/#NT-Char
+_bad_control_character_codes = set(range(0, 0x20)) - {0x9, 0xA, 0xD}
+
+
+_control_character_conversions = {
+    chr(i): '\\x{:02x}'.format(i) for i in _bad_control_character_codes}
+
+
+_escape_xml_attr_conversions = {
+    '"': '"',
+    "'": ''',
+    '\n': '
',
+    '\t': '	',
+    '\r': '
',
+    ' ': ' '}
+_escape_xml_attr_conversions.update(_control_character_conversions)
+
+
+# When class or module level function fails, unittest/suite.py adds a
+# _ErrorHolder instance instead of a real TestCase, and it has a description
+# like "setUpClass (__main__.MyTestCase)".
+_CLASS_OR_MODULE_LEVEL_TEST_DESC_REGEX = re.compile(r'^(\w+) \((\S+)\)$')
+
+
+# NOTE: while saxutils.quoteattr() theoretically does the same thing; it
+# seems to often end up being too smart for it's own good not escaping properly.
+# This function is much more reliable.
+def _escape_xml_attr(content):
+  """Escapes xml attributes."""
+  # Note: saxutils doesn't escape the quotes.
+  return saxutils.escape(content, _escape_xml_attr_conversions)
+
+
+def _escape_cdata(s):
+  """Escapes a string to be used as XML CDATA.
+
+  CDATA characters are treated strictly as character data, not as XML markup,
+  but there are still certain restrictions on them.
+
+  Args:
+    s: the string to be escaped.
+  Returns:
+    An escaped version of the input string.
+  """
+  for char, escaped in _control_character_conversions.items():
+    s = s.replace(char, escaped)
+  return s.replace(']]>', ']] >')
+
+
+def _iso8601_timestamp(timestamp):
+  """Produces an ISO8601 datetime.
+
+  Args:
+    timestamp: an Epoch based timestamp in seconds.
+
+  Returns:
+    A iso8601 format timestamp if the input is a valid timestamp, None otherwise
+  """
+  if timestamp is None or timestamp < 0:
+    return None
+  return datetime.datetime.fromtimestamp(
+      timestamp, tz=datetime.timezone.utc).isoformat()
+
+
+def _print_xml_element_header(element, attributes, stream, indentation=''):
+  """Prints an XML header of an arbitrary element.
+
+  Args:
+    element: element name (testsuites, testsuite, testcase)
+    attributes: 2-tuple list with (attributes, values) already escaped
+    stream: output stream to write test report XML to
+    indentation: indentation added to the element header
+  """
+  stream.write('%s<%s' % (indentation, element))
+  for attribute in attributes:
+    if (len(attribute) == 2 and attribute[0] is not None and
+        attribute[1] is not None):
+      stream.write(' %s="%s"' % (attribute[0], attribute[1]))
+  stream.write('>\n')
+
+# Copy time.time which ensures the real time is used internally.
+# This prevents bad interactions with tests that stub out time.
+_time_copy = time.time
+
+if hasattr(traceback, '_some_str'):
+  # Use the traceback module str function to format safely.
+  _safe_str = traceback._some_str
+else:
+  _safe_str = str  # pylint: disable=invalid-name
+
+
+class _TestCaseResult(object):
+  """Private helper for _TextAndXMLTestResult that represents a test result.
+
+  Attributes:
+    test: A TestCase instance of an individual test method.
+    name: The name of the individual test method.
+    full_class_name: The full name of the test class.
+    run_time: The duration (in seconds) it took to run the test.
+    start_time: Epoch relative timestamp of when test started (in seconds)
+    errors: A list of error 4-tuples. Error tuple entries are
+        1) a string identifier of either "failure" or "error"
+        2) an exception_type
+        3) an exception_message
+        4) a string version of a sys.exc_info()-style tuple of values
+           ('error', err[0], err[1], self._exc_info_to_string(err))
+           If the length of errors is 0, then the test is either passed or
+           skipped.
+    skip_reason: A string explaining why the test was skipped.
+  """
+
+  def __init__(self, test):
+    self.run_time = -1
+    self.start_time = -1
+    self.skip_reason = None
+    self.errors = []
+    self.test = test
+
+    # Parse the test id to get its test name and full class path.
+    # Unfortunately there is no better way of knowning the test and class.
+    # Worse, unittest uses _ErrorHandler instances to represent class / module
+    # level failures.
+    test_desc = test.id() or str(test)
+    # Check if it's something like "setUpClass (__main__.TestCase)".
+    match = _CLASS_OR_MODULE_LEVEL_TEST_DESC_REGEX.match(test_desc)
+    if match:
+      name = match.group(1)
+      full_class_name = match.group(2)
+    else:
+      class_name = unittest.util.strclass(test.__class__)
+      if isinstance(test, unittest.case._SubTest):
+        # If the test case is a _SubTest, the real TestCase instance is
+        # available as _SubTest.test_case.
+        class_name = unittest.util.strclass(test.test_case.__class__)
+      if test_desc.startswith(class_name + '.'):
+        # In a typical unittest.TestCase scenario, test.id() returns with
+        # a class name formatted using unittest.util.strclass.
+        name = test_desc[len(class_name)+1:]
+        full_class_name = class_name
+      else:
+        # Otherwise make a best effort to guess the test name and full class
+        # path.
+        parts = test_desc.rsplit('.', 1)
+        name = parts[-1]
+        full_class_name = parts[0] if len(parts) == 2 else ''
+    self.name = _escape_xml_attr(name)
+    self.full_class_name = _escape_xml_attr(full_class_name)
+
+  def set_run_time(self, time_in_secs):
+    self.run_time = time_in_secs
+
+  def set_start_time(self, time_in_secs):
+    self.start_time = time_in_secs
+
+  def print_xml_summary(self, stream):
+    """Prints an XML Summary of a TestCase.
+
+    Status and result are populated as per JUnit XML test result reporter.
+    A test that has been skipped will always have a skip reason,
+    as every skip method in Python's unittest requires the reason arg to be
+    passed.
+
+    Args:
+      stream: output stream to write test report XML to
+    """
+
+    if self.skip_reason is None:
+      status = 'run'
+      result = 'completed'
+    else:
+      status = 'notrun'
+      result = 'suppressed'
+
+    test_case_attributes = [
+        ('name', '%s' % self.name),
+        ('status', '%s' % status),
+        ('result', '%s' % result),
+        ('time', '%.3f' % self.run_time),
+        ('classname', self.full_class_name),
+        ('timestamp', _iso8601_timestamp(self.start_time)),
+    ]
+    _print_xml_element_header('testcase', test_case_attributes, stream, '  ')
+    self._print_testcase_details(stream)
+    stream.write('  </testcase>\n')
+
+  def _print_testcase_details(self, stream):
+    for error in self.errors:
+      outcome, exception_type, message, error_msg = error  # pylint: disable=unpacking-non-sequence
+      message = _escape_xml_attr(_safe_str(message))
+      exception_type = _escape_xml_attr(str(exception_type))
+      error_msg = _escape_cdata(error_msg)
+      stream.write('  <%s message="%s" type="%s"><![CDATA[%s]]></%s>\n'
+                   % (outcome, message, exception_type, error_msg, outcome))
+
+
+class _TestSuiteResult(object):
+  """Private helper for _TextAndXMLTestResult."""
+
+  def __init__(self):
+    self.suites = {}
+    self.failure_counts = {}
+    self.error_counts = {}
+    self.overall_start_time = -1
+    self.overall_end_time = -1
+    self._testsuites_properties = {}
+
+  def add_test_case_result(self, test_case_result):
+    suite_name = type(test_case_result.test).__name__
+    if suite_name == '_ErrorHolder':
+      # _ErrorHolder is a special case created by unittest for class / module
+      # level functions.
+      suite_name = test_case_result.full_class_name.rsplit('.')[-1]
+    if isinstance(test_case_result.test, unittest.case._SubTest):
+      # If the test case is a _SubTest, the real TestCase instance is
+      # available as _SubTest.test_case.
+      suite_name = type(test_case_result.test.test_case).__name__
+
+    self._setup_test_suite(suite_name)
+    self.suites[suite_name].append(test_case_result)
+    for error in test_case_result.errors:
+      # Only count the first failure or error so that the sum is equal to the
+      # total number of *testcases* that have failures or errors.
+      if error[0] == 'failure':
+        self.failure_counts[suite_name] += 1
+        break
+      elif error[0] == 'error':
+        self.error_counts[suite_name] += 1
+        break
+
+  def print_xml_summary(self, stream):
+    overall_test_count = sum(len(x) for x in self.suites.values())
+    overall_failures = sum(self.failure_counts.values())
+    overall_errors = sum(self.error_counts.values())
+    overall_attributes = [
+        ('name', ''),
+        ('tests', '%d' % overall_test_count),
+        ('failures', '%d' % overall_failures),
+        ('errors', '%d' % overall_errors),
+        ('time', '%.3f' % (self.overall_end_time - self.overall_start_time)),
+        ('timestamp', _iso8601_timestamp(self.overall_start_time)),
+    ]
+    _print_xml_element_header('testsuites', overall_attributes, stream)
+    if self._testsuites_properties:
+      stream.write('    <properties>\n')
+      for name, value in sorted(self._testsuites_properties.items()):
+        stream.write('      <property name="%s" value="%s"></property>\n' %
+                     (_escape_xml_attr(name), _escape_xml_attr(str(value))))
+      stream.write('    </properties>\n')
+
+    for suite_name in self.suites:
+      suite = self.suites[suite_name]
+      suite_end_time = max(x.start_time + x.run_time for x in suite)
+      suite_start_time = min(x.start_time for x in suite)
+      failures = self.failure_counts[suite_name]
+      errors = self.error_counts[suite_name]
+      suite_attributes = [
+          ('name', '%s' % suite_name),
+          ('tests', '%d' % len(suite)),
+          ('failures', '%d' % failures),
+          ('errors', '%d' % errors),
+          ('time', '%.3f' % (suite_end_time - suite_start_time)),
+          ('timestamp', _iso8601_timestamp(suite_start_time)),
+      ]
+      _print_xml_element_header('testsuite', suite_attributes, stream)
+
+      # test_case_result entries are not guaranteed to be in any user-friendly
+      # order, especially when using subtests. So sort them.
+      for test_case_result in sorted(suite, key=lambda t: t.name):
+        test_case_result.print_xml_summary(stream)
+      stream.write('</testsuite>\n')
+    stream.write('</testsuites>\n')
+
+  def _setup_test_suite(self, suite_name):
+    """Adds a test suite to the set of suites tracked by this test run.
+
+    Args:
+      suite_name: string, The name of the test suite being initialized.
+    """
+    if suite_name in self.suites:
+      return
+    self.suites[suite_name] = []
+    self.failure_counts[suite_name] = 0
+    self.error_counts[suite_name] = 0
+
+  def set_end_time(self, timestamp_in_secs):
+    """Sets the start timestamp of this test suite.
+
+    Args:
+      timestamp_in_secs: timestamp in seconds since epoch
+    """
+    self.overall_end_time = timestamp_in_secs
+
+  def set_start_time(self, timestamp_in_secs):
+    """Sets the end timestamp of this test suite.
+
+    Args:
+      timestamp_in_secs: timestamp in seconds since epoch
+    """
+    self.overall_start_time = timestamp_in_secs
+
+
+class _TextAndXMLTestResult(_pretty_print_reporter.TextTestResult):
+  """Private TestResult class that produces both formatted text results and XML.
+
+  Used by TextAndXMLTestRunner.
+  """
+
+  _TEST_SUITE_RESULT_CLASS = _TestSuiteResult
+  _TEST_CASE_RESULT_CLASS = _TestCaseResult
+
+  def __init__(self, xml_stream, stream, descriptions, verbosity,
+               time_getter=_time_copy, testsuites_properties=None):
+    super(_TextAndXMLTestResult, self).__init__(stream, descriptions, verbosity)
+    self.xml_stream = xml_stream
+    self.pending_test_case_results = {}
+    self.suite = self._TEST_SUITE_RESULT_CLASS()
+    if testsuites_properties:
+      self.suite._testsuites_properties = testsuites_properties
+    self.time_getter = time_getter
+
+    # This lock guards any mutations on pending_test_case_results.
+    self._pending_test_case_results_lock = threading.RLock()
+
+  def startTest(self, test):
+    self.start_time = self.time_getter()
+    super(_TextAndXMLTestResult, self).startTest(test)
+
+  def stopTest(self, test):
+    # Grabbing the write lock to avoid conflicting with stopTestRun.
+    with self._pending_test_case_results_lock:
+      super(_TextAndXMLTestResult, self).stopTest(test)
+      result = self.get_pending_test_case_result(test)
+      if not result:
+        test_name = test.id() or str(test)
+        sys.stderr.write('No pending test case: %s\n' % test_name)
+        return
+      if getattr(self, 'start_time', None) is None:
+        # startTest may not be called for skipped tests since Python 3.12.1.
+        self.start_time = self.time_getter()
+      test_id = id(test)
+      run_time = self.time_getter() - self.start_time
+      result.set_run_time(run_time)
+      result.set_start_time(self.start_time)
+      self.suite.add_test_case_result(result)
+      del self.pending_test_case_results[test_id]
+
+  def startTestRun(self):
+    self.suite.set_start_time(self.time_getter())
+    super(_TextAndXMLTestResult, self).startTestRun()
+
+  def stopTestRun(self):
+    self.suite.set_end_time(self.time_getter())
+    # All pending_test_case_results will be added to the suite and removed from
+    # the pending_test_case_results dictionary. Grabbing the write lock to avoid
+    # results from being added during this process to avoid duplicating adds or
+    # accidentally erasing newly appended pending results.
+    with self._pending_test_case_results_lock:
+      # Errors in the test fixture (setUpModule, tearDownModule,
+      # setUpClass, tearDownClass) can leave a pending result which
+      # never gets added to the suite.  The runner calls stopTestRun
+      # which gives us an opportunity to add these errors for
+      # reporting here.
+      for test_id in self.pending_test_case_results:
+        result = self.pending_test_case_results[test_id]
+        if getattr(self, 'start_time', None) is not None:
+          run_time = self.suite.overall_end_time - self.start_time
+          result.set_run_time(run_time)
+          result.set_start_time(self.start_time)
+        self.suite.add_test_case_result(result)
+      self.pending_test_case_results.clear()
+
+  def _exc_info_to_string(self, err, test=None):
+    """Converts a sys.exc_info()-style tuple of values into a string.
+
+    This method must be overridden because the method signature in
+    unittest.TestResult changed between Python 2.2 and 2.4.
+
+    Args:
+      err: A sys.exc_info() tuple of values for an error.
+      test: The test method.
+
+    Returns:
+      A formatted exception string.
+    """
+    if test:
+      return super(_TextAndXMLTestResult, self)._exc_info_to_string(err, test)
+    return ''.join(traceback.format_exception(*err))
+
+  def add_pending_test_case_result(self, test, error_summary=None,
+                                   skip_reason=None):
+    """Adds result information to a test case result which may still be running.
+
+    If a result entry for the test already exists, add_pending_test_case_result
+    will add error summary tuples and/or overwrite skip_reason for the result.
+    If it does not yet exist, a result entry will be created.
+    Note that a test result is considered to have been run and passed
+    only if there are no errors or skip_reason.
+
+    Args:
+      test: A test method as defined by unittest
+      error_summary: A 4-tuple with the following entries:
+          1) a string identifier of either "failure" or "error"
+          2) an exception_type
+          3) an exception_message
+          4) a string version of a sys.exc_info()-style tuple of values
+             ('error', err[0], err[1], self._exc_info_to_string(err))
+             If the length of errors is 0, then the test is either passed or
+             skipped.
+      skip_reason: a string explaining why the test was skipped
+    """
+    with self._pending_test_case_results_lock:
+      test_id = id(test)
+      if test_id not in self.pending_test_case_results:
+        self.pending_test_case_results[test_id] = self._TEST_CASE_RESULT_CLASS(
+            test)
+      if error_summary:
+        self.pending_test_case_results[test_id].errors.append(error_summary)
+      if skip_reason:
+        self.pending_test_case_results[test_id].skip_reason = skip_reason
+
+  def delete_pending_test_case_result(self, test):
+    with self._pending_test_case_results_lock:
+      test_id = id(test)
+      del self.pending_test_case_results[test_id]
+
+  def get_pending_test_case_result(self, test):
+    test_id = id(test)
+    return self.pending_test_case_results.get(test_id, None)
+
+  def addSuccess(self, test):
+    super(_TextAndXMLTestResult, self).addSuccess(test)
+    self.add_pending_test_case_result(test)
+
+  def addError(self, test, err):
+    super(_TextAndXMLTestResult, self).addError(test, err)
+    error_summary = ('error', err[0], err[1],
+                     self._exc_info_to_string(err, test=test))
+    self.add_pending_test_case_result(test, error_summary=error_summary)
+
+  def addFailure(self, test, err):
+    super(_TextAndXMLTestResult, self).addFailure(test, err)
+    error_summary = ('failure', err[0], err[1],
+                     self._exc_info_to_string(err, test=test))
+    self.add_pending_test_case_result(test, error_summary=error_summary)
+
+  def addSkip(self, test, reason):
+    super(_TextAndXMLTestResult, self).addSkip(test, reason)
+    self.add_pending_test_case_result(test, skip_reason=reason)
+
+  def addExpectedFailure(self, test, err):
+    super(_TextAndXMLTestResult, self).addExpectedFailure(test, err)
+    if callable(getattr(test, 'recordProperty', None)):
+      test.recordProperty('EXPECTED_FAILURE',
+                          self._exc_info_to_string(err, test=test))
+    self.add_pending_test_case_result(test)
+
+  def addUnexpectedSuccess(self, test):
+    super(_TextAndXMLTestResult, self).addUnexpectedSuccess(test)
+    test_name = test.id() or str(test)
+    error_summary = ('error', '', '',
+                     'Test case %s should have failed, but passed.'
+                     % (test_name))
+    self.add_pending_test_case_result(test, error_summary=error_summary)
+
+  def addSubTest(self, test, subtest, err):  # pylint: disable=invalid-name
+    super(_TextAndXMLTestResult, self).addSubTest(test, subtest, err)
+    if err is not None:
+      if issubclass(err[0], test.failureException):
+        error_summary = ('failure', err[0], err[1],
+                         self._exc_info_to_string(err, test=test))
+      else:
+        error_summary = ('error', err[0], err[1],
+                         self._exc_info_to_string(err, test=test))
+    else:
+      error_summary = None
+    self.add_pending_test_case_result(subtest, error_summary=error_summary)
+
+  def printErrors(self):
+    super(_TextAndXMLTestResult, self).printErrors()
+    self.xml_stream.write('<?xml version="1.0"?>\n')
+    self.suite.print_xml_summary(self.xml_stream)
+
+
+class TextAndXMLTestRunner(unittest.TextTestRunner):
+  """A test runner that produces both formatted text results and XML.
+
+  It prints out the names of tests as they are run, errors as they
+  occur, and a summary of the results at the end of the test run.
+  """
+
+  _TEST_RESULT_CLASS = _TextAndXMLTestResult
+
+  _xml_stream = None
+  _testsuites_properties = {}
+
+  def __init__(self, xml_stream=None, *args, **kwargs):
+    """Initialize a TextAndXMLTestRunner.
+
+    Args:
+      xml_stream: file-like or None; XML-formatted test results are output
+          via this object's write() method.  If None (the default), the
+          new instance behaves as described in the set_default_xml_stream method
+          documentation below.
+      *args: passed unmodified to unittest.TextTestRunner.__init__.
+      **kwargs: passed unmodified to unittest.TextTestRunner.__init__.
+    """
+    super(TextAndXMLTestRunner, self).__init__(*args, **kwargs)
+    if xml_stream is not None:
+      self._xml_stream = xml_stream
+    # else, do not set self._xml_stream to None -- this allows implicit fallback
+    # to the class attribute's value.
+
+  @classmethod
+  def set_default_xml_stream(cls, xml_stream):
+    """Sets the default XML stream for the class.
+
+    Args:
+      xml_stream: file-like or None; used for instances when xml_stream is None
+          or not passed to their constructors.  If None is passed, instances
+          created with xml_stream=None will act as ordinary TextTestRunner
+          instances; this is the default state before any calls to this method
+          have been made.
+    """
+    cls._xml_stream = xml_stream
+
+  def _makeResult(self):
+    if self._xml_stream is None:
+      return super(TextAndXMLTestRunner, self)._makeResult()
+    else:
+      return self._TEST_RESULT_CLASS(
+          self._xml_stream, self.stream, self.descriptions, self.verbosity,
+          testsuites_properties=self._testsuites_properties)
+
+  @classmethod
+  def set_testsuites_property(cls, key, value):
+    cls._testsuites_properties[key] = value

env-llmeval/lib/python3.10/site-packages/accelerate-0.29.2.dist-info/INSTALLER

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

env-llmeval/lib/python3.10/site-packages/accelerate-0.29.2.dist-info/LICENSE

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

env-llmeval/lib/python3.10/site-packages/accelerate-0.29.2.dist-info/METADATA

@@ -0,0 +1,378 @@
+Metadata-Version: 2.1
+Name: accelerate
+Version: 0.29.2
+Summary: Accelerate
+Home-page: https://github.com/huggingface/accelerate
+Author: The HuggingFace team
+Author-email: [email protected]
+License: Apache
+Keywords: deep learning
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy (>=1.17)
+Requires-Dist: packaging (>=20.0)
+Requires-Dist: psutil
+Requires-Dist: pyyaml
+Requires-Dist: torch (>=1.10.0)
+Requires-Dist: huggingface-hub
+Requires-Dist: safetensors (>=0.3.1)
+Provides-Extra: dev
+Requires-Dist: black (~=23.1) ; extra == 'dev'
+Requires-Dist: hf-doc-builder (>=0.3.0) ; extra == 'dev'
+Requires-Dist: ruff (~=0.2.1) ; extra == 'dev'
+Requires-Dist: pytest (<=8.0.0,>=7.2.0) ; extra == 'dev'
+Requires-Dist: pytest-xdist ; extra == 'dev'
+Requires-Dist: pytest-subtests ; extra == 'dev'
+Requires-Dist: parameterized ; extra == 'dev'
+Requires-Dist: datasets ; extra == 'dev'
+Requires-Dist: evaluate ; extra == 'dev'
+Requires-Dist: torchpippy (>=0.2.0) ; extra == 'dev'
+Requires-Dist: transformers ; extra == 'dev'
+Requires-Dist: scipy ; extra == 'dev'
+Requires-Dist: scikit-learn ; extra == 'dev'
+Requires-Dist: deepspeed ; extra == 'dev'
+Requires-Dist: tqdm ; extra == 'dev'
+Requires-Dist: bitsandbytes ; extra == 'dev'
+Requires-Dist: timm ; extra == 'dev'
+Requires-Dist: rich ; extra == 'dev'
+Provides-Extra: docs
+Provides-Extra: quality
+Requires-Dist: black (~=23.1) ; extra == 'quality'
+Requires-Dist: hf-doc-builder (>=0.3.0) ; extra == 'quality'
+Requires-Dist: ruff (~=0.2.1) ; extra == 'quality'
+Provides-Extra: rich
+Requires-Dist: rich ; extra == 'rich'
+Provides-Extra: sagemaker
+Requires-Dist: sagemaker ; extra == 'sagemaker'
+Provides-Extra: test_dev
+Requires-Dist: datasets ; extra == 'test_dev'
+Requires-Dist: evaluate ; extra == 'test_dev'
+Requires-Dist: torchpippy (>=0.2.0) ; extra == 'test_dev'
+Requires-Dist: transformers ; extra == 'test_dev'
+Requires-Dist: scipy ; extra == 'test_dev'
+Requires-Dist: scikit-learn ; extra == 'test_dev'
+Requires-Dist: deepspeed ; extra == 'test_dev'
+Requires-Dist: tqdm ; extra == 'test_dev'
+Requires-Dist: bitsandbytes ; extra == 'test_dev'
+Requires-Dist: timm ; extra == 'test_dev'
+Provides-Extra: test_prod
+Requires-Dist: pytest (<=8.0.0,>=7.2.0) ; extra == 'test_prod'
+Requires-Dist: pytest-xdist ; extra == 'test_prod'
+Requires-Dist: pytest-subtests ; extra == 'test_prod'
+Requires-Dist: parameterized ; extra == 'test_prod'
+Provides-Extra: test_trackers
+Requires-Dist: wandb ; extra == 'test_trackers'
+Requires-Dist: comet-ml ; extra == 'test_trackers'
+Requires-Dist: tensorboard ; extra == 'test_trackers'
+Requires-Dist: dvclive ; extra == 'test_trackers'
+Provides-Extra: testing
+Requires-Dist: pytest (<=8.0.0,>=7.2.0) ; extra == 'testing'
+Requires-Dist: pytest-xdist ; extra == 'testing'
+Requires-Dist: pytest-subtests ; extra == 'testing'
+Requires-Dist: parameterized ; extra == 'testing'
+Requires-Dist: datasets ; extra == 'testing'
+Requires-Dist: evaluate ; extra == 'testing'
+Requires-Dist: torchpippy (>=0.2.0) ; extra == 'testing'
+Requires-Dist: transformers ; extra == 'testing'
+Requires-Dist: scipy ; extra == 'testing'
+Requires-Dist: scikit-learn ; extra == 'testing'
+Requires-Dist: deepspeed ; extra == 'testing'
+Requires-Dist: tqdm ; extra == 'testing'
+Requires-Dist: bitsandbytes ; extra == 'testing'
+Requires-Dist: timm ; extra == 'testing'
+
+<!---
+Copyright 2021 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+<p align="center">
+    <br>
+    <img src="https://raw.githubusercontent.com/huggingface/accelerate/main/docs/source/imgs/accelerate_logo.png" width="400"/>
+    <br>
+<p>
+
+<p align="center">
+    <!-- Uncomment when CircleCI is set up
+    <a href="https://circleci.com/gh/huggingface/accelerate">
+        <img alt="Build" src="https://img.shields.io/circleci/build/github/huggingface/transformers/master">
+    </a>
+    -->
+    <a href="https://github.com/huggingface/accelerate/blob/main/LICENSE">
+        <img alt="License" src="https://img.shields.io/github/license/huggingface/accelerate.svg?color=blue">
+    </a>
+    <a href="https://huggingface.co/docs/accelerate/index.html">
+        <img alt="Documentation" src="https://img.shields.io/website/http/huggingface.co/docs/accelerate/index.html.svg?down_color=red&down_message=offline&up_message=online">
+    </a>
+    <a href="https://github.com/huggingface/accelerate/releases">
+        <img alt="GitHub release" src="https://img.shields.io/github/release/huggingface/accelerate.svg">
+    </a>
+    <a href="https://github.com/huggingface/accelerate/blob/main/CODE_OF_CONDUCT.md">
+        <img alt="Contributor Covenant" src="https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg">
+    </a>
+</p>
+
+<h3 align="center">
+<p>Run your *raw* PyTorch training script on any kind of device
+</h3>
+
+<h3 align="center">
+    <a href="https://hf.co/course"><img src="https://raw.githubusercontent.com/huggingface/accelerate/main/docs/source/imgs/course_banner.png"></a>
+</h3>
+
+## Easy to integrate
+
+🤗 Accelerate was created for PyTorch users who like to write the training loop of PyTorch models but are reluctant to write and maintain the boilerplate code needed to use multi-GPUs/TPU/fp16.
+
+🤗 Accelerate abstracts exactly and only the boilerplate code related to multi-GPUs/TPU/fp16 and leaves the rest of your code unchanged.
+
+Here is an example:
+
+```diff
+  import torch
+  import torch.nn.functional as F
+  from datasets import load_dataset
++ from accelerate import Accelerator
+
++ accelerator = Accelerator()
+- device = 'cpu'
++ device = accelerator.device
+
+  model = torch.nn.Transformer().to(device)
+  optimizer = torch.optim.Adam(model.parameters())
+
+  dataset = load_dataset('my_dataset')
+  data = torch.utils.data.DataLoader(dataset, shuffle=True)
+
++ model, optimizer, data = accelerator.prepare(model, optimizer, data)
+
+  model.train()
+  for epoch in range(10):
+      for source, targets in data:
+          source = source.to(device)
+          targets = targets.to(device)
+
+          optimizer.zero_grad()
+
+          output = model(source)
+          loss = F.cross_entropy(output, targets)
+
+-         loss.backward()
++         accelerator.backward(loss)
+
+          optimizer.step()
+```
+
+As you can see in this example, by adding 5-lines to any standard PyTorch training script you can now run on any kind of single or distributed node setting (single CPU, single GPU, multi-GPUs and TPUs) as well as with or without mixed precision (fp8, fp16, bf16).
+
+In particular, the same code can then be run without modification on your local machine for debugging or your training environment.
+
+🤗 Accelerate even handles the device placement for you (which requires a few more changes to your code, but is safer in general), so you can even simplify your training loop further:
+
+```diff
+  import torch
+  import torch.nn.functional as F
+  from datasets import load_dataset
++ from accelerate import Accelerator
+
+- device = 'cpu'
++ accelerator = Accelerator()
+
+- model = torch.nn.Transformer().to(device)
++ model = torch.nn.Transformer()
+  optimizer = torch.optim.Adam(model.parameters())
+
+  dataset = load_dataset('my_dataset')
+  data = torch.utils.data.DataLoader(dataset, shuffle=True)
+
++ model, optimizer, data = accelerator.prepare(model, optimizer, data)
+
+  model.train()
+  for epoch in range(10):
+      for source, targets in data:
+-         source = source.to(device)
+-         targets = targets.to(device)
+
+          optimizer.zero_grad()
+
+          output = model(source)
+          loss = F.cross_entropy(output, targets)
+
+-         loss.backward()
++         accelerator.backward(loss)
+
+          optimizer.step()
+```
+
+Want to learn more? Check out the [documentation](https://huggingface.co/docs/accelerate) or have a look at our [examples](https://github.com/huggingface/accelerate/tree/main/examples).
+
+## Launching script
+
+🤗 Accelerate also provides an optional CLI tool that allows you to quickly configure and test your training environment before launching the scripts. No need to remember how to use `torch.distributed.run` or to write a specific launcher for TPU training!
+On your machine(s) just run:
+
+```bash
+accelerate config
+```
+
+and answer the questions asked. This will generate a config file that will be used automatically to properly set the default options when doing
+
+```bash
+accelerate launch my_script.py --args_to_my_script
+``` 
+
+For instance, here is how you would run the GLUE example on the MRPC task (from the root of the repo):
+
+```bash
+accelerate launch examples/nlp_example.py
+```
+
+This CLI tool is **optional**, and you can still use `python my_script.py` or `python -m torchrun my_script.py` at your convenience.
+
+You can also directly pass in the arguments you would to `torchrun` as arguments to `accelerate launch` if you wish to not run` accelerate config`.
+
+For example, here is how to launch on two GPUs:
+
+```bash
+accelerate launch --multi_gpu --num_processes 2 examples/nlp_example.py
+```
+
+To learn more, check the CLI documentation available [here](https://huggingface.co/docs/accelerate/package_reference/cli).
+
+## Launching multi-CPU run using MPI
+
+🤗 Here is another way to launch multi-CPU run using MPI. You can learn how to install Open MPI on [this page](https://www.open-mpi.org/faq/?category=building#easy-build). You can use Intel MPI or MVAPICH as well.
+Once you have MPI setup on your cluster, just run:
+```bash
+accelerate config
+```
+Answer the questions that are asked, selecting to run using multi-CPU, and answer "yes" when asked if you want accelerate to launch mpirun.
+Then, use `accelerate launch` with your script like:
+```bash
+accelerate launch examples/nlp_example.py
+```
+Alternatively, you can use mpirun directly, without using the CLI like:
+```bash
+mpirun -np 2 python examples/nlp_example.py
+```
+
+## Launching training using DeepSpeed
+
+🤗 Accelerate supports training on single/multiple GPUs using DeepSpeed. To use it, you don't need to change anything in your training code; you can set everything using just `accelerate config`. However, if you desire to tweak your DeepSpeed related args from your Python script, we provide you the `DeepSpeedPlugin`.
+
+```python
+from accelerate import Accelerator, DeepSpeedPlugin
+
+# deepspeed needs to know your gradient accumulation steps beforehand, so don't forget to pass it
+# Remember you still need to do gradient accumulation by yourself, just like you would have done without deepspeed
+deepspeed_plugin = DeepSpeedPlugin(zero_stage=2, gradient_accumulation_steps=2)
+accelerator = Accelerator(mixed_precision='fp16', deepspeed_plugin=deepspeed_plugin)
+
+# How to save your 🤗 Transformer?
+accelerator.wait_for_everyone()
+unwrapped_model = accelerator.unwrap_model(model)
+unwrapped_model.save_pretrained(save_dir, save_function=accelerator.save, state_dict=accelerator.get_state_dict(model))
+```
+
+Note: DeepSpeed support is experimental for now. In case you get into some problem, please open an issue.
+
+## Launching your training from a notebook
+
+🤗 Accelerate also provides a `notebook_launcher` function you can use in a notebook to launch a distributed training. This is especially useful for Colab or Kaggle notebooks with a TPU backend. Just define your training loop in a `training_function` then in your last cell, add:
+
+```python
+from accelerate import notebook_launcher
+
+notebook_launcher(training_function)
+```
+
+An example can be found in [this notebook](https://github.com/huggingface/notebooks/blob/main/examples/accelerate_examples/simple_nlp_example.ipynb). [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/accelerate_examples/simple_nlp_example.ipynb)
+
+## Why should I use 🤗 Accelerate?
+
+You should use 🤗 Accelerate when you want to easily run your training scripts in a distributed environment without having to renounce full control over your training loop. This is not a high-level framework above PyTorch, just a thin wrapper so you don't have to learn a new library. In fact, the whole API of 🤗 Accelerate is in one class, the `Accelerator` object.
+
+## Why shouldn't I use 🤗 Accelerate?
+
+You shouldn't use 🤗 Accelerate if you don't want to write a training loop yourself. There are plenty of high-level libraries above PyTorch that will offer you that, 🤗 Accelerate is not one of them.
+
+## Frameworks using 🤗 Accelerate
+
+If you like the simplicity of 🤗 Accelerate but would prefer a higher-level abstraction around its capabilities, some frameworks and libraries that are built on top of 🤗 Accelerate are listed below:
+
+* [Amphion](https://github.com/open-mmlab/Amphion) is a toolkit for Audio, Music, and Speech Generation. Its purpose is to support reproducible research and help junior researchers and engineers get started in the field of audio, music, and speech generation research and development.
+* [Animus](https://github.com/Scitator/animus) is a minimalistic framework to run machine learning experiments. Animus highlights common "breakpoints" in ML experiments and provides a unified interface for them within [IExperiment](https://github.com/Scitator/animus/blob/main/animus/core.py#L76).
+* [Catalyst](https://github.com/catalyst-team/catalyst#getting-started) is a PyTorch framework for Deep Learning Research and Development. It focuses on reproducibility, rapid experimentation, and codebase reuse so you can create something new rather than write yet another train loop. Catalyst provides a [Runner](https://catalyst-team.github.io/catalyst/api/core.html#runner) to connect all parts of the experiment: hardware backend, data transformations, model training, and inference logic.
+* [fastai](https://github.com/fastai/fastai#installing) is a PyTorch framework for Deep Learning that simplifies training fast and accurate neural nets using modern best practices. fastai provides a [Learner](https://docs.fast.ai/learner.html#Learner) to handle the training, fine-tuning, and inference of deep learning algorithms.
+* [Finetuner](https://github.com/jina-ai/finetuner) is a service that enables models to create higher-quality embeddings for semantic search, visual similarity search, cross-modal text<->image search, recommendation systems, clustering, duplication detection, anomaly detection, or other uses.
+* [InvokeAI](https://github.com/invoke-ai/InvokeAI) is a creative engine for Stable Diffusion models, offering industry-leading WebUI, terminal usage support, and serves as the foundation for many commercial products.
+* [Kornia](https://kornia.readthedocs.io/en/latest/get-started/introduction.html) is a differentiable library that allows classical computer vision to be integrated into deep learning models. Kornia provides a [Trainer](https://kornia.readthedocs.io/en/latest/x.html#kornia.x.Trainer) with the specific purpose to train and fine-tune the supported deep learning algorithms within the library.
+* [Open Assistant](https://projects.laion.ai/Open-Assistant/) is a chat-based assistant that understands tasks, can interact with their party systems, and retrieve information dynamically to do so. 
+* [pytorch-accelerated](https://github.com/Chris-hughes10/pytorch-accelerated) is a lightweight training library, with a streamlined feature set centered around a general-purpose [Trainer](https://pytorch-accelerated.readthedocs.io/en/latest/trainer.html), that places a huge emphasis on simplicity and transparency; enabling users to understand exactly what is going on under the hood, but without having to write and maintain the boilerplate themselves!
+* [Stable Diffusion web UI](https://github.com/AUTOMATIC1111/stable-diffusion-webui) is an open-source browser-based easy-to-use interface based on the Gradio library for Stable Diffusion.
+* [torchkeras](https://github.com/lyhue1991/torchkeras) is a simple tool for training pytorch model just in a keras style, a dynamic and beautiful plot is provided in notebook to monitor your loss or metric.
+* [transformers](https://github.com/huggingface/transformers) as a tool for helping train state-of-the-art machine learning models in PyTorch, Tensorflow, and JAX. (Accelerate is the backend for the PyTorch side).
+
+
+## Installation
+
+This repository is tested on Python 3.8+ and PyTorch 1.10.0+
+
+You should install 🤗 Accelerate in a [virtual environment](https://docs.python.org/3/library/venv.html). If you're unfamiliar with Python virtual environments, check out the [user guide](https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/).
+
+First, create a virtual environment with the version of Python you're going to use and activate it.
+
+Then, you will need to install PyTorch: refer to the [official installation page](https://pytorch.org/get-started/locally/#start-locally) regarding the specific install command for your platform. Then 🤗 Accelerate can be installed using pip as follows:
+
+```bash
+pip install accelerate
+```
+
+## Supported integrations
+
+- CPU only
+- multi-CPU on one node (machine)
+- multi-CPU on several nodes (machines)
+- single GPU
+- multi-GPU on one node (machine)
+- multi-GPU on several nodes (machines)
+- TPU
+- FP16/BFloat16 mixed precision
+- FP8 mixed precision with [Transformer Engine](https://github.com/NVIDIA/TransformerEngine)
+- DeepSpeed support (Experimental)
+- PyTorch Fully Sharded Data Parallel (FSDP) support (Experimental)
+- Megatron-LM support (Experimental)
+
+## Citing 🤗 Accelerate
+
+If you use 🤗 Accelerate in your publication, please cite it by using the following BibTeX entry.
+
+```bibtex
+@Misc{accelerate,
+  title =        {Accelerate: Training and inference at scale made simple, efficient and adaptable.},
+  author =       {Sylvain Gugger and Lysandre Debut and Thomas Wolf and Philipp Schmid and Zachary Mueller and Sourab Mangrulkar and Marc Sun and Benjamin Bossan},
+  howpublished = {\url{https://github.com/huggingface/accelerate}},
+  year =         {2022}
+}
+```

env-llmeval/lib/python3.10/site-packages/accelerate-0.29.2.dist-info/RECORD

@@ -0,0 +1,163 @@
+../../../bin/accelerate,sha256=BMhR7IPBrkcxmZ7nWXIeRgnrnhJmrdjee8KIXhgtYdk,259
+../../../bin/accelerate-config,sha256=_nmL3uln1BEsmG5LBCWZc-Jrz6bVgsNc-KdbFNHdRs8,251
+../../../bin/accelerate-estimate-memory,sha256=gmoXcy4yYs5YHPtp71NGOdpsG5WD0oZaZdNTFK-I77E,253
+../../../bin/accelerate-launch,sha256=KIOgqpBnhsRCaEi_V3uM_yO_nOLRuKSASHtce3c8OHU,251
+accelerate-0.29.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+accelerate-0.29.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+accelerate-0.29.2.dist-info/METADATA,sha256=FjUkmeCY24ElAVCof9Q9TqEllme-f6G0FbuJR9PfjWY,18942
+accelerate-0.29.2.dist-info/RECORD,,
+accelerate-0.29.2.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+accelerate-0.29.2.dist-info/entry_points.txt,sha256=Z_KV59tIt4oZtUDEQ0w8JThJ6_1dd8vR8heH24DeAXI,238
+accelerate-0.29.2.dist-info/top_level.txt,sha256=esVfdxTidsjQ90zsN_rPpjLFJ4ijRlx4mnLrG09hlt4,11
+accelerate/__init__.py,sha256=7PnXknD50D0dgEHWiHkz-2s1bLDKCwrYetYFxSzqd6A,1456
+accelerate/__pycache__/__init__.cpython-310.pyc,,
+accelerate/__pycache__/accelerator.cpython-310.pyc,,
+accelerate/__pycache__/big_modeling.cpython-310.pyc,,
+accelerate/__pycache__/checkpointing.cpython-310.pyc,,
+accelerate/__pycache__/data_loader.cpython-310.pyc,,
+accelerate/__pycache__/hooks.cpython-310.pyc,,
+accelerate/__pycache__/inference.cpython-310.pyc,,
+accelerate/__pycache__/launchers.cpython-310.pyc,,
+accelerate/__pycache__/local_sgd.cpython-310.pyc,,
+accelerate/__pycache__/logging.cpython-310.pyc,,
+accelerate/__pycache__/memory_utils.cpython-310.pyc,,
+accelerate/__pycache__/optimizer.cpython-310.pyc,,
+accelerate/__pycache__/scheduler.cpython-310.pyc,,
+accelerate/__pycache__/state.cpython-310.pyc,,
+accelerate/__pycache__/tracking.cpython-310.pyc,,
+accelerate/accelerator.py,sha256=rh4-KBMCkCGLldjKo1CRtBIbsXG76fJqYWdgOugaw7w,143024
+accelerate/big_modeling.py,sha256=eytO1vW8nxNNkyb8o9uh4L8iavzwJxbxc9selyG_8MU,29034
+accelerate/checkpointing.py,sha256=vFyLNg9-8qsPBYhAkcm-WwKEeK5Lrq9qLrQWNGFKoPk,11378
+accelerate/commands/__init__.py,sha256=m1PPTDT4ziIAvM0-FDSgIMIZ69Konn126s6LwuzH6v8,606
+accelerate/commands/__pycache__/__init__.cpython-310.pyc,,
+accelerate/commands/__pycache__/accelerate_cli.cpython-310.pyc,,
+accelerate/commands/__pycache__/env.cpython-310.pyc,,
+accelerate/commands/__pycache__/estimate.cpython-310.pyc,,
+accelerate/commands/__pycache__/launch.cpython-310.pyc,,
+accelerate/commands/__pycache__/test.cpython-310.pyc,,
+accelerate/commands/__pycache__/tpu.cpython-310.pyc,,
+accelerate/commands/__pycache__/utils.cpython-310.pyc,,
+accelerate/commands/accelerate_cli.py,sha256=i3nge5Wj8i4zkV0CVIk9P8veleRZbTZY0AU4fJOrKF8,1749
+accelerate/commands/config/__init__.py,sha256=iJK8dgj3pc5Vdr1E7UuGoFu-BlybyXLxYDoTg9gXngE,1645
+accelerate/commands/config/__pycache__/__init__.cpython-310.pyc,,
+accelerate/commands/config/__pycache__/cluster.cpython-310.pyc,,
+accelerate/commands/config/__pycache__/config.cpython-310.pyc,,
+accelerate/commands/config/__pycache__/config_args.cpython-310.pyc,,
+accelerate/commands/config/__pycache__/config_utils.cpython-310.pyc,,
+accelerate/commands/config/__pycache__/default.cpython-310.pyc,,
+accelerate/commands/config/__pycache__/sagemaker.cpython-310.pyc,,
+accelerate/commands/config/__pycache__/update.cpython-310.pyc,,
+accelerate/commands/config/cluster.py,sha256=lA55beGeo0fAowfffKhf8nGcy6lBjaOxTtV-Yg_Rz6s,29926
+accelerate/commands/config/config.py,sha256=FuRlQvOjgATEtyqOSsGD-KEtOCvACOHjs2C-krrtldk,3035
+accelerate/commands/config/config_args.py,sha256=hE42coVnn0UU-ysqp2ZH-jlqaXoPaHt5E_3qxT42GIM,10024
+accelerate/commands/config/config_utils.py,sha256=DcjIV1mDInFmct2_XQ-9KYAkREINs6YuHRbZe5HFjT8,2926
+accelerate/commands/config/default.py,sha256=3-SdEhl_zXM9S3f-FxkSVtiBQ5VY-QNsC4O26u60bss,5350
+accelerate/commands/config/sagemaker.py,sha256=GjHE2-h4tRr1P_PFtMF3miiAtJlzkbHbMb6kFXqn8eo,10341
+accelerate/commands/config/update.py,sha256=NXW1J7GkUHpg71QlIXsmMB_0z8S8IZo2FWax5POwrhc,2395
+accelerate/commands/env.py,sha256=HXXUozMFlxs0b-bU2a3nEcXwYz-5EBkfCvE9svqeN2U,3595
+accelerate/commands/estimate.py,sha256=shEn2nXyHmz94zpAzV2R8__lcNYW9f9djl7bOHoo04k,12398
+accelerate/commands/launch.py,sha256=rYmkdc0Kbcux4TOqBG_sJN-NNc4nmV90vuwHqhGNfWw,41439
+accelerate/commands/menu/__init__.py,sha256=uqSlBM0TFHBwzdv3p3SXfpAk1lZFp4h1a7mbBdscPHs,645
+accelerate/commands/menu/__pycache__/__init__.cpython-310.pyc,,
+accelerate/commands/menu/__pycache__/cursor.cpython-310.pyc,,
+accelerate/commands/menu/__pycache__/helpers.cpython-310.pyc,,
+accelerate/commands/menu/__pycache__/input.cpython-310.pyc,,
+accelerate/commands/menu/__pycache__/keymap.cpython-310.pyc,,
+accelerate/commands/menu/__pycache__/selection_menu.cpython-310.pyc,,
+accelerate/commands/menu/cursor.py,sha256=-lmpJVAzvNc0c3EOtSuLoKB59zqylVCbYyWLPnrOmvQ,2028
+accelerate/commands/menu/helpers.py,sha256=KrSB5fJjH4MUEUAQJ6bYaN16AYcnl9UalDrPD3DYeeg,1483
+accelerate/commands/menu/input.py,sha256=Uj9eDp8-Mb0Fe49nuogqo9W_RCfYd6udfjiPKx7Wjmg,2537
+accelerate/commands/menu/keymap.py,sha256=eXj-suyYs1m5dEHoUKN4mKAMLc8DWHnwhP6G6JSU0jQ,4086
+accelerate/commands/menu/selection_menu.py,sha256=bxy-DHaKKC6SCToOlMBv5_z0MdUzylEg6Sio9OuV3GM,4921
+accelerate/commands/test.py,sha256=YrPYEaAACOGZ6btn2MV6NbMSEdBUcMWADLbQWaZSHtk,2149
+accelerate/commands/tpu.py,sha256=KyxDP7IuveidZrbW4rx2s8Ku3o_ptI6tzwr_R7ck0os,5548
+accelerate/commands/utils.py,sha256=ilcfE32oHh28EToM00nc_SR6upfZiuxUI0AjjZu8KYY,3995
+accelerate/data_loader.py,sha256=qQojnHAW0cjTL7jLQN_g-oHlRZBkKzti3ifk84Izuw4,48307
+accelerate/hooks.py,sha256=x0FBwwoy6PKSwulavYTpc4gERIoB7RHGPF0Qe6qjXNA,31244
+accelerate/inference.py,sha256=Ci7kkw2cocNpuvmbo1ytW2QgcI_HKWoXkIdonFOr0tg,7977
+accelerate/launchers.py,sha256=iFDZ7seDdRwHAHy1BbVPmPccAONiPdV2aBOHNuT2ZD8,11375
+accelerate/local_sgd.py,sha256=v0-AxldUSCYCI-rqjLiEHsVtSqyEIWTC5ppn7CW7qfY,4002
+accelerate/logging.py,sha256=kvUvk33r_7T2BNzIwqRZBOhuC-50Ju4rm4HbsM6h2G8,4897
+accelerate/memory_utils.py,sha256=3R5LoeHl6GgTZ-IMPrDZMdaEehWarGdPqODushb-6pg,862
+accelerate/optimizer.py,sha256=H7e1XwEysZ_GFR8V_3bHjFAY7zzrzO8samCyW_r7dZo,7453
+accelerate/scheduler.py,sha256=des_4M_Tt1W8gCYZZbLla0GHBEgJY3Wx2EGBQPTzeiY,4238
+accelerate/state.py,sha256=9EDuO_uxO2-SxFnVSjUQuR9lDPMYXjwd1yfAgM-Oiws,50116
+accelerate/test_utils/__init__.py,sha256=amEDYw-ztgIvHkYT3mv3ixk1QJirUnf6jfPJzqUUYkQ,1459
+accelerate/test_utils/__pycache__/__init__.cpython-310.pyc,,
+accelerate/test_utils/__pycache__/examples.cpython-310.pyc,,
+accelerate/test_utils/__pycache__/testing.cpython-310.pyc,,
+accelerate/test_utils/__pycache__/training.cpython-310.pyc,,
+accelerate/test_utils/examples.py,sha256=jRm1S9TkmeoLaqprBvtVFN4LesiaDZtKMNIoLNY2euw,7281
+accelerate/test_utils/scripts/__init__.py,sha256=m1PPTDT4ziIAvM0-FDSgIMIZ69Konn126s6LwuzH6v8,606
+accelerate/test_utils/scripts/__pycache__/__init__.cpython-310.pyc,,
+accelerate/test_utils/scripts/__pycache__/test_cli.cpython-310.pyc,,
+accelerate/test_utils/scripts/__pycache__/test_distributed_data_loop.cpython-310.pyc,,
+accelerate/test_utils/scripts/__pycache__/test_notebook.cpython-310.pyc,,
+accelerate/test_utils/scripts/__pycache__/test_ops.cpython-310.pyc,,
+accelerate/test_utils/scripts/__pycache__/test_script.cpython-310.pyc,,
+accelerate/test_utils/scripts/__pycache__/test_sync.cpython-310.pyc,,
+accelerate/test_utils/scripts/external_deps/__init__.py,sha256=m1PPTDT4ziIAvM0-FDSgIMIZ69Konn126s6LwuzH6v8,606
+accelerate/test_utils/scripts/external_deps/__pycache__/__init__.cpython-310.pyc,,
+accelerate/test_utils/scripts/external_deps/__pycache__/test_checkpointing.cpython-310.pyc,,
+accelerate/test_utils/scripts/external_deps/__pycache__/test_metrics.cpython-310.pyc,,
+accelerate/test_utils/scripts/external_deps/__pycache__/test_peak_memory_usage.cpython-310.pyc,,
+accelerate/test_utils/scripts/external_deps/__pycache__/test_performance.cpython-310.pyc,,
+accelerate/test_utils/scripts/external_deps/__pycache__/test_pippy.cpython-310.pyc,,
+accelerate/test_utils/scripts/external_deps/__pycache__/test_zero3_integration.cpython-310.pyc,,
+accelerate/test_utils/scripts/external_deps/test_checkpointing.py,sha256=zILzHevzqxB1NPPDrJ1furaitI8MTvhBeG9QzzL0bmE,10668
+accelerate/test_utils/scripts/external_deps/test_metrics.py,sha256=67-S1qeCpCL9ceaH22RsIsBJscMS7VQWaO4Krcszzbw,12133
+accelerate/test_utils/scripts/external_deps/test_peak_memory_usage.py,sha256=D0YnKCxkI4ZwDOmZ5Ev6hL9jPyP7SU4WffpVFiK14bs,11072
+accelerate/test_utils/scripts/external_deps/test_performance.py,sha256=8fV3wCM1H9HVRRyC5C4EGWt-9aHILX_y3-E7LfSiv7M,9803
+accelerate/test_utils/scripts/external_deps/test_pippy.py,sha256=RdMoD1rlLKMyjyl0soSqR3iDbGidS6-z5GHo3bJUOw8,4647
+accelerate/test_utils/scripts/external_deps/test_zero3_integration.py,sha256=bJ0Jio-6OCyS2FIgFmZi3duqG1gbkOoTEcHsrORYIL4,1503
+accelerate/test_utils/scripts/test_cli.py,sha256=qfk1aYFtdvYFCYPkl05602SNGvk08QTv0xZVVcFVtzM,833
+accelerate/test_utils/scripts/test_distributed_data_loop.py,sha256=VqFPKNRu8yx2MoZ4nHy5wRocEthSymcIA2mg1knqDq8,8315
+accelerate/test_utils/scripts/test_notebook.py,sha256=Q4OOWHa_GMmzwfiq71BTpKYmhCHLC02J42OO94ut9xk,1629
+accelerate/test_utils/scripts/test_ops.py,sha256=BcGn3xJT2wUJ0Yk_6VLNkneSv9z24JeAoQjsgdIIRr4,6170
+accelerate/test_utils/scripts/test_script.py,sha256=QyHRWvHQm1XWkAH7YilQ0gZe3zwvEkyqD6JXmneWqak,32059
+accelerate/test_utils/scripts/test_sync.py,sha256=3kltq-GuUjOVuo6_FOuWiPyc5f3pGiqiwEAbex5x_-o,18263
+accelerate/test_utils/testing.py,sha256=HIp7n6qPMh8KPbwEzNWu5mzfxnQRcU15EQ1AQKehpo0,20571
+accelerate/test_utils/training.py,sha256=8k_YAQ21MzUdb2aFWq1t2fihW1b-iBGh1OJSL3whY68,4019
+accelerate/tracking.py,sha256=WLY-H1DTsxrz4BVzle7QZMp0Irg84yFMbA1e6JaY3pM,39789
+accelerate/utils/__init__.py,sha256=SEP34Od2TbTZt7AbhPJoWWDxFoNMeNEyAuVfaPgVu7k,6065
+accelerate/utils/__pycache__/__init__.cpython-310.pyc,,
+accelerate/utils/__pycache__/bnb.cpython-310.pyc,,
+accelerate/utils/__pycache__/constants.cpython-310.pyc,,
+accelerate/utils/__pycache__/dataclasses.cpython-310.pyc,,
+accelerate/utils/__pycache__/deepspeed.cpython-310.pyc,,
+accelerate/utils/__pycache__/environment.cpython-310.pyc,,
+accelerate/utils/__pycache__/fsdp_utils.cpython-310.pyc,,
+accelerate/utils/__pycache__/imports.cpython-310.pyc,,
+accelerate/utils/__pycache__/launch.cpython-310.pyc,,
+accelerate/utils/__pycache__/megatron_lm.cpython-310.pyc,,
+accelerate/utils/__pycache__/memory.cpython-310.pyc,,
+accelerate/utils/__pycache__/modeling.cpython-310.pyc,,
+accelerate/utils/__pycache__/offload.cpython-310.pyc,,
+accelerate/utils/__pycache__/operations.cpython-310.pyc,,
+accelerate/utils/__pycache__/other.cpython-310.pyc,,
+accelerate/utils/__pycache__/random.cpython-310.pyc,,
+accelerate/utils/__pycache__/rich.cpython-310.pyc,,
+accelerate/utils/__pycache__/torch_xla.cpython-310.pyc,,
+accelerate/utils/__pycache__/tqdm.cpython-310.pyc,,
+accelerate/utils/__pycache__/transformer_engine.cpython-310.pyc,,
+accelerate/utils/__pycache__/versions.cpython-310.pyc,,
+accelerate/utils/bnb.py,sha256=3i59dy8EcBYJEnT2alJ5_M-zeIpFsrceQ4bImiJJKOk,20570
+accelerate/utils/constants.py,sha256=e6Bpf7gSZLFkvfr-1B1841b6lVoKJ5uyyf5kefe0aT4,2566
+accelerate/utils/dataclasses.py,sha256=QSP-gYjXz68s0PAseKwLHRBQUnzcBQwPk80otV4X20k,74253
+accelerate/utils/deepspeed.py,sha256=1JFnz-dY6xP9yHywnX8bzZNq-d-8Cpg5CvVNLZ74b_0,10276
+accelerate/utils/environment.py,sha256=8eVGMCu7xT1y0Hxochnxz_RghDePtWo2TghDlOm5Gf0,10409
+accelerate/utils/fsdp_utils.py,sha256=QURWBtK8D00zppqJko0yeznEovXvnkRLI0NpPPkog1Q,10667
+accelerate/utils/imports.py,sha256=gYj_W3E5V83dYlSqqYE89OAK6JonzwhlcEjsJcOpB3E,12232
+accelerate/utils/launch.py,sha256=hHpcnR0NrSmqaT7AIaeIeXOAJVIhWnWdq3kA1XSnOYs,27459
+accelerate/utils/megatron_lm.py,sha256=IfHrtMiPSwuzh5ri96rTTIcEluuMNuIj3O8Y4jW6Fzk,57124
+accelerate/utils/memory.py,sha256=VxJCU-tMX8uE34GbJnxtDXYPHh4D9p2Y-d6rkGxqSa0,5200
+accelerate/utils/modeling.py,sha256=OfTHPg7oM9-jzYotLZjJKj6TrhCTFV3qOtQAOhKXmzQ,80246
+accelerate/utils/offload.py,sha256=qjaVai81wbkA0YH2WkmOXvZT0BRphygfRV_4Ua4j4U4,7837
+accelerate/utils/operations.py,sha256=zsmRx8mP2eoImPc42pOmBIqaHX7RDugw8AZ_HF3onpg,30610
+accelerate/utils/other.py,sha256=kgON65EhzQN3oQZqzgAOmmNC2vsQkeO77qEuzN7Zv7c,12283
+accelerate/utils/random.py,sha256=t-HsLQRm8etSiLSyONCU9wNhj-0VjDUyDme9p6RxDNU,4881
+accelerate/utils/rich.py,sha256=8JZX_uGMQX-BufdXxJpdne7BWd1KyLHSgbiGxrDMYr8,847
+accelerate/utils/torch_xla.py,sha256=Pq1tuqN0X_pWDVza6YgjfO45uoJdoRVRForLeLQzFus,1908
+accelerate/utils/tqdm.py,sha256=9Ovx4GL8AvjSaBd_OysoUGPW9ZJ3ZBOde6776HMEMOA,1344
+accelerate/utils/transformer_engine.py,sha256=gNPkOv_D1SDLm6nVZtxWIjyA6snxWtAQeBWUZLIErJE,3582
+accelerate/utils/versions.py,sha256=UgmcbjBm--6CIx1ZamSAMjAK_B_2l48LbeaNygqej8M,2149

env-llmeval/lib/python3.10/site-packages/accelerate-0.29.2.dist-info/WHEEL

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

env-llmeval/lib/python3.10/site-packages/accelerate-0.29.2.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+accelerate = accelerate.commands.accelerate_cli:main
+accelerate-config = accelerate.commands.config:main
+accelerate-estimate-memory = accelerate.commands.estimate:main
+accelerate-launch = accelerate.commands.launch:main

env-llmeval/lib/python3.10/site-packages/accelerate-0.29.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+accelerate

env-llmeval/lib/python3.10/site-packages/certifi-2024.2.2.dist-info/INSTALLER

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

env-llmeval/lib/python3.10/site-packages/certifi-2024.2.2.dist-info/LICENSE

@@ -0,0 +1,20 @@
+This package contains a modified version of ca-bundle.crt:
+
+ca-bundle.crt -- Bundle of CA Root Certificates
+
+This is a bundle of X.509 certificates of public Certificate Authorities
+(CA). These were automatically extracted from Mozilla's root certificates
+file (certdata.txt).  This file can be found in the mozilla source tree:
+https://hg.mozilla.org/mozilla-central/file/tip/security/nss/lib/ckfw/builtins/certdata.txt
+It contains the certificates in PEM format and therefore
+can be directly used with curl / libcurl / php_curl, or with
+an Apache+mod_ssl webserver for SSL client authentication.
+Just configure this file as the SSLCACertificateFile.#
+
+***** BEGIN LICENSE BLOCK *****
+This Source Code Form is subject to the terms of the Mozilla Public License,
+v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain
+one at http://mozilla.org/MPL/2.0/.
+
+***** END LICENSE BLOCK *****
+@(#) $RCSfile: certdata.txt,v $ $Revision: 1.80 $ $Date: 2011/11/03 15:11:58 $

env-llmeval/lib/python3.10/site-packages/certifi-2024.2.2.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.1
+Name: certifi
+Version: 2024.2.2
+Summary: Python package for providing Mozilla's CA Bundle.
+Home-page: https://github.com/certifi/python-certifi
+Author: Kenneth Reitz
+Author-email: [email protected]
+License: MPL-2.0
+Project-URL: Source, https://github.com/certifi/python-certifi
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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
+Requires-Python: >=3.6
+License-File: LICENSE
+
+Certifi: Python SSL Certificates
+================================
+
+Certifi provides Mozilla's carefully curated collection of Root Certificates for
+validating the trustworthiness of SSL certificates while verifying the identity
+of TLS hosts. It has been extracted from the `Requests`_ project.
+
+Installation
+------------
+
+``certifi`` is available on PyPI. Simply install it with ``pip``::
+
+    $ pip install certifi
+
+Usage
+-----
+
+To reference the installed certificate authority (CA) bundle, you can use the
+built-in function::
+
+    >>> import certifi
+
+    >>> certifi.where()
+    '/usr/local/lib/python3.7/site-packages/certifi/cacert.pem'
+
+Or from the command line::
+
+    $ python -m certifi
+    /usr/local/lib/python3.7/site-packages/certifi/cacert.pem
+
+Enjoy!
+
+.. _`Requests`: https://requests.readthedocs.io/en/master/
+
+Addition/Removal of Certificates
+--------------------------------
+
+Certifi does not support any addition/removal or other modification of the
+CA trust store content. This project is intended to provide a reliable and
+highly portable root of trust to python deployments. Look to upstream projects
+for methods to use alternate trust.

env-llmeval/lib/python3.10/site-packages/certifi-2024.2.2.dist-info/RECORD

@@ -0,0 +1,14 @@
+certifi-2024.2.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+certifi-2024.2.2.dist-info/LICENSE,sha256=6TcW2mucDVpKHfYP5pWzcPBpVgPSH2-D8FPkLPwQyvc,989
+certifi-2024.2.2.dist-info/METADATA,sha256=1noreLRChpOgeSj0uJT1mehiBl8ngh33Guc7KdvzYYM,2170
+certifi-2024.2.2.dist-info/RECORD,,
+certifi-2024.2.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+certifi-2024.2.2.dist-info/top_level.txt,sha256=KMu4vUCfsjLrkPbSNdgdekS-pVJzBAJFO__nI8NF6-U,8
+certifi/__init__.py,sha256=ljtEx-EmmPpTe2SOd5Kzsujm_lUD0fKJVnE9gzce320,94
+certifi/__main__.py,sha256=xBBoj905TUWBLRGANOcf7oi6e-3dMP4cEoG9OyMs11g,243
+certifi/__pycache__/__init__.cpython-310.pyc,,
+certifi/__pycache__/__main__.cpython-310.pyc,,
+certifi/__pycache__/core.cpython-310.pyc,,
+certifi/cacert.pem,sha256=ejR8qP724p-CtuR4U1WmY1wX-nVeCUD2XxWqj8e9f5I,292541
+certifi/core.py,sha256=qRDDFyXVJwTB_EmoGppaXU_R9qCZvhl-EzxPMuV3nTA,4426
+certifi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

env-llmeval/lib/python3.10/site-packages/certifi-2024.2.2.dist-info/WHEEL

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

env-llmeval/lib/python3.10/site-packages/certifi-2024.2.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+certifi

env-llmeval/lib/python3.10/site-packages/chardet-5.2.0.dist-info/INSTALLER

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

env-llmeval/lib/python3.10/site-packages/chardet-5.2.0.dist-info/WHEEL

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

env-llmeval/lib/python3.10/site-packages/chardet-5.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+chardetect = chardet.cli.chardetect:main

env-llmeval/lib/python3.10/site-packages/filelock-3.13.4.dist-info/RECORD

@@ -0,0 +1,22 @@
+filelock-3.13.4.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+filelock-3.13.4.dist-info/METADATA,sha256=id-2QR57cZ5P7lgQZdhd_xGLBlUrD1p_mFir6ITfRx4,2792
+filelock-3.13.4.dist-info/RECORD,,
+filelock-3.13.4.dist-info/WHEEL,sha256=as-1oFTWSeWBgyzh0O_qF439xqBe6AbBgt4MfYe5zwY,87
+filelock-3.13.4.dist-info/licenses/LICENSE,sha256=iNm062BXnBkew5HKBMFhMFctfu3EqG2qWL8oxuFMm80,1210
+filelock/__init__.py,sha256=c_wPy9Fo0fmqE4V448Q2A2dDYnMTZeAVHX-kUoN3KCY,1214
+filelock/__pycache__/__init__.cpython-310.pyc,,
+filelock/__pycache__/_api.cpython-310.pyc,,
+filelock/__pycache__/_error.cpython-310.pyc,,
+filelock/__pycache__/_soft.cpython-310.pyc,,
+filelock/__pycache__/_unix.cpython-310.pyc,,
+filelock/__pycache__/_util.cpython-310.pyc,,
+filelock/__pycache__/_windows.cpython-310.pyc,,
+filelock/__pycache__/version.cpython-310.pyc,,
+filelock/_api.py,sha256=rdQfF14SEH01ZoSQXdRm7CW7xGFUTBZyQytd8TySiio,12330
+filelock/_error.py,sha256=-5jMcjTu60YAvAO1UbqDD1GIEjVkwr8xCFwDBtMeYDg,787
+filelock/_soft.py,sha256=haqtc_TB_KJbYv2a8iuEAclKuM4fMG1vTcp28sK919c,1711
+filelock/_unix.py,sha256=-FXP0tjInBHUYygOlMpp4taUmD87QOkrD_4ybg_iT7Q,2259
+filelock/_util.py,sha256=QHBoNFIYfbAThhotH3Q8E2acFc84wpG49-T-uu017ZE,1715
+filelock/_windows.py,sha256=eMKL8dZKrgekf5VYVGR14an29JGEInRtUO8ui9ABywg,2177
+filelock/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+filelock/version.py,sha256=7_6ZiCN2IEbqvGolC1tvkUZXIMID8-9wKt9GAmhPeyU,413

env-llmeval/lib/python3.10/site-packages/filelock-3.13.4.dist-info/WHEEL

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

env-llmeval/lib/python3.10/site-packages/fsspec-2024.2.0.dist-info/INSTALLER

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

env-llmeval/lib/python3.10/site-packages/fsspec-2024.2.0.dist-info/LICENSE

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

env-llmeval/lib/python3.10/site-packages/fsspec-2024.2.0.dist-info/METADATA

@@ -0,0 +1,167 @@
+Metadata-Version: 2.1
+Name: fsspec
+Version: 2024.2.0
+Summary: File-system specification
+Home-page: https://github.com/fsspec/filesystem_spec
+Maintainer: Martin Durant
+Maintainer-email: [email protected]
+License: BSD
+Project-URL: Changelog, https://filesystem-spec.readthedocs.io/en/latest/changelog.html
+Project-URL: Documentation, https://filesystem-spec.readthedocs.io/en/latest/
+Keywords: file
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: abfs
+Requires-Dist: adlfs ; extra == 'abfs'
+Provides-Extra: adl
+Requires-Dist: adlfs ; extra == 'adl'
+Provides-Extra: arrow
+Requires-Dist: pyarrow >=1 ; extra == 'arrow'
+Provides-Extra: dask
+Requires-Dist: dask ; extra == 'dask'
+Requires-Dist: distributed ; extra == 'dask'
+Provides-Extra: devel
+Requires-Dist: pytest ; extra == 'devel'
+Requires-Dist: pytest-cov ; extra == 'devel'
+Provides-Extra: dropbox
+Requires-Dist: dropboxdrivefs ; extra == 'dropbox'
+Requires-Dist: requests ; extra == 'dropbox'
+Requires-Dist: dropbox ; extra == 'dropbox'
+Provides-Extra: entrypoints
+Provides-Extra: full
+Requires-Dist: adlfs ; extra == 'full'
+Requires-Dist: aiohttp !=4.0.0a0,!=4.0.0a1 ; extra == 'full'
+Requires-Dist: dask ; extra == 'full'
+Requires-Dist: distributed ; extra == 'full'
+Requires-Dist: dropbox ; extra == 'full'
+Requires-Dist: dropboxdrivefs ; extra == 'full'
+Requires-Dist: fusepy ; extra == 'full'
+Requires-Dist: gcsfs ; extra == 'full'
+Requires-Dist: libarchive-c ; extra == 'full'
+Requires-Dist: ocifs ; extra == 'full'
+Requires-Dist: panel ; extra == 'full'
+Requires-Dist: paramiko ; extra == 'full'
+Requires-Dist: pyarrow >=1 ; extra == 'full'
+Requires-Dist: pygit2 ; extra == 'full'
+Requires-Dist: requests ; extra == 'full'
+Requires-Dist: s3fs ; extra == 'full'
+Requires-Dist: smbprotocol ; extra == 'full'
+Requires-Dist: tqdm ; extra == 'full'
+Provides-Extra: fuse
+Requires-Dist: fusepy ; extra == 'fuse'
+Provides-Extra: gcs
+Requires-Dist: gcsfs ; extra == 'gcs'
+Provides-Extra: git
+Requires-Dist: pygit2 ; extra == 'git'
+Provides-Extra: github
+Requires-Dist: requests ; extra == 'github'
+Provides-Extra: gs
+Requires-Dist: gcsfs ; extra == 'gs'
+Provides-Extra: gui
+Requires-Dist: panel ; extra == 'gui'
+Provides-Extra: hdfs
+Requires-Dist: pyarrow >=1 ; extra == 'hdfs'
+Provides-Extra: http
+Requires-Dist: aiohttp !=4.0.0a0,!=4.0.0a1 ; extra == 'http'
+Provides-Extra: libarchive
+Requires-Dist: libarchive-c ; extra == 'libarchive'
+Provides-Extra: oci
+Requires-Dist: ocifs ; extra == 'oci'
+Provides-Extra: s3
+Requires-Dist: s3fs ; extra == 's3'
+Provides-Extra: sftp
+Requires-Dist: paramiko ; extra == 'sftp'
+Provides-Extra: smb
+Requires-Dist: smbprotocol ; extra == 'smb'
+Provides-Extra: ssh
+Requires-Dist: paramiko ; extra == 'ssh'
+Provides-Extra: tqdm
+Requires-Dist: tqdm ; extra == 'tqdm'
+
+# filesystem_spec
+
+[![PyPI version](https://badge.fury.io/py/fsspec.svg)](https://pypi.python.org/pypi/fsspec/)
+[![Anaconda-Server Badge](https://anaconda.org/conda-forge/fsspec/badges/version.svg)](https://anaconda.org/conda-forge/fsspec)
+![Build](https://github.com/fsspec/filesystem_spec/workflows/CI/badge.svg)
+[![Docs](https://readthedocs.org/projects/filesystem-spec/badge/?version=latest)](https://filesystem-spec.readthedocs.io/en/latest/?badge=latest)
+[![PyPi downloads](https://img.shields.io/pypi/dm/fsspec?label=pypi%20downloads&style=flat)](https://pepy.tech/project/fsspec)
+
+A specification for pythonic filesystems.
+
+## Install
+
+```bash
+pip install fsspec
+```
+
+would install the base fsspec. Various optionally supported features might require specification of custom
+extra require, e.g. `pip install fsspec[ssh]` will install dependencies for `ssh` backends support.
+Use `pip install fsspec[full]` for installation of all known extra dependencies.
+
+Up-to-date package also provided through conda-forge distribution:
+
+```bash
+conda install -c conda-forge fsspec
+```
+
+
+## Purpose
+
+To produce a template or specification for a file-system interface, that specific implementations should follow,
+so that applications making use of them can rely on a common behaviour and not have to worry about the specific
+internal implementation decisions with any given backend. Many such implementations are included in this package,
+or in sister projects such as `s3fs` and `gcsfs`.
+
+In addition, if this is well-designed, then additional functionality, such as a key-value store or FUSE
+mounting of the file-system implementation may be available for all implementations "for free".
+
+## Documentation
+
+Please refer to [RTD](https://filesystem-spec.readthedocs.io/en/latest/?badge=latest)
+
+## Develop
+
+fsspec uses GitHub Actions for CI. Environment files can be found
+in the "ci/" directory. Note that the main environment is called "py38",
+but it is expected that the version of python installed be adjustable at
+CI runtime. For local use, pick a version suitable for you.
+
+### Testing
+
+Tests can be run in the dev environment, if activated, via ``pytest fsspec``.
+
+The full fsspec suite requires a system-level docker, docker-compose, and fuse
+installation. If only making changes to one backend implementation, it is
+not generally necessary to run all tests locally.
+
+It is expected that contributors ensure that any change to fsspec does not
+cause issues or regressions for either other fsspec-related packages such
+as gcsfs and s3fs, nor for downstream users of fsspec. The "downstream" CI
+run and corresponding environment file run a set of tests from the dask
+test suite, and very minimal tests against pandas and zarr from the
+test_downstream.py module in this repo.
+
+### Code Formatting
+
+fsspec uses [Black](https://black.readthedocs.io/en/stable) to ensure
+a consistent code format throughout the project.
+Run ``black fsspec`` from the root of the filesystem_spec repository to
+auto-format your code. Additionally, many editors have plugins that will apply
+``black`` as you edit files. ``black`` is included in the ``tox`` environments.
+
+Optionally, you may wish to setup [pre-commit hooks](https://pre-commit.com) to
+automatically run ``black`` when you make a git commit.
+Run ``pre-commit install --install-hooks`` from the root of the
+filesystem_spec repository to setup pre-commit hooks. ``black`` will now be run
+before you commit, reformatting any changed files. You can format without
+committing via ``pre-commit run`` or skip these checks with ``git commit
+--no-verify``.

env-llmeval/lib/python3.10/site-packages/fsspec-2024.2.0.dist-info/RECORD

@@ -0,0 +1,104 @@
+fsspec-2024.2.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+fsspec-2024.2.0.dist-info/LICENSE,sha256=LcNUls5TpzB5FcAIqESq1T53K0mzTN0ARFBnaRQH7JQ,1513
+fsspec-2024.2.0.dist-info/METADATA,sha256=uwzW1Braxnd_QGVI8W6J0KHi5KTiTJEm8YzSUdG-_Dc,6786
+fsspec-2024.2.0.dist-info/RECORD,,
+fsspec-2024.2.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+fsspec-2024.2.0.dist-info/top_level.txt,sha256=blt2pDrQDwN3Gklcw13CSPLQRd6aaOgJ8AxqrW395MI,7
+fsspec/__init__.py,sha256=2kT62GfFK-AjgS-LgwSsCo_VA2IePvsyv8Ash5oiaFA,1982
+fsspec/__pycache__/__init__.cpython-310.pyc,,
+fsspec/__pycache__/_version.cpython-310.pyc,,
+fsspec/__pycache__/archive.cpython-310.pyc,,
+fsspec/__pycache__/asyn.cpython-310.pyc,,
+fsspec/__pycache__/caching.cpython-310.pyc,,
+fsspec/__pycache__/callbacks.cpython-310.pyc,,
+fsspec/__pycache__/compression.cpython-310.pyc,,
+fsspec/__pycache__/config.cpython-310.pyc,,
+fsspec/__pycache__/conftest.cpython-310.pyc,,
+fsspec/__pycache__/core.cpython-310.pyc,,
+fsspec/__pycache__/dircache.cpython-310.pyc,,
+fsspec/__pycache__/exceptions.cpython-310.pyc,,
+fsspec/__pycache__/fuse.cpython-310.pyc,,
+fsspec/__pycache__/generic.cpython-310.pyc,,
+fsspec/__pycache__/gui.cpython-310.pyc,,
+fsspec/__pycache__/mapping.cpython-310.pyc,,
+fsspec/__pycache__/parquet.cpython-310.pyc,,
+fsspec/__pycache__/registry.cpython-310.pyc,,
+fsspec/__pycache__/spec.cpython-310.pyc,,
+fsspec/__pycache__/transaction.cpython-310.pyc,,
+fsspec/__pycache__/utils.cpython-310.pyc,,
+fsspec/_version.py,sha256=onTKKWe4fXkBjQxbTwM82SUT0H3x4U17IYrciFAryaU,500
+fsspec/archive.py,sha256=S__DzfZj-urAN3tp2W6jJ6YDiXG1fAl7FjvWUN73qIE,2386
+fsspec/asyn.py,sha256=kJ45sFFya2lZsmu2v8CVc8ZPRs8AccEzAy6Jot2ylkU,36157
+fsspec/caching.py,sha256=N45pzJdD4w5FOX_sxGvHWirggPNB66JTGP1HH6fpSck,28781
+fsspec/callbacks.py,sha256=BDIwLzK6rr_0V5ch557fSzsivCElpdqhXr5dZ9Te-EE,9210
+fsspec/compression.py,sha256=Yyd8FXw2rwWRtVoRVah_yguv-J7BUcBo4yDu6Qt52a0,4859
+fsspec/config.py,sha256=LF4Zmu1vhJW7Je9Q-cwkRc3xP7Rhyy7Xnwj26Z6sv2g,4279
+fsspec/conftest.py,sha256=fVfx-NLrH_OZS1TIpYNoPzM7efEcMoL62reHOdYeFCA,1245
+fsspec/core.py,sha256=0yCj1Z5MhbSDIQiqFs49VORl9QaGwV6hp9bXdkIoPIo,22363
+fsspec/dircache.py,sha256=YzogWJrhEastHU7vWz-cJiJ7sdtLXFXhEpInGKd4EcM,2717
+fsspec/exceptions.py,sha256=xcS7LiRrQ748kvOB9mrUR14kpjNztrHgEkZWi9M-VaI,330
+fsspec/fuse.py,sha256=66amOa6wdIbS0DMhhfAPUoOB37HPorfXD1izV0prmTY,10145
+fsspec/generic.py,sha256=NuNaP66OaphwMbuLHRFBLda78TD81isa9O4ozJqbUv0,13455
+fsspec/gui.py,sha256=XKoXZpUhRE7jOhRCJH4-jRbKhVu56aS8h9tecvPD3nc,13932
+fsspec/implementations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fsspec/implementations/__pycache__/__init__.cpython-310.pyc,,
+fsspec/implementations/__pycache__/arrow.cpython-310.pyc,,
+fsspec/implementations/__pycache__/cache_mapper.cpython-310.pyc,,
+fsspec/implementations/__pycache__/cache_metadata.cpython-310.pyc,,
+fsspec/implementations/__pycache__/cached.cpython-310.pyc,,
+fsspec/implementations/__pycache__/dask.cpython-310.pyc,,
+fsspec/implementations/__pycache__/data.cpython-310.pyc,,
+fsspec/implementations/__pycache__/dbfs.cpython-310.pyc,,
+fsspec/implementations/__pycache__/dirfs.cpython-310.pyc,,
+fsspec/implementations/__pycache__/ftp.cpython-310.pyc,,
+fsspec/implementations/__pycache__/git.cpython-310.pyc,,
+fsspec/implementations/__pycache__/github.cpython-310.pyc,,
+fsspec/implementations/__pycache__/http.cpython-310.pyc,,
+fsspec/implementations/__pycache__/jupyter.cpython-310.pyc,,
+fsspec/implementations/__pycache__/libarchive.cpython-310.pyc,,
+fsspec/implementations/__pycache__/local.cpython-310.pyc,,
+fsspec/implementations/__pycache__/memory.cpython-310.pyc,,
+fsspec/implementations/__pycache__/reference.cpython-310.pyc,,
+fsspec/implementations/__pycache__/sftp.cpython-310.pyc,,
+fsspec/implementations/__pycache__/smb.cpython-310.pyc,,
+fsspec/implementations/__pycache__/tar.cpython-310.pyc,,
+fsspec/implementations/__pycache__/webhdfs.cpython-310.pyc,,
+fsspec/implementations/__pycache__/zip.cpython-310.pyc,,
+fsspec/implementations/arrow.py,sha256=_7TLuV6ZzNlpmUU_v6ud56u2wadzsKmY5qugPBxgMEs,8649
+fsspec/implementations/cache_mapper.py,sha256=iHgBA6gjzDJ7_mBboHFzpLTf55HP3UEwUOZ43xyUK4M,2429
+fsspec/implementations/cache_metadata.py,sha256=ZvyA7Y3KK-5Ct4E5pELzD6mH_5T03XqaKVT96qYDADU,8576
+fsspec/implementations/cached.py,sha256=LbbPbeUup07O0y7gXD_atFgajWM9p1vlDKu_BOyLfbo,30943
+fsspec/implementations/dask.py,sha256=CXZbJzIVOhKV8ILcxuy3bTvcacCueAbyQxmvAkbPkrk,4466
+fsspec/implementations/data.py,sha256=Oti0dKzyeadnVIedo3s8CADoh9bNM-96_6viTEYr4lo,1245
+fsspec/implementations/dbfs.py,sha256=cix9OYUveuSOx5UO5uRUwNUkYqjzyY0fkKnca1kTgZ0,15014
+fsspec/implementations/dirfs.py,sha256=inDIRSDPhI1_ud1MMBFrpZQ11VIAMJ_dZQtbE4V08Ng,11384
+fsspec/implementations/ftp.py,sha256=rp6cTog8xqjDPlKdSLKcsyP7K593_ByMabxGbNSEpTo,11655
+fsspec/implementations/git.py,sha256=vKGI-Vd5q4H2RrvhebkPc9NwlfkZ980OUGhebeCw-M0,4034
+fsspec/implementations/github.py,sha256=0kIiKkeAaROuHgdWBHVQFrzJ2ZfoDgymCehL_kJXHYA,7565
+fsspec/implementations/http.py,sha256=PkhfgUV3-T7fG2Jf-NLX9doH52snV5Wmw91uVA9k74M,29454
+fsspec/implementations/jupyter.py,sha256=B2uj7OEm7yIk-vRSsO37_ND0t0EBvn4B-Su43ibN4Pg,3811
+fsspec/implementations/libarchive.py,sha256=5_I2DiLXwQ1JC8x-K7jXu-tBwhO9dj7tFLnb0bTnVMQ,7102
+fsspec/implementations/local.py,sha256=nxiRKg9FAQHTQss9-ET8ZzDXPGhSOktgkxrg0ffMs2I,13454
+fsspec/implementations/memory.py,sha256=2iU--pOV2KCTrS-d5K8VKSygh9MPk2D7NZ_C8lMMEIw,9701
+fsspec/implementations/reference.py,sha256=0iGu8mscaQ3a5iTlRNByytQ3_-1Bj8__ARqVwyy4q2M,43871
+fsspec/implementations/sftp.py,sha256=fMY9XZcmpjszQ2tCqO_TPaJesaeD_Dv7ptYzgUPGoO0,5631
+fsspec/implementations/smb.py,sha256=k3RtzW97lJtYuw_QpP1rJRFnUBmSsw9twFjUCex0a5U,10591
+fsspec/implementations/tar.py,sha256=dam78Tp_CozybNqCY2JYgGBS3Uc9FuJUAT9oB0lolOs,4111
+fsspec/implementations/webhdfs.py,sha256=wqVfno7z0TY1HepaIvKTUUcl_bi5NkV6qWsST8t_s7Y,16745
+fsspec/implementations/zip.py,sha256=JDX-3HOI15qUl6VTBsNPuDp5RVN6s2n3Bywd4mMu0T0,4347
+fsspec/mapping.py,sha256=WFEXRWxujQwfzzkRP5tpdIE0265okAtlP97qFZGvV1k,8165
+fsspec/parquet.py,sha256=qVxDhwc960SGOt5etcYAJxCr-7HQKP01687KpDR02Gw,19463
+fsspec/registry.py,sha256=-dl7sh2tsfhMA2uxz5KQDsPFehQTgMJIbVjNq6QLoKU,11145
+fsspec/spec.py,sha256=3t96RgizRN_slIuHXnuR0bXjVUfBS1TfuDrEua4oQvE,66277
+fsspec/tests/abstract/__init__.py,sha256=i1wcFixV6QhOwdoB24c8oXjzobISNqiKVz9kl2DvAY8,10028
+fsspec/tests/abstract/__pycache__/__init__.cpython-310.pyc,,
+fsspec/tests/abstract/__pycache__/common.cpython-310.pyc,,
+fsspec/tests/abstract/__pycache__/copy.cpython-310.pyc,,
+fsspec/tests/abstract/__pycache__/get.cpython-310.pyc,,
+fsspec/tests/abstract/__pycache__/put.cpython-310.pyc,,
+fsspec/tests/abstract/common.py,sha256=1GQwNo5AONzAnzZj0fWgn8NJPLXALehbsuGxS3FzWVU,4973
+fsspec/tests/abstract/copy.py,sha256=gU5-d97U3RSde35Vp4RxPY4rWwL744HiSrJ8IBOp9-8,19967
+fsspec/tests/abstract/get.py,sha256=vNR4HztvTR7Cj56AMo7_tx7TeYz1Jgr_2Wb8Lv-UiBY,20755
+fsspec/tests/abstract/put.py,sha256=7aih17OKB_IZZh1Mkq1eBDIjobhtMQmI8x-Pw-S_aZk,21201
+fsspec/transaction.py,sha256=jeexB-H6Aw_gN6Z7hoKKe6v8zizITq39-gyTgpipIKE,2251
+fsspec/utils.py,sha256=_VX_0VwDtoAFSjMYrxvJvnPNX9FMoHO5BlFHXJ0bHFI,23053

env-llmeval/lib/python3.10/site-packages/fsspec-2024.2.0.dist-info/WHEEL

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

env-llmeval/lib/python3.10/site-packages/fsspec-2024.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fsspec

env-llmeval/lib/python3.10/site-packages/huggingface_hub-0.22.2.dist-info/INSTALLER

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

env-llmeval/lib/python3.10/site-packages/huggingface_hub-0.22.2.dist-info/LICENSE

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