Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/sacrebleu-2.4.2.dist-info/INSTALLER

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

env-llmeval/lib/python3.10/site-packages/sacrebleu-2.4.2.dist-info/LICENSE.txt

@@ -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/sacrebleu-2.4.2.dist-info/METADATA

@@ -0,0 +1,1124 @@
+Metadata-Version: 2.1
+Name: sacrebleu
+Version: 2.4.2
+Summary: Hassle-free computation of shareable, comparable, and reproducible BLEU, chrF, and TER scores
+Home-page: https://github.com/mjpost/sacrebleu
+Author: Matt Post
+Author-email: [email protected]
+Maintainer-email: [email protected]
+License: Apache License 2.0
+Keywords: machine translation, evaluation, NLP, natural language processing, computational linguistics
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Text Processing
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: portalocker
+Requires-Dist: regex
+Requires-Dist: tabulate (>=0.8.9)
+Requires-Dist: numpy (>=1.17)
+Requires-Dist: colorama
+Requires-Dist: lxml
+Provides-Extra: dev
+Requires-Dist: wheel ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Dist: mypy ; extra == 'dev'
+Requires-Dist: types-tabulate ; extra == 'dev'
+Requires-Dist: lxml-stubs ; extra == 'dev'
+Provides-Extra: ja
+Requires-Dist: mecab-python3 (<=1.0.6,>=1.0.5) ; extra == 'ja'
+Requires-Dist: ipadic (<2.0,>=1.0) ; extra == 'ja'
+Provides-Extra: ko
+Requires-Dist: mecab-ko (<=1.0.1,>=1.0.0) ; extra == 'ko'
+Requires-Dist: mecab-ko-dic (<2.0,>=1.0) ; extra == 'ko'
+
+# sacreBLEU
+
+[![PyPI version](https://img.shields.io/pypi/v/sacrebleu)](https://img.shields.io/pypi/v/sacrebleu)
+[![Python version](https://img.shields.io/pypi/pyversions/sacrebleu)](https://img.shields.io/pypi/pyversions/sacrebleu)
+[![GitHub issues](https://img.shields.io/github/issues/mjpost/sacreBLEU.svg)](https://github.com/mjpost/sacrebleu/issues)
+
+SacreBLEU ([Post, 2018](http://aclweb.org/anthology/W18-6319)) provides hassle-free computation of shareable, comparable, and reproducible **BLEU** scores.
+Inspired by Rico Sennrich's `multi-bleu-detok.perl`, it produces the official WMT scores but works with plain text.
+It also knows all the standard test sets and handles downloading, processing, and tokenization for you.
+
+The official version is hosted at <https://github.com/mjpost/sacrebleu>.
+
+# Motivation
+
+Comparing BLEU scores is harder than it should be. Every decoder has its own implementation, often borrowed from Moses, but maybe with subtle changes.
+Moses itself has a number of implementations as standalone scripts, with little indication of how they differ (note: they mostly don't, but `multi-bleu.pl` expects tokenized input). Different flags passed to each of these scripts can produce wide swings in the final score. All of these may handle tokenization in different ways. On top of this, downloading and managing test sets is a moderate annoyance.
+
+Sacre bleu! What a mess.
+
+**SacreBLEU** aims to solve these problems by wrapping the original reference implementation ([Papineni et al., 2002](https://www.aclweb.org/anthology/P02-1040.pdf)) together with other useful features.
+The defaults are set the way that BLEU should be computed, and furthermore, the script outputs a short version string that allows others to know exactly what you did.
+As an added bonus, it automatically downloads and manages test sets for you, so that you can simply tell it to score against `wmt14`, without having to hunt down a path on your local file system.
+It is all designed to take BLEU a little more seriously.
+After all, even with all its problems, BLEU is the default and---admit it---well-loved metric of our entire research community.
+Sacre BLEU.
+
+# Features
+
+- It automatically downloads common WMT test sets and processes them to plain text
+- It produces a short version string that facilitates cross-paper comparisons
+- It properly computes scores on detokenized outputs, using WMT ([Conference on Machine Translation](http://statmt.org/wmt17)) standard tokenization
+- It produces the same values as the official script (`mteval-v13a.pl`) used by WMT
+- It outputs the BLEU score without the comma, so you don't have to remove it with `sed` (Looking at you, `multi-bleu.perl`)
+- It supports different tokenizers for BLEU including support for Japanese and Chinese
+- It supports **chrF, chrF++** and **Translation error rate (TER)** metrics
+- It performs paired bootstrap resampling and paired approximate randomization tests for statistical significance reporting
+
+# Breaking Changes
+
+## v2.0.0
+
+As of v2.0.0, the default output format is changed to `json` for less painful parsing experience. This means that software that parse the output of sacreBLEU should be modified to either (i) parse the JSON using for example the `jq` utility or (ii) pass `-f text` to sacreBLEU to preserve the old textual output. The latter change can also be made **persistently** by exporting `SACREBLEU_FORMAT=text` in relevant shell configuration files.
+
+Here's an example of parsing the `score` key of the JSON output using `jq`:
+
+```
+$ sacrebleu -i output.detok.txt -t wmt17 -l en-de | jq -r .score
+20.8
+```
+
+# Installation
+
+Install the official Python module from PyPI (**Python>=3.6 only**):
+
+    pip install sacrebleu
+
+In order to install Japanese tokenizer support through `mecab-python3`, you need to run the
+following command instead, to perform a full installation with dependencies:
+
+    pip install "sacrebleu[ja]"
+
+In order to install Korean tokenizer support through `pymecab-ko`, you need to run the
+following command instead, to perform a full installation with dependencies:
+
+    pip install "sacrebleu[ko]"
+
+# Command-line Usage
+
+You can get a list of available test sets with `sacrebleu --list`. Please see [DATASETS.md](DATASETS.md)
+for an up-to-date list of supported datasets. You can also list available test sets for a given language pair
+with `sacrebleu --list -l en-fr`.
+
+## Basics
+
+### Downloading test sets
+
+Downloading is triggered when you request a test set. If the dataset is not available, it is downloaded
+and unpacked.
+
+E.g., you can use the following commands to download the source, pass it through your translation system
+in `translate.sh`, and then score it:
+
+```
+$ sacrebleu -t wmt17 -l en-de --echo src > wmt17.en-de.en
+$ cat wmt17.en-de.en | translate.sh | sacrebleu -t wmt17 -l en-de
+```
+
+Some test sets also have the outputs of systems that were submitted to the task.
+For example, the `wmt/systems` test set.
+
+```bash
+$ sacrebleu -t wmt21/systems -l zh-en --echo NiuTrans
+```
+
+This provides a convenient way to score:
+
+```bash
+$ sacrebleu -t wmt21/system -l zh-en --echo NiuTrans | sacrebleu -t wmt21/systems -l zh-en
+``
+
+You can see a list of the available outputs by passing an invalid value to `--echo`.
+
+### JSON output
+
+As of version `>=2.0.0`, sacreBLEU prints the computed scores in JSON format to make parsing less painful:
+
+```
+$ sacrebleu -i output.detok.txt -t wmt17 -l en-de
+```
+
+```json
+{
+ "name": "BLEU",
+ "score": 20.8,
+ "signature": "nrefs:1|case:mixed|eff:no|tok:13a|smooth:exp|version:2.0.0",
+ "verbose_score": "54.4/26.6/14.9/8.7 (BP = 1.000 ratio = 1.026 hyp_len = 62880 ref_len = 61287)",
+ "nrefs": "1",
+ "case": "mixed",
+ "eff": "no",
+ "tok": "13a",
+ "smooth": "exp",
+ "version": "2.0.0"
+}
+```
+
+If you want to keep the old behavior, you can pass `-f text` or export `SACREBLEU_FORMAT=text`:
+
+```
+$ sacrebleu -i output.detok.txt -t wmt17 -l en-de -f text
+BLEU|nrefs:1|case:mixed|eff:no|tok:13a|smooth:exp|version:2.0.0 = 20.8 54.4/26.6/14.9/8.7 (BP = 1.000 ratio = 1.026 hyp_len = 62880 ref_len = 61287)
+```
+
+### Scoring
+
+(All examples below assume old-style text output for a compact representation that save space)
+
+Let's say that you just translated the `en-de` test set of WMT17 with your fancy MT system and the **detokenized** translations are in a file called `output.detok.txt`:
+
+```
+# Option 1: Redirect system output to STDIN
+$ cat output.detok.txt | sacrebleu -t wmt17 -l en-de
+BLEU|nrefs:1|case:mixed|eff:no|tok:13a|smooth:exp|version:2.0.0 = 20.8 54.4/26.6/14.9/8.7 (BP = 1.000 ratio = 1.026 hyp_len = 62880 ref_len = 61287)
+
+# Option 2: Use the --input/-i argument
+$ sacrebleu -t wmt17 -l en-de -i output.detok.txt
+BLEU|nrefs:1|case:mixed|eff:no|tok:13a|smooth:exp|version:2.0.0 = 20.8 54.4/26.6/14.9/8.7 (BP = 1.000 ratio = 1.026 hyp_len = 62880 ref_len = 61287)
+```
+
+You can obtain a short version of the signature with `--short/-sh`:
+
+```
+$ sacrebleu -t wmt17 -l en-de -i output.detok.txt -sh
+BLEU|#:1|c:mixed|e:no|tok:13a|s:exp|v:2.0.0 = 20.8 54.4/26.6/14.9/8.7 (BP = 1.000 ratio = 1.026 hyp_len = 62880 ref_len = 61287)
+```
+
+If you only want the score to be printed, you can use the `--score-only/-b` flag:
+
+```
+$ sacrebleu -t wmt17 -l en-de -i output.detok.txt -b
+20.8
+```
+
+The precision of the scores can be configured via the `--width/-w` flag:
+
+```
+$ sacrebleu -t wmt17 -l en-de -i output.detok.txt -b -w 4
+20.7965
+```
+
+### Using your own reference file
+
+SacreBLEU knows about common test sets (as detailed in the `--list` example above), but you can also use it to score system outputs with arbitrary references. In this case, do not forget to provide **detokenized** reference and hypotheses files:
+
+```
+# Let's save the reference to a text file
+$ sacrebleu -t wmt17 -l en-de --echo ref > ref.detok.txt
+
+# Option 1: Pass the reference file as a positional argument to sacreBLEU
+$ sacrebleu ref.detok.txt -i output.detok.txt -m bleu -b -w 4
+20.7965
+
+# Option 2: Redirect the system into STDIN (Compatible with multi-bleu.perl way of doing things)
+$ cat output.detok.txt | sacrebleu ref.detok.txt -m bleu -b -w 4
+20.7965
+```
+
+### Using multiple metrics
+
+Let's first compute BLEU, chrF and TER with the default settings:
+
+```
+$ sacrebleu -t wmt17 -l en-de -i output.detok.txt -m bleu chrf ter
+        BLEU|nrefs:1|case:mixed|eff:no|tok:13a|smooth:exp|version:2.0.0 = 20.8 <stripped>
+      chrF2|nrefs:1|case:mixed|eff:yes|nc:6|nw:0|space:no|version:2.0.0 = 52.0
+TER|nrefs:1|case:lc|tok:tercom|norm:no|punct:yes|asian:no|version:2.0.0 = 69.0
+```
+
+Let's now enable `chrF++` which is a revised version of chrF that takes into account word n-grams.
+Observe how the `nw:0` gets changed into `nw:2` in the signature:
+
+```
+$ sacrebleu -t wmt17 -l en-de -i output.detok.txt -m bleu chrf ter --chrf-word-order 2
+        BLEU|nrefs:1|case:mixed|eff:no|tok:13a|smooth:exp|version:2.0.0 = 20.8 <stripped>
+    chrF2++|nrefs:1|case:mixed|eff:yes|nc:6|nw:2|space:no|version:2.0.0 = 49.0
+TER|nrefs:1|case:lc|tok:tercom|norm:no|punct:yes|asian:no|version:2.0.0 = 69.0
+```
+
+Metric-specific arguments are detailed in the output of `--help`:
+
+```
+BLEU related arguments:
+  --smooth-method {none,floor,add-k,exp}, -s {none,floor,add-k,exp}
+                        Smoothing method: exponential decay, floor (increment zero counts), add-k (increment num/denom by k for n>1), or none. (Default: exp)
+  --smooth-value BLEU_SMOOTH_VALUE, -sv BLEU_SMOOTH_VALUE
+                        The smoothing value. Only valid for floor and add-k. (Defaults: floor: 0.1, add-k: 1)
+  --tokenize {none,zh,13a,char,intl,ja-mecab,ko-mecab}, -tok {none,zh,13a,char,intl,ja-mecab,ko-mecab}
+                        Tokenization method to use for BLEU. If not provided, defaults to `zh` for Chinese, `ja-mecab` for Japanese, `ko-mecab` for Korean and `13a` (mteval) otherwise.
+  --lowercase, -lc      If True, enables case-insensitivity. (Default: False)
+  --force               Insist that your tokenized input is actually detokenized.
+
+chrF related arguments:
+  --chrf-char-order CHRF_CHAR_ORDER, -cc CHRF_CHAR_ORDER
+                        Character n-gram order. (Default: 6)
+  --chrf-word-order CHRF_WORD_ORDER, -cw CHRF_WORD_ORDER
+                        Word n-gram order (Default: 0). If equals to 2, the metric is referred to as chrF++.
+  --chrf-beta CHRF_BETA
+                        Determine the importance of recall w.r.t precision. (Default: 2)
+  --chrf-whitespace     Include whitespaces when extracting character n-grams. (Default: False)
+  --chrf-lowercase      Enable case-insensitivity. (Default: False)
+  --chrf-eps-smoothing  Enables epsilon smoothing similar to chrF++.py, NLTK and Moses; instead of effective order smoothing. (Default: False)
+
+TER related arguments (The defaults replicate TERCOM's behavior):
+  --ter-case-sensitive  Enables case sensitivity (Default: False)
+  --ter-asian-support   Enables special treatment of Asian characters (Default: False)
+  --ter-no-punct        Removes punctuation. (Default: False)
+  --ter-normalized      Applies basic normalization and tokenization. (Default: False)
+```
+
+### Version Signatures
+As you may have noticed, sacreBLEU generates version strings such as `BLEU|nrefs:1|case:mixed|eff:no|tok:13a|smooth:exp|version:2.0.0` for reproducibility reasons. It's strongly recommended to share these signatures in your papers!
+
+### Outputting other metadata
+
+Sacrebleu knows about metadata for some test sets, and you can output it like this:
+
+```
+$ sacrebleu -t wmt21 -l en-de --echo src docid ref | head 2
+Couple MACED at California dog park for not wearing face masks while having lunch (VIDEO) - RT USA News	rt.com.131279	Paar in Hundepark in Kalifornien mit Pfefferspray besprüht, weil es beim Mittagessen keine Masken trug (VIDEO) - RT USA News
+There's mask-shaming and then there's full on assault.	rt.com.131279	Masken-Shaming ist eine Sache, Körperverletzung eine andere.
+```
+
+If multiple fields are requested, they are output as tab-separated columns (a TSV).
+
+To see the available fields, add `--echo asdf` (or some other garbage data):
+
+```
+$ sacrebleu -t wmt21 -l en-de --echo asdf
+sacreBLEU: No such field asdf in test set wmt21 for language pair en-de.
+sacreBLEU: available fields for wmt21/en-de: src, ref:A, ref, docid, origlang
+```
+
+## Translationese Support
+
+If you are interested in the translationese effect, you can evaluate BLEU on a subset of sentences
+with a given original language (identified based on the `origlang` tag in the raw SGM files).
+E.g., to evaluate only against originally German sentences translated to English use:
+
+    $ sacrebleu -t wmt13 -l de-en --origlang=de -i my-wmt13-output.txt
+
+and to evaluate against the complement (in this case `origlang` en, fr, cs, ru, de) use:
+
+    $ sacrebleu -t wmt13 -l de-en --origlang=non-de -i my-wmt13-output.txt
+
+**Please note** that the evaluator will return a BLEU score only on the requested subset,
+but it expects that you pass through the entire translated test set.
+
+## Languages & Preprocessing
+
+### BLEU
+
+- You can compute case-insensitive BLEU by passing `--lowercase` to sacreBLEU
+- The default tokenizer for BLEU is `13a` which mimics the `mteval-v13a` script from Moses.
+- Other tokenizers are:
+   - `none` which will not apply any kind of tokenization at all
+   - `char` for language-agnostic character-level tokenization
+   - `intl` applies international tokenization and mimics the `mteval-v14` script from Moses
+   - `zh` separates out **Chinese** characters and tokenizes the non-Chinese parts using `13a` tokenizer
+   - `ja-mecab` tokenizes **Japanese** inputs using the [MeCab](https://pypi.org/project/mecab-python3) morphological analyzer
+   - `ko-mecab` tokenizes **Korean** inputs using the [MeCab-ko](https://pypi.org/project/mecab-ko) morphological analyzer
+   - `flores101` and `flores200` uses the SentencePiece model built from the Flores-101 and [Flores-200](https://github.com/facebookresearch/flores/blob/main/flores200/README.md#languages-in-flores-200) dataset, respectively. Note: the canonical .spm file will be automatically fetched if not found locally.
+- You can switch tokenizers using the `--tokenize` flag of sacreBLEU. Alternatively, if you provide language-pair strings
+  using `--language-pair/-l`, `zh`, `ja-mecab` and `ko-mecab` tokenizers will be used if the target language is `zh` or `ja` or `ko`, respectively.
+- **Note that** there's no automatic language detection from the hypotheses so you need to make sure that you are correctly
+  selecting the tokenizer for **Japanese**, **Korean** and **Chinese**.
+
+
+Default 13a tokenizer will produce poor results for Japanese:
+
+```
+$ sacrebleu kyoto-test.ref.ja -i kyoto-test.hyp.ja -b
+2.1
+```
+
+Let's use the `ja-mecab` tokenizer:
+```
+$ sacrebleu kyoto-test.ref.ja -i kyoto-test.hyp.ja --tokenize ja-mecab -b
+14.5
+```
+
+If you provide the language-pair, sacreBLEU will use ja-mecab automatically:
+
+```
+$ sacrebleu kyoto-test.ref.ja -i kyoto-test.hyp.ja -l en-ja -b
+14.5
+```
+
+### chrF / chrF++
+
+chrF applies minimum to none pre-processing as it deals with character n-grams:
+
+- If you pass `--chrf-whitespace`, whitespace characters will be preserved when computing character n-grams.
+- If you pass `--chrf-lowercase`, sacreBLEU will compute case-insensitive chrF.
+- If you enable non-zero `--chrf-word-order` (pass `2` for `chrF++`), a very simple punctuation tokenization will be internally applied.
+
+
+### TER
+
+Translation Error Rate (TER) has its own special tokenizer that you can configure through the command line.
+The defaults provided are **compatible with the upstream TER implementation (TERCOM)** but you can nevertheless modify the
+behavior through the command-line:
+
+- TER is by default case-insensitive. Pass `--ter-case-sensitive` to enable case-sensitivity.
+- Pass `--ter-normalize` to apply a general Western tokenization
+- Pass `--ter-asian-support` to enable the tokenization of Asian characters. If provided with `--ter-normalize`,
+  both will be applied.
+- Pass `--ter-no-punct` to strip punctuation.
+
+## Multi-reference Evaluation
+
+All three metrics support the use of multiple references during evaluation. Let's first pass all references as positional arguments:
+
+```
+$ sacrebleu ref1 ref2 -i system -m bleu chrf ter
+        BLEU|nrefs:2|case:mixed|eff:no|tok:13a|smooth:exp|version:2.0.0 = 61.8 <stripped>
+      chrF2|nrefs:2|case:mixed|eff:yes|nc:6|nw:0|space:no|version:2.0.0 = 75.0
+TER|nrefs:2|case:lc|tok:tercom|norm:no|punct:yes|asian:no|version:2.0.0 = 31.2
+```
+
+Alternatively (less recommended), we can concatenate references using tabs as delimiters as well. Don't forget to pass `--num-refs/-nr` in this case!
+
+```
+$ paste ref1 ref2 > refs.tsv
+
+$ sacrebleu refs.tsv --num-refs 2 -i system -m bleu
+BLEU|nrefs:2|case:mixed|eff:no|tok:13a|smooth:exp|version:2.0.0 = 61.8 <stripped>
+```
+
+## Multi-system Evaluation
+As of version `>=2.0.0`, SacreBLEU supports evaluation of an arbitrary number of systems for a particular
+test set and language-pair. This has the advantage of seeing all results in a
+nicely formatted table.
+
+Let's pass all system output files that match the shell glob `newstest2017.online-*` to sacreBLEU for evaluation:
+
+```
+$ sacrebleu -t wmt17 -l en-de -i newstest2017.online-* -m bleu chrf
+╒═══════════════════════════════╤════════╤═════════╕
+│                        System │  BLEU  │  chrF2  │
+╞═══════════════════════════════╪════════╪═════════╡
+│ newstest2017.online-A.0.en-de │  20.8  │  52.0   │
+├───────────────────────────────┼────────┼─────────┤
+│ newstest2017.online-B.0.en-de │  26.7  │  56.3   │
+├───────────────────────────────┼────────┼─────────┤
+│ newstest2017.online-F.0.en-de │  15.5  │  49.3   │
+├───────────────────────────────┼────────┼─────────┤
+│ newstest2017.online-G.0.en-de │  18.2  │  51.6   │
+╘═══════════════════════════════╧════════╧═════════╛
+
+-----------------
+Metric signatures
+-----------------
+ - BLEU       nrefs:1|case:mixed|eff:no|tok:13a|smooth:exp|version:2.0.0
+ - chrF2      nrefs:1|case:mixed|eff:yes|nc:6|nw:0|space:no|version:2.0.0
+```
+
+You can also change the output format to `latex`:
+
+```
+$ sacrebleu -t wmt17 -l en-de -i newstest2017.online-* -m bleu chrf -f latex
+\begin{tabular}{rcc}
+\toprule
+                        System &  BLEU  &  chrF2  \\
+\midrule
+ newstest2017.online-A.0.en-de &  20.8  &  52.0   \\
+ newstest2017.online-B.0.en-de &  26.7  &  56.3   \\
+ newstest2017.online-F.0.en-de &  15.5  &  49.3   \\
+ newstest2017.online-G.0.en-de &  18.2  &  51.6   \\
+\bottomrule
+\end{tabular}
+
+...
+```
+
+## Confidence Intervals for Single System Evaluation
+
+When enabled with the `--confidence` flag, SacreBLEU will print
+(1) the actual system score, (2) the true mean estimated from bootstrap resampling and (3),
+the 95% [confidence interval](https://en.wikipedia.org/wiki/Confidence_interval) around the mean.
+By default, the number of bootstrap resamples is 1000 (`bs:1000` in the signature)
+and can be changed with `--confidence-n`:
+
+```
+$ sacrebleu -t wmt17 -l en-de -i output.detok.txt -m bleu chrf --confidence -f text --short
+   BLEU|#:1|bs:1000|rs:12345|c:mixed|e:no|tok:13a|s:exp|v:2.0.0 = 22.675 (μ = 22.669 ± 0.598) ...
+chrF2|#:1|bs:1000|rs:12345|c:mixed|e:yes|nc:6|nw:0|s:no|v:2.0.0 = 51.953 (μ = 51.953 ± 0.462)
+```
+
+**NOTE:** Although provided as a functionality, having access to confidence intervals for just one system
+may not reveal much information about the underlying model. It often makes more sense to perform
+**paired statistical tests** across multiple systems.
+
+**NOTE:** When resampling, the seed of the `numpy`'s random number generator (RNG)
+is fixed to `12345`. If you want to relax this and set your own seed, you can
+export the environment variable `SACREBLEU_SEED` to an integer. Alternatively, you can export
+`SACREBLEU_SEED=None` to skip initializing the RNG's seed and allow for non-deterministic
+behavior.
+
+## Paired Significance Tests for Multi System Evaluation
+Ideally, one would have access to many systems in cases such as (1) investigating
+whether a newly added feature yields significantly different scores than the baseline or
+(2) evaluating submissions for a particular shared task. SacreBLEU offers two different paired significance tests that are widely used in MT research.
+
+### Paired bootstrap resampling (--paired-bs)
+
+This is an efficient implementation of the paper [Statistical Significance Tests for Machine Translation Evaluation](https://www.aclweb.org/anthology/W04-3250.pdf) and is result-compliant with the [reference Moses implementation](https://github.com/moses-smt/mosesdecoder/blob/master/scripts/analysis/bootstrap-hypothesis-difference-significance.pl). The number of bootstrap resamples can be changed with the `--paired-bs-n` flag and its default is 1000.
+
+When launched, paired bootstrap resampling will perform:
+ - Bootstrap resampling to estimate 95% CI for all systems and the baseline
+ - A significance test between the **baseline** and each **system** to compute a [p-value](https://en.wikipedia.org/wiki/P-value).
+
+### Paired approximate randomization (--paired-ar)
+
+Paired approximate randomization (AR) is another type of paired significance test that is claimed to be more accurate than paired bootstrap resampling when it comes to Type-I errors ([Riezler and Maxwell III, 2005](https://www.aclweb.org/anthology/W05-0908.pdf)). Type-I errors indicate failures to reject the null hypothesis when it is true. In other words, AR should in theory be more robust to subtle changes across systems.
+
+Our implementation is verified to be result-compliant with the [Multeval toolkit](https://github.com/jhclark/multeval) that also uses paired AR test for pairwise comparison. The number of approximate randomization trials is set to 10,000 by default. This can be changed with the `--paired-ar-n` flag.
+
+### Running the tests
+
+- The **first system** provided to `--input/-i` will be automatically taken as the **baseline system** against which you want to compare **other systems.**
+- When `--input/-i` is used, the system output files will be automatically named according to the file paths. For the sake of simplicity, SacreBLEU will automatically discard the **baseline system** if it also appears amongst **other systems**. This is useful if you would like to run the tool by passing `-i systems/baseline.txt systems/*.txt`. Here, the `baseline.txt` file will not be also considered as a candidate system.
+- Alternatively, you can also use a tab-separated input file redirected to SacreBLEU. In this case, the first column hypotheses will be taken as the **baseline system**. However, this method is **not recommended** as it won't allow naming your systems in a human-readable way. It will instead enumerate the systems from 1 to N following the column order in the tab-separated input.
+- On Linux and Mac OS X, you can launch the tests on multiple CPU's by passing the flag `--paired-jobs N`. If `N == 0`, SacreBLEU will launch one worker for each pairwise comparison. If `N > 0`, `N` worker processes will be spawned. This feature will substantially speed up the runtime especially if you want the **TER** metric to be computed.
+
+#### Example: Paired bootstrap resampling
+In the example below, we select `newstest2017.LIUM-NMT.4900.en-de` as the baseline and compare it to 4 other WMT17 submissions using paired bootstrap resampling. According to the results, the null hypothesis (i.e. the two systems being essentially the same) could not be rejected (at the significance level of 0.05) for the following comparisons:
+
+- 0.1 BLEU difference between the baseline and the online-B system (p = 0.3077)
+
+```
+$ sacrebleu -t wmt17 -l en-de -i newstest2017.LIUM-NMT.4900.en-de newstest2017.online-* -m bleu chrf --paired-bs
+╒════════════════════════════════════════════╤═════════════════════╤══════════════════════╕
+│                                     System │  BLEU (μ ± 95% CI)  │  chrF2 (μ ± 95% CI)  │
+╞════════════════════════════════════════════╪═════════════════════╪══════════════════════╡
+│ Baseline: newstest2017.LIUM-NMT.4900.en-de │  26.6 (26.6 ± 0.6)  │  55.9 (55.9 ± 0.5)   │
+├────────────────────────────────────────────┼─────────────────────┼──────────────────────┤
+│              newstest2017.online-A.0.en-de │  20.8 (20.8 ± 0.6)  │  52.0 (52.0 ± 0.4)   │
+│                                            │    (p = 0.0010)*    │    (p = 0.0010)*     │
+├────────────────────────────────────────────┼─────────────────────┼──────────────────────┤
+│              newstest2017.online-B.0.en-de │  26.7 (26.6 ± 0.7)  │  56.3 (56.3 ± 0.5)   │
+│                                            │    (p = 0.3077)     │    (p = 0.0240)*     │
+├────────────────────────────────────────────┼─────────────────────┼──────────────────────┤
+│              newstest2017.online-F.0.en-de │  15.5 (15.4 ± 0.5)  │  49.3 (49.3 ± 0.4)   │
+│                                            │    (p = 0.0010)*    │    (p = 0.0010)*     │
+├────────────────────────────────────────────┼─────────────────────┼──────────────────────┤
+│              newstest2017.online-G.0.en-de │  18.2 (18.2 ± 0.5)  │  51.6 (51.6 ± 0.4)   │
+│                                            │    (p = 0.0010)*    │    (p = 0.0010)*     │
+╘════════════════════════════════════════════╧═════════════════════╧══════════════════════╛
+
+------------------------------------------------------------
+Paired bootstrap resampling test with 1000 resampling trials
+------------------------------------------------------------
+ - Each system is pairwise compared to Baseline: newstest2017.LIUM-NMT.4900.en-de.
+   Actual system score / bootstrap estimated true mean / 95% CI are provided for each metric.
+
+ - Null hypothesis: the system and the baseline translations are essentially
+   generated by the same underlying process. For a given system and the baseline,
+   the p-value is roughly the probability of the absolute score difference (delta)
+   or higher occurring due to chance, under the assumption that the null hypothesis is correct.
+
+ - Assuming a significance threshold of 0.05, the null hypothesis can be rejected
+   for p-values < 0.05 (marked with "*"). This means that the delta is unlikely to be attributed
+   to chance, hence the system is significantly "different" than the baseline.
+   Otherwise, the p-values are highlighted in red.
+
+ - NOTE: Significance does not tell whether a system is "better" than the baseline but rather
+   emphasizes the "difference" of the systems in terms of the replicability of the delta.
+
+-----------------
+Metric signatures
+-----------------
+ - BLEU       nrefs:1|bs:1000|seed:12345|case:mixed|eff:no|tok:13a|smooth:exp|version:2.0.0
+ - chrF2      nrefs:1|bs:1000|seed:12345|case:mixed|eff:yes|nc:6|nw:0|space:no|version:2.0.0
+```
+
+#### Example: Paired approximate randomization
+
+Let's now run the paired approximate randomization test for the same comparison. According to the results, the findings are compatible with the paired bootstrap resampling test. However, the p-value for the `baseline vs. online-B` comparison is much higher (`0.8066`) than the paired bootstrap resampling test.
+
+(**Note that** the AR test does not provide confidence intervals around the true mean as it does not perform bootstrap resampling.)
+
+```
+$ sacrebleu -t wmt17 -l en-de -i newstest2017.LIUM-NMT.4900.en-de newstest2017.online-* -m bleu chrf --paired-ar
+╒════════════════════════════════════════════╤═══════════════╤═══════════════╕
+│                                     System │     BLEU      │     chrF2     │
+╞════════════════════════════════════════════╪═══════════════╪═══════════════╡
+│ Baseline: newstest2017.LIUM-NMT.4900.en-de │     26.6      │     55.9      │
+├────────────────────────────────────────────┼───────────────┼───────────────┤
+│              newstest2017.online-A.0.en-de │     20.8      │     52.0      │
+│                                            │ (p = 0.0001)* │ (p = 0.0001)* │
+├────────────────────────────────────────────┼───────────────┼───────────────┤
+│              newstest2017.online-B.0.en-de │     26.7      │     56.3      │
+│                                            │ (p = 0.8066)  │ (p = 0.0385)* │
+├────────────────────────────────────────────┼───────────────┼───────────────┤
+│              newstest2017.online-F.0.en-de │     15.5      │     49.3      │
+│                                            │ (p = 0.0001)* │ (p = 0.0001)* │
+├────────────────────────────────────────────┼───────────────┼───────────────┤
+│              newstest2017.online-G.0.en-de │     18.2      │     51.6      │
+│                                            │ (p = 0.0001)* │ (p = 0.0001)* │
+╘════════════════════════════════════════════╧═══════════════╧═══════════════╛
+
+-------------------------------------------------------
+Paired approximate randomization test with 10000 trials
+-------------------------------------------------------
+ - Each system is pairwise compared to Baseline: newstest2017.LIUM-NMT.4900.en-de.
+   Actual system score is provided for each metric.
+
+ - Null hypothesis: the system and the baseline translations are essentially
+   generated by the same underlying process. For a given system and the baseline,
+   the p-value is roughly the probability of the absolute score difference (delta)
+   or higher occurring due to chance, under the assumption that the null hypothesis is correct.
+
+ - Assuming a significance threshold of 0.05, the null hypothesis can be rejected
+   for p-values < 0.05 (marked with "*"). This means that the delta is unlikely to be attributed
+   to chance, hence the system is significantly "different" than the baseline.
+   Otherwise, the p-values are highlighted in red.
+
+ - NOTE: Significance does not tell whether a system is "better" than the baseline but rather
+   emphasizes the "difference" of the systems in terms of the replicability of the delta.
+
+-----------------
+Metric signatures
+-----------------
+ - BLEU       nrefs:1|ar:10000|seed:12345|case:mixed|eff:no|tok:13a|smooth:exp|version:2.0.0
+ - chrF2      nrefs:1|ar:10000|seed:12345|case:mixed|eff:yes|nc:6|nw:0|space:no|version:2.0.0
+```
+
+# Using SacreBLEU from Python
+
+For evaluation, it may be useful to compute BLEU, chrF or TER from a Python script. The recommended
+way of doing this is to use the object-oriented API, by creating an instance of the `metrics.BLEU` class
+for example:
+
+```python
+In [1]: from sacrebleu.metrics import BLEU, CHRF, TER
+   ...:
+   ...: refs = [ # First set of references
+   ...:          ['The dog bit the man.', 'It was not unexpected.', 'The man bit him first.'],
+   ...:          # Second set of references
+   ...:          ['The dog had bit the man.', 'No one was surprised.', 'The man had bitten the dog.'],
+   ...:        ]
+   ...: sys = ['The dog bit the man.', "It wasn't surprising.", 'The man had just bitten him.']
+
+In [2]: bleu = BLEU()
+
+In [3]: bleu.corpus_score(sys, refs)
+Out[3]: BLEU = 48.53 82.4/50.0/45.5/37.5 (BP = 0.943 ratio = 0.944 hyp_len = 17 ref_len = 18)
+
+In [4]: bleu.get_signature()
+Out[4]: nrefs:2|case:mixed|eff:no|tok:13a|smooth:exp|version:2.0.0
+
+In [5]: chrf = CHRF()
+
+In [6]: chrf.corpus_score(sys, refs)
+Out[6]: chrF2 = 59.73
+```
+
+### Variable Number of References
+
+Let's now remove the first reference sentence for the first system sentence `The dog bit the man.` by replacing it with either `None` or the empty string `''`.
+This allows using a variable number of reference segments per hypothesis. Observe how the signature changes from `nrefs:2` to `nrefs:var`:
+
+```python
+In [1]: from sacrebleu.metrics import BLEU, CHRF, TER
+   ...:
+   ...: refs = [ # First set of references
+                 # 1st sentence does not have a ref here
+   ...:          ['', 'It was not unexpected.', 'The man bit him first.'],
+   ...:          # Second set of references
+   ...:          ['The dog had bit the man.', 'No one was surprised.', 'The man had bitten the dog.'],
+   ...:        ]
+   ...: sys = ['The dog bit the man.', "It wasn't surprising.", 'The man had just bitten him.']
+
+In [2]: bleu = BLEU()
+
+In [3]: bleu.corpus_score(sys, refs)
+Out[3]: BLEU = 29.44 82.4/42.9/27.3/12.5 (BP = 0.889 ratio = 0.895 hyp_len = 17 ref_len = 19)
+
+In [4]: bleu.get_signature()
+Out[4]: nrefs:var|case:mixed|eff:no|tok:13a|smooth:exp|version:2.0.0
+```
+
+## Compatibility API
+
+You can also use the compatibility API that provides wrapper functions around the object-oriented API to
+compute sentence-level and corpus-level BLEU, chrF and TER: (It should be noted that this API can be
+removed in future releases)
+
+```python
+In [1]: import sacrebleu
+   ...: 
+   ...: refs = [ # First set of references
+   ...:          ['The dog bit the man.', 'It was not unexpected.', 'The man bit him first.'],
+   ...:          # Second set of references
+   ...:          ['The dog had bit the man.', 'No one was surprised.', 'The man had bitten the dog.'],
+   ...:        ]
+   ...: sys = ['The dog bit the man.', "It wasn't surprising.", 'The man had just bitten him.']
+
+In [2]: sacrebleu.corpus_bleu(sys, refs)
+Out[2]: BLEU = 48.53 82.4/50.0/45.5/37.5 (BP = 0.943 ratio = 0.944 hyp_len = 17 ref_len = 18)
+```
+
+# License
+
+SacreBLEU is licensed under the [Apache 2.0 License](LICENSE.txt).
+
+# Credits
+
+This was all [Rico Sennrich's idea](https://twitter.com/RicoSennrich/status/883246242763026433)
+Originally written by Matt Post.
+New features and ongoing support provided by Martin Popel (@martinpopel) and Ozan Caglayan (@ozancaglayan).
+
+If you use SacreBLEU, please cite the following:
+
+```
+@inproceedings{post-2018-call,
+  title = "A Call for Clarity in Reporting {BLEU} Scores",
+  author = "Post, Matt",
+  booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",
+  month = oct,
+  year = "2018",
+  address = "Belgium, Brussels",
+  publisher = "Association for Computational Linguistics",
+  url = "https://www.aclweb.org/anthology/W18-6319",
+  pages = "186--191",
+}
+```
+
+# Release Notes
+
+- 2.4.2 (2024-04-12)
+  Added:
+  - The CLI "--echo" now will return the domain for WMT22 and WMT23.
+
+  Fixed:
+  - Default reference for wmt23:en-de
+
+- 2.4.1 (2024-03-12)
+  Fixed:
+  - Add exports to package __init__.py
+
+- 2.4.0 (2023-12-11)
+  Added:
+  - WMT23 test sets (test set `wmt23`)
+
+- 2.3.3 (2023-11-28)
+  Fixed:
+  - Typing issues (#249, #250)
+  - Improved builds (#252)
+
+- 2.3.2 (2023-11-06)
+  Fixed:
+  - Special treatment of empty references in TER (#232)
+  - Bump in mecab version for JA (#234)
+
+  Added:
+  - Warning if `-tok spm` is used (use explicit `flores101` instead) (#238)
+
+- 2.3.1 (2022-10-18)
+  Bugfix:
+  - Set lru_cache to 2^16 for SPM tokenizer (was set to infinite)
+
+- 2.3.0 (2022-10-18)
+  Features:
+  - (#203) Added `-tok flores101` and `-tok flores200`, a.k.a. `spbleu`.
+    These are multilingual tokenizations that make use of the
+    multilingual SPM models released by Facebook and described in the
+    following papers:
+    * Flores-101: https://arxiv.org/abs/2106.03193
+    * Flores-200: https://arxiv.org/abs/2207.04672
+  - (#213) Added JSON formatting for multi-system output (thanks to Manikanta Inugurthi @me-manikanta)
+  - (#211) You can now list all test sets for a language pair with `--list SRC-TRG`.
+    Thanks to Jaume Zaragoza (@ZJaume) for adding this feature.
+  - Added WMT22 test sets (test set `wmt22`)
+  - System outputs: include with wmt22. Also added wmt21/systems which will produce WMT21 submitted systems.
+    To see available systems, give a dummy system to `--echo`, e.g., `sacrebleu -t wmt22 -l en-de --echo ?`
+
+- 2.2.1 (2022-09-13)
+  Bugfix: Standard usage was returning (and using) each reference twice.
+
+- 2.2.0 (2022-07-25)
+  Features:
+  - Added WMT21 datasets (thanks to @BrighXiaoHan)
+  - `--echo` now exposes document metadata where available (e.g., docid, genre, origlang)
+  - Bugfix: allow empty references (#161)
+  - Adds a Korean tokenizer (thanks to @NoUnique)
+
+  Under the hood:
+  - Moderate code refactoring
+  - Processed files have adopted a more sensible internal naming scheme under ~/.sacrebleu
+    (e.g., wmt17_ms.zh-en.src instead of zh-en.zh)
+  - Processed file extensions correspond to the values passed to `--echo` (e.g., "src")
+  - Now explicitly representing NoneTokenizer
+  - Got rid of the ".lock" lockfile for downloading (using the tarball itself)
+
+  Many thanks to @BrightXiaoHan (https://github.com/BrightXiaoHan) for the bulk of
+  the code contributions in this release.
+
+- 2.1.0 (2022-05-19)
+  Features:
+  - Added `-tok spm` for multilingual SPM tokenization (#168)
+    (thanks to Naman Goyal and James Cross at Facebook)
+
+  Fixes:
+  - Handle potential memory usage issues due to LRU caching in tokenizers (#167)
+  - Bugfix: BLEU.corpus_score() now using max_ngram_order (#173)
+  - Upgraded ja-mecab to 1.0.5 (#196)
+
+- 2.0.0 (2021-07-18)
+  - Build: Add Windows and OS X testing to Travis CI.
+  - Improve documentation and type annotations.
+  - Drop `Python < 3.6` support and migrate to f-strings.
+  - Relax `portalocker` version pinning, add `regex, tabulate, numpy` dependencies.
+  - Drop input type manipulation through `isinstance` checks. If the user does not obey
+    to the expected annotations, exceptions will be raised. Robustness attempts lead to
+    confusions and obfuscated score errors in the past (#121)
+  - Variable # references per segment is supported for all metrics by default. It is
+    still only available through the API.
+  - Use colored strings in tabular outputs (multi-system evaluation mode) through
+    the help of `colorama` package.
+  - tokenizers: Add caching to tokenizers which seem to speed up things a bit.
+  - `intl` tokenizer: Use `regex` module. Speed goes from ~4 seconds to ~0.6 seconds
+    for a particular test set evaluation. (#46)
+  - Signature: Formatting changed (mostly to remove '+' separator as it was
+    interfering with chrF++). The field separator is now '|' and key values
+    are separated with ':' rather than '.'.
+  - Signature: Boolean true / false values are shortened to yes / no.
+  - Signature: Number of references is `var` if variable number of references is used.
+  - Signature: Add effective order (yes/no) to BLEU and chrF signatures.
+  - Metrics: Scale all metrics into the [0, 100] range (#140)
+  - Metrics API: Use explicit argument names and defaults for the metrics instead of
+    passing obscure `argparse.Namespace` objects.
+  - Metrics API: A base abstract `Metric` class is introduced to guide further
+    metric development. This class defines the methods that should be implemented
+    in the derived classes and offers boilerplate methods for the common functionality.
+    A new metric implemented this way will automatically support significance testing.
+  - Metrics API: All metrics now receive an optional `references` argument at
+    initialization time to process and cache the references. Further evaluations
+    of different systems against the same references becomes faster this way
+    for example when using significance testing.
+  - BLEU: In case of no n-gram matches at all, skip smoothing and return 0.0 BLEU (#141).
+  - CHRF: Added multi-reference support, verified the scores against chrF++.py, added test case.
+  - CHRF: Added chrF+ support through `word_order` argument. Added test cases against chrF++.py.
+    Exposed it through the CLI (--chrf-word-order) (#124)
+  - CHRF: Add possibility to disable effective order smoothing (pass --chrf-eps-smoothing).
+    This way, the scores obtained are exactly the same as chrF++, Moses and NLTK implementations.
+    We keep the effective ordering as the default for compatibility, since this only
+    affects sentence-level scoring with very short sentences. (#144)
+  - CLI: `--input/-i` can now ingest multiple systems. For this reason, the positional
+    `references` should always preceed the `-i` flag.
+  - CLI: Allow modifying TER arguments through CLI. We still keep the TERCOM defaults.
+  - CLI: Prefix metric-specific arguments with --chrf and --ter. To maintain compatibility,
+    BLEU argument names are kept the same.
+  - CLI: Separate metric-specific arguments for clarity when `--help` is printed.
+  - CLI: Added `--format/-f` flag. The single-system output mode is now `json` by default.
+    If you want to keep the old text format persistently, you can export `SACREBLEU_FORMAT=text` into your
+    shell.
+  - CLI: For multi-system mode, `json` falls back to plain text. `latex` output can only
+    be generated for multi-system mode.
+  - CLI: sacreBLEU now supports evaluating multiple systems for a given test set
+    in an efficient way. Through the use of `tabulate` package, the results are
+    nicely rendered into a plain text table, LaTeX, HTML or RST (cf. --format/-f argument).
+    The systems can be either given as a list of plain text files to `-i/--input` or
+    as a tab-separated single stream redirected into `STDIN`. In the former case,
+    the basenames of the files will be automatically used as system names.
+  - Statistical tests: sacreBLEU now supports confidence interval estimation
+    through bootstrap resampling for single-system evaluation (`--confidence` flag)
+    as well as paired bootstrap resampling (`--paired-bs`) and paired approximate
+    randomization tests (`--paired-ar`) when evaluating multiple systems (#40 and #78).
+
+- 1.5.1 (2021-03-05)
+  - Fix extraction error for WMT18 extra test sets (test-ts) (#142)
+  - Validation and test datasets are added for multilingual TEDx
+
+- 1.5.0 (2021-01-15)
+  - Fix an assertion error in chrF (#121)
+  - Add missing `__repr__()` methods for BLEU and TER
+  - TER: Fix exception when `--short` is used (#131)
+  - Pin Mecab version to 1.0.3 for Python 3.5 support
+  - [API Change]: Default value for `floor` smoothing is now 0.1 instead of 0.
+  - [API Change]: `sacrebleu.sentence_bleu()` now uses the `exp` smoothing method,
+    exactly the same as the CLI's --sentence-level behavior. This was mainly done
+    to make two methods behave the same.
+  - Add smoothing value to BLEU signature (#98)
+  - dataset: Fix IWSLT links (#128)
+  - Allow variable number of references for BLEU (only via API) (#130).
+    Thanks to Ondrej Dusek (@tuetschek)
+
+- 1.4.14 (2020-09-13)
+  - Added character-based tokenization (`-tok char`).
+    Thanks to Christian Federmann.
+  - Added TER (`-m ter`). Thanks to Ales Tamchyna! (fixes #90)
+  - Allow calling the script as a standalone utility (fixes #86)
+  - Fix type annotation issues (fixes #100) and mark sacrebleu as supporting mypy
+  - Added WMT20 robustness test sets:
+    - wmt20/robust/set1 (en-ja, en-de)
+    - wmt20/robust/set2 (en-ja, ja-en)
+    - wmt20/robust/set3 (de-en)
+
+- 1.4.13 (2020-07-30)
+  - Added WMT20 newstest test sets (#103)
+  - Make mecab3-python an extra dependency, adapt code to new mecab3-python
+    This fixes the recent Windows installation issues as well (#104)
+    Japanese support should now be explicitly installed through sacrebleu[ja] package.
+  - Fix return type annotation of corpus_bleu()
+  - Improve sentence_score's documentation, do not allow single ref string (#98)
+
+- 1.4.12 (2020-07-03)
+  - Fix a deployment bug (#96)
+
+- 1.4.11 (2020-07-03)
+  - Added Multi30k multimodal MT test set metadata
+  - Refactored all tokenizers into respective classes (fixes #85)
+  - Refactored all metrics into respective classes
+  - Moved utility functions into `utils.py`
+  - Implemented signatures using `BLEUSignature` and `CHRFSignature` classes
+  - Simplified checking of Chinese characters (fixes #5)
+  - Unified common regexp tokenization codes for tokenizers (fixes #27)
+  - Fixed --detail failing when no test sets are provided
+  - Fixed multi-reference BLEU failing when tab-delimited reference stream is used
+  - Removed lowercase option for ChrF which was not functional (#85)
+  - Simplified ChrF and used the same I/O logic as BLEU to allow for future
+    multi-reference reading
+  - Added score regression tests for chrF using reference chrF++ implementation
+  - Added multi-reference & tokenizer & signature tests
+
+- 1.4.10 (2020-05-30)
+  - Fixed bug in signature with mecab tokenizer
+  - Cleaned up deprecation warnings (thanks to Karthikeyan Singaravelan @tirkarthi)
+  - Now only lists the external [typing](https://pypi.org/project/typing/)
+    module as a dependency for Python `<= 3.4`, as it was integrated in the standard
+    library in Python 3.5 (thanks to Erwan de Lépinau @ErwanDL).
+  - Added LICENSE to pypi (thanks to Mark Harfouche @hmaarrfk)
+
+- 1.4.9 (2020-04-30)
+  - Changed `get_available_testsets()` to return a list
+  - Remove Japanese MeCab tokenizer from requirements.
+    (Must be installed manually to avoid Windows incompatibility).
+    Many thanks to Makoto Morishita (@MorinoseiMorizo).
+
+- 1.4.8 (2020-04-26)
+  - Added to API:
+    - get_source_file()
+    - get_reference_files()
+    - get_available_testsets()
+    - get_langpairs_for_testset()
+  - Some internal refactoring
+  - Fixed descriptions of some WMT19/google test sets
+  - Added API test case (test/test_apy.py)
+
+- 1.4.7 (2020-04-19)
+  - Added Google's extra wmt19/en-de refs (-t wmt19/google/{ar,arp,hqall,hqp,hqr,wmtp})
+    (Freitag, Grangier, & Caswell
+     BLEU might be Guilty but References are not Innocent
+     https://arxiv.org/abs/2004.06063)
+  - Restored SACREBLEU_DIR and smart_open to exports (thanks to Thomas Liao @tholiao)
+
+- 1.4.6 (2020-03-28)
+  - Large internal reorganization as a module (thanks to Thamme Gowda @thammegowda)
+
+- 1.4.5 (2020-03-28)
+  - Added Japanese MeCab tokenizer (`-tok ja-mecab`) (thanks to Makoto Morishita @MorinoseiMorizo)
+  - Added wmt20/dev test sets (thanks to Martin Popel @martinpopel)
+
+- 1.4.4 (2020-03-10)
+  - Smoothing changes (Sebastian Nickels @sn1c)
+    - Fixed bug that only applied smoothing to n-grams for n > 2
+    - Added default smoothing values for methods "floor" (0) and "add-k" (1)
+  - `--list` now returns a list of all language pairs for a task when combined with `-t`
+    (e.g., `sacrebleu -t wmt19 --list`)
+  - added missing languages for IWSLT17
+  - Minor code improvements (Thomas Liao @tholiao)
+
+- 1.4.3 (2019-12-02)
+  - Bugfix: handling of result object for CHRF
+  - Improved API example
+
+- 1.4.2 (2019-10-11)
+  - Tokenization variant omitted from the chrF signature; it is relevant only for BLEU (thanks to Martin Popel)
+  - Bugfix: call to sentence_bleu (thanks to Rachel Bawden)
+  - Documentation example for Python API (thanks to Vlad Lyalin)
+  - Calls to corpus_chrf and sentence_chrf now return a an object instead of a float (use result.score)
+
+- 1.4.1 (2019-09-11)
+   - Added sentence-level scoring via -sl (--sentence-level)
+
+- 1.4.0 (2019-09-10)
+   - Many thanks to Martin Popel for all the changes below!
+   - Added evaluation on concatenated test sets (e.g., `-t wmt17,wmt18`).
+     Works as long as they all have the same language pair.
+   - Added `sacrebleu --origlang` (both for evaluation on a subset and for `--echo`).
+     Note that while echoing prints just the subset, evaluation expects the complete
+     test set (and just skips the irrelevant parts).
+   - Added `sacrebleu --detail` for breakdown by domain-specific subsets of the test sets.
+     (Available for WMT19).
+   - Minor changes
+     - Improved display of `sacrebleu -h`
+     - Added `sacrebleu --list`
+     - Code refactoring
+     - Documentation and tests updates
+     - Fixed a race condition bug (`os.makedirs(outdir, exist_ok=True)` instead of `if os.path.exists`)
+
+- 1.3.7 (2019-07-12)
+   - Lazy loading of regexes cuts import time from ~1s to nearly nothing (thanks, @louismartin!)
+   - Added a simple (non-atomic) lock on downloading
+   - Can now read multiple refs from a single tab-delimited file.
+     You need to pass `--num-refs N` to tell it to run the split.
+     Only works with a single reference file passed from the command line.
+
+- 1.3.6 (2019-06-10)
+   - Removed another f-string for Python 3.5 compatibility
+
+- 1.3.5 (2019-06-07)
+   - Restored Python 3.5 compatibility
+
+- 1.3.4 (2019-05-28)
+   - Added MTNT 2019 test sets
+   - Added a BLEU object
+
+- 1.3.3 (2019-05-08)
+   - Added WMT'19 test sets
+
+- 1.3.2 (2018-04-24)
+   - Bugfix in test case (thanks to Adam Roberts, @adarob)
+   - Passing smoothing method through `sentence_bleu`
+
+- 1.3.1 (2019-03-20)
+   - Added another smoothing approach (add-k) and a command-line option for choosing the smoothing method
+     (`--smooth exp|floor|add-n|none`) and the associated value (`--smooth-value`), when relevant.
+   - Changed interface to some functions (backwards incompatible)
+     - 'smooth' is now 'smooth_method'
+     - 'smooth_floor' is now 'smooth_value'
+
+- 1.2.21 (19 March 2019)
+   - Ctrl-M characters are now treated as normal characters, previously treated as newline.
+
+- 1.2.20 (28 February 2018)
+   - Tokenization now defaults to "zh" when language pair is known
+
+- 1.2.19 (19 February 2019)
+   - Updated checksum for wmt19/dev (seems to have changed)
+
+- 1.2.18 (19 February 2019)
+   - Fixed checksum for wmt17/dev (copy-paste error)
+
+- 1.2.17 (6 February 2019)
+   - Added kk-en and en-kk to wmt19/dev
+
+- 1.2.16 (4 February 2019)
+   - Added gu-en and en-gu to wmt19/dev
+
+- 1.2.15 (30 January 2019)
+   - Added MD5 checksumming of downloaded files for all datasets.
+
+- 1.2.14 (22 January 2019)
+   - Added mtnt1.1/train mtnt1.1/valid mtnt1.1/test data from [MTNT](http://www.cs.cmu.edu/~pmichel1/mtnt/)
+
+- 1.2.13 (22 January 2019)
+   - Added 'wmt19/dev' task for 'lt-en' and 'en-lt' (development data for new tasks).
+   - Added MD5 checksum for downloaded tarballs.
+
+- 1.2.12 (8 November 2018)
+   - Now outputs only only digit after the decimal
+
+- 1.2.11 (29 August 2018)
+   - Added a function for sentence-level, smoothed BLEU
+
+- 1.2.10 (23 May 2018)
+   - Added wmt18 test set (with references)
+
+- 1.2.9 (15 May 2018)
+   - Added zh-en, en-zh, tr-en, and en-tr datasets for wmt18/test-ts
+
+- 1.2.8 (14 May 2018)
+   - Added wmt18/test-ts, the test sources (only) for [WMT18](http://statmt.org/wmt18/translation-task.html)
+   - Moved README out of `sacrebleu.py` and the CHANGELOG into a separate file
+
+- 1.2.7 (10 April 2018)
+   - fixed another locale issue (with --echo)
+   - grudgingly enabled `-tok none` from the command line
+
+- 1.2.6 (22 March 2018)
+   - added wmt17/ms (Microsoft's [additional ZH-EN references](https://github.com/MicrosoftTranslator/Translator-HumanParityData)).
+     Try `sacrebleu -t wmt17/ms --cite`.
+   - `--echo ref` now pastes together all references, if there is more than one
+
+- 1.2.5 (13 March 2018)
+   - added wmt18/dev datasets (en-et and et-en)
+   - fixed logic with --force
+   - locale-independent installation
+   - added "--echo both" (tab-delimited)
+
+- 1.2.3 (28 January 2018)
+   - metrics (`-m`) are now printed in the order requested
+   - chrF now prints a version string (including the beta parameter, importantly)
+   - attempt to remove dependence on locale setting
+
+- 1.2 (17 January 2018)
+   - added the chrF metric (`-m chrf` or `-m bleu chrf` for both)
+     See 'CHRF: character n-gram F-score for automatic MT evaluation' by Maja Popovic (WMT 2015)
+     [http://www.statmt.org/wmt15/pdf/WMT49.pdf]
+   - added IWSLT 2017 test and tuning sets for DE, FR, and ZH
+     (Thanks to Mauro Cettolo and Marcello Federico).
+   - added `--cite` to produce the citation for easy inclusion in papers
+   - added `--input` (`-i`) to set input to a file instead of STDIN
+   - removed accent mark after objection from UN official
+
+- 1.1.7 (27 November 2017)
+   - corpus_bleu() now raises an exception if input streams are different lengths
+   - thanks to Martin Popel for:
+      - small bugfix in tokenization_13a (not affecting WMT references)
+      - adding `--tok intl` (international tokenization)
+   - added wmt17/dev and wmt17/dev sets (for languages intro'd those years)
+
+- 1.1.6 (15 November 2017)
+   - bugfix for tokenization warning
+
+- 1.1.5 (12 November 2017)
+   - added -b option (only output the BLEU score)
+   - removed fi-en from list of WMT16/17 systems with more than one reference
+   - added WMT16/tworefs and WMT17/tworefs for scoring with both en-fi references
+
+- 1.1.4 (10 November 2017)
+   - added effective order for sentence-level BLEU computation
+   - added unit tests from sockeye
+
+- 1.1.3 (8 November 2017).
+   - Factored code a bit to facilitate API:
+      - compute_bleu: works from raw stats
+      - corpus_bleu for use from the command line
+      - raw_corpus_bleu: turns off tokenization, command-line sanity checks, floor smoothing
+   - Smoothing (type 'exp', now the default) fixed to produce mteval-v13a.pl results
+   - Added 'floor' smoothing (adds 0.01 to 0 counts, more versatile via API), 'none' smoothing (via API)
+   - Small bugfixes, windows compatibility (H/T Christian Federmann)
+
+- 1.0.3 (4 November 2017).
+   - Contributions from Christian Federmann:
+      - Added explicit support for encoding
+      - Fixed Windows support
+      - Bugfix in handling reference length with multiple refs
+
+- version 1.0.1 (1 November 2017).
+   - Small bugfix affecting some versions of Python.
+   - Code reformatting due to Ozan Çağlayan.
+
+- version 1.0 (23 October 2017).
+   - Support for WMT 2008--2017.
+   - Single tokenization (v13a) with lowercase fix (proper lower() instead of just A-Z).
+   - Chinese tokenization.
+   - Tested to match all WMT17 scores on all arcs.
+

env-llmeval/lib/python3.10/site-packages/sacrebleu-2.4.2.dist-info/RECORD

@@ -0,0 +1,75 @@
+../../../bin/sacrebleu,sha256=xGl1UQEIi3XGJ-ZmBESEe8PtLzNoFRFF8nqwn5TrLII,244
+sacrebleu-2.4.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+sacrebleu-2.4.2.dist-info/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sacrebleu-2.4.2.dist-info/METADATA,sha256=nqHo74uPqdWFe4CAQXRARYbVcrPNfYjt8pCnOV6yzEM,58040
+sacrebleu-2.4.2.dist-info/RECORD,,
+sacrebleu-2.4.2.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+sacrebleu-2.4.2.dist-info/entry_points.txt,sha256=oacOmm24wUB3Xd7hB1dBABMzlZh9ReRJRNhaKu1fDlw,55
+sacrebleu-2.4.2.dist-info/top_level.txt,sha256=H3cpHXPQtQtVbKIwDN8Au2t8nwrTQlA9omGuoF7tJOA,10
+sacrebleu/__init__.py,sha256=UUPHuhC7GiZVAAQCArR_33Tgk-kBShN07vaS233ye1k,1706
+sacrebleu/__main__.py,sha256=Eim2Tft9Xcoh5PJ4n23mVnpP36UmecOtCAH1Upl5kao,1062
+sacrebleu/__pycache__/__init__.cpython-310.pyc,,
+sacrebleu/__pycache__/__main__.cpython-310.pyc,,
+sacrebleu/__pycache__/compat.cpython-310.pyc,,
+sacrebleu/__pycache__/sacrebleu.cpython-310.pyc,,
+sacrebleu/__pycache__/significance.cpython-310.pyc,,
+sacrebleu/__pycache__/utils.cpython-310.pyc,,
+sacrebleu/compat.py,sha256=rq8s6SgH9xgBc2uK6JXoH0HWZ6CbcpP_4_X66nQhyCs,9100
+sacrebleu/dataset/__init__.py,sha256=1KRahpk98bOFnIQaZLGDy0XgndrHjQXotCvogSvZ0RQ,106142
+sacrebleu/dataset/__main__.py,sha256=4zJ7F7mtk2LKCGorTJe0YCtZ0al5lvrJNMrfrxl3_OQ,1250
+sacrebleu/dataset/__pycache__/__init__.cpython-310.pyc,,
+sacrebleu/dataset/__pycache__/__main__.cpython-310.pyc,,
+sacrebleu/dataset/__pycache__/base.cpython-310.pyc,,
+sacrebleu/dataset/__pycache__/fake_sgml.cpython-310.pyc,,
+sacrebleu/dataset/__pycache__/iwslt_xml.cpython-310.pyc,,
+sacrebleu/dataset/__pycache__/plain_text.cpython-310.pyc,,
+sacrebleu/dataset/__pycache__/tsv.cpython-310.pyc,,
+sacrebleu/dataset/__pycache__/wmt_xml.cpython-310.pyc,,
+sacrebleu/dataset/base.py,sha256=TZGsir4PvdcO8YF_MWevd3Qb95ycQB2rvtAOkYIR0XM,6724
+sacrebleu/dataset/fake_sgml.py,sha256=SW00xrlhdc9Sr9Z8Q7RF8mXVuLo3s1aNLC-zu3Crevo,4098
+sacrebleu/dataset/iwslt_xml.py,sha256=nAwIXBfbcQLbbI3Eoe2DqdjGfD1V-429_qrwuZZqmj0,210
+sacrebleu/dataset/plain_text.py,sha256=AKYCHFRtVLCoFod5pKBrqvKRxYmkqoPwUpcPup1Jg_8,1237
+sacrebleu/dataset/tsv.py,sha256=m__O5lc8GmPvKl_901bndLAOuh9a1fK1koHOKWX6h90,2179
+sacrebleu/dataset/wmt_xml.py,sha256=6xyzgctfaFWSxsUjKseWPy6YwHZekB-Ci-aUQrZFHP0,7828
+sacrebleu/metrics/__init__.py,sha256=MzC5hSbprlwwvbeu6_6_FOz3L7c1KvtBkmkgOaGVTDk,260
+sacrebleu/metrics/__pycache__/__init__.cpython-310.pyc,,
+sacrebleu/metrics/__pycache__/base.cpython-310.pyc,,
+sacrebleu/metrics/__pycache__/bleu.cpython-310.pyc,,
+sacrebleu/metrics/__pycache__/chrf.cpython-310.pyc,,
+sacrebleu/metrics/__pycache__/helpers.cpython-310.pyc,,
+sacrebleu/metrics/__pycache__/lib_ter.cpython-310.pyc,,
+sacrebleu/metrics/__pycache__/ter.cpython-310.pyc,,
+sacrebleu/metrics/base.py,sha256=xTWUzNfXJIjnbiIYBlwhSoRgfiFYLqe84rIhYH1nSXM,16559
+sacrebleu/metrics/bleu.py,sha256=TqGdxEDu3H0P1uGKi-Y_BMNYK0xtpqtEGe7T0dJpgbs,17485
+sacrebleu/metrics/chrf.py,sha256=lhkOB3nwuSOvsub17Mct9gQ0oR038gEj5vj-1IFQhXU,10674
+sacrebleu/metrics/helpers.py,sha256=VWngO3F_9gUa4uQFH1WJm4xZqpq3CLYeAWEOeMuECx4,2339
+sacrebleu/metrics/lib_ter.py,sha256=OBJjJHmDBzq_supZW68Vma-tkSVy1tibSLw_R093ncE,16477
+sacrebleu/metrics/ter.py,sha256=TuS52VLjayllPf-EB6-8Sf7EdkIGdJ0L1QfXzCSOcBo,7769
+sacrebleu/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sacrebleu/sacrebleu.py,sha256=ZwXF3KtqBb-NGDVYclj5gkO7IlfV8-T7gM7kBDPX1VM,28458
+sacrebleu/significance.py,sha256=PDO7mCu5zL-7XNc9tA7QKs0C3TkcfrJgbKqYXwnXTp4,18329
+sacrebleu/tokenizers/__init__.py,sha256=V1unPdEJPrfDKNDYR1VSLu1bXCX0Fr8Uu8y9pNcZXGA,89
+sacrebleu/tokenizers/__pycache__/__init__.cpython-310.pyc,,
+sacrebleu/tokenizers/__pycache__/tokenizer_13a.cpython-310.pyc,,
+sacrebleu/tokenizers/__pycache__/tokenizer_base.cpython-310.pyc,,
+sacrebleu/tokenizers/__pycache__/tokenizer_char.cpython-310.pyc,,
+sacrebleu/tokenizers/__pycache__/tokenizer_intl.cpython-310.pyc,,
+sacrebleu/tokenizers/__pycache__/tokenizer_ja_mecab.cpython-310.pyc,,
+sacrebleu/tokenizers/__pycache__/tokenizer_ko_mecab.cpython-310.pyc,,
+sacrebleu/tokenizers/__pycache__/tokenizer_none.cpython-310.pyc,,
+sacrebleu/tokenizers/__pycache__/tokenizer_re.cpython-310.pyc,,
+sacrebleu/tokenizers/__pycache__/tokenizer_spm.cpython-310.pyc,,
+sacrebleu/tokenizers/__pycache__/tokenizer_ter.cpython-310.pyc,,
+sacrebleu/tokenizers/__pycache__/tokenizer_zh.cpython-310.pyc,,
+sacrebleu/tokenizers/tokenizer_13a.py,sha256=_1ClpQPIGqRj6uaklsFegAvSZUtlbE-yztmr51dLirU,985
+sacrebleu/tokenizers/tokenizer_base.py,sha256=YNvqL3oW3rsCtUbMNat6RhlYSn2VlZuPHgYHBj6jfJg,461
+sacrebleu/tokenizers/tokenizer_char.py,sha256=ubPsBjzNXqFPJ7WEpHQ2XD2ZWWqPgeOli9ErHOxmjTw,458
+sacrebleu/tokenizers/tokenizer_intl.py,sha256=EGayKRqqcY6oV-Zstah4mrYw979W5jK0AWK8Uo3C55Q,1869
+sacrebleu/tokenizers/tokenizer_ja_mecab.py,sha256=WYHc7xtAruICGfe-D6RYmnyrXxrlHlyNXVqQVs-6l1o,1420
+sacrebleu/tokenizers/tokenizer_ko_mecab.py,sha256=BWTEkHp8d2dJOAmlqdBtLt2MHJtpOdM78CWztQ-qS00,1455
+sacrebleu/tokenizers/tokenizer_none.py,sha256=0VX-qoUM3HzuLpF59L-gHjNgmoXXXpco23zYJtwmEmw,236
+sacrebleu/tokenizers/tokenizer_re.py,sha256=OGck3pPhwibf48Dssy-6cZObsHNetwb3IIJnUYGRiAg,1271
+sacrebleu/tokenizers/tokenizer_spm.py,sha256=otBUswldtMcpE95vvIDf-74eddy35_9p88mgv9J5T9g,2096
+sacrebleu/tokenizers/tokenizer_ter.py,sha256=37KPsx0jwsSZsqZ7UJKWAYyttvqS11SxzkHZIjrZBdA,6219
+sacrebleu/tokenizers/tokenizer_zh.py,sha256=GmBe3E29uECf61dFsR_qAHNzATEkgwwp0XAqb8de9wU,4724
+sacrebleu/utils.py,sha256=lwyJiKniOQYhX5Yb2Dfe2kTROa0Fs-q-weO2kIVAz00,22530

env-llmeval/lib/python3.10/site-packages/sacrebleu-2.4.2.dist-info/WHEEL

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

env-llmeval/lib/python3.10/site-packages/sacrebleu-2.4.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sacrebleu = sacrebleu.sacrebleu:main

env-llmeval/lib/python3.10/site-packages/sacrebleu-2.4.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+sacrebleu

env-llmeval/lib/python3.10/site-packages/urllib3-2.2.1.dist-info/INSTALLER

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

env-llmeval/lib/python3.10/site-packages/urllib3-2.2.1.dist-info/METADATA

@@ -0,0 +1,154 @@
+Metadata-Version: 2.1
+Name: urllib3
+Version: 2.2.1
+Summary: HTTP library with thread-safe connection pooling, file post, and more.
+Project-URL: Changelog, https://github.com/urllib3/urllib3/blob/main/CHANGES.rst
+Project-URL: Documentation, https://urllib3.readthedocs.io
+Project-URL: Code, https://github.com/urllib3/urllib3
+Project-URL: Issue tracker, https://github.com/urllib3/urllib3/issues
+Author-email: Andrey Petrov <[email protected]>
+Maintainer-email: Seth Michael Larson <[email protected]>, Quentin Pradet <[email protected]>, Illia Volochii <[email protected]>
+License-File: LICENSE.txt
+Keywords: filepost,http,httplib,https,pooling,ssl,threadsafe,urllib
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Provides-Extra: brotli
+Requires-Dist: brotli>=1.0.9; (platform_python_implementation == 'CPython') and extra == 'brotli'
+Requires-Dist: brotlicffi>=0.8.0; (platform_python_implementation != 'CPython') and extra == 'brotli'
+Provides-Extra: h2
+Requires-Dist: h2<5,>=4; extra == 'h2'
+Provides-Extra: socks
+Requires-Dist: pysocks!=1.5.7,<2.0,>=1.5.6; extra == 'socks'
+Provides-Extra: zstd
+Requires-Dist: zstandard>=0.18.0; extra == 'zstd'
+Description-Content-Type: text/markdown
+
+<h1 align="center">
+
+![urllib3](https://github.com/urllib3/urllib3/raw/main/docs/_static/banner_github.svg)
+
+</h1>
+
+<p align="center">
+  <a href="https://pypi.org/project/urllib3"><img alt="PyPI Version" src="https://img.shields.io/pypi/v/urllib3.svg?maxAge=86400" /></a>
+  <a href="https://pypi.org/project/urllib3"><img alt="Python Versions" src="https://img.shields.io/pypi/pyversions/urllib3.svg?maxAge=86400" /></a>
+  <a href="https://discord.gg/urllib3"><img alt="Join our Discord" src="https://img.shields.io/discord/756342717725933608?color=%237289da&label=discord" /></a>
+  <a href="https://github.com/urllib3/urllib3/actions?query=workflow%3ACI"><img alt="Coverage Status" src="https://img.shields.io/badge/coverage-100%25-success" /></a>
+  <a href="https://github.com/urllib3/urllib3/actions?query=workflow%3ACI"><img alt="Build Status on GitHub" src="https://github.com/urllib3/urllib3/workflows/CI/badge.svg" /></a>
+  <a href="https://urllib3.readthedocs.io"><img alt="Documentation Status" src="https://readthedocs.org/projects/urllib3/badge/?version=latest" /></a><br>
+  <a href="https://deps.dev/pypi/urllib3"><img alt="OpenSSF Scorecard" src="https://api.securityscorecards.dev/projects/github.com/urllib3/urllib3/badge" /></a>
+  <a href="https://slsa.dev"><img alt="SLSA 3" src="https://slsa.dev/images/gh-badge-level3.svg" /></a>
+  <a href="https://bestpractices.coreinfrastructure.org/projects/6227"><img alt="CII Best Practices" src="https://bestpractices.coreinfrastructure.org/projects/6227/badge" /></a>
+</p>
+
+urllib3 is a powerful, *user-friendly* HTTP client for Python. Much of the
+Python ecosystem already uses urllib3 and you should too.
+urllib3 brings many critical features that are missing from the Python
+standard libraries:
+
+- Thread safety.
+- Connection pooling.
+- Client-side SSL/TLS verification.
+- File uploads with multipart encoding.
+- Helpers for retrying requests and dealing with HTTP redirects.
+- Support for gzip, deflate, brotli, and zstd encoding.
+- Proxy support for HTTP and SOCKS.
+- 100% test coverage.
+
+urllib3 is powerful and easy to use:
+
+```python3
+>>> import urllib3
+>>> resp = urllib3.request("GET", "http://httpbin.org/robots.txt")
+>>> resp.status
+200
+>>> resp.data
+b"User-agent: *\nDisallow: /deny\n"
+```
+
+## Installing
+
+urllib3 can be installed with [pip](https://pip.pypa.io):
+
+```bash
+$ python -m pip install urllib3
+```
+
+Alternatively, you can grab the latest source code from [GitHub](https://github.com/urllib3/urllib3):
+
+```bash
+$ git clone https://github.com/urllib3/urllib3.git
+$ cd urllib3
+$ pip install .
+```
+
+
+## Documentation
+
+urllib3 has usage and reference documentation at [urllib3.readthedocs.io](https://urllib3.readthedocs.io).
+
+
+## Community
+
+urllib3 has a [community Discord channel](https://discord.gg/urllib3) for asking questions and
+collaborating with other contributors. Drop by and say hello 👋
+
+
+## Contributing
+
+urllib3 happily accepts contributions. Please see our
+[contributing documentation](https://urllib3.readthedocs.io/en/latest/contributing.html)
+for some tips on getting started.
+
+
+## Security Disclosures
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure with maintainers.
+
+
+## Maintainers
+
+- [@sethmlarson](https://github.com/sethmlarson) (Seth M. Larson)
+- [@pquentin](https://github.com/pquentin) (Quentin Pradet)
+- [@illia-v](https://github.com/illia-v) (Illia Volochii)
+- [@theacodes](https://github.com/theacodes) (Thea Flowers)
+- [@haikuginger](https://github.com/haikuginger) (Jess Shapiro)
+- [@lukasa](https://github.com/lukasa) (Cory Benfield)
+- [@sigmavirus24](https://github.com/sigmavirus24) (Ian Stapleton Cordasco)
+- [@shazow](https://github.com/shazow) (Andrey Petrov)
+
+👋
+
+
+## Sponsorship
+
+If your company benefits from this library, please consider [sponsoring its
+development](https://urllib3.readthedocs.io/en/latest/sponsors.html).
+
+
+## For Enterprise
+
+Professional support for urllib3 is available as part of the [Tidelift
+Subscription][1].  Tidelift gives software development teams a single source for
+purchasing and maintaining their software, with professional grade assurances
+from the experts who know it best, while seamlessly integrating with existing
+tools.
+
+[1]: https://tidelift.com/subscription/pkg/pypi-urllib3?utm_source=pypi-urllib3&utm_medium=referral&utm_campaign=readme

env-llmeval/lib/python3.10/site-packages/urllib3-2.2.1.dist-info/RECORD

@@ -0,0 +1,75 @@
+urllib3-2.2.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+urllib3-2.2.1.dist-info/METADATA,sha256=uROmjQwfAbwRYjV9PMdc5JF5NA3kRkpoKafPkNzybfc,6434
+urllib3-2.2.1.dist-info/RECORD,,
+urllib3-2.2.1.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
+urllib3-2.2.1.dist-info/licenses/LICENSE.txt,sha256=Ew46ZNX91dCWp1JpRjSn2d8oRGnehuVzIQAmgEHj1oY,1093
+urllib3/__init__.py,sha256=JMo1tg1nIV1AeJ2vENC_Txfl0e5h6Gzl9DGVk1rWRbo,6979
+urllib3/__pycache__/__init__.cpython-310.pyc,,
+urllib3/__pycache__/_base_connection.cpython-310.pyc,,
+urllib3/__pycache__/_collections.cpython-310.pyc,,
+urllib3/__pycache__/_request_methods.cpython-310.pyc,,
+urllib3/__pycache__/_version.cpython-310.pyc,,
+urllib3/__pycache__/connection.cpython-310.pyc,,
+urllib3/__pycache__/connectionpool.cpython-310.pyc,,
+urllib3/__pycache__/exceptions.cpython-310.pyc,,
+urllib3/__pycache__/fields.cpython-310.pyc,,
+urllib3/__pycache__/filepost.cpython-310.pyc,,
+urllib3/__pycache__/http2.cpython-310.pyc,,
+urllib3/__pycache__/poolmanager.cpython-310.pyc,,
+urllib3/__pycache__/response.cpython-310.pyc,,
+urllib3/_base_connection.py,sha256=p-DOG_Me7-sJXO1R9VgDpNmdVU_kIS8VtaC7ptEllA0,5640
+urllib3/_collections.py,sha256=vzKA-7X-9resOamEWq52uV1nHshChjbYDvz47H0mMjw,17400
+urllib3/_request_methods.py,sha256=ucEpHQyQf06b9o1RxKLkCpzGH0ct-v7X2xGpU6rmmlo,9984
+urllib3/_version.py,sha256=12idLAcGmrAURPX52rGioBo33oQ__-ENJEdeqHvUUZg,98
+urllib3/connection.py,sha256=zFgaaoqrICsl7-kBp-_4va9m82sYhioAuy4-4iDpK0I,34704
+urllib3/connectionpool.py,sha256=XjTfYowLwN5ZzRMO41_OTbGNX4ANifgYVpWsVMRuC00,43556
+urllib3/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+urllib3/contrib/__pycache__/__init__.cpython-310.pyc,,
+urllib3/contrib/__pycache__/pyopenssl.cpython-310.pyc,,
+urllib3/contrib/__pycache__/socks.cpython-310.pyc,,
+urllib3/contrib/emscripten/__init__.py,sha256=u6KNgzjlFZbuAAXa_ybCR7gQ71VJESnF-IIdDA73brw,733
+urllib3/contrib/emscripten/__pycache__/__init__.cpython-310.pyc,,
+urllib3/contrib/emscripten/__pycache__/connection.cpython-310.pyc,,
+urllib3/contrib/emscripten/__pycache__/fetch.cpython-310.pyc,,
+urllib3/contrib/emscripten/__pycache__/request.cpython-310.pyc,,
+urllib3/contrib/emscripten/__pycache__/response.cpython-310.pyc,,
+urllib3/contrib/emscripten/connection.py,sha256=kaBe2tWt7Yy9vNUFRBV7CSyDnfhCYILGxju9KTZj8Sw,8755
+urllib3/contrib/emscripten/emscripten_fetch_worker.js,sha256=CDfYF_9CDobtx2lGidyJ1zjDEvwNT5F-dchmVWXDh0E,3655
+urllib3/contrib/emscripten/fetch.py,sha256=ymwJlHBBuw6WTpKgPHpdmmrNBxlsr75HqoD4Rn27YXk,14131
+urllib3/contrib/emscripten/request.py,sha256=mL28szy1KvE3NJhWor5jNmarp8gwplDU-7gwGZY5g0Q,566
+urllib3/contrib/emscripten/response.py,sha256=wIDmdJ4doFWqLl5s86l9n0V70gFjQ2HWaPgz69jM52E,9546
+urllib3/contrib/pyopenssl.py,sha256=X31eCYGwB09EkAHX8RhDKC0X0Ki7d0cCVWoMJZUM5bQ,19161
+urllib3/contrib/socks.py,sha256=gFS2-zOw4_vLGpUvExOf3fNVT8liz6vhM2t6lBPn3CY,7572
+urllib3/exceptions.py,sha256=RDaiudtR7rqbVKTKpLSgZBBtwaIqV7eZtervZV_mZag,9393
+urllib3/fields.py,sha256=8vi0PeRo_pE5chPmJA07LZtMkVls4UrBS1k2xM506jM,10843
+urllib3/filepost.py,sha256=-9qJT11cNGjO9dqnI20-oErZuTvNaM18xZZPCjZSbOE,2395
+urllib3/http2.py,sha256=4QQcjTM9UYOQZe0r8KnA8anU9ST4p_s3SB3gRTueyPc,7480
+urllib3/poolmanager.py,sha256=fcC3OwjFKxha06NsOORwbZOzrVt1pyY-bNCbKiqC0l8,22935
+urllib3/py.typed,sha256=UaCuPFa3H8UAakbt-5G8SPacldTOGvJv18pPjUJ5gDY,93
+urllib3/response.py,sha256=lmvseToQbkLXuFyA3jcSyCPjTgSfa6YPA4xUhVqq8QI,43874
+urllib3/util/__init__.py,sha256=-qeS0QceivazvBEKDNFCAI-6ACcdDOE4TMvo7SLNlAQ,1001
+urllib3/util/__pycache__/__init__.cpython-310.pyc,,
+urllib3/util/__pycache__/connection.cpython-310.pyc,,
+urllib3/util/__pycache__/proxy.cpython-310.pyc,,
+urllib3/util/__pycache__/request.cpython-310.pyc,,
+urllib3/util/__pycache__/response.cpython-310.pyc,,
+urllib3/util/__pycache__/retry.cpython-310.pyc,,
+urllib3/util/__pycache__/ssl_.cpython-310.pyc,,
+urllib3/util/__pycache__/ssl_match_hostname.cpython-310.pyc,,
+urllib3/util/__pycache__/ssltransport.cpython-310.pyc,,
+urllib3/util/__pycache__/timeout.cpython-310.pyc,,
+urllib3/util/__pycache__/url.cpython-310.pyc,,
+urllib3/util/__pycache__/util.cpython-310.pyc,,
+urllib3/util/__pycache__/wait.cpython-310.pyc,,
+urllib3/util/connection.py,sha256=QeUUEuNmhznpuKNPL-B0IVOkMdMCu8oJX62OC0Vpzug,4462
+urllib3/util/proxy.py,sha256=seP8-Q5B6bB0dMtwPj-YcZZQ30vHuLqRu-tI0JZ2fzs,1148
+urllib3/util/request.py,sha256=PQnBmKUHMQ0hQQ41uhbLNAeA24ke60m6zeiwfwocpGo,8102
+urllib3/util/response.py,sha256=vQE639uoEhj1vpjEdxu5lNIhJCSUZkd7pqllUI0BZOA,3374
+urllib3/util/retry.py,sha256=WB-7x1m7fQH_-Qqtrk2OGvz93GvBTxc-pRn8Vf3p4mg,18384
+urllib3/util/ssl_.py,sha256=FeymdS68RggEROwMB9VLGSqLHq2hRUKnIbQC_bCpGJI,19109
+urllib3/util/ssl_match_hostname.py,sha256=gaWqixoYtQ_GKO8fcRGFj3VXeMoqyxQQuUTPgWeiL_M,5812
+urllib3/util/ssltransport.py,sha256=SF__JQXVcHBQniFJZp3P9q-UeHM310WVwcBwqT9dCLE,9034
+urllib3/util/timeout.py,sha256=4eT1FVeZZU7h7mYD1Jq2OXNe4fxekdNvhoWUkZusRpA,10346
+urllib3/util/url.py,sha256=wHORhp80RAXyTlAIkTqLFzSrkU7J34ZDxX-tN65MBZk,15213
+urllib3/util/util.py,sha256=j3lbZK1jPyiwD34T8IgJzdWEZVT-4E-0vYIJi9UjeNA,1146
+urllib3/util/wait.py,sha256=_ph8IrUR3sqPqi0OopQgJUlH4wzkGeM5CiyA7XGGtmI,4423

env-llmeval/lib/python3.10/site-packages/urllib3-2.2.1.dist-info/WHEEL

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

env-llmeval/lib/python3.10/site-packages/urllib3-2.2.1.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2008-2020 Andrey Petrov and contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,211 @@
+"""
+Python HTTP library with thread-safe connection pooling, file post support, user friendly, and more
+"""
+
+from __future__ import annotations
+
+# Set default logging handler to avoid "No handler found" warnings.
+import logging
+import sys
+import typing
+import warnings
+from logging import NullHandler
+
+from . import exceptions
+from ._base_connection import _TYPE_BODY
+from ._collections import HTTPHeaderDict
+from ._version import __version__
+from .connectionpool import HTTPConnectionPool, HTTPSConnectionPool, connection_from_url
+from .filepost import _TYPE_FIELDS, encode_multipart_formdata
+from .poolmanager import PoolManager, ProxyManager, proxy_from_url
+from .response import BaseHTTPResponse, HTTPResponse
+from .util.request import make_headers
+from .util.retry import Retry
+from .util.timeout import Timeout
+
+# Ensure that Python is compiled with OpenSSL 1.1.1+
+# If the 'ssl' module isn't available at all that's
+# fine, we only care if the module is available.
+try:
+    import ssl
+except ImportError:
+    pass
+else:
+    if not ssl.OPENSSL_VERSION.startswith("OpenSSL "):  # Defensive:
+        warnings.warn(
+            "urllib3 v2 only supports OpenSSL 1.1.1+, currently "
+            f"the 'ssl' module is compiled with {ssl.OPENSSL_VERSION!r}. "
+            "See: https://github.com/urllib3/urllib3/issues/3020",
+            exceptions.NotOpenSSLWarning,
+        )
+    elif ssl.OPENSSL_VERSION_INFO < (1, 1, 1):  # Defensive:
+        raise ImportError(
+            "urllib3 v2 only supports OpenSSL 1.1.1+, currently "
+            f"the 'ssl' module is compiled with {ssl.OPENSSL_VERSION!r}. "
+            "See: https://github.com/urllib3/urllib3/issues/2168"
+        )
+
+__author__ = "Andrey Petrov ([email protected])"
+__license__ = "MIT"
+__version__ = __version__
+
+__all__ = (
+    "HTTPConnectionPool",
+    "HTTPHeaderDict",
+    "HTTPSConnectionPool",
+    "PoolManager",
+    "ProxyManager",
+    "HTTPResponse",
+    "Retry",
+    "Timeout",
+    "add_stderr_logger",
+    "connection_from_url",
+    "disable_warnings",
+    "encode_multipart_formdata",
+    "make_headers",
+    "proxy_from_url",
+    "request",
+    "BaseHTTPResponse",
+)
+
+logging.getLogger(__name__).addHandler(NullHandler())
+
+
+def add_stderr_logger(
+    level: int = logging.DEBUG,
+) -> logging.StreamHandler[typing.TextIO]:
+    """
+    Helper for quickly adding a StreamHandler to the logger. Useful for
+    debugging.
+
+    Returns the handler after adding it.
+    """
+    # This method needs to be in this __init__.py to get the __name__ correct
+    # even if urllib3 is vendored within another package.
+    logger = logging.getLogger(__name__)
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
+    logger.addHandler(handler)
+    logger.setLevel(level)
+    logger.debug("Added a stderr logging handler to logger: %s", __name__)
+    return handler
+
+
+# ... Clean up.
+del NullHandler
+
+
+# All warning filters *must* be appended unless you're really certain that they
+# shouldn't be: otherwise, it's very hard for users to use most Python
+# mechanisms to silence them.
+# SecurityWarning's always go off by default.
+warnings.simplefilter("always", exceptions.SecurityWarning, append=True)
+# InsecurePlatformWarning's don't vary between requests, so we keep it default.
+warnings.simplefilter("default", exceptions.InsecurePlatformWarning, append=True)
+
+
+def disable_warnings(category: type[Warning] = exceptions.HTTPWarning) -> None:
+    """
+    Helper for quickly disabling all urllib3 warnings.
+    """
+    warnings.simplefilter("ignore", category)
+
+
+_DEFAULT_POOL = PoolManager()
+
+
+def request(
+    method: str,
+    url: str,
+    *,
+    body: _TYPE_BODY | None = None,
+    fields: _TYPE_FIELDS | None = None,
+    headers: typing.Mapping[str, str] | None = None,
+    preload_content: bool | None = True,
+    decode_content: bool | None = True,
+    redirect: bool | None = True,
+    retries: Retry | bool | int | None = None,
+    timeout: Timeout | float | int | None = 3,
+    json: typing.Any | None = None,
+) -> BaseHTTPResponse:
+    """
+    A convenience, top-level request method. It uses a module-global ``PoolManager`` instance.
+    Therefore, its side effects could be shared across dependencies relying on it.
+    To avoid side effects create a new ``PoolManager`` instance and use it instead.
+    The method does not accept low-level ``**urlopen_kw`` keyword arguments.
+
+    :param method:
+        HTTP request method (such as GET, POST, PUT, etc.)
+
+    :param url:
+        The URL to perform the request on.
+
+    :param body:
+        Data to send in the request body, either :class:`str`, :class:`bytes`,
+        an iterable of :class:`str`/:class:`bytes`, or a file-like object.
+
+    :param fields:
+        Data to encode and send in the request body.
+
+    :param headers:
+        Dictionary of custom headers to send, such as User-Agent,
+        If-None-Match, etc.
+
+    :param bool preload_content:
+        If True, the response's body will be preloaded into memory.
+
+    :param bool decode_content:
+        If True, will attempt to decode the body based on the
+        'content-encoding' header.
+
+    :param redirect:
+        If True, automatically handle redirects (status codes 301, 302,
+        303, 307, 308). Each redirect counts as a retry. Disabling retries
+        will disable redirect, too.
+
+    :param retries:
+        Configure the number of retries to allow before raising a
+        :class:`~urllib3.exceptions.MaxRetryError` exception.
+
+        If ``None`` (default) will retry 3 times, see ``Retry.DEFAULT``. Pass a
+        :class:`~urllib3.util.retry.Retry` object for fine-grained control
+        over different types of retries.
+        Pass an integer number to retry connection errors that many times,
+        but no other types of errors. Pass zero to never retry.
+
+        If ``False``, then retries are disabled and any exception is raised
+        immediately. Also, instead of raising a MaxRetryError on redirects,
+        the redirect response will be returned.
+
+    :type retries: :class:`~urllib3.util.retry.Retry`, False, or an int.
+
+    :param timeout:
+        If specified, overrides the default timeout for this one
+        request. It may be a float (in seconds) or an instance of
+        :class:`urllib3.util.Timeout`.
+
+    :param json:
+        Data to encode and send as JSON with UTF-encoded in the request body.
+        The ``"Content-Type"`` header will be set to ``"application/json"``
+        unless specified otherwise.
+    """
+
+    return _DEFAULT_POOL.request(
+        method,
+        url,
+        body=body,
+        fields=fields,
+        headers=headers,
+        preload_content=preload_content,
+        decode_content=decode_content,
+        redirect=redirect,
+        retries=retries,
+        timeout=timeout,
+        json=json,
+    )
+
+
+if sys.platform == "emscripten":
+    from .contrib.emscripten import inject_into_urllib3  # noqa: 401
+
+    inject_into_urllib3()

env-llmeval/lib/python3.10/site-packages/urllib3/_base_connection.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+import typing
+
+from .util.connection import _TYPE_SOCKET_OPTIONS
+from .util.timeout import _DEFAULT_TIMEOUT, _TYPE_TIMEOUT
+from .util.url import Url
+
+_TYPE_BODY = typing.Union[bytes, typing.IO[typing.Any], typing.Iterable[bytes], str]
+
+
+class ProxyConfig(typing.NamedTuple):
+    ssl_context: ssl.SSLContext | None
+    use_forwarding_for_https: bool
+    assert_hostname: None | str | Literal[False]
+    assert_fingerprint: str | None
+
+
+class _ResponseOptions(typing.NamedTuple):
+    # TODO: Remove this in favor of a better
+    # HTTP request/response lifecycle tracking.
+    request_method: str
+    request_url: str
+    preload_content: bool
+    decode_content: bool
+    enforce_content_length: bool
+
+
+if typing.TYPE_CHECKING:
+    import ssl
+    from typing import Literal, Protocol
+
+    from .response import BaseHTTPResponse
+
+    class BaseHTTPConnection(Protocol):
+        default_port: typing.ClassVar[int]
+        default_socket_options: typing.ClassVar[_TYPE_SOCKET_OPTIONS]
+
+        host: str
+        port: int
+        timeout: None | (
+            float
+        )  # Instance doesn't store _DEFAULT_TIMEOUT, must be resolved.
+        blocksize: int
+        source_address: tuple[str, int] | None
+        socket_options: _TYPE_SOCKET_OPTIONS | None
+
+        proxy: Url | None
+        proxy_config: ProxyConfig | None
+
+        is_verified: bool
+        proxy_is_verified: bool | None
+
+        def __init__(
+            self,
+            host: str,
+            port: int | None = None,
+            *,
+            timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,
+            source_address: tuple[str, int] | None = None,
+            blocksize: int = 8192,
+            socket_options: _TYPE_SOCKET_OPTIONS | None = ...,
+            proxy: Url | None = None,
+            proxy_config: ProxyConfig | None = None,
+        ) -> None:
+            ...
+
+        def set_tunnel(
+            self,
+            host: str,
+            port: int | None = None,
+            headers: typing.Mapping[str, str] | None = None,
+            scheme: str = "http",
+        ) -> None:
+            ...
+
+        def connect(self) -> None:
+            ...
+
+        def request(
+            self,
+            method: str,
+            url: str,
+            body: _TYPE_BODY | None = None,
+            headers: typing.Mapping[str, str] | None = None,
+            # We know *at least* botocore is depending on the order of the
+            # first 3 parameters so to be safe we only mark the later ones
+            # as keyword-only to ensure we have space to extend.
+            *,
+            chunked: bool = False,
+            preload_content: bool = True,
+            decode_content: bool = True,
+            enforce_content_length: bool = True,
+        ) -> None:
+            ...
+
+        def getresponse(self) -> BaseHTTPResponse:
+            ...
+
+        def close(self) -> None:
+            ...
+
+        @property
+        def is_closed(self) -> bool:
+            """Whether the connection either is brand new or has been previously closed.
+            If this property is True then both ``is_connected`` and ``has_connected_to_proxy``
+            properties must be False.
+            """
+
+        @property
+        def is_connected(self) -> bool:
+            """Whether the connection is actively connected to any origin (proxy or target)"""
+
+        @property
+        def has_connected_to_proxy(self) -> bool:
+            """Whether the connection has successfully connected to its proxy.
+            This returns False if no proxy is in use. Used to determine whether
+            errors are coming from the proxy layer or from tunnelling to the target origin.
+            """
+
+    class BaseHTTPSConnection(BaseHTTPConnection, Protocol):
+        default_port: typing.ClassVar[int]
+        default_socket_options: typing.ClassVar[_TYPE_SOCKET_OPTIONS]
+
+        # Certificate verification methods
+        cert_reqs: int | str | None
+        assert_hostname: None | str | Literal[False]
+        assert_fingerprint: str | None
+        ssl_context: ssl.SSLContext | None
+
+        # Trusted CAs
+        ca_certs: str | None
+        ca_cert_dir: str | None
+        ca_cert_data: None | str | bytes
+
+        # TLS version
+        ssl_minimum_version: int | None
+        ssl_maximum_version: int | None
+        ssl_version: int | str | None  # Deprecated
+
+        # Client certificates
+        cert_file: str | None
+        key_file: str | None
+        key_password: str | None
+
+        def __init__(
+            self,
+            host: str,
+            port: int | None = None,
+            *,
+            timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,
+            source_address: tuple[str, int] | None = None,
+            blocksize: int = 16384,
+            socket_options: _TYPE_SOCKET_OPTIONS | None = ...,
+            proxy: Url | None = None,
+            proxy_config: ProxyConfig | None = None,
+            cert_reqs: int | str | None = None,
+            assert_hostname: None | str | Literal[False] = None,
+            assert_fingerprint: str | None = None,
+            server_hostname: str | None = None,
+            ssl_context: ssl.SSLContext | None = None,
+            ca_certs: str | None = None,
+            ca_cert_dir: str | None = None,
+            ca_cert_data: None | str | bytes = None,
+            ssl_minimum_version: int | None = None,
+            ssl_maximum_version: int | None = None,
+            ssl_version: int | str | None = None,  # Deprecated
+            cert_file: str | None = None,
+            key_file: str | None = None,
+            key_password: str | None = None,
+        ) -> None:
+            ...

env-llmeval/lib/python3.10/site-packages/urllib3/_collections.py

@@ -0,0 +1,483 @@
+from __future__ import annotations
+
+import typing
+from collections import OrderedDict
+from enum import Enum, auto
+from threading import RLock
+
+if typing.TYPE_CHECKING:
+    # We can only import Protocol if TYPE_CHECKING because it's a development
+    # dependency, and is not available at runtime.
+    from typing import Protocol
+
+    from typing_extensions import Self
+
+    class HasGettableStringKeys(Protocol):
+        def keys(self) -> typing.Iterator[str]:
+            ...
+
+        def __getitem__(self, key: str) -> str:
+            ...
+
+
+__all__ = ["RecentlyUsedContainer", "HTTPHeaderDict"]
+
+
+# Key type
+_KT = typing.TypeVar("_KT")
+# Value type
+_VT = typing.TypeVar("_VT")
+# Default type
+_DT = typing.TypeVar("_DT")
+
+ValidHTTPHeaderSource = typing.Union[
+    "HTTPHeaderDict",
+    typing.Mapping[str, str],
+    typing.Iterable[typing.Tuple[str, str]],
+    "HasGettableStringKeys",
+]
+
+
+class _Sentinel(Enum):
+    not_passed = auto()
+
+
+def ensure_can_construct_http_header_dict(
+    potential: object,
+) -> ValidHTTPHeaderSource | None:
+    if isinstance(potential, HTTPHeaderDict):
+        return potential
+    elif isinstance(potential, typing.Mapping):
+        # Full runtime checking of the contents of a Mapping is expensive, so for the
+        # purposes of typechecking, we assume that any Mapping is the right shape.
+        return typing.cast(typing.Mapping[str, str], potential)
+    elif isinstance(potential, typing.Iterable):
+        # Similarly to Mapping, full runtime checking of the contents of an Iterable is
+        # expensive, so for the purposes of typechecking, we assume that any Iterable
+        # is the right shape.
+        return typing.cast(typing.Iterable[typing.Tuple[str, str]], potential)
+    elif hasattr(potential, "keys") and hasattr(potential, "__getitem__"):
+        return typing.cast("HasGettableStringKeys", potential)
+    else:
+        return None
+
+
+class RecentlyUsedContainer(typing.Generic[_KT, _VT], typing.MutableMapping[_KT, _VT]):
+    """
+    Provides a thread-safe dict-like container which maintains up to
+    ``maxsize`` keys while throwing away the least-recently-used keys beyond
+    ``maxsize``.
+
+    :param maxsize:
+        Maximum number of recent elements to retain.
+
+    :param dispose_func:
+        Every time an item is evicted from the container,
+        ``dispose_func(value)`` is called.  Callback which will get called
+    """
+
+    _container: typing.OrderedDict[_KT, _VT]
+    _maxsize: int
+    dispose_func: typing.Callable[[_VT], None] | None
+    lock: RLock
+
+    def __init__(
+        self,
+        maxsize: int = 10,
+        dispose_func: typing.Callable[[_VT], None] | None = None,
+    ) -> None:
+        super().__init__()
+        self._maxsize = maxsize
+        self.dispose_func = dispose_func
+        self._container = OrderedDict()
+        self.lock = RLock()
+
+    def __getitem__(self, key: _KT) -> _VT:
+        # Re-insert the item, moving it to the end of the eviction line.
+        with self.lock:
+            item = self._container.pop(key)
+            self._container[key] = item
+            return item
+
+    def __setitem__(self, key: _KT, value: _VT) -> None:
+        evicted_item = None
+        with self.lock:
+            # Possibly evict the existing value of 'key'
+            try:
+                # If the key exists, we'll overwrite it, which won't change the
+                # size of the pool. Because accessing a key should move it to
+                # the end of the eviction line, we pop it out first.
+                evicted_item = key, self._container.pop(key)
+                self._container[key] = value
+            except KeyError:
+                # When the key does not exist, we insert the value first so that
+                # evicting works in all cases, including when self._maxsize is 0
+                self._container[key] = value
+                if len(self._container) > self._maxsize:
+                    # If we didn't evict an existing value, and we've hit our maximum
+                    # size, then we have to evict the least recently used item from
+                    # the beginning of the container.
+                    evicted_item = self._container.popitem(last=False)
+
+        # After releasing the lock on the pool, dispose of any evicted value.
+        if evicted_item is not None and self.dispose_func:
+            _, evicted_value = evicted_item
+            self.dispose_func(evicted_value)
+
+    def __delitem__(self, key: _KT) -> None:
+        with self.lock:
+            value = self._container.pop(key)
+
+        if self.dispose_func:
+            self.dispose_func(value)
+
+    def __len__(self) -> int:
+        with self.lock:
+            return len(self._container)
+
+    def __iter__(self) -> typing.NoReturn:
+        raise NotImplementedError(
+            "Iteration over this class is unlikely to be threadsafe."
+        )
+
+    def clear(self) -> None:
+        with self.lock:
+            # Copy pointers to all values, then wipe the mapping
+            values = list(self._container.values())
+            self._container.clear()
+
+        if self.dispose_func:
+            for value in values:
+                self.dispose_func(value)
+
+    def keys(self) -> set[_KT]:  # type: ignore[override]
+        with self.lock:
+            return set(self._container.keys())
+
+
+class HTTPHeaderDictItemView(typing.Set[typing.Tuple[str, str]]):
+    """
+    HTTPHeaderDict is unusual for a Mapping[str, str] in that it has two modes of
+    address.
+
+    If we directly try to get an item with a particular name, we will get a string
+    back that is the concatenated version of all the values:
+
+    >>> d['X-Header-Name']
+    'Value1, Value2, Value3'
+
+    However, if we iterate over an HTTPHeaderDict's items, we will optionally combine
+    these values based on whether combine=True was called when building up the dictionary
+
+    >>> d = HTTPHeaderDict({"A": "1", "B": "foo"})
+    >>> d.add("A", "2", combine=True)
+    >>> d.add("B", "bar")
+    >>> list(d.items())
+    [
+        ('A', '1, 2'),
+        ('B', 'foo'),
+        ('B', 'bar'),
+    ]
+
+    This class conforms to the interface required by the MutableMapping ABC while
+    also giving us the nonstandard iteration behavior we want; items with duplicate
+    keys, ordered by time of first insertion.
+    """
+
+    _headers: HTTPHeaderDict
+
+    def __init__(self, headers: HTTPHeaderDict) -> None:
+        self._headers = headers
+
+    def __len__(self) -> int:
+        return len(list(self._headers.iteritems()))
+
+    def __iter__(self) -> typing.Iterator[tuple[str, str]]:
+        return self._headers.iteritems()
+
+    def __contains__(self, item: object) -> bool:
+        if isinstance(item, tuple) and len(item) == 2:
+            passed_key, passed_val = item
+            if isinstance(passed_key, str) and isinstance(passed_val, str):
+                return self._headers._has_value_for_header(passed_key, passed_val)
+        return False
+
+
+class HTTPHeaderDict(typing.MutableMapping[str, str]):
+    """
+    :param headers:
+        An iterable of field-value pairs. Must not contain multiple field names
+        when compared case-insensitively.
+
+    :param kwargs:
+        Additional field-value pairs to pass in to ``dict.update``.
+
+    A ``dict`` like container for storing HTTP Headers.
+
+    Field names are stored and compared case-insensitively in compliance with
+    RFC 7230. Iteration provides the first case-sensitive key seen for each
+    case-insensitive pair.
+
+    Using ``__setitem__`` syntax overwrites fields that compare equal
+    case-insensitively in order to maintain ``dict``'s api. For fields that
+    compare equal, instead create a new ``HTTPHeaderDict`` and use ``.add``
+    in a loop.
+
+    If multiple fields that are equal case-insensitively are passed to the
+    constructor or ``.update``, the behavior is undefined and some will be
+    lost.
+
+    >>> headers = HTTPHeaderDict()
+    >>> headers.add('Set-Cookie', 'foo=bar')
+    >>> headers.add('set-cookie', 'baz=quxx')
+    >>> headers['content-length'] = '7'
+    >>> headers['SET-cookie']
+    'foo=bar, baz=quxx'
+    >>> headers['Content-Length']
+    '7'
+    """
+
+    _container: typing.MutableMapping[str, list[str]]
+
+    def __init__(self, headers: ValidHTTPHeaderSource | None = None, **kwargs: str):
+        super().__init__()
+        self._container = {}  # 'dict' is insert-ordered
+        if headers is not None:
+            if isinstance(headers, HTTPHeaderDict):
+                self._copy_from(headers)
+            else:
+                self.extend(headers)
+        if kwargs:
+            self.extend(kwargs)
+
+    def __setitem__(self, key: str, val: str) -> None:
+        # avoid a bytes/str comparison by decoding before httplib
+        if isinstance(key, bytes):
+            key = key.decode("latin-1")
+        self._container[key.lower()] = [key, val]
+
+    def __getitem__(self, key: str) -> str:
+        val = self._container[key.lower()]
+        return ", ".join(val[1:])
+
+    def __delitem__(self, key: str) -> None:
+        del self._container[key.lower()]
+
+    def __contains__(self, key: object) -> bool:
+        if isinstance(key, str):
+            return key.lower() in self._container
+        return False
+
+    def setdefault(self, key: str, default: str = "") -> str:
+        return super().setdefault(key, default)
+
+    def __eq__(self, other: object) -> bool:
+        maybe_constructable = ensure_can_construct_http_header_dict(other)
+        if maybe_constructable is None:
+            return False
+        else:
+            other_as_http_header_dict = type(self)(maybe_constructable)
+
+        return {k.lower(): v for k, v in self.itermerged()} == {
+            k.lower(): v for k, v in other_as_http_header_dict.itermerged()
+        }
+
+    def __ne__(self, other: object) -> bool:
+        return not self.__eq__(other)
+
+    def __len__(self) -> int:
+        return len(self._container)
+
+    def __iter__(self) -> typing.Iterator[str]:
+        # Only provide the originally cased names
+        for vals in self._container.values():
+            yield vals[0]
+
+    def discard(self, key: str) -> None:
+        try:
+            del self[key]
+        except KeyError:
+            pass
+
+    def add(self, key: str, val: str, *, combine: bool = False) -> None:
+        """Adds a (name, value) pair, doesn't overwrite the value if it already
+        exists.
+
+        If this is called with combine=True, instead of adding a new header value
+        as a distinct item during iteration, this will instead append the value to
+        any existing header value with a comma. If no existing header value exists
+        for the key, then the value will simply be added, ignoring the combine parameter.
+
+        >>> headers = HTTPHeaderDict(foo='bar')
+        >>> headers.add('Foo', 'baz')
+        >>> headers['foo']
+        'bar, baz'
+        >>> list(headers.items())
+        [('foo', 'bar'), ('foo', 'baz')]
+        >>> headers.add('foo', 'quz', combine=True)
+        >>> list(headers.items())
+        [('foo', 'bar, baz, quz')]
+        """
+        # avoid a bytes/str comparison by decoding before httplib
+        if isinstance(key, bytes):
+            key = key.decode("latin-1")
+        key_lower = key.lower()
+        new_vals = [key, val]
+        # Keep the common case aka no item present as fast as possible
+        vals = self._container.setdefault(key_lower, new_vals)
+        if new_vals is not vals:
+            # if there are values here, then there is at least the initial
+            # key/value pair
+            assert len(vals) >= 2
+            if combine:
+                vals[-1] = vals[-1] + ", " + val
+            else:
+                vals.append(val)
+
+    def extend(self, *args: ValidHTTPHeaderSource, **kwargs: str) -> None:
+        """Generic import function for any type of header-like object.
+        Adapted version of MutableMapping.update in order to insert items
+        with self.add instead of self.__setitem__
+        """
+        if len(args) > 1:
+            raise TypeError(
+                f"extend() takes at most 1 positional arguments ({len(args)} given)"
+            )
+        other = args[0] if len(args) >= 1 else ()
+
+        if isinstance(other, HTTPHeaderDict):
+            for key, val in other.iteritems():
+                self.add(key, val)
+        elif isinstance(other, typing.Mapping):
+            for key, val in other.items():
+                self.add(key, val)
+        elif isinstance(other, typing.Iterable):
+            other = typing.cast(typing.Iterable[typing.Tuple[str, str]], other)
+            for key, value in other:
+                self.add(key, value)
+        elif hasattr(other, "keys") and hasattr(other, "__getitem__"):
+            # THIS IS NOT A TYPESAFE BRANCH
+            # In this branch, the object has a `keys` attr but is not a Mapping or any of
+            # the other types indicated in the method signature. We do some stuff with
+            # it as though it partially implements the Mapping interface, but we're not
+            # doing that stuff safely AT ALL.
+            for key in other.keys():
+                self.add(key, other[key])
+
+        for key, value in kwargs.items():
+            self.add(key, value)
+
+    @typing.overload
+    def getlist(self, key: str) -> list[str]:
+        ...
+
+    @typing.overload
+    def getlist(self, key: str, default: _DT) -> list[str] | _DT:
+        ...
+
+    def getlist(
+        self, key: str, default: _Sentinel | _DT = _Sentinel.not_passed
+    ) -> list[str] | _DT:
+        """Returns a list of all the values for the named field. Returns an
+        empty list if the key doesn't exist."""
+        try:
+            vals = self._container[key.lower()]
+        except KeyError:
+            if default is _Sentinel.not_passed:
+                # _DT is unbound; empty list is instance of List[str]
+                return []
+            # _DT is bound; default is instance of _DT
+            return default
+        else:
+            # _DT may or may not be bound; vals[1:] is instance of List[str], which
+            # meets our external interface requirement of `Union[List[str], _DT]`.
+            return vals[1:]
+
+    def _prepare_for_method_change(self) -> Self:
+        """
+        Remove content-specific header fields before changing the request
+        method to GET or HEAD according to RFC 9110, Section 15.4.
+        """
+        content_specific_headers = [
+            "Content-Encoding",
+            "Content-Language",
+            "Content-Location",
+            "Content-Type",
+            "Content-Length",
+            "Digest",
+            "Last-Modified",
+        ]
+        for header in content_specific_headers:
+            self.discard(header)
+        return self
+
+    # Backwards compatibility for httplib
+    getheaders = getlist
+    getallmatchingheaders = getlist
+    iget = getlist
+
+    # Backwards compatibility for http.cookiejar
+    get_all = getlist
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({dict(self.itermerged())})"
+
+    def _copy_from(self, other: HTTPHeaderDict) -> None:
+        for key in other:
+            val = other.getlist(key)
+            self._container[key.lower()] = [key, *val]
+
+    def copy(self) -> HTTPHeaderDict:
+        clone = type(self)()
+        clone._copy_from(self)
+        return clone
+
+    def iteritems(self) -> typing.Iterator[tuple[str, str]]:
+        """Iterate over all header lines, including duplicate ones."""
+        for key in self:
+            vals = self._container[key.lower()]
+            for val in vals[1:]:
+                yield vals[0], val
+
+    def itermerged(self) -> typing.Iterator[tuple[str, str]]:
+        """Iterate over all headers, merging duplicate ones together."""
+        for key in self:
+            val = self._container[key.lower()]
+            yield val[0], ", ".join(val[1:])
+
+    def items(self) -> HTTPHeaderDictItemView:  # type: ignore[override]
+        return HTTPHeaderDictItemView(self)
+
+    def _has_value_for_header(self, header_name: str, potential_value: str) -> bool:
+        if header_name in self:
+            return potential_value in self._container[header_name.lower()][1:]
+        return False
+
+    def __ior__(self, other: object) -> HTTPHeaderDict:
+        # Supports extending a header dict in-place using operator |=
+        # combining items with add instead of __setitem__
+        maybe_constructable = ensure_can_construct_http_header_dict(other)
+        if maybe_constructable is None:
+            return NotImplemented
+        self.extend(maybe_constructable)
+        return self
+
+    def __or__(self, other: object) -> HTTPHeaderDict:
+        # Supports merging header dicts using operator |
+        # combining items with add instead of __setitem__
+        maybe_constructable = ensure_can_construct_http_header_dict(other)
+        if maybe_constructable is None:
+            return NotImplemented
+        result = self.copy()
+        result.extend(maybe_constructable)
+        return result
+
+    def __ror__(self, other: object) -> HTTPHeaderDict:
+        # Supports merging header dicts using operator | when other is on left side
+        # combining items with add instead of __setitem__
+        maybe_constructable = ensure_can_construct_http_header_dict(other)
+        if maybe_constructable is None:
+            return NotImplemented
+        result = type(self)(maybe_constructable)
+        result.extend(self)
+        return result